vladpad — Protocol Reference

Protocol: Robinhood Chain (Arbitrum Orbit L2) | Chain ID: 46630 | Gas: ETH

vladpad deploys ERC-20 tokens that carry their own trading logic. A shared contract handles curve math and swap routing for every token; the per-token behavior module is chosen at deploy and committed to immutable state. There is no upgrade hatch and no admin key over a live token.

The token trades on its bonding curve from inception — no migration step, no second venue. Once the curve fills, the same contract seeds and locks an AMM position and steps aside.

The Curve

A constant-product invariant vx · vy = K over virtual reserves, initialized with the full 1B token supply paired against 1.5 ETH of virtual depth.

Parameter	Value
Total supply	1,000,000,000
Curve allocation	750,000,000
LP reserve	250,000,000
Virtual ETH	1.5
Sellout point	~4.5 ETH raised
Anti-snipe	30-second timestamp window

Every swap is exact-input — you specify what goes in, never what comes out
Pricing is fully deterministic — call quoteBuy / quoteSell for an exact figure
Integer rounding always resolves in the pool's favor, so round-trips can't be gamed
Selling pushes tokens back into curve inventory — the curve can de-fill before graduation

Anti-Snipe

The first 30 seconds after deploy are a cooldown window. On a chain producing blocks every ~250ms, block-count alone is meaningless — vladpad uses block.timestamp instead.

Window: 30 seconds from token deployment timestamp
Per-tx cap: 0.05 ETH per tx.origin during the window
Same-tx lock: Buy and sell in the same transaction reverts
Cooldown check: require(block.timestamp >= launchTimestamp + 30) — after 30s the cap lifts completely

This blocks the most common bot pattern: a script that fires a max-buy in the same block as deploy. It doesn't pretend to solve MEV entirely — just the zero-effort sniping at launch.

Graduation

Fires when total ETH in the curve hits ~4.5. A single atomic transaction walks the spot price to the final curve value, deploys a full-range AMM position at that price, and permanently locks it. Zero price dislocation between phases.

The LP contract has no withdrawal path — it cannot be removed, re-deployed, or transferred. The key is effectively burned at creation.

Fees & Tax

Flat 1% per swap (denominated in ETH, applied in both phases):

Destination	Rate
Protocol	0.50%
Creator	0.50%
Mechanics (per pool)	0–5%

Taken from input ETH on buys; deducted from output ETH on sells
Module fees accumulate in the contract, isolated and claimable per token
A failing module hook cannot halt the swap — the trade always completes

Buyback & Burn

The 0.5% protocol slice accumulates in a vault. Anyone can call the buyback function — it's permissionless. The contract:

Claims accrued protocol fees from the vault
Swaps into the platform's native token on its own curve
Sends bought tokens to 0x…dEaD — permanent supply destruction

The buy is protected by an on-chain slippage floor derived from the pool's pre-swap spot price — the call cannot be sandwiched even though it's open to anyone.

Why permissionless?

No keeper, no multisig, no reliance on the team to press a button. Any wallet — EOA or contract — triggers the cycle. The protocol doesn't accumulate fees beyond a single epoch.

Modules (11 total)

The behavior module is selected during deployment and committed to contract storage. No key, multisig, or timelock can alter a live token's configuration. Each module runs in its own per-pool vault — a bug in one token's accounting can never reach another's.

00Plain — A bare bonding curve into a locked full-range AMM position. No module hook fires on trades. The reference implementation everything else builds on. No extra fee.

01Tontine — A 2% fee fills a per-pool vault. Sell once through the pool and you're ejected permanently. Every 30 days a new epoch unlocks 10% of the vault to holders who never sold, split by balance. Trustless — no keeper loops. Moving tokens between your own wallets keeps you "pure." +2% module fee.

02Streak — One qualifying buy per UTC day (≥ the pool minimum, measured after the base fee) extends your streak; miss a day and it resets to one. Personal bests and the pool record are stored and emitted on-chain — the leaderboard is the module. No extra fee.

03Heartbeat — The token must be kept alive. If a full day passes with no buy above the minimum beat, buys close permanently — supply freezes, only exits remain. The minimum beat doubles every 7 days survived, so staying alive gets harder. A standing dead-man's switch. No extra fee.

04Last Call — A 3% fee fills the pot. Each qualifying buy resets a countdown: 60 minutes when the pot is small, shrinking one minute per 0.1 ETH down to a 10-minute floor. At zero, the final buyer claims 85% of the pot (5% protocol, 10% seeds the next round) — with a 2-block claim gap against endgame MEV. +3% module fee.

05Halving — On every buy, 1% of bought tokens are burned on the spot — real supply reduction. Cumulative volume milestones advance the epoch counter, each one twice as far as the last. On sells the 1% accrues as ETH to a holder-rebate vault, claimable pro-rata each epoch. Runs alone. +1% module fee.

06Seatbelt — A 2% premium on every trade fills a per-pool vault. If price draws down more than 60% within 7 days of your buy, claim from the vault — capped three ways: at most 50% of your loss, at most your pro-rata share, at most 20% of the vault per day. A first-loss cushion, not insurance — the vault can run dry. +2% module fee.

07Moneyback — When the graduation trigger fires, a one-way 72-hour window opens: buyers may return tokens for exactly their recorded average entry (net of the base fee). Buys are disabled during the window. When it closes, liquidity seeds and trading resumes. Transferred tokens have no recorded entry and can't refund. Runs alone. No extra fee.

08Cure — A 2% fee on every buy and sell streams to holders who lock ("cure") their tokens, pro-rata to how much each has cured — precise per-share accounting. Cured supply leaves the float; rewards accrue in ETH and claim any time. Tokens unlock after the cure period (default 7 days, set by creator). Adding to a cure restarts its timer. +2% module fee.

09Burn — On every buy, 5% of bought tokens burn on the spot. Sells pay the same 5% as an ETH fee that is itself burned to 0x…dEaD. Pure deflation: no vaults, no claims, no rebates — holders benefit as the float shrinks with every trade. Runs alone. +5% module fee.

10Dividends — Pick a tax rate (1–5%) and a reward token at launch. Every ~15 minutes the tax vault buys that token and distributes it to holders pro-rata to balance; claim any time on the Rewards page. Hold one token, earn another. 1–5% tax.

Combinability: Most modules can compose, each in its own isolated vault with fees summed under a 10% cap. Three run alone — Halving and Burn take their cut in tokens, and Moneyback re-routes graduation — combining those is rejected at launch.

Failure Policy

A module is just code — it can have bugs, run out of gas, or revert by design. The protocol defines exactly what happens to the trade when that occurs:

Pre-trade gate

Modules can vote to block a buy before it happens (this is how Heartbeat closes its buy gate). A revert here cancels the trade cleanly — no fees taken, no state change. Working as designed.

Post-trade callback during curve phase

If the after-trade hook reverts during the bonding-curve phase, the entire trade reverts. A broken module halts its own pool early — better to freeze the token than let it drift into corrupted state.

Post-trade callback after graduation

Once the AMM is locked and trading is permissioned by Uniswap rules, a reverting module is caught and emitted as an event. The trade proceeds. A graduated pool can never be stranded by its module — the protocol prioritizes liveness over module correctness post-graduation.

Token Addresses

Every token deploys via CREATE2 for deterministic addressing — the contract address is known before the deploy transaction confirms. This enables pre-trade UIs and indexers to track a token before it's live.

Deterministic: address = keccak256(deployer, salt, bytecodeHash) — predictable, no surprises
Identifiable: any indexer can confirm a vladpad token by checking the deploying factory address on-chain
Events: TokenLaunched(address token, address creator, uint8 module) emitted at deploy for off-chain indexing

Integrators

Two rules for routers, aggregators, and any contract calling the launchpad:

1. Exact-input only

Both phases reject exact-output swaps. Build orders as swapExactETHForTokens / swapExactTokensForETH patterns; output is whatever the curve or AMM resolves to.

2. Pass the trader's identity

The real trader address must be ABI-encoded in the call's hookData. If omitted, the contract falls back to msg.sender (the router) and modules will key per-wallet state to the router itself — meaning your users get no streak, no tontine purity, no seatbelt coverage. Always pass the user's address.

Quotes

Curve phase: call quoteBuy(tokenAddr, ethIn) / quoteSell(tokenAddr, tokensIn) on the launchpad — exact figures, no slippage from rounding
Post-graduation: standard Uniswap-style pool math

Pool key

Always (ETH, token, fee=0, tickSpacing=60, hook=launchpadAddr). The 0 fee tier is enforced — the launchpad is the only entity skimming fees, the AMM tier itself takes nothing.

Robinhood Chain

An Arbitrum Orbit Layer-2 built on Ethereum. ETH as gas token. Permissionless.

Property	Value
Network Name	Robinhood Chain Testnet
Chain ID	46630
Currency	ETH
RPC	`https://rpc.testnet.chain.robinhood.com`
Explorer	explorer.testnet.chain.robinhood.com
Faucet	faucet.testnet.chain.robinhood.com

Contracts

Deployed on Robinhood Chain Testnet:

Contract	Address
Launchpad	`TBD (after deploy)`
BondingCurve (lib)	embedded in Launchpad

Source

All contracts are open source. Built with Foundry (Solidity 0.8.26), audited with Slither.

API

Public read-only API for token data:

Endpoint	Returns
`GET /api/stats`	Global stats (tokens deployed, ETH in curves, graduated count)
`GET /api/tokens`	Array of all tokens with curve state, module, creator
`GET /api/tokens/:addr`	Single token detail (curve fill %, holders, trades, module state)
`GET /api/health`	Service health + chain sync status

Rate limits

No auth required. 60 requests/minute per IP. Responses are JSON, CORS open.

Glossary

Term	Definition
Bonding curve	A mathematical price function where token price increases as supply sells out. vladpad uses constant-product virtual reserves.
Virtual reserves	Imaginary token/ETH balances used in the constant-product formula. No real ETH is deposited upfront — reserves are purely computational.
Graduation	The moment the curve sells out and liquidity is permanently deployed to the AMM. Irreversible, permissionless, atomic.
Module	A behavior hook attached to a token at deploy. Runs on every trade, cannot be changed after launch.
Cure period	The lockup duration for the Cure module. Tokens cannot be moved until this timer expires.
Epoch (Tontine)	A 30-day cycle after which 10% of the vault unlocks for holder claims.
Epoch (Halving)	A volume milestone that doubles the distance to the next one, advancing the burn counter.
Purity (Tontine)	A wallet that has never sold through the pool. Pure wallets receive vault payouts; impure ones are permanently excluded.
Dead-man's switch	Heartbeat module — if nobody buys for 24h, the pool seals permanently.
CREATE2	An EVM opcode that deploys contracts to deterministic addresses — the address is computable before deploy, enabling pre-launch tracking.
Full-range position	AMM liquidity spread from tick MIN to MAX — always provides quotes at every price. Used for graduated pools.
Slippage floor	An on-chain minimum output enforced by the buyback contract so permissionless calls can't be exploited via sandwiching.