194 STOCK TOKENS · 12 HAVE TICKED · 24 REPRICINGS SCHEDULED

Built on the corporate-action multiplier

One token isnot one share.

Dividends and splits on Robinhood Chain never touch your balance. They move a multiplier inside the token. 12 have already moved, 24 more are scheduled, and every chart on this chain still shows the raw number.

tokens
194
ticked
12
on-chain feeds
35/194
block
58,035,551
next
LLY 1d 21h

194 stock tokens · radius carries the multiplier · 12 have stepped out

Why it exists

Priced in dollars.Owned in shares.

CRWD

CrowdStrike Holdings

every tracker shows
$823.38 · +293.02%
multiplier on chain
4.000000000
actually worth
$838.00 · -1.74%

One CRWD token stands for 4.00 shares at $209.50 each. The token is priced correctly. The display is not.

001A split already happened and no chart showed it

CrowdStrike split four for one. On chain the token’s multiplier went to 4.0, so one token now stands for four shares and its price is four times the share price. Every tracker that reads one token as one share prints a premium of nearly three hundred per cent that does not exist.

002The chain does not know what is coming

Ask a stock token what its next multiplier will be and it answers zero. The schedule lives in the issuer’s API, off chain, until the tick lands. Scrip publishes that schedule so the repricing is visible before it happens rather than after.

003Dollars are the wrong unit on a stock chain

Pools already quote memecoins against NVDA and AMZN. On this chain the question worth asking is not what something costs in dollars, it is how many shares it is worth, and whether it beat the index while you held it.

Every multiplier that has moved

Twelve have moved.Here is every one.

The other 182 tokens on Robinhood Chain still read exactly 1.000000000, so for them one token is one share and the quoted price needs no correction. On these, a split or a dividend has already moved the multiplier: the price a tracker prints and the price the token is worth are different numbers, and both are on the card.

The scale

Every token, corrected.

tokenmultipliershownworthdriftliquidity
NVDA1.000000000$225.84$225.89-0.02%$7.4M
SGOV1.005101770$101.34$100.99+0.35%$4.3M
SPCX1.000000000$152.74$153.13-0.25%$2.3M
HIMS1.000000000$28.11$28.15-0.14%$2M
SPY1.000000000$767.41$768.97-0.20%$1.9M
RDDT1.000000000$150.46$150.53-0.05%$1.8M
MU1.000074823$1,003.45$1,003.74-0.03%$1.8M
AMZN1.000000000$257.13$257.52-0.15%$1.5M
TSLA1.000000000$367.08$366.62+0.13%$1.5M
QQQ1.000000000$718.27$719.16-0.12%$1.4M

The contracts

Two files. No fee, no upgrade path,nothing to withdraw.

Scrip composes the multiplier a token carries with the feed that already contains it, so a share price can never be read as a token price. ScripCalendar publishes the schedule the token does not carry, and settlement is permissionless because a tick has to be proved against the token rather than asserted by us. Both went to chain 4663 on 6 September 2026 with no payable function, no upgrade path and nothing to withdraw. Scrip has no owner at all; the calendar keeps a single poster role that can publish a forecast and hand itself on, and can never touch a record once it is settled.

1// SPDX-License-Identifier: MIT
2pragma solidity ^0.8.28;
3
4import {IStockToken, IAggregatorV3} from "./interfaces.sol";
5
6/**
7 * @title Scrip
8 * @notice The unit of account for Robinhood Chain.
9 *
10 * A stock token on chain 4663 carries a corporate-action multiplier: after a
11 * dividend or a split, one token no longer stands for one share. Chainlink
12 * publishes the token price with that multiplier already inside; the token
13 * publishes the multiplier but no price; a pool publishes a price but knows
14 * nothing about either.
15 *
16 * Scrip composes them. One call returns the multiplier, the token price, the
17 * share price and the freshness of the feed, so an integrator can never
18 * accidentally read a token price as a share price or apply the multiplier
19 * twice.
20 *
21 * The contract holds nothing, charges nothing, and has no owner. The feed
22 * registry is fixed at construction and cannot be changed afterwards, so
23 * there is no address in here that anyone can point somewhere else later.
24 */
25contract Scrip {
26 uint256 private constant WAD = 1e18;
27
28 /// @dev token => Chainlink aggregator. Immutable set, written once.
29 mapping(address => address) private _feed;
30
31 /// @notice Every token registered at construction, in order.
32 address[] public tokens;
33
34 struct Asset {
35 address token;
36 uint256 multiplier; // 1e18, shares represented by one token
37 uint256 tokenPrice; // 1e8, multiplier already inside; 0 when unknown
38 uint256 sharePrice; // 1e8, tokenPrice * WAD / multiplier; 0 when unknown
39 uint64 updatedAt; // feed timestamp; 0 when there is no feed
40 bool hasFeed;
41 }
// lines 42 to 68 not shown
69 /// @notice Shares represented by one whole token, scaled by 1e18.
70 function multiplierOf(address token) public view returns (uint256 m) {
71 m = IStockToken(token).uiMultiplier();
72 if (m == 0) revert BadMultiplier(token);
73 }
74
75 /// @notice Everything about one token in a single call.
76 function asset(address token) public view returns (Asset memory a) {
77 a.token = token;
78 a.multiplier = multiplierOf(token);
79
80 address f = _feed[token];
81 if (f == address(0)) return a;
82
83 (, int256 answer,, uint256 updatedAt,) = IAggregatorV3(f).latestRoundData();
84 if (answer <= 0) return a;
85
86 a.hasFeed = true;
87 a.tokenPrice = uint256(answer);
88 a.updatedAt = uint64(updatedAt);
89 // The feed answer is the token price. Dividing by the multiplier is
90 // the only correct way to get back to one underlying share.
91 a.sharePrice = (a.tokenPrice * WAD) / a.multiplier;
92 }
// lines 93 to 144 not shown
145 /**
146 * @notice What a screen implies when it reads one token as one share.
147 * @dev Exposed so the error can be measured on chain rather than argued about.
148 */
149 function displayErrorBps(address token) external view returns (int256 bps) {
150 uint256 m = multiplierOf(token);
151 bps = (int256(m) - int256(WAD)) * 10_000 / int256(WAD);
152 }
contracts/src/ScripCalendar.sol0x4e08e149…8a5910011,452,567gas
1// SPDX-License-Identifier: MIT
2pragma solidity ^0.8.28;
3
4import {IStockToken} from "./interfaces.sol";
5
6/**
7 * @title ScripCalendar
8 * @notice The corporate-action schedule for Robinhood Chain, on chain.
9 *
10 * A stock token does not know what is coming. Ask it for its pending
11 * multiplier the day before a dividend and it answers zero; the schedule
12 * lives only in the issuer's off-chain API until the tick is applied.
13 *
14 * This contract publishes that schedule so the repricing is visible before it
15 * happens. The forecast is posted by a keeper and is therefore trusted input.
16 * The settlement is not: settle() is permissionless, reads uiMultiplier()
17 * straight from the token, and writes down the values it actually observed.
18 *
19 * There is no fee, no token, no pause and no upgrade path. The poster can
20 * post and can hand the role on. It cannot touch a settled record, cannot
21 * delete history, and cannot take anything, because there is nothing here to
22 * take.
23 */
24contract ScripCalendar {
25 uint8 public constant KIND_CASH_DIVIDEND = 0;
26 uint8 public constant KIND_SPLIT = 1;
27 uint8 public constant KIND_OTHER = 2;
28
29 struct Action {
30 uint8 kind;
31 uint64 effectiveAt; // when the issuer processes it
32 uint128 rate1e8; // per underlying share, 8 decimals
33 uint64 postedAt;
34 uint256 multiplierAtPost; // what the token read when we posted
35 bool settled;
36 uint256 oldMultiplier; // observed at settlement
37 uint256 newMultiplier; // observed at settlement
38 uint64 settledAt;
39 }
// lines 40 to 113 not shown
114 /**
115 * @notice Close out an action once the chain has actually moved.
116 * @dev Permissionless on purpose. Anyone can prove the tick landed;
117 * nobody, including the poster, can fake one that did not.
118 */
119 function settle(address token, uint256 index) public {
120 Action[] storage list = _actions[token];
121 if (index >= list.length) revert NoSuchAction();
122
123 Action storage a = list[index];
124 if (a.settled) revert AlreadySettled();
125 if (block.timestamp < a.effectiveAt) revert NotYetEffective();
126
127 uint256 nowM = IStockToken(token).uiMultiplier();
128 if (nowM == a.multiplierAtPost) revert MultiplierUnchanged();
129
130 a.settled = true;
131 a.oldMultiplier = a.multiplierAtPost;
132 a.newMultiplier = nowM;
133 a.settledAt = uint64(block.timestamp);
134
135 emit ActionSettled(token, index, a.multiplierAtPost, nowM, uint64(block.timestamp));
136 }
// lines 137 to 198 not shown
199 /// @notice The next unsettled action for a token, or a zeroed struct.
200 function nextAction(address token) external view returns (Action memory out) {
201 Action[] storage list = _actions[token];
202 uint64 best = type(uint64).max;
203 for (uint256 i = 0; i < list.length; i++) {
204 if (list[i].settled) continue;
205 if (list[i].effectiveAt < best) {
206 best = list[i].effectiveAt;
207 out = list[i];
208 }
209 }
210 }

~/scrip/contracts > forge test

Ran 4 test suites: 51 tests passed, 0 failed, 0 skipped

~/scrip/contracts > forge test --match-contract ForkTest --fork-url robinhood

Ran 1 test suite: 6 tests passed, 0 failed, 0 skipped

~/scrip/contracts > cast call 0xcc40c9915b08dfd3b4494ee54332781b676b48a0 \

"multiplierOf(address)(uint256)" 0xea72Ecca2d0f6bFA1394DBBCff85b52CD4233931 --rpc-url robinhood

4000000000000000000

# one CRWD token stands for four shares, and every chart reads it as one

~/scrip/contracts >

The calendar

24 repricings arealready scheduled.

  1. 001LLY2026-09-10$1.73 / share+0.154% step1d 21h
  2. 002MSFT2026-09-10$0.91 / share+0.184% step1d 21h
  3. 003AMAT2026-09-10$0.53 / share+0.116% step1d 21h
  4. 004IBM2026-09-10$1.69 / share+0.729% step1d 21h
  5. 005XOM2026-09-10$1.03 / share+0.635% step1d 21h
  6. 006HII2026-09-11$1.38 / share+0.509% step2d 21h

Verify

Nothing here asksto be believed.

Every number on this site is derived, and each derivation is a command you can run. If what you compute disagrees with what is published here, what is published is wrong.

# the multiplier that breaks every CRWD chart

cast call 0xea72Ecca2d0f6bFA1394DBBCff85b52CD4233931 "uiMultiplier()(uint256)" \

--rpc-url https://rpc.mainnet.chain.robinhood.com

4000000000000000000 [4.0e18]

# what the pool thinks one token costs

curl -s "https://api.dexscreener.com/tokens/v1/robinhood/0xea72Ecca2d0f6bFA1394DBBCff85b52CD4233931"

priceUsd 823.38

# divide one by the other and the premium disappears

What Scrip does not do

No fees

There is no payable function in either contract, and no owner that can add one.

No custody

Scrip never holds a token. There is nothing to deposit and nothing to withdraw.

No private feed

The calendar is published to everyone at once. We do not run a bot that trades it first.

No yield

Scrip measures. It does not promise a return, and the token does not entitle you to one.

2026-09-08 · block 58,035,551

Scrip

Your position does.