FACTA

master.multiplier

Version
0.1.0

How many shares of the underlying stock one token stands for, as the issuer states it and as the chain applies it, and any change the issuer has scheduled.

Changelog

Changelog
VersionDateChange
0.1.0
2026-11-11
First version.

What it measures

The shares per token of each listed token (shares_per_token) and a scheduled new value with its effective time (pending_shares_per_token). Underlying shares = raw token amount × multiplier ÷ 10^18. It does not measure the token's price or the value of a holding.

Inputs

Robinhood tokens, by master.registry-sync:

  • the registry's currentMultiplier, pendingMultiplier and pendingMultiplierEffectiveTime, every 6 hours;
  • on chain, every 6 hours, 20 tokens a step, all pinned to one block: uid(), uiMultiplier(), newUIMultiplier(), effectiveAt(), oraclePaused(), and the token's beacon (storage slot 0xa3f0ad74…3d50). The calls of a step travel as one call to Multicall3, and its 20 beacon slots as one plain batch of storage reads, the most a public endpoint takes in one.

Ondo tokens, by master.ondo-sync: getSValue(address) on Ondo's SyntheticSharesOracle on Ethereum (0x9bc39db6fbb44b91a48b8d5a6c208b82b1741be6), keyed by the token's Ethereum address from the reviewed file. 18 decimals. On 2026-11-10 it answered for QQQon, SPYon and TSLAon and reverted for the other twelve; at Ethereum block 26,394,267 (2026-11-11 21:06:47 UTC) it answered for MSTRon, QQQon, SPYon and TSLAon and reverted with AssetNotFound() for the other eleven.

The rule

  • A Robinhood token shows the value the chain answered at the last cross-check, read with uiMultiplier(). Its source is a sentence that says how the registry states that value: "Robinhood's registry and the token's contract on chain 4663 state the same value." when it is the registry's current multiplier; "The token's contract on chain 4663; Robinhood's registry states this value as its pending multiplier." when it is not the current one and is the pending one; "The token's contract on chain 4663; Robinhood's registry states another value." when it is neither; "The token's contract on chain 4663; Robinhood's registry states no value." when the registry states no current multiplier; "The token's contract on chain 4663; Robinhood's registry states another value as current, and a pending value in a form this method does not read." when it is not the current one and the registry states a pending value this method cannot read. Before its first cross-check a token shows the registry's value with the source "Robinhood's registry; the token's contract on chain 4663 has not been read yet."
  • When the last completed cross-check did not confirm the token's reading, or the token gave no multiplier at it, the source never says what the chain states now. The value shown is the chain's at its last confirmed read, with the source "The token's contract on chain 4663, at its last confirmed read; a second endpoint did not confirm the reading of the last cross-check." or "The token's contract on chain 4663, at its last confirmed read; it gave no multiplier at the last cross-check." With no confirmed read on chain on file, it is the registry's value, with the source "Robinhood's registry; no confirmed reading of the token's contract on chain 4663 is on file." or "Robinhood's registry; the token's contract on chain 4663 gave no multiplier at the last cross-check." The token's line on its sibling's answer and on the instrument page carries the same source. A token whose contract gave no multiplier was read, so no answer says its multiplier is still being read on chain.
  • An Ondo token's source is "Ondo's oracle on Ethereum.", or "Ondo's oracle on Ethereum, which reports this asset paused." when the oracle reports the asset paused.
  • Before Ondo's oracle has answered for a token, the token's record holds no multiplier at all (multiplier: null): a page says that it has not been read yet, beside the stale entry below, and never "not published", since the oracle may well publish a value for it. The same holds for the token's line on its sibling's answer and on the instrument page. An answer of the oracle is a stored shares_per_token figure that rests on the call: a value, or a revert.
  • A change is scheduled when newUIMultiplier() differs from uiMultiplier(). Its effective time is effectiveAt(). It is shown as pending before that time. uiMultiplier() itself switches at the effective time.
  • The registry's effective time is read only as an RFC 3339 time with Z or an explicit offset, and kept as the instant it names, in UTC. A date alone, a time with no offset, a number, a time no calendar holds, a leap second and a fraction finer than a millisecond are not a time the issuer stated in a form this method can quote. The pending value is then kept without a time: the pending pair is not compared with the chain, no notice quotes a time for it, and the job's state counts it (pendingWithoutTime, beside pendingStated). The registry's own format had not been observed when this version was written: the recorded response of 2026-11-10 states no pending multiplier.
  • When uiMultiplier() or newUIMultiplier() gives no value, or a change is scheduled and effectiveAt() gives no time, no schedule is read: that is neither a schedule nor the absence of one. The stored schedule stays as it was, and a scheduled value is never shown without its time.
  • A side that returned no value is quoted in one of three fixed words, and in no other: reverted only for a call that reverted or halted; no data for a call that succeeded and returned nothing, as an address with no code does; unreadable answer for bytes that do not decode as the value asked for, which includes an effectiveAt() of zero or of a number beyond any date. A fourth word, none, is for a schedule the calls show to be absent. A call with no value changes nothing on the record.
  • An Ondo token whose multiplier the oracle does not publish has the value null and the source "Ondo's oracle on Ethereum publishes no value for this token." It is never assumed to be 1.0.
  • Only a revert is the oracle's answer that it publishes no value: it reverts with AssetNotFound() for an asset it does not know. A token's item that was not read, or an answer that holds no value, is never "not published" and never a value: the token keeps what an earlier read left, and no multiplier at all when there was none. An item is not read when the call to the oracle failed as a whole, or when the reader could not read that item: the fifteen reads travel as one call to Multicall3, the reader reads each item the multicall answered as failed again, one call a request, before it counts as a revert, and an endpoint can refuse those re-reads, as one did from Cloudflare's addresses on 2026-11-12. The run then keeps every answer and every revert the call read, item by item: a value the multicall answered is shown, and only the items not read stay as they were. The step's log and the job's state master.ondo say why the call failed (oracleFailure), the Ethereum block of the read when any item of it was read (oracleBlock), and name each token not read (oracleNotRead). A check of such a token, of its sibling or of their instrument carries a stale entry for the source "Ondo's oracle on Ethereum". Each entry's time is the time of the last run that read the token's item: a run is one step, read at its own time, and master.ondo carries that time for each token a run did not read (oracleReadAt). It is never the time of the read that first returned the value shown. A page prints that time as the oracle's last read, before the note, so the note names the later read that did not succeed and never calls both reads the last one: "A later read of it did not succeed for Ondo's token, so the token's value shown is from the read at that time." When an earlier read is on file and its time is not kept, no time is printed, and the note is "The last read of it did not succeed for Ondo's token, so the token's value shown is from an earlier read."; with no earlier read, "The last read of it did not succeed for Ondo's token, and no earlier read of it is on file." When the job's last run, which read the token, completed more than 12 hours ago, the entry says "That is more than 12 hours ago, the limit for a multiplier."
  • A row written before these sentences holds its source in an earlier form, in lowercase machine words. A record shows the sentence that replaced it, and the next run of the job writes the sentence into the row.
  • Two issuers' tokens for one stock are shown side by side. Their multipliers are never merged.

The cross-check

Each Robinhood token is compared with what the registry states and, for its beacon, which the registry does not state, with the Stock Token beacon:

The cross-check
FieldCompared withChain
uid
the registry's id
uid()
multiplier
the registry's currentMultiplier
uiMultiplier()
pendingMultiplier
the registry's pendingMultiplier and its effective time, when the registry states both
uiMultiplier(), newUIMultiplier() and effectiveAt(): the scheduled value and its time; none when the first two answer the same value; when no schedule could be read, the fixed word for the first of the three calls that gave no value
beacon
the Stock Token beacon 0xe10b6f6b275de231345c20d14ab812db62151b00; the registry states none
the beacon slot

A disagreement is one only if the registry's own statement cannot explain the chain. The registry states a current multiplier and, at times, a pending one with its effective time, and uiMultiplier() switches to a scheduled value at its effective time. So:

  • When the chain's multiplier equals the pending value the registry itself states, and it was read at or after that value's effective time, the schedule has taken effect, whether or not the registry also states that value as its current one: the registry's fields can move at different moments around the effective time. It is no disagreement on multiplier. It is no disagreement on pendingMultiplier either: the chain no longer schedules a change it has applied. The token's row is written, with the source that says how the registry states the value, and the job's state counts the token (inEffect).
  • A step reads its own clock when it starts, before it reads the chain, and that clock is not the chain's. So the pending value counts as in effect from 600 seconds before the registry's effective time.
  • The same value read earlier than that is a disagreement like any other: the registry states that its current value still applies.
  • When the registry gives the pending value no effective time, or none in the form above, whether it is in effect cannot be said. The chain answering that value is then no notice, the pending pair is not compared, and the job's state counts the token (untimed).
  • A pending value equal to the registry's own current value states no change. The pending pair is then not compared, as when the registry states no pending value.
  • A pending value the registry writes in a form this method does not read, neither absent nor empty and not a plain decimal of at most 18 places (a JSON number, or a value with a sign, for example), is a failed read and never "no pending value": whether it explains the chain cannot be said. Neither the multiplier nor the pending pair is then compared for the token, a write of the registry's version leaves the record's pending value and time as they were, and the job's state counts it (pendingUnreadable; the job's state master.registry names the token in pendingUnread).

What the registry states as pending is kept in the job's state master.registry (pending), written with the last page of the version it comes from. A token's own record holds the chain's schedule once the chain has been read.

A disagreement becomes a registry_chain_mismatch notice only after a second read of the same values, at the same block, from an endpoint run by another operator, gives the same answer. When that read fails or differs, nothing is written for the token in that step: neither the notice nor the row. A read that fails is never a change: a refused or throttled request fails the step, which is retried.

The beacon slot is read twice in the same way. A step's second reading is one request for the calls to confirm, those of each field that disagreed and of each new schedule, and one for the beacon slots that disagreed, because a call and a storage read cannot share a request. A step reads 20 tokens, so each of the two requests is one: the calls travel as one call, and 20 slots are one plain batch. Only a second read that returns the same beacon as the first confirms it. Another address, a failed read, or a reading that does not fit the step's budget leaves the token as it was in that step, and the next pass meets it again.

The registry states no beacon. Every token it lists is expected to be a beacon proxy of the one Stock Token beacon: listed tokens were read pointing there on chain before this method's first version, which is an inference, not a statement of the issuer. So a beacon notice names beacon as its field, that beacon as the value the slot was compared with (the payload's registry field, which here holds no statement of the registry), and the address the slot holds as the chain's.

For every other field, the registry's side of a notice is what the processed registry response states: the value stored for the token, or, for the pending pair, what the job's state holds for that response. The notice cites that response by the time it was first fetched and its SHA-256. So the stored values and the response must agree, and a cross-check runs only over rows written in full from that response:

  • A new version is written 40 assets a step, and the cross-check starts only after its last page is written. Every page of an unfinished write is saved together with a mark in the job's state master.registry (writing), so the mark survives a run that fails in the middle of a write.
  • When the registry answers the processed version again in the middle of a write, as a cache that serves two versions in turn does, or in a run after one that failed in the middle of a write, every row is written again from that answer before the cross-check. That request is sent without the ETag, because a 304 would carry no body to write the rows from.
  • A step that finds the mark compares nothing: it reads no token on chain, and writes the rows again from its own fetch.
  • A record's pending multiplier and its effective time are the registry's statement until the cross-check has read the chain's schedule, and until then they follow each processed version exactly, an absent value or time included. From then on they are the chain's schedule. What the job's state holds as the registry's pending statement is replaced with each processed version, so a schedule that an earlier version stated, and the current one does not, is never quoted as the registry's.

A token whose entry in the processed response could not be read, for want of its decimals for example (master.listing, "An entry that cannot be read"), keeps the record an earlier response left. Nothing is compared for it and nothing is written for it, and the job's state counts it (unread).

Every step fetches the registry before it does anything else, and a step compares only when its own fetch returned the version the rows were written from. So no comparison rests on a fetch older than its own step. A run that the daily hold-back or the day's step limit paused in the middle of its cross-check fetches again when it resumes. When the registry has moved meanwhile, the step writes the new version, and the cross-check begins again once every row states it. A fetch that fails, or answers anything but 200 or 304, fails the step: nothing is compared, and the step is retried.

The request names an ETag only when it is the strong ETag of a body the job hashed: a 304 to it shows that body is still the registry's answer. A weak ETag is never sent, because a 304 to it does not show that the bytes are the same.

When the values shown are not the last cross-check's

A value is still shown when the last cross-check could not confirm it or could not read it, and it is never presented as current. The job's state master.registry keeps, from each completed pass, the tokens whose chain side that pass did not confirm or did not read, and why (chainNotConfirmed): held when the second endpoint did not confirm the reading, so nothing was written for the token; multiplier when uiMultiplier() gave no value; schedule when the schedule's calls did not show one. A check of the token, of its sibling, or of their instrument then carries a stale entry. Each note names the Robinhood token, since the entry is also shown on its sibling's answer and on the instrument page:

When the values shown are not the last cross-check's
CaseSourceNote
held, with a read on chain on file
the Robinhood token's multiplier on chain 4663
A second endpoint did not confirm the chain's answers for the Robinhood token at the last cross-check, so its values shown are from an earlier read.
held, with none
the Robinhood token's multiplier on chain 4663
A second endpoint did not confirm the chain's answers for the Robinhood token at the last cross-check, and no earlier read of them on chain is on file.
multiplier, with a read on chain on file
the Robinhood token's multiplier on chain 4663
The Robinhood token gave no multiplier at the last cross-check, so its values shown are from an earlier read.
multiplier, with none
the Robinhood token's multiplier on chain 4663
The Robinhood token gave no multiplier at the last cross-check, and no earlier read of it on chain is on file.
schedule, with a read of the schedule on file
the Robinhood token's scheduled change on chain 4663
The Robinhood token did not show at the last cross-check whether a change is scheduled, so its scheduled change shown is from an earlier read.
schedule, with none
the Robinhood token's scheduled change on chain 4663
The Robinhood token did not show at the last cross-check whether a change is scheduled, and no earlier read of its schedule on chain is on file.
A value read on chain, when the last completed pass ended more than 12 hours ago
the Robinhood token's multiplier on chain 4663
The last cross-check on chain completed more than 12 hours ago.
A value read on chain, before any pass has completed, when it was first read more than 12 hours ago
the Robinhood token's multiplier on chain 4663
No cross-check on chain has completed yet, and the Robinhood token's value shown was first read more than 12 hours ago.

An entry's time is the time of the last read of its source that succeeded, never the time of the read that first returned the value shown. A figure keeps that first read, because a pass that reads the same value again writes nothing. So the job keeps the times itself, without a row written for each token at each pass: master.registry holds the time of each step of the last completed pass and the last token address it read (crossCheckSteps), which dates the read of every token that pass read in full; and, for each token it did not, the time of the last read of its multiplier and of its schedule that succeeded, carried from pass to pass (chainLastGood). An entry with no read of its source on file, or before any pass has completed, has no time.

The hold itself stays: nothing is written and nothing is published for a token whose reading was not confirmed.

A scheduled change seen on chain becomes a multiplier_scheduled notice, once for each schedule, and only after a second read of uiMultiplier(), newUIMultiplier() and effectiveAt(), at the same block, from an endpoint run by another operator, gives the same three answers. The registry may state no pending value, so nothing else would corroborate the first read. When the second read fails, differs or does not fit the step's budget, nothing is written for the token in that step: neither the notice nor the schedule on its record, and the next pass reads it again. A schedule the record already shows as read from the chain is not read twice again, and a schedule that ends is no notice.

Thresholds

Thresholds
ThresholdDefaultWhere
A chain multiplier equal to the registry's pending value counts as in effect from this long before the registry's effective time
600 seconds
MULTIPLIER_RULES.effectiveTimeMarginSeconds
A token's values read on chain are stale once the last completed cross-check, or before any, the read of the value shown, is older than
12 hours
MULTIPLIER_RULES.crossCheckStaleSeconds

Values are compared exactly: multipliers as 18-place decimals, effective times as instants, the beacon as the 20-byte address its slot holds.

Terms

None. This method produces figures, not terms.

Evidence

Every value a figure or a notice quotes has an evidence item behind it, but one: the Stock Token beacon a beacon notice compares the slot with is a fixed value of this method, named on this page, and not a read.

  • shares_per_token of a Robinhood token: the registry response (URL, fetch time, SHA-256) and the call uiMultiplier() at its block.
  • pending_shares_per_token, once the chain has been read: the calls uiMultiplier(), newUIMultiplier() and effectiveAt() at the same block. The first two show whether a change is scheduled and its value, and the third gives the effective time the record shows beside it. Its value is null when nothing is scheduled. Before the chain's schedule is read, it is the registry's statement, and its evidence is the registry response.
  • shares_per_token of an Ondo token: the call getSValue(address) on chain 1 (Ethereum) at its Ethereum block, with the Ethereum address as its argument.
  • A registry_chain_mismatch notice: the processed registry response every stored row was written from (URL, the time it was first fetched, SHA-256), which lists the token and states its symbol; the step's own fetch of the registry, made before its chain read, which answered that response again (URL, the time of that fetch, the same SHA-256; for an answer 304, the SHA-256 of the body whose ETag it confirmed); then every chain read the chain's side comes from, all at one block. That is uid() for uid; uiMultiplier() for multiplier; uiMultiplier(), newUIMultiplier() and effectiveAt() for pendingMultiplier, whose chain side quotes a value and its time; and the storage slot for beacon. For uid, multiplier and pendingMultiplier the response also states the registry's side. For beacon it does not, because the registry states no beacon: the side the slot is compared with is the Stock Token beacon, the fixed value this page names above. The second reading reads the same calls, or the same slot, at the same block.
  • A multiplier_scheduled notice: the processed registry response, which states the token's symbol, and the calls uiMultiplier(), newUIMultiplier() and effectiveAt() at one block, which give the current value, the pending value and its effective time. Between the two it cites the step's own fetch of the registry, as a disagreement does. The second reading reads the same three calls at the same block.

A figure keeps the evidence of the read that last changed its value or, for a Robinhood token's shares_per_token, its source: a later read that finds the same value with the same source writes nothing. A source says what the registry states about the value, so when it changes the figure is written again and cites the registry response that states it.

Recomputation

pnpm tool packages/master/recompute.ts --envelope answer.json --rpc <endpoint> calls uiMultiplier(), newUIMultiplier() and effectiveAt() again and compares: the value, and for a pending value the effective time the answer shows beside it. For an Ondo figure pass --ethereum-rpc <endpoint> as well. No free endpoint serves past state, so without an archive endpoint the script re-reads at the head block and says so; a multiplier changed since the figure was read then shows as a mismatch.

Ways to game it, and what the method does

Ways to game it, and what the method does
WayWhat the method does
A throttled or lying endpoint makes the chain disagree with the registry
A notice needs the same answer from a second operator's endpoint at the same block, for a beacon slot as for a call.
An endpoint that shows a schedule the token does not have
A schedule becomes a notice, and is shown on the record, only when a second operator's endpoint answers its three calls the same way at the same block.
A token that copies a Stock Token's functions
It is not in the registry, so it has no multiplier here: see master.listing.
A registry answer that drops many tokens by mistake
A run that would remove more than 10% of the stored tokens fails instead, with that reason, and changes nothing.
A registry, or a cache in front of it, that serves two versions in turn
No notice quotes one version while citing another: every row is written from one response before any cross-check, and the mark of an unfinished write survives a failed run.
A schedule that takes effect between the fetch of the registry and the read of the chain; a registry that goes on stating its old current value after the effective time; or one that already states the new value as current while it still lists it as pending
A chain multiplier equal to the registry's own pending value, read at or after its effective time, is the schedule taking effect, whatever the registry states as current: no notice. A pending value equal to the registry's current value states no change, and is not compared.
A run paused for hours in the middle of its cross-check, while the registry and the chain move on
Every step fetches the registry again before it compares, and compares only against the version that fetch returned.
A registry time written as a date alone or with no offset, which a reader would have to place in a zone of its own choosing
It is not read as a time. The pending pair is not compared, and no notice quotes a time the issuer did not state as an instant.
An endpoint that refuses some items of the Ondo oracle's call, so that a token the oracle knows would read as "not published"
Only a revert the reader read is "not published". An item not read keeps what an earlier read left, with a stale entry that says so, and every answer and revert the call did read is used. A token the oracle has never answered for has no multiplier on its record at all, on its own answer, on its sibling's and on the instrument page.

Limits

  • A step's reads have to fit its budget of 40 outside requests. Its usual reads are four: the registry, the head block, one call for its 20 tokens and one batch for their beacon slots. A second reading is two more. When an endpoint refuses and a read falls back, it costs more. A step whose budget cannot cover its page reads a smaller page and moves on by that many tokens; when not even one token's reads fit, the step fails with that reason and is retried. A second reading the budget cannot cover is not sent: nothing is confirmed in that step, and the next pass, 6 hours later, reads the tokens again.
  • A run over 203 tokens is 11 steps when the registry is unchanged, and 17 when a new version is written first.
  • A pending Ondo multiplier is not read: the oracle's assetData is not called.
  • When the registry states a schedule the chain does not show, the record shows the chain's schedule once the disagreement is confirmed.
  • A registry that answers two versions in turn, step after step, holds the cross-check back: each answer of the other version starts a write, and the cross-check begins again after it. Tokens are compared only in a step whose own fetch returned the version the rows state. Until a pass completes, the tokens show the last cross-check's values, and from 12 hours after the last pass completed, every check of them says their values on chain are stale.
  • A token that a pass did not confirm is said to be stale from the moment that pass completes, not from the step that read it, and until the next pass completes.
  • Values are re-read every 6 hours: a change made and reverted between two reads is not seen.
  • A disagreement is what two reads showed seconds apart: the step's fetch of the registry, then its chain read. When a new multiplier applies on chain with no pending value stated beforehand, and the registry states it only later, the two are published as disagreeing for as long as that lasts.
  • When the registry already states as current a value the chain still only schedules, the two are published as disagreeing on multiplier. The rule above covers a chain that has applied the registry's pending value, not a registry that states the chain's pending value as current.
  • A chain multiplier equal to the registry's pending value is not published as a disagreement within 600 seconds before the registry's effective time, although the chain may have applied it that much early.
  • A pending value the registry states without an effective time, or with one in any form but RFC 3339 with Z or an offset, is never compared with the chain's schedule. If the registry writes its times in another form, no disagreement on a schedule is published until this method reads that form: pendingWithoutTime in the job's state shows it.
  • If the registry writes its pending values in a form this method does not read, no disagreement on those tokens' multipliers is published until it does: pendingUnreadable in the job's state shows it. The recorded response of 2026-11-10 writes multipliers as decimal strings and states no pending value.

What overlaps elsewhere

Robinhood's registry API and Ondo's oracle publish these values. Chainlink's page for its Robinhood feeds, https://docs.chain.link/data-feeds/tokenized-equity-feeds/robinhood.md as read on 2026-11-10, gives a token's price as the underlying price times uiMultiplier(). This method puts the two issuers' values side by side with the reads behind them.