Environment-Driven Config

The frontend reads the chain and every contract address from NEXT_PUBLIC_* environment variables at build time. Point them at Robinhood Chain, the testnet, or a local Hardhat node. The app doesn't care, it just follows the env.

# Chain
NEXT_PUBLIC_CHAIN_ID=4663
NEXT_PUBLIC_RPC_URL=https://rpc.mainnet.chain.robinhood.com
NEXT_PUBLIC_BLOCK_EXPLORER_URL=https://robinhoodchain.blockscout.com

# Hood protocol
NEXT_PUBLIC_HOOD_TOKEN_REGISTRY_ADDRESS=0x...
NEXT_PUBLIC_HOOD_LAUNCHER_FACTORY_ADDRESS=0x...
NEXT_PUBLIC_HOOD_LAUNCHER_FACTORY_START_BLOCK=0
NEXT_PUBLIC_ORIGINAL_NFT_ADDRESS=0x...
NEXT_PUBLIC_MARKETPLACE_ADDRESS=0x...
NEXT_PUBLIC_DIVIDEND_VAULT_ADDRESS=0x...

# Uniswap V3 (self-deployed)
NEXT_PUBLIC_WETH9_ADDRESS=0x...
NEXT_PUBLIC_UNISWAP_V3_FACTORY_ADDRESS=0x...
NEXT_PUBLIC_UNISWAP_V3_SWAP_ROUTER_ADDRESS=0x...
NEXT_PUBLIC_UNISWAP_V3_QUOTER_V2_ADDRESS=0x...
NEXT_PUBLIC_UNISWAP_V3_POSITION_MANAGER_ADDRESS=0x...

For local development, run a Hardhat node, deploy the stack, and swap the chain ID + RPC for your local values. Same contracts, same UI, zero code changes.

Runtime addresses are read from NEXT_PUBLIC_* environment variables on the deployed site. The tables below reflect whatever this deployment is configured with, so click through to the explorer to verify.

Exchange & Uniswap V3

Hood Protocol

Hoodlums is a collection of 444 fully on-chain generative pixel PFPs. Art and metadata are rendered by the contract itself as base64-encoded SVG and JSON: no IPFS, no off-chain server, nothing that can rot. Each mint also deploys an ERC-6551 token-bound account (the hood wallet) that belongs to the token id for life. Whatever you park in it travels with the NFT when it sells.

Collection Details

What Happens When You Mint

1. 1.You call mint(quantity) with 0.05 ETH × quantity attached (max 2 per tx, max 2 per wallet lifetime; the cap counts mints only, transfers are uncapped) on the mint page.
2. 2.The contract assigns a unique trait seed and mints your Hoodlum. Art is generated on-chain: no reveal, no metadata server.
3. 3.An ERC-6551 hood wallet is deployed for the token via the ERC6551Registry using the Hoodlum6551Account implementation.
4. 4.The token id starts accruing rarity-weighted dividends in the HoodDividendVault from the next distribution onward.
5. 5.Whoever holds the NFT controls the wallet and claims the dividends. Trade, LP, stack payouts, or sell the Hoodlum and the bag goes with it.

Core ABI

// Hoodlums: token ids 1-444 (the full collection)
function mint(uint256 quantity) external payable;
// msg.value must equal MINT_PRICE * quantity (0.05 ether each)
// max 2 per tx (MAX_PER_TX) and 2 per wallet lifetime (MAX_PER_WALLET);
// mintedBy counts mints only, transfers never reduce an address's allowance

function mintedBy(address minter) external view returns (uint256);
function dividendWeightOf(uint256 tokenId) external pure returns (uint256);
// rarity weight for dividend payouts: 100 standard, 200 street headset
// (~1-in-10), 500 for the 20 one-of-ones

function predictWallet(uint256 tokenId) external view returns (address);
function tokenWallet(uint256 tokenId) external view returns (address);
function tokenURI(uint256 tokenId) external view returns (string memory);
// returns data:application/json;base64,... with an embedded base64 SVG

event WalletCreated(uint256 indexed tokenId, address indexed wallet);

Traits & Rarity Weights

Every Hoodlum carries six named attributes (Hair, Glasses, Headset, Earbud, Mouth, Eyes) rendered and derived entirely on-chain. Rarity feeds directly into dividends via dividendWeightOf(tokenId): standard Hoodlums earn 1x (weight 100), the rare street headset (~1 in 10) earns 2x (200), and the 20 one-of-one specials earn 5x (500). The collection also sets an ERC-2981 royalty of 2.5% paid to the HoodDividendVault, so honored royalties flow straight back to holders.

Contracts

• ▸Hoodlums.sol: the collection, token ids 1-444. 444 and done. This is the only Hoodlums collection; no expansion exists.
• ▸ERC6551Registry + Hoodlum6551Account: deterministic token-bound accounts. predictWallet(tokenId) computes the address before mint.

Configured collection addresses are listed under Contract Addresses.

Holding a Hoodlum is a fee position. Three separate revenue streams route into the HoodDividendVault, which splits every distribution across the 444 token ids by rarity weight. Claim in the Claim tab and take the payout as ETH, WETH, or a real tokenized stock.

Three Fee Sources

Marketplace fees and royalties arrive as ETH. Launch LP fees arrive as WETH (and, for token-denominated pools, as the launched ERC-20). The vault tracks each asset separately, so ETH and token dividends are claimed independently.

How the Split Works

Every distribution is divided by total collection weight, then credited per token id according to dividendWeightOf(tokenId). Because the vault books an accumulator per weight unit, a claim is O(1) no matter how many distributions have piled up since you last touched it, and unclaimed dividends never expire.

Claim ABI

// HoodDividendVault at 0x4d8feBbB4DD03C464Aa6f833f02b11078F3A5285
// payouts are pro-rata by dividendWeightOf(tokenId): 100 / 200 / 500

function pendingOf(address collection, uint256 tokenId) external view returns (uint256);
function pendingTokenOf(address token, address collection, uint256 tokenId)
    external view returns (uint256);

function claim(address collection, uint256 tokenId) external;              // ETH
function claimMany(address collection, uint256[] calldata tokenIds) external;
function claimToken(address token, address collection, uint256 tokenId) external;   // ERC-20
function claimTokenMany(address token, address collection, uint256[] calldata tokenIds) external;

function dividendTokens(uint256 i) external view returns (address);        // enumerate ERC-20 streams

Dividends are keyed by (collection, tokenId), not by the hood wallet. Whoever holds the NFT at claim time receives everything accrued to that id. The Claim tab batches every Hoodlum you own into a single Claim All transaction per asset.

Take Your Dividends as Real Stocks

After claiming, the same flow can route your payout straight through the Hood Exchange into a tokenized stock. Pick a ticker, confirm, and the claimed ETH or WETH is swapped into that token in one go. All of them are ordinary transferable ERC-20s with live Uniswap V3 pools on the protocol's own factory, so you can hold, LP, or sell them like anything else.

Every stock pool is quoted against WETH (0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73). The UI passes the correct fee tier automatically; if you are routing manually through the SwapRouter, use the tier listed above.

The Hood Exchange is a self-deployed Uniswap V3 stack on Robinhood Chain: WETH9, factory, SwapRouter, QuoterV2, and NonfungiblePositionManager. Swap any token pair with direct ETH ↔ WETH wrapping.

Quote a Swap

// QuoterV2 at 0x33e885eD0Ec9bF04EcfB19341582aADCb4c8A9E7
function quoteExactInputSingle(
    address tokenIn,
    address tokenOut,
    uint24 fee,
    uint256 amountIn,
    uint160 sqrtPriceLimitX96
) external returns (uint256 amountOut, ...);

Execute a Swap

// SwapRouter at 0xCaf681a66D020601342297493863E78C959E5cb2
struct ExactInputSingleParams {
    address tokenIn;
    address tokenOut;
    uint24 fee;
    address recipient;
    uint256 deadline;
    uint256 amountIn;
    uint256 amountOutMinimum;
    uint160 sqrtPriceLimitX96;
}
function exactInputSingle(ExactInputSingleParams calldata params)
    external payable returns (uint256 amountOut);

For native ETH swaps, send msg.value and set tokenIn = WETH9 (0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73).

ETH ↔ WETH Wrap / Unwrap

// WETH9 at 0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73
function deposit() external payable;    // ETH → WETH
function withdraw(uint256 wad) external; // WETH → ETH

Fee Tiers

Every pool created by the launcher runs on the Uniswap V3 1% tier (fee = 10000, tick spacing 200): one tier, maximum fee flow to stakers and Hoodlum holders. Tokenized stock pools use their own tiers, listed under Dividends. The UI fills the right tier in automatically when quoting or swapping.

Create Uniswap V3 concentrated liquidity pools and mint LP positions with fine-grained tick ranges. Supports native ETH on either side, since the PositionManager wraps it to WETH automatically. Full position management (add, remove, collect fees) lives in Exchange → Pools.

Create and Initialize a Pool

// PositionManager at 0x73991a25C818Bf1f1128dEAaB1492D45638DE0D3
function createAndInitializePoolIfNecessary(
    address token0,
    address token1,
    uint24 fee,
    uint160 sqrtPriceX96
) external payable returns (address pool);

token0 must be < token1 (sorted by address).

Mint an LP Position

struct MintParams {
    address token0;
    address token1;
    uint24 fee;
    int24 tickLower;
    int24 tickUpper;
    uint256 amount0Desired;
    uint256 amount1Desired;
    uint256 amount0Min;
    uint256 amount1Min;
    address recipient;
    uint256 deadline;
}
function mint(MintParams calldata params)
    external payable returns (
        uint256 tokenId,
        uint128 liquidity,
        uint256 amount0,
        uint256 amount1
    );

Key Parameters

• ▸Full-range: tickLower = -887272, tickUpper = 887272
• ▸Native ETH: Send msg.value and use WETH9 as the token address. The PositionManager wraps automatically.
• ▸Refund: Include refundETH() in a multicall to return unused native ETH.

The Hood Launcher deploys a new ERC-20 (HoodMemeCoin) in one transaction: it mints the token, opens a Uniswap V3 pool at the 1% fee tier, deposits the entire supply as single-sided liquidity, and hands the LP NFT to a fee splitter the creator can never withdraw from. There is no presale, no fixed-price phase, and no second step. Idea to live market in one click.

What the Transaction Does

Instant Launch ABI

// HoodLauncherFactory at 0x469826885EaccB0533898FB1D8C0ad8FC55bD9dE
struct InstantLaunchParams {
    string name;                  // Token name (e.g. "My Token")
    string symbol;                // Token symbol (e.g. "MTKN")
    string metadataURI;           // JSON metadata URI
    string imageURI;              // Token icon URI
    uint256 totalSupplyWei;       // Total supply in wei (18 decimals)
    uint256 creatorAllocationBps; // Creator's share in bps (max 500 = 5%)
    uint256 priceWeiPerToken;     // Starting price (WETH per token, both 18 dec)
}

function instantLaunch(InstantLaunchParams calldata p)
    external payable returns (address token, address launch);

All non-creator supply becomes LP inventory in an asymmetric range placed just outside the starting price, so the entire float is tradeable depth with zero ETH required for liquidity. msg.value is ignition, not liquidity: it is the creator's first buy, swapped through the fresh pool with the bought tokens sent to the creator. Leave it at zero and a launch costs nothing but gas. Emits LaunchCreated and LaunchFinalized in the same transaction.

Fee Flywheel: Splitter + Staking Vault

The LP NFT is held by HoodLpFeeSplitter. Its collectAndSplit() is permissionless, so anyone can call it, collecting the pool's trading fees and splitting them 50% to the token's HoodYieldStakingVault, 50% to the treasury. The treasury is the HoodDividendVault, and its half is auto-distributed to NFT holders via distributeToken in the same call (emitting TreasuryShareRouted). No admin in the loop, end to end.

// HoodLpFeeSplitter (one per launch, holds the LP NFT forever)
function collectAndSplit() external returns (uint256 amount0, uint256 amount1);
// permissionless: 50% -> HoodYieldStakingVault, 50% -> HoodDividendVault
// (auto-distributed to holders; emits TreasuryShareRouted)

// HoodYieldStakingVault
function stake(uint256 amount) external;
function unstake(uint256 amount) external;
function claim() external; // claim accumulated fee yield

Half of those fees land with Hoodlum holders and are claimed rarity-weighted. See Dividends for the claim ABI and the stock payout flow.

HoodlumMarketplace is a fully on-chain marketplace for Hoodlums: fixed-price ETH listings, ERC-20 token listings, and NFT-for-NFT swap offers, all with on-chain escrow and instant settlement. No off-chain order book, no signatures floating around. Remember: the hood wallet and its bag travel with the NFT.

Features

• ▸List Hoodlums for sale at a fixed ETH or ERC-20 price.
• ▸Propose Hoodlum-for-Hoodlum swaps (on-chain bartering, escrowed by the contract).
• ▸Browse all active listings with on-chain metadata previews.
• ▸Instant settlement: the contract escrows the NFT until sale, swap, or cancel.
• ▸Cancel listings and swap offers anytime before they're filled.

Core ABI

// HoodlumMarketplace at 0xfCaEA01f28cBBe54c03cf869fb94a2814925957C
function createEthListing(address nft, uint256 tokenId, uint256 price)
    external returns (uint256 listingId);
function createTokenListing(address nft, uint256 tokenId, address paymentToken, uint256 price)
    external returns (uint256 listingId);
function buyWithEth(uint256 listingId) external payable;   // msg.value == price
function buyWithToken(uint256 listingId) external;          // approve paymentToken first
function cancelListing(uint256 listingId) external;

function createSwapOffer(
    address offeredNft, uint256 offeredTokenId,
    address requestedNft, uint256 requestedTokenId
) external returns (uint256 swapId);
function acceptSwapOffer(uint256 swapId) external;
function cancelSwapOffer(uint256 swapId) external;

Sellers must approve (or setApprovalForAll) the marketplace before listing. The NFT is transferred into escrow on listing creation.

HoodTokenRegistry maintains the on-chain list of recognized tokens with metadata (symbol, decimals, icon, description). Tokens created through the Hood Launcher are registered automatically at launch; the exchange UI reads the registry to populate token dropdowns and swap panels.

Contract: 0x0d375aA65A0A294Bb7eaE328dF73379106fDA029

Everything in Hoodlum settles on-chain and emits events. Mints, launches, swaps, LP positions, fee distributions, and claims are all fully auditable via the Robinhood Chain block explorer or direct RPC queries.

Tracking Mints & Hood Wallets

The collection emits WalletCreated(tokenId, wallet) on every mint. Use tokenWallet(tokenId) to resolve any Hoodlum's hood wallet and inspect its holdings.

Tracking Token Launches

All tokens launched via the HoodLauncherFactory emit a LaunchCreated event. The UI indexes every launch from the factory start block and displays them in the Launcher tab.

event LaunchCreated(
    address indexed creator,
    address indexed token,
    address indexed launch,
    string name,
    string symbol,
    string metadataURI,
    string imageURI
);
event LaunchFinalized(address indexed creator, address indexed launch, address indexed pool, uint256 lpTokenId);

Filter by creator to see every token launched by a specific wallet. Both events fire in the same transaction, since the pool goes live the moment the token is deployed.

Tracking Swaps & Trades

Uniswap V3 pools emit standard Swap events. Query the pool contract directly or use the block explorer:

https://robinhoodchain.blockscout.com/address/<POOL_ADDRESS>#events

Tracking LP Positions

LP positions are ERC-721 NFTs minted by the NonfungiblePositionManager. Query balanceOf(owner) and tokenOfOwnerByIndex to enumerate positions, or view them in the Exchange → Pools tab.

Tracking Dividends

HoodLpFeeSplitter emits TreasuryShareRouted whenever fees are swept into the vault, and the HoodDividendVault emits a distribution event per asset plus a claim event per token id. Call pendingOf or pendingTokenOf to read what any Hoodlum is owed right now, or open the Claim tab.

One-line summary of the key entry points across the protocol. Full signatures live in the module sections above.