Building with Stock Tokens

Stock tokens are standard ERC-20 tokens, so building with them uses the same patterns you already know — plus onchain price feeds for real-world asset data. This guide covers what you can build, how to integrate, and how to get started.

Use cases

Tokenized stocks trade via RFQ at launch. They remain standard ERC-20s and can be transferred and held in any wallet.

Trading Venues & Liquidity

Overview

Stock Tokens are standard ERC-20 assets and can be held or transferred in any compatible wallet. For trading, several venues are available.

Liquidity Sources

RFQ

RFQ uses signed market-maker quotes sourced through aggregators such as 0x RFQ, 1inch Fusion, and LiFi. Wallets and exchanges can leverage RFQ as a source of liquidity by integrating these aggregators.

AMM

Stock Tokens can also be traded through standard automated market maker (AMM) pools such as Uniswap. AMM pools provide composable, on-chain liquidity that DeFi applications can integrate directly into smart-contract flows.

Proprietary AMM (propAMM)

Where on-chain AMM liquidity is limited, Stock Tokens can also be traded through proprietary AMM (propAMM) like Rialto, which provides market-maker-backed liquidity. Because it's onchain, a propAMM offers composable liquidity that DeFi applications can integrate directly into smart-contract flows — unlike RFQ, which relies on off-chain signed quotes.

Direct mint & burn

Stock Tokens are minted and burned directly with the issuer, Robinhood Assets (Jersey) Limited in the primary market. This is the ultimate source of Stock Token supply and underpins secondary-market liquidity. Direct mint/burn is available only to Authorized Participants / market makers and requires KYB onboarding; regular holders acquire and exit positions on the secondary market through the venues above.

Orderbook

Stock Tokens also trade on Lighter (spot & perps). Refer to the Lighter Domain for specific integration details.

Integrations, contracts & APIs

Contracts

Stock tokens are ERC-20 (18 decimals). All standard token operations work without modification:

IERC20 nvda = IERC20(NVDA_TOKEN_ADDRESS);
uint256 balance = nvda.balanceOf(user);
nvda.transfer(recipient, amount);
nvda.approve(spender, amount);

Stock tokens also implement ERC-8056 (Scaled UI Amount Extension), which defines the corporate-action multiplier (uiMultiplier()). The multiplier scales the effective amount without changing raw balances or total supply — balanceOf() and totalSupply() stay fixed. Stock tokens are not rebasing tokens. See the ERC-8056 spec.

Find all stock tokens and ETF addresses on the Token Contracts page.

Prices

Every stock token has a per-asset Chainlink price feed implementing the standard AggregatorV3Interface (latestRoundData(), read via the feed proxy — same interface as crypto feeds):

AggregatorV3Interface feed = AggregatorV3Interface(NVDA_PRICE_FEED);
(, int256 price, , uint256 updatedAt, ) = feed.latestRoundData();
require(price > 0 && updatedAt > 0, "Invalid price");

The Chainlink price already includes the corporate-action multiplier (dividends, splits), so the value you read is the token's full price — don't apply the multiplier yourself. If you need the raw ratio, read it onchain via the token's uiMultiplier().

See Oracles & Price Feeds for feed addresses, decimals, and best practices (staleness checks, sequencer uptime).

Multiplier Conversion

Each token represents a number of underlying shares equal to its raw token amount scaled by the multiplier:

underlying shares = raw token amount × uiMultiplier ÷ 1e18

• uiMultiplier() is fixed-point with 18 decimals — 1e18 = 1.0.
• At launch the multiplier is 1e18 (one token = one underlying share).
• When a corporate action is applied (e.g. a reinvested dividend or a stock split), the multiplier is updated and UIMultiplierUpdated is emitted with the effective timestamp.

Multiplier Updates

When a corporate action schedules a multiplier change ahead of time, the pending value and its effective time are readable on-chain:

interface IScaledUIAmountNewUIMultiplier {
  // The pending UI multiplier scheduled to take effect at effectiveAt.
  function newUIMultiplier() external view returns (uint256);
 
  // The timestamp at which the pending multiplier becomes effective.
  function effectiveAt() external view returns (uint256);
}

• newUIMultiplier() — the multiplier that will take effect at effectiveAt(). Before any update is scheduled this tracks the current multiplier.
• effectiveAt() — the timestamp at which newUIMultiplier() becomes the active uiMultiplier().

UI-Adjust Views

Rather than mutating raw balances, the token exposes UI-adjusted (underlying-share) views of balance and supply:

interface IScaledUIAmountBalances {
  // UI-adjusted balance of an account (raw balance scaled by uiMultiplier).
  function balanceOfUI(address account) external view returns (uint256);
 
  // UI-adjusted total supply.
  function totalSupplyUI() external view returns (uint256);
}

• balanceOfUI(account) — the account's balance expressed in underlying shares. Use this to display how many underlying shares a holder's tokens represent. To convert any raw amount yourself, apply the formula in Multiplier Conversion above.
• totalSupplyUI() — total supply expressed in underlying shares.

ERC-8056 events

The multiplier and its movements are exposed by the core ERC-8056 interface:

interface IScaledUIAmount {
  // Current UI multiplier, expressed with 18 decimals (1e18 = 1.0).
  function uiMultiplier() external view returns (uint256);
 
  // Emitted when the multiplier changes (e.g. a dividend or split).
  event UIMultiplierUpdated(
    uint256 oldMultiplier,
    uint256 newMultiplier,
    uint256 effectiveAtTimestamp
  );
 
  // Emitted on a transfer, carrying both the raw value and the UI-adjusted
  // (underlying-share) value.
  event TransferWithScaledUI(
    address indexed from,
    address indexed to,
    uint256 value,
    uint256 uiValue
  );
}

• Subscribe to UIMultiplierUpdated to track corporate-action adjustments and the timestamp each became effective.
• Use TransferWithScaledUI to record the underlying-share value (uiValue) of each transfer alongside the raw value.

Getting started

1. Pick a stock token — grab its address from Token Contracts.
2. Read a balance — call balanceOf like any ERC-20.
3. Read its price — call latestRoundData() on the token's Chainlink feed.
4. Build — display it, swap it, use it as collateral, or compose it into your product.

Example: value a user's holdings in USD

// Returns the USD value of a user's stock token balance.
function holdingValueUsd(
   IERC20 stockToken,
   AggregatorV3Interface priceFeed,
   address user
) external view returns (uint256) {
   uint256 balance = stockToken.balanceOf(user);          // 18 decimals
   (, int256 price, , uint256 updatedAt, ) = priceFeed.latestRoundData();
   require(price > 0 && updatedAt > 0, "Invalid price");   // price: 8 decimals
   // (balance * price) scaled by token + feed decimals
   return (balance * uint256(price)) / 1e8;
}

Next steps

• Token Contracts — all stock token & ETF addresses
• Oracles & Price Feeds — price feed integration
• Deploy a Contract — ship your contracts to Robinhood Chain

Disclaimer