Integration checklist for Coinbase tokenized stocks on Base

We recorded 13 Coinbase stock feeds over 100 days. All 182 weekends in that data had no round for at least 48 hours. An ordinary weekend ran 48.0 to 58.3 hours with a median of 52.2. Over Labor Day the gap was 74.5 to 81.6 hours. The feeds came back at Sunday 8 PM New York, within two minutes, on all 169 ordinary weekends.

Through all of it latestRoundData() keeps answering with Friday's price and Friday's updatedAt. Nothing reverts. Base's docs describe the same behaviour (24/5, value held on nights, weekends, holidays and corporate action pauses) and tell integrators to "never settle or liquidate against a frozen feed".

Check: every price read looks at updatedAt. For each function that uses a price, write down what it does when the price is old: revert, wait, or fall back. Settlement, liquidation and any swap at the oracle price should not run on a held value. Add a test that warps to a Saturday.

These feeds publish on a 0.5% price move or a 24 hour heartbeat. A quiet stock can go most of a trading day without a round. Share of time the newest round was older than the bound, with the weekend gaps taken out:

The longest gap that was not a weekend ranged from 7.0 hours (MSTR) to 24.0 hours (GOOGL, MSFT).

Check: a bound a little above 24 hours keeps the trading week open. Anything shorter rejects live weekday prices. A staleness bound on its own also cannot tell a quiet Tuesday from a Saturday morning: with a 25 hour bound, a round from Friday 14:21 UTC still passes at Saturday noon. If that matters to you, add a market hours check and keep the staleness bound as the backstop. In our data the feeds published from Sunday 8 PM to Friday 8 PM New York and skipped the Labor Day holiday.

On 111 of the 182 weekends, the last round before the weekend was published before the 4 PM New York close on Friday. The earliest was 13:41 UTC on a Friday, more than six hours before the close. Since a round needs a 0.5% move, the held value can be up to 0.5% away from the last trade even when it is recent.

The price on the first round after the weekend differed from the held one by a median of 48 bps. The largest we saw was 410 bps (INTC, weekend of 11 September 2026).

Check: if an option, loan or auction expires at the Friday close and settles on "the first round at or after expiry", it will usually settle on Sunday night's price, about 52 hours later. If you want Friday's price, put the expiry inside the trading day or settle on the last round before expiry. If you keep the first round after, say so in the product, because holders carry the weekend.

For TSLA, NVDA and GOOGL there is a second Chainlink feed whose description() ends in (24/7). Their first rounds are from 4 and 5 November 2026 and they do print on weekends. On Saturday 14 November 2026 at 17:48 UTC:

Base's docs table lists the ten 24/5 feeds. We have not found the 24/7 feeds described there, so we do not know what they price on a weekend or how they are meant to be used.

Check: pin the feed by address and assert its description() in a test. Use the same feed for pricing and for settlement. Ask Base or Chainlink before you rely on a 24/7 feed.

The Coinbase feeds report a total return value: the share price times the token's multiplier (see item 11). GOOGLc's multiplier is 1.000377 today, so the GOOGL feed sits 0.04% above the share price, and that difference grows with each dividend.

Check: token amount times feed price is the value. Do not apply the multiplier a second time. If you take a share price from a stock data API, multiply it by the multiplier to get the token price. A strike or limit quoted "per share" is a different number from one quoted per token.

During a corporate action the feed's pause flag is set and its price goes stale, on a weekday, while transfers of the token are not paused. The feed resumes once both the price and the multiplier reflect the new values. So your contract can keep taking deposits, trades or liquidations against a frozen price in the middle of the week.

Check: the same guard as item 1 covers this, as long as it is a staleness bound and not only a weekend calendar. Run the Saturday test on a Wednesday timestamp as well.

Coinbase's public token list returned 358 stock tokens on 14 November 2026. Twelve of them carried a NAV price. Base's docs list ten Chainlink feeds.

Check: keep an explicit list of tokens that have a feed and reject the rest. Do not fall back to a DEX spot price for a token without one. Base's docs note that the token's DEX price does not feed the oracle, and a thin pool is cheap to move.

A Chainlink proxy numbers rounds as (phase << 64) | round. The TSLA feed moved from phase 1 to phase 2 in August 2026 and the two phases overlap in time. getRoundData for a round that does not exist inside an existing phase returned all zeros and did not revert. For a phase that does not exist it reverted with no data.

Check: treat updatedAt == 0 as "no round". Do not walk rounds with roundId - 1 across a phase change. If anyone can supply the round you settle on, verify it: the round before it is older than the expiry and this one is at or after it.

This one is not specific to stocks, but it is easy to drop when the staleness logic gets rewritten. Chainlink's guidance for L2 feeds is to read the sequencer uptime feed and wait out a grace period after a restart. On Base that feed is 0xBCF85224fc0756B9Fa45aA7892530B47e10b6433 (its description() reads "L2 Sequencer Uptime Status Feed").

Check: the price path reads the uptime feed before it trusts a round.

The stock tokens are B20 precompiles inside the Base node. eth_getCode at TSLAc (0xb2000000000000000000001e800a7f5189430cD0) returns one byte, 0xef. There is no per token contract and no verified source on Basescan. On a stock Foundry fork that byte is all there is: with anvil 1.5.1 a call to the token failed with OpcodeNotFound, and inside forge test the call burned all the gas it was given.

Check: your fork tests really execute the token. Use Base's base-std mocks or base-anvil. To run against the real precompile without a key, send one eth_call with a state override that puts your test contract's code at an unused address. That worked for us on three public Base RPCs. Do not gate anything on the token's code size or code hash.

Dividends are reinvested and stock splits are applied through a multiplier. balanceOf, totalSupply, transfer amounts and allowances stay in raw token units and do not change. The number of shares a balance stands for is raw * uiMultiplier() / 1e18.

This is already live. On 14 November 2026, 9 of the 358 listed tokens had a multiplier other than 1, for example NVDAc at 1.00054, SANc at 1.0106 and PMc at 1.5588. GOOGLc's uiMultiplier() read 1000377118676784179 on chain.

Check: keep all accounting in raw token units and price them with the token's feed. Convert to shares only for display, with toUIAmount. Search the code and the front end for anything that assumes 1 token equals 1 share. Read the multiplier when you need it and do not cache it: a scheduled change takes effect at effectiveAt with no transaction and no event at that moment (UIMultiplierUpdated fires earlier, when the change is scheduled), and an instant update path also exists.

All 358 listed stock tokens report 8 decimals, and the feeds return 8 decimals too. The B20 standard allows 6 to 18, so a later token could differ.

Check: read decimals() and look for 1e18 constants in share and price maths. Check the rounding direction of every division, and test with a deposit of one raw unit.

Each transfer is checked against a policy for the sender, the receiver and the caller. On TSLAc all three scopes point at policy id 5 in the policy registry (0x8453000000000000000000000000000000000002). If any of the three is not authorized the transfer reverts with PolicyForbids(scope, policyId). The list is edited in the registry by the policy's admin, so the token itself emits nothing when an address is added.

Check:

• One blocked recipient must not stop everyone else. Avoid loops that push tokens to many users. Let each user claim, or catch the failed transfer and hold that amount for them.
• A liquidation or settlement that pays a blocked address should park the payment, not revert.
• approve is not gated by policy or by pause. A good allowance does not show that a transfer will go through.
• isAuthorized(policyId, account) never reverts, even for a policy id that does not exist. Call policyExists first.
• If your own contract is blocked, deposits and withdrawals both revert and no code path fixes it. Say that in your risk section.

B20 has seizeWithMemo, which moves a balance from a holder to another address with no allowance and without the transfer policies. An account is seizable when the token's seize exempt policy does not authorize it. On TSLAc that scope is set (policy id 129). A fresh address and our own vault both read as exempt today.

Check: do not assume balanceOf(address(this)) is always at least your internal total. Decide who carries a shortfall. Share based accounting spreads it across holders. Fixed claims pay the first withdrawers in full and leave the last ones short.

B20 pauses four features separately: transfer, mint, burn and seize. A paused transfer reverts with ContractPaused, while approve keeps working. Base's docs call an onchain pause unlikely. On TSLAc none of the four was paused when we read it.

Check: list every deadline in the contract (expiry, auction end, liquidation grace, withdrawal window) and ask what happens if transfers are paused across it. Test it with a mock that pauses.

The issuer can change a token's name and symbol. A name change also changes the EIP-712 domain. permit accepts EOA signatures only, with no ERC-1271 support.

Check: identify tokens by address everywhere, the front end included. Keep a plain approve path, since smart accounts cannot use permit and a permit signed before a rename stops working.

From a 41 call probe of the real TSLAc on 13 November 2026 (one read only eth_call with a state override, nothing signed):

• transfer, transferFrom and approve return true. Zero amounts and transfers to yourself succeed.
• A transfer to address(0) or to the token's own address reverts with InvalidReceiver.
• Failures are custom errors: InsufficientBalance(sender, balance, needed), InsufficientAllowance(spender, allowance, needed).
• transferFrom checks the receiver, then the sender, then the allowance, then the balance.
• An allowance of type(uint256).max is not spent down.
• An unknown selector reverts with that selector as the revert data.

Check: anything that reads revert data (a try/catch, a router, a front end error map) expects these custom errors and not a string.

3,000 blocks took 600 seconds when we read them on 14 November 2026. A duration written as a block count at 2 seconds a block is off by ten times.

Check: every epoch, cooldown, expiry and TWAP window uses block.timestamp. Fork tests that roll blocks to pass time use the same block time.

Base's docs state that Coinbase tokenized stocks are only available to persons in eligible jurisdictions outside the US. The Stocks Maxxing FAQ puts projects that enable trading for US users out of scope.

Check: the app says who it is for, and the front end does something about it. This is not legal advice. Ask someone who gives it.

The B20 standard has no built in timelock. The issuer's roles can change the multiplier, edit policy lists, pause features, seize, rename the token and change the supply cap, and each takes effect when the call lands. Announcement events are notice and they do not enforce a delay.

Check: your docs name these as assumptions users take on. A monitor watches UIMultiplierUpdated, Paused, Unpaused, PolicyUpdated, Seized and Announcement on the tokens you hold.