Docs

Every Greenback market is a pair: a fair-launch ERC-20 and a bonding curve that holds real Robinhood stock tokens as backing — either one stock, or a small basket of stocks.

Before graduation you trade against the curve. After graduation you trade against a Uniswap V4 pool. The economic story is the same: your coin’s market is tied to the underlying (stock or vault shares), priced with Chainlink feeds, with protocol + creator fees (and optional holder tax) taken in that backing.

When you create a market, the factory deploys a StockBackToken. The entire supply is minted once — there is no team allocation and no ongoing mint.

/// @title StockBackToken
/// @notice Fair-launch ERC-20. Entire supply minted once at creation;
///         no team allocation.
/// @dev When wired to its BondingCurve, transfers sync holder-tax
///      reward debt so claims cannot be double-spent across wallets
///      (or post-grad Uniswap balance moves).

Your public page lives at /token/TICKER. Tickers and names must be unique across launches in the app.

The curve is a hybrid constant-product design backed by Robinhood stock tokens. The on-chain docs spell out the model:

/**
 * @title BondingCurve
 * @notice Hybrid pump.fun-style constant-product curve backed by
 *         Robinhood Stock Tokens.
 *
 * Users may pay with Stock Tokens (`buy`) or native ETH (`buyWithETH`).
 * ETH path: swap ETH → Stock Token via factory router, then hold
 * stock in the curve.
 *
 * Trading fees (changeable on factory, apply to curves + V4 hook):
 *   - protocol: factory.protocolFeeBps() → protocolFeeRecipient (0.5%)
 *   - creator:  factory.creatorFeeBps()  → token creator         (0.5%)
 *
 * Optional immutable holder tax (holderTaxBps, 0 = off)...
 * Graduation migrates liquidity into a Uniswap V4 pool via
 * factory.v4Graduator().
 */

Core constants that shape every launch:

uint256 public constant TOTAL_SUPPLY = 1_000_000_000 ether;
uint256 public constant TOKENS_FOR_SALE = 800_000_000 ether;
uint256 public constant TOKENS_FOR_LP = 200_000_000 ether;

/// @dev Steep curve: ~10x token price on cheap names (e.g. NVDA)
///      by $6k graduation.
uint256 public constant VIRTUAL_STOCK_RESERVE = 20 ether;
uint256 public constant VIRTUAL_TOKEN_RESERVE = 320_000_000 ether;
uint256 public constant MAX_HOLDER_TAX_BPS = 1_000; // 10%

Stock path. You approve the underlying stock (e.g. NVDA) and call buy / sell on the curve. This always works when the stock is listed.

ETH path. buyWithETH / sellForETH route through the factory’s ETH→stock router (Uniswap V3 or V4). The app only enables ETH seed / ETH trade UI when that route is liquid enough — SPY seed buys are currently disabled because the ETH↔SPY pool is too thin for reliable swaps.

The curve flips to graduated mode and refuses new curve trades. All backing stock moves into a Uniswap V4 pool seeded at the final curve spot when inventory allows; excess unsold meme supply is dead-addressed rather than diluted into the pool. The graduator locks full-range liquidity (LP fee 0). Ongoing swap fees are collected by StockBackHook using the same protocol / creator / holder-tax order as the curve.

Details live in Graduation.