One share in, two tokens out.

01The split

Stock tokens on Robinhood Chain never pay out cash. When a company pays a dividend, the issuer reinvests it for every holder at once by raising the token's uiMultiplier(). Raw balances do not move. Each token simply stands for a little more stock than it did the day before, and that quiet climb is income. Jevstocks gives that income a token of its own.

Everything happens inside a series: one stock token and one maturity date, named by a tag such as AAPL-DEC27. Deposit the stock and the series vault mints two ERC-20s in equal amounts:

• pTOKEN, the principal leg (pAAPL-DEC27). The share with its dividends peeled off until maturity. It trades a little below one share, and at settlement it redeems for the share count you deposited, measured when the series began. In bond terms it is a zero coupon bond made out of equity.
• yTOKEN, the yield leg (yAAPL-DEC27). Every dividend the deposit earns before maturity, and nothing else. It costs a small slice of the share price, carries no leverage and cannot be liquidated. At settlement it redeems for the extra stock those dividends added, less a 5% fee on that extra.

Merge is the way home. One pTOKEN plus one yTOKEN always turns back into one stock token. It works while the series is active, after it matures and after it settles, and it never charges a fee. Because that door never closes, the two legs cannot wander far from the share they came from.

02Where the idea comes from

Separating an asset from the income it throws off is one of the oldest moves in finance. Bond dealers do it every day, a family of 1980s trusts did it to blue chip shares, and futures exchanges list contracts on nothing but dividends. Jevstocks makes the same cut on stock tokens.

• Treasury STRIPS, 1985 onward. Under the STRIPS program a US Treasury note or bond can be separated into its principal payment and each of its interest payments, and every piece then trades as its own zero coupon security. A principal strip sells below face value and pays face value at maturity. The pTOKEN has the same shape: you hold the asset without its income and collect the full principal at the end.
• PRIMES and SCORES, 1983 to 1992. The Americus Trusts took in shares of large US companies and issued two units against each share, listed on the American Stock Exchange. The PRIME collected the dividends and the price gains up to a cap, and the SCORE took whatever gain ran past that cap. A PRIME and a SCORE turned in together came back out as the share. It is the nearest equity ancestor of Jevstocks, with the knife in a different place: Jevstocks cuts income away from principal instead of cutting the price at a cap.
• Dividend futures. Eurex lists futures on the dividends of index members and of single stocks, and CME lists futures on S&P 500 dividends. Each contract settles on the cash dividends actually paid over a fixed window, which is the exposure an yTOKEN holds. Those contracts sit behind futures accounts and margin rules. An yTOKEN is an ERC-20 in any wallet.

What Jevstocks changes is the plumbing. The split is self-serve, the bookkeeping reads the token's own multiplier on chain, and a matched pair merges back into the stock at any moment, with no trust to wind up and no desk to call.

03The math

Every stock token gets one accountant. It keeps a dividend index d that starts at 1 and is multiplied by each classified dividend, and by nothing else. Stock splits go into a separate split factor, so they never touch d. A series writes down d0, the index on the day it was created, and at settlement it freezes dT, the index in force at maturity.

// split(a), only while ACTIVE
fee    = a × splitFee
minted = a - fee
// you receive minted of each leg
// splitFee = splitFeeBps / 10000

// merge(a), any state, free
a pTOKEN + a yTOKEN  ->  a stock

// after settle(), redeeming a
pTOKEN out   = a × d0 / dT
yTOKEN gross = a × (dT - d0) / dT
yTOKEN fee   = gross × yieldFee
yTOKEN out   = gross - fee
// yieldFee = yieldFeeBps / 10000

// the legs add back to the deposit
d0/dT + (dT - d0)/dT = 1

// in wei, divisions round down
sum = pTOKEN out + yTOKEN gross
a - 1  <=  sum  <=  a

Rounding always favours the vault. Every division in the vault rounds down, so redeeming a of each leg pays out exactly a, or one wei less when both results round. The vault can never owe more stock than it holds. A split mints a minus the fee, never more than it took in, and the vault checks that it received exactly the amount it asked for.

A worked example

Illustrative numbers, not a forecast. Launch series start at d0 = 1 because their accountants are created in the same deployment.

// split 100 AAPL at 10 bps
fee    = 100 × 0.001 = 0.1 AAPL
minted = 99.9 pAAPL + 99.9 yAAPL

// say d0 = 1 and dT = 1.004
pAAPL out   = 99.9 × 1 / 1.004
            = 99.50199 AAPL
yAAPL gross = 99.9 × 0.004 / 1.004
            = 0.39801 AAPL
yAAPL fee   = 0.01990 AAPL
yAAPL out   = 0.37811 AAPL

The 99.50199 AAPL tokens the principal gets back are worth 99.9 tokens as they stood at d0, which is exactly what was split. The dividend growth on top, 0.39801 AAPL, belongs to the yield leg, and the treasury keeps 5% of it.

A stock split changes the multiplier and the split factor but leaves d0 and dT alone, so both legs keep the same raw token amounts and the split washes straight through. While a series is active, previewRedeemPT, previewRedeemYT and accruedDripFactor use today's index, so they show what has accrued so far. Once it matures they use the index in force at maturity, because a dividend after that belongs to no one in the series. Those are estimates until dT is frozen.

04Fees

Fees are fixed per series. The factory owner can change the split and yield fee with setFees, only up to the hard caps of 50 bps and 1000 bps, and only for series created afterwards. Each vault copies both fees the moment it is created and keeps them for life, so nobody can raise the fee on a series you already hold.

Where fees go. Both fees are paid in the stock token itself, straight to the treasury address the factory names at that moment. If the stock token refuses that transfer, the fee waits in the vault as unclaimedFees instead of blocking the split or the redemption, and anyone can send it on later with claimFees(). What happens after that is treasury policy, not contract code: the plan is to put fees back to work as liquidity in the series pools and, once $JEVSTOCK is live, to spend a share of them buying $JEVSTOCK on the market and burning it. No contract enforces either part, so judge the policy by the treasury's public transactions.

Swaps pay the ordinary Uniswap pool fee, 0.05% on pTOKEN/stock and 1% on yTOKEN/stock. That fee goes to whoever provides the liquidity, not to Jevstocks.

05The pools

Each series gets two Uniswap v3 pools on Robinhood Chain, and both are priced in the stock itself: pTOKEN/stock on the 0.05% fee tier and yTOKEN/stock on the 1% tier. There is no dollar side. Every pTOKEN and yTOKEN price in the app is read from those two pools.

• Why pair with the stock. An pTOKEN is the same share minus a thin slice of dividends, so measured in the stock it hardly moves: it sits a little under 1 and drifts up to 1 as maturity gets close. When both sides of a pool move together, liquidity providers suffer much less impermanent loss, and nobody in the pool ends up short a rally in the share.
• Fair value. Call G the whole dividend growth of the series, dT / d0 - 1. Part of it has already happened and the rest is a forecast, so every fair value below is an estimate, never a quote.

// G = dT / d0 - 1
pTOKEN fair ≈ 1 / (1 + G)
yTOKEN fair ≈ G / (1 + G)
// less 5% of it if you redeem

• The pair polices itself. Splitting turns one stock into 0.999 of each leg, and merging turns one of each back into a full stock for free. When the pools price pTOKEN plus yTOKEN clearly above one stock, splitting and selling both legs pays. When they price the pair below one stock, buying both and merging pays. Whoever makes either trade pockets the gap and closes it, so the pair stays close to one share without anyone's permission. How close depends on the 10 bps split fee, the two pool fees and how deep the pools are.
• Tiers and ranges. The pTOKEN pool uses the 0.05% tier because its price moves slowly in a narrow band. The yTOKEN pool uses the 1% tier and a wide range, because a small token with a forecast inside it swings much harder in percentage terms. The seeding script's default ranges run from 1.5% under fair value to 0.1% over par for pTOKEN, and from a quarter of fair value to four times it for yTOKEN.
• Who provides liquidity. At launch the treasury seeds the first positions from its own stock with seed-pools.sh. After that anyone can add liquidity: the app's Liquidity tab mints, lists and removes positions, and because these are ordinary Uniswap v3 pools, any tool that talks to the position manager works too. Swap fees go to whoever holds the positions.

No Jevstocks pools exist yet. They are created after the contracts are deployed, so until then the app has no pTOKEN or yTOKEN prices to show.

06Dividends vs stock splits

The multiplier goes up for two very different reasons. A dividend adds value, and that value belongs to the yTOKEN. A stock split adds nothing: there are more shares and each one is worth less. Confusing the two would hand value from one leg to the other, so the accountant sorts every change with rules the contract checks on each call. Write r for the new multiplier divided by the old one.

• Dividend when 0 < r - 1 ≤ 3%. Exactly 3% passes and one wei more does not. sync() books an in-band dividend the moment it sees it, and anyone can also call classifyDividend().
• Stock split when r is a clean ratio num:den with both terms from 1 to 50 and at least 20% away from 1, in either direction. 2:1, 3:2, 7:1 and 1:10 qualify; 23:20 sits too close to 1 and does not. Anyone can call classifySplit(num, den).
• The bands never overlap. Nothing can be a dividend and a split at the same time, so calling the wrong classifier simply reverts. The only way a keeper can fail is by showing up late.
• Everything else waits for the guardian. A special dividend above 3%, an odd ratio, or a drop that is not a clean reverse split. The accountant queues up to four waiting moves, oldest first, each with its own date; a fifth folds into the last entry and marks it collapsed. For the oldest move the guardian proposes how much of it was dividend, and the ratio has to explain the move: no dividend, the whole move (only from 1/1.03 up to 1.2), or at most 3% inside a clean split. The split factor absorbs the rest. The proposal sits in public for a 2 day timelock before anyone can execute it, and the guardian can cancel it.
• Nobody can stall a move forever. Once a move has waited 14 days since it was recorded, anyone can call executeResolution() to book the default: a rise under 20% counts as a dividend of the whole move, anything else as none. A proposal made in time still runs its full timelock first.

// dividend
new > old
new × 10000 <= old × 10300

// split num:den
1 <= num, den <= 50
|new × den - old × num| <= den
num/den >= 1.2 or num/den <= 0.8

// guardian ratio for the oldest waiting move
ratio = 1, or
1/1.03 <= ratio <= 1.2 and |old × ratio - new| <= old, or
1 <= ratio <= 1.03 with a clean num:den split left over

While a move is waiting, isSynced() returns false in the same block the multiplier moves, because it reads the token live on every call. During that window no new series can open on the stock. The principal oracle keeps pricing, counting any waiting rise as a dividend, and stops only for a move the size of a split. Settlement waits only for moves dated on or before maturity. Split, merge and trading keep working.

Every classification writes a checkpoint, a timestamp and an index, that anyone can read back with checkpointAt(i), and every step emits an event. The full history can be rebuilt from the chain alone.

07Lifecycle

A series moves one way through three states, read from state(). Nothing can send it back.

1. ACTIVEstate 0

   now < maturity

   Split while splits are not paused and the deposit cap has room. Merge, trade and provide liquidity.

2. MATUREDstate 1

   maturity passed, not settled

   No new splits. Merge and trading continue, and anyone can call settle().

3. SETTLEDstate 2

   dT frozen for good

   Redeem pTOKEN and yTOKEN at the formulas in 03. Merge still works.

Settlement is permissionless and patient. Once the maturity timestamp passes, anyone can call settle(). It first calls sync() on the accountant, which records any new multiplier change and books an in-band dividend on the spot. It goes on once every move dated at or before maturity is booked (isFinalAt(maturity)), sets dT = dividendIndexAt(maturity), never below d0, and never changes it again. A move still waiting but dated after maturity does not hold it up. If the stock token ever stops answering uiMultiplier(), the series settles on the index already booked 30 days after maturity.

Maturity is a timestamp, not a block. Every recorded change carries a time. When the token's own schedule explains the change, meaning its newUIMultiplier() matches and its effectiveAt() has passed, the accountant dates the change by effectiveAt instead of by the block that noticed it. A scheduled dividend that took effect before maturity counts toward dT even if nobody synced until afterwards, and a change that took effect after maturity never does. A change no schedule explains happened some time between the accountant's last look and now: it is dated now, unless a series of that stock matured inside the window, and then it is dated just after the last look, so a dividend paid before maturity is never dropped for want of a keeper. One sync() at or after each maturity keeps later changes on the right side of it, and the app offers that button.

New series need a maturity at least 7 days out. The launch series mature on Dec 31, 2027 (AAPL, SPY, QQQ) and Dec 31, 2027 (PFE); the exact timestamps are listed in 09.

08$JEVSTOCK

$JEVSTOCK is the Jevstocks community token. It launches on ponsfamily.com, and its contract address is posted here and on the landing page at launch, not before. Until then no token calling itself $JEVSTOCK is ours.

• Separate from the series. No vault, accountant, pTOKEN or yTOKEN reads $JEVSTOCK, and you never need it to split, merge, trade or redeem.
• Fees and $JEVSTOCK. Once it is live, treasury policy is to use a share of protocol fees to buy $JEVSTOCK on the market and burn it. That is a decision of the treasury, not something any Jevstocks contract does, and the only way to check it is to watch the treasury's transactions.
• Nothing more is promised. $JEVSTOCK does not lower your fees, does not vote on anything inside the contracts, and gives no claim on the stock a vault holds.

09Contracts and scripts

Jevstocks is five contracts. JevFactory keeps the list and the admin settings. JevAccountant follows one stock token's multiplier. JevVault is one series and creates its two JevToken legs, plain ERC-20s with permit and 18 decimals that only their vault can mint or burn. JevPtOracle prices an pTOKEN for a lending market. Every table below is built from this site's config, so the page changes the moment a deployment is recorded.

Jevstocks contracts

Who can do what

Robinhood Chain contracts Jevstocks uses

Scripts the deployer runs

Deployment happens by hand in a terminal, signed by whoever holds the deployer key. This website never asks for a key and cannot run any of these. Every script simulates first and sends nothing until you type a confirmation word.

1. deploy.sh runs the contract tests, prints the plan (the factory, 14 accountants and the 4 launch series with their deposit caps), simulates against Robinhood Chain and checks the deployer balance against the gas estimate. Only after you type deploy does it broadcast. It then reads every contract back, submits the source to Sourcify, writes a deployments file and rewrites the deploy block in this site's config, which is what flips these docs from planned to live. Default caps are 770 AAPL, 330 SPY, 350 QQQ and 9,100 PFE, roughly $250k of stock each at September 2026 prices.

# from the repository root
cd contracts
./deploy.sh
# optional caps, in whole shares
CAP_AAPL=770 CAP_SPY=330 \
  CAP_QQQ=350 CAP_PFE=9100 \
  ./deploy.sh
# over an existing factory
REDEPLOY=1 ./deploy.sh

2. tools/abi.mjs regenerates the ABI module the pages import from the fresh build. With --check it fails when that module is stale.

node tools/abi.mjs --check
node tools/abi.mjs

3. seed-pools.sh splits some of the treasury's stock, creates and initialises the pTOKEN/stock and yTOKEN/stock pools at a fair price from an assumed remaining drip, and mints one position in each. A dry run prints the assumption, both ranges and exactly how much stock it needs. It refuses to send anything when the wallet holds less, and it waits for you to type seed.

cd contracts
DRY_RUN=1 SHARES=10 \
  ./seed-pools.sh AAPL-DEC27
SHARES=10 \
  ./seed-pools.sh AAPL-DEC27

4. create-market.sh deploys a JevPtOracle for a series and opens a Morpho Blue market that lends USDG against the pTOKEN at a 62.5% LLTV with the Adaptive Curve IRM. The oracle prices one pTOKEN as the stock feed times what it redeems for in stock, d0 / d discounted for the time left to maturity and capped at one share; no pool price goes in. The script refuses unless the IRM and LLTV are enabled, the market uses the launch values, the accountant is synced, the feed has 8 decimals, names the stock and is fresh and positive, and the principal pool holds real depth with a large enough observation ring and TWAP history at least 30 minutes old. It waits for you to type create.

cd contracts
DRY_RUN=1 \
  ./create-market.sh SPY-DEC27
./create-market.sh SPY-DEC27

Source verification goes through Sourcify during deploy.sh. Nothing is deployed, so nothing is verified yet.

10Risks

• Unaudited at launch. The contracts have unit, fuzz and invariant tests and a full lifecycle run on a fork of Robinhood Chain, but no outside firm has audited them. Size positions with that in mind.
• Smart contract bugs. A flaw in the vault, accountant, tokens or oracle could lock or misprice funds. No admin function can move a vault's stock, which also means nobody can rescue it, or stock sent to a vault by mistake.
• Issuer and custody. Every series rests on a stock token and on the company that issues it: that it holds the shares, reinvests dividends faithfully through the multiplier, and keeps the token running. The token has a pause switch Jevstocks cannot override, and while it is on, stock may not move into or out of a vault. An yTOKEN tracks the dividends the issuer reinvests. It is not a claim on cash dividends or on shares.
• Classification. Changes inside the bands sort themselves by rule. Anything outside them depends on the guardian's judgment, bounded to the move itself, visible for 2 days before it executes, and replaced by a fixed default after 14 days. If you disagree with a proposal, merge out during that window if you hold both legs, or sell in the pools if you hold one.
• Liquidity. New pools start thin. A large trade can move the price a lot, and leaving one leg early means selling into whatever depth exists. The app shows pool balances beside every quote and will not offer a quote that runs into them. Merge and redemption never touch the pools.
• Oracle and lending. An pTOKEN lending market prices collateral from a stock feed times the principal's redeem value, d0 / d discounted for the time left. No pool price goes in. A stale feed, a feed that has not updated since a split, or a split-sized move nobody has classified halts that price, a fixed discount can sit away from where the pool trades, and a Morpho Blue market liquidates without asking. No market exists until a series has a pool with price history.
• Caps and pauses. Each series has a deposit cap and the owner can pause new splits. Neither can stop merge, settlement or redemption.

11FAQ