One share. Two tradable halves.
price and yield.

Why you'd need this

Four people, one share, incompatible wishes.

A tokenized stock bundles two different assets into one price. That is fine until you want only one of them, and there is no way to ask for it. Prism exists because these four trades are impossible today and obvious tomorrow.

None of this needs a new asset class. It needs the existing one to stop being sold as a single indivisible number.

How it works

One deposit, one settlement, one redemption.

A full lifecycle with real arithmetic: a share at $100 paying a $1.00 quarterly distribution, one share deposited.

1. 1

   Deposit the share

   You send 1 NVDAt to the vault and it stays there. The vault does not lend it, rehypothecate it, or route it to a strategy. You receive 1 pNVDA and 1 dNVDA in the same transaction.

   deposit(1e18) → 1 pNVDA + 1 dNVDA
2. 2

   Trade the legs apart

   Both tokens are ordinary ERC-20s with their own pools. The market prices them independently: the principal leg tracks the share minus its future income, the dividend leg tracks that income. Their sum should track the share, and where it does not, that gap is the arbitrage.

   pNVDA ≈ $96.20  ·  dNVDA ≈ $3.80  ·  Σ ≈ NVDAt
3. 3

   The distribution arrives

   No cash moves and your balance does not change. The token's uiMultiplier() rises by 1%, the real share price falls by 1%, and the total-return feed does not move at all. That multiplier step is the distribution, so the vault reads it from the token instead of waiting for money that never arrives.

   uiMultiplier 1.000000 → 1.010000 · feed continuous → INCOME
4. 4

   The step routes to one leg only

   The 1% accrues to dNVDA holders. pNVDA receives nothing, which is correct: the real share it tracks is worth 1% less than it was. Entitlement follows the token, so it survives a transfer — sell your dNVDA and the buyer inherits the unclaimed accrual.

   incomeIndex ×1.01  ·  price leg unchanged
5. 5

   Swaps during the gap pay the LPs

   Between the multiplier moving and settlement landing, the pool's books and the token disagree. A hook replaces the 0.30% static fee with a surge fee scaled to the unexplained gap, so the arbitrageur who came to extract that gap funds it instead. Adding liquidity is blocked outright until anyone calls poke().

   currentFee() = BASE_FEE + gapBps × surgeMultiplier / 100
6. 6

   Redeem whenever you hold both

   Burn 1 pNVDA and 1 dNVDA together and the original share comes back. No maturity, no rollover, no expiry. The two halves are always worth exactly one share, which is what makes the arbitrage between them enforceable rather than hopeful.

   redeem(1e18) → 1 NVDAt

What the bytecode shows

Both legs already exist inside the token.

Every stock token on this chain is a beacon proxy over one implementation exposing uiMultiplier(), effectiveAt() and oraclePaused(), and emitting exactly one corporate-action event. Three properties fall out of reading it.

// UIMultiplierUpdated(old, new, effectiveAt)
old         1.000000000000000000
new         1.002208724969205741
effectiveAt 1788534626

That last line is the whole opportunity. The price leg and the income leg are already separated inside every one of these tokens. They are multiplied together into a single quote, and nobody trades them apart. Prism does not have to invent the decomposition, only expose one that already exists. effectiveAt() is the bonus: corporate actions are announced before they land, so a vault knows what is coming and when.

The problem

A pool prices from a number the action never touches.

An AMM quotes from balanceOf(). A corporate action here does not move balances, it moves a global multiplier. So the pool quotes yesterday for the block after the action lands, and whoever crosses first takes the difference out of LP inventory. Every distribution. Forever.

Prism settles the multiplier before the pool has to answer for it.

The hook

LPs get paid for the gap instead of paying it.

The hook reads the vault's reconciliation state on every swap. While the pool and the token disagree, the static fee is replaced with a surge fee scaled to the unexplained gap, so the value an arbitrageur came to extract is charged to them and paid to the LPs. Liquidity cannot be added to an unreconciled pool at all, and anyone can clear the state with one permissionless poke().

// StripHook.sol
function currentFee() public view returns (uint24) {
    if (!vault.unsettled()) return BASE_FEE;              // 0.30%
    uint256 gapBps = unexplainedGapBps();
    uint256 surge  = BASE_FEE + (gapBps * surgeMultiplier) / 100;
    if (surge > MAX_SURGE_FEE) revert GapTooLarge();      // refuse, don't guess
    return uint24(surge);
}

Live

Run the classifier yourself.

The multiplier model, running live in your browser with integer WAD arithmetic — the same code path the test suite asserts against. Move the inputs and watch the verdict change. Note what a 4-for-1 does: it looks exactly like a distribution, so it stops at a human.

Network

Connect and read the chain.

The panel reads live chain state over JSON-RPC without a wallet. Point the vault field at any deployed vault and it will read that vault's real settlement state, including whether escrow matches accounting.