Contract addresses

Every tokenized stock address this site tracks, in plain HTML you can copy, script against or search. Each one is re-checked against its issuer's own test every time this page rebuilds.

27 listings · 1 issuer · 1 chain · updated 3 hours ago

Chains

Listings

The ERC-8056 interface

Robinhood use the Scaled UI Amount extension: a standard ERC-20 plus one contract-level multiplier. These are the functions that matter beyond the ERC-20 basics. Other issuers do not implement this — check the issuer before you assume it is there.

interface IStockToken is IERC20 {
    // ERC-8056 Scaled UI Amount
    function uiMultiplier()        external view returns (uint256); // 1e18 == 1.0
    function balanceOfUI(address)  external view returns (uint256); // may revert on overflow
    function totalSupplyUI()       external view returns (uint256); // may revert on overflow

    // Corporate actions, announced before they take effect
    function newUIMultiplier()     external view returns (uint256);
    function effectiveAt()         external view returns (uint256); // unix seconds

    // Operational state
    function paused()              external view returns (bool);
    function tokenPaused()         external view returns (bool);
    function oraclePaused()        external view returns (bool);
    function terms()               external view returns (string memory);
    function uid()                 external view returns (bytes32);

    event UIMultiplierUpdated(uint256 oldMultiplier, uint256 newMultiplier, uint256 effectiveAt);
    event TransferWithScaledUI(address indexed from, address indexed to, uint256 value, uint256 uiValue);
}

Event topics

Reading share-equivalent balances safely

balanceOfUI and totalSupplyUI revert rather than returning a misleading zero when the scaled amount would overflow. That is deliberate in ERC-8056, so treat a revert as "compute it yourself", not as an error:

import { createPublicClient, http, parseAbi } from 'viem'

const abi = parseAbi([
  'function balanceOf(address) view returns (uint256)',
  'function balanceOfUI(address) view returns (uint256)',
  'function uiMultiplier() view returns (uint256)',
])

const client = createPublicClient({
  transport: http('https://rpc.mainnet.chain.robinhood.com'),
})

async function shareBalance(token, wallet) {
  try {
    return await client.readContract({
      address: token, abi, functionName: 'balanceOfUI', args: [wallet],
    })
  } catch {
    const [raw, mult] = await Promise.all([
      client.readContract({ address: token, abi, functionName: 'balanceOf', args: [wallet] }),
      client.readContract({ address: token, abi, functionName: 'uiMultiplier' }),
    ])
    return (raw * mult) / 10n ** 18n
  }
}

A note on event history

Robinhood Chain produces a block roughly every 0.12 seconds, so it passes a million blocks every day and a half, and eth_getLogs on the public RPC returns 429 for practically any range. If you need event history, read it from the explorer API ( https://robinhoodchain.blockscout.com/api/v2/addresses/{address}/logs), which returns decoded logs and paginates, or use a keyed RPC provider.

Free JSON API

Everything on this page is available as static JSON, no key required. Licensed CC BY 4.0 — attribution with a link back is all we ask.

GET https://stocksonchain.io/api/tokens.json          # every stock, with all its listings
GET https://stocksonchain.io/api/tokens/nvda.json     # one stock
GET https://stocksonchain.io/api/events.json          # corporate actions, scheduled and past

Embeddable widgets → · How this data is collected →

Developer FAQ

What are the RPC URLs and chain IDs?

Every chain is listed in the table above with its public RPC and chain ID. Note that eth_getLogs is heavily rate-limited on most public endpoints — read event history from the explorer API, or use a keyed provider.

How do I read a share-equivalent balance?

Only some issuers have one. Where they do, call balanceOfUI(address). It can revert by design when an extreme multiplier would overflow, so always wrap it and fall back to balanceOf(address) * uiMultiplier() / 1e18 computed in a big-integer type.

Is there an on-chain registry of stock tokens?

Not a public one, and issuers render their own token tables client-side, so the addresses are not machine-readable there. This list is maintained by hand and every entry is re-checked on each refresh, plus a daily job that scans each chain for listings we are missing. Take it as JSON from /api/tokens.json.

How do I know an address is genuine?

It depends on the issuer, because each publishes its own test. Robinhood publishes a shared beacon at 0xe10b6f6B275de231345c20D14Ab812db62151b00, and a genuine token is an EIP-1967 proxy over it. Any contract can claim a ticker. Run the issuer's test, which is exactly what our verification script does.