the field named multiplier
1.0130866005227463
The old value. Token-2022 keeps the multiplier from before the most recent activation here, and it's the field you'd reach for first.
Type any xStock. The desk reads its mint on mainnet and shows you both multipliers side by side, what your wallet shows against what you actually own, the tax taken before your dividend was reinvested, and whether a trade should settle right now. Below that, the deployed program answers the same question itself.
01/ a real xStock, held
A real mint on mainnet, read live. The verdict applies the program's settlement_window rule right here in your browser; the devnet desk asks the deployed program directly.
the field named multiplier
1.0130866005227463
The old value. Token-2022 keeps the multiplier from before the most recent activation here, and it's the field you'd reach for first.
the live value, in the field beside it
1.017648970535191
In force since 2026-08-15T00:30:00Z. These two disagree, which is the trap.
what your wallet would show
1.013087
Your raw amount times the field named multiplier. This is the number a wallet that read the obvious field puts on screen.
what you own
1.017649
Your raw amount times the live value. The difference between these two is what one corporate action is worth to you.
your raw amount
Base units, as the mint stores them. 8 decimals on this token, so the default is one share.
the dividend, reinvested
3
How many times the issuer's feed has moved this token. The dividend is reinvested, not paid: your raw balance never moves, the multiplier does.
per share, gross to net
3.09
The feed's gross cashflow per share, against the 2.163 the multiplier actually reinvests. The gap is the withholding.
withheld at 30%
0.927
Per share, taken before reinvestment. Across this token's whole float it's $112,965, and nothing a holder looks at ever reports it.
withheld on your holding
0.927
The same rate applied to your raw amount above, at this token's decimals. This is the number your wallet never shows you.
at 159.09 USD a share
XsaHND8sHyfMfsWPj6kSdd5VwvCayZvjYgKmmcNL5qh
The mint account this is read from, live, over plain RPC with no key.
the program's two numbers
39.4 days ago · nothing staged
Seconds since the last activation, and seconds until a staged one. -1 is "nothing to report", because 0 is a real answer and means 1970.
Read over plain RPC from https://solana-rpc.publicnode.com, with the build from 2026-09-23 09:53:57 UTC as the fallback.
02/ every xStock the issuer has moved
Every xStock whose multiplier has moved, by a dividend or a split, read from its mint on mainnet the moment this page opens. The widest gaps are splits, where the field named multiplier is off by the whole ratio. Sort by any column, or pick a dividend row to open it above.
| ticker | field named multiplier | live value | gap | in force since | withheld, whole float | settle now |
|---|
03/ the devnet desk
These are the mints this program has registered on devnet, and there are 6 of them. A dot marks one where the field named multiplier and the live new_multiplier disagree, which is exactly the trap.
multiplier
1
The field you'd reach for first. Token-2022 keeps the value from before the most recent activation here.
new_multiplier
1.0042
Live from 2026-09-16T17:02:02Z, and the value the program applies. These two disagree, which is the trap.
mint account
5N7aHZRBfQ92y4NBjwKx2EKzvFCaUPZRzReA8gRAQCjR
token record
7MupvMRPG1RCmxsy1xGM9nM3a1mhprNSZv241mrjX1BV
activations recorded
1
Receipts this program has written for this mint.
The two fields are read from the mint's own scaledUiAmountConfig extension. The rule for which one is live is Token-2022's: new_multiplier once its timestamp has passed, multiplier otherwise. This page applies that rule to say what a naive reader would get, and then asks the program for its own answer below, so the two are compared rather than asserted.
04/ what a holding is worth
One question, asked two ways. Once of the deployed program, through its read_entitlement instruction, and once by multiplying the raw amount by the field named multiplier, which is what a wallet that trusted the obvious field would show.
the obvious read
1
raw × multiplier, which is the previous value.
the program's answer
1.0042
read_entitlement, signed by nobody, executed by the deployed program on devnet.
the difference
0.0042
raw × 1 against the program's own answer.
// the whole question, as the page sends it instruction read_entitlement(raw_amount: u64) accounts mint, token_record // both read-only signed by nobody. sigVerify: false, nothing is spent. answered by ycg2obpKmccwAz1zGf4QqgV2vnkWd6CQKLdJSGDxtmG returned 0x00000000000000000000000005fc49a0 // little-endian u128, the program's own bytes
05/ whether to settle
The issuer's own docs ask venues to pause around each activation, and nothing in a mint account can make them. The program's settlement_window instruction returns two numbers: seconds since the current multiplier took effect, and seconds until one the issuer has staged. Both use the validator's clock, not yours, so the answer is the same from any machine.
That second number is something the mint can't tell you. The issuer stages the next value about four hours ahead, and staging overwrites the timestamp of the value in force, so for those hours the mint has no idea when the live multiplier started. This program's own record does, and the first number is where you see it.
since the last, until the next
96,724s ago · nothing staged
Two little-endian i64s. Either is -1 when there is nothing to report.
the venue's rule
±15 min
Hold within 900 seconds either side of an activation. That's this desk's policy; the program supplies both numbers it's applied to.
the raw answer
d479010000000000ffffffffffffffff
The program's return data, unedited. Sixteen bytes, two i64s.
// settlement_window: two numbers, because the issuer's window is two-sided let since = if live.staged_at == 0 && live.effective_at > 0 { now - live.effective_at // the mint can answer this one itself } else if record.live_effective_at > 0 { now - record.live_effective_at // the mint overwrote it; the record kept it } else { -1 }; let until = if live.staged_at > 0 { live.staged_at - now } else { -1 }; // A venue holds while either is inside 900.
06/ the trail
A mint keeps the latest two multipliers and nothing older. No sequence, no account per activation, so the history of what a token paid lives in an HTTP API and in transaction logs. These are the receipts this program wrote, one per activation, and every machine that reads them sees the same thing.
| seq | activation | before | after | change | effective | recorded | raw supply |
|---|---|---|---|---|---|---|---|
| 0 | moved | 1 | 1.0042 | +0.0042 | 2026-09-16T17:02:02Z | 2026-09-16T17:02:03Z | 100,000,000 |
1 receipt for this mint, written in order and never changed. Read from the program's own accounts, not from an index.
07/ the reference price
Everything above reads the issuer's own mint account, so on its own it's the issuer agreeing with itself. verify_against_pyth checks against a price this program doesn't control. It refuses for three reasons: the account isn't a Pyth price, the price is for a different feed, or the price is older than the caller allows.
| mint | feed bound | newest account | published | age | the program |
|---|---|---|---|---|---|
| DEMOx · 5N7a… | AAPL | DJgUxxLVN1QxAXykPzpH5Kz5feo1bTCBDipGRUYYqMw | 2026-08-14T20:00:19Z | 34.0 days | StalePythPrice |
| DEMOx · 8RUM… | SOL | 7UVimffxr9ow1uXYxsr4LHAcV58mLzhmwaeKvJ1pjLiE | 2026-09-17T19:53:02Z | 1.5 minutes | accepted |
| DEMOx · DoF9… | SOL | 7UVimffxr9ow1uXYxsr4LHAcV58mLzhmwaeKvJ1pjLiE | 2026-09-17T19:53:02Z | 1.5 minutes | accepted |
These rows are the program's answers as recorded on 17 September 2026. The caller settles at exactly Pyth's own price, so the deviation is zero and age is the only thing that can cause a refusal. At the time, devnet's equity publisher had been silent since 14 August, so the newest stock price on the cluster was weeks old while a crypto feed updated every second. Same instruction, same cluster; the only difference is age.
08/ how this page talks to the chain
Everything on this page came from your browser talking to api.devnet.solana.com with fetch. Nothing was signed and nothing was spent.
The page builds Solana's wire format by hand: a compact-u16 signature count, a zeroed 64-byte signature, the message header, the account keys in the order the header needs, then the instruction. No web3.js and no CDN, which is also why the page opens straight from a file on disk.
The simulations run with sigVerify: false and replaceRecentBlockhash: true. The runtime still requires an account in the fee slot, so the page uses one whose key is the sha256 of a fixed public string and was never generated. It cannot be spent from.
Every figure is already in the page, so it reads correctly with JavaScript off or from a file on disk. The script re-reads the chain and swaps in live values. If a read fails, the page says so and keeps the recorded values rather than going blank.
// what the page sends, in full POST api.devnet.solana.com {"method":"simulateTransaction","params":["<base64 transaction>", {"encoding":"base64","sigVerify":false,"replaceRecentBlockhash":true}]} // fee slot, so the runtime will load it. The key was never generated: // sha256("record-date settlement desk fee payer v1") payer 9GwUYoXLix8k27MjwnYFqzwsn4bKD2tZf5Dcz9ydp9vX
The program is deployed at ycg2obpKmccwAz1zGf4QqgV2vnkWd6CQKLdJSGDxtmG and its accounts are readable at that address. The receipt accounts below are real devnet accounts and each one links to the explorer.