vladpad — Protocol Reference

One hook, every pool. Network: Robinhood Chain (Arbitrum Orbit L2) · Chain ID: 46630 · Gas: ETH

vladpad runs the entire launchpad through a single contract. One UUPS-upgradeable hook mediates every buy, every sell, every fee, and every graduation across all pools. Five mechanics are frozen at launch and cannot be swapped afterward. Every token deployed through the system ends its address in 0x01ad.

A token trades on its bonding curve the instant it exists. Once the curve fills, one transaction graduates it into a permanent Uniswap V3 position. There is no separate migration step, no second deployment, and no human in the loop.

Three things to hold onto

• A pool's rules never change. Mechanic choice and fee schedule are written to storage at launch. Neither the creator nor the protocol owner can rewrite them, and no upgrade reaches into a live pool's configuration.
• The platform stays maintainable. The hook itself is upgradeable, so bugs get patched and new mechanics can be registered. That is a deliberate trust tradeoff in exchange for keeping a live system healthy.
• Graduated liquidity is permanent. Not through a timer and not through a burn address — through a locker contract that simply contains no code to remove the position.

The curve

Pricing follows a constant-product invariant vx · vy = K evaluated over virtual reserves. The math sits in BondingCurve.sol, a pure library the hook calls into. The full supply is minted to the hook at creation and the curve opens against 1.5 ETH of virtual depth, so the first buyer faces a sensible price instead of an empty book.

• Every swap is exact-input — you name what goes in and the curve resolves what comes out.
• Quotes are deterministic. Call quoteBuy or quoteSell for the exact figure before you sign.
• Integer rounding always lands in the pool's favor, so round-trips cannot be milked for free value.
• Selling returns tokens to curve inventory and lowers raised ETH. A curve can de-fill and retreat from the threshold before it ever graduates.

Opening-window guard

The first 30 seconds after creation form a guarded window. On an L2 that produces blocks roughly every 250ms, counting blocks is meaningless, so the guard keys on block.timestamp instead. While the window is open, buys are capped at 0.05 ETH per transaction; once it closes the cap lifts and trading runs normally. This is a narrow, deliberate measure against the zero-effort opening snipe — a bot firing one oversized buy to corner supply at launch. It does not claim to address MEV in general.

Graduation

When raised ETH crosses ~4.5, the next swap atomically graduates the pool. The hook delegatecalls into GraduationLib — extracted to keep the hook under the EIP-170 24KB bytecode limit — and a single transaction performs the full migration:

1. Reads the curve's terminal spot price.
2. Mints a full-range Uniswap V3 position at ticks ±887272, opened at exactly that price, using the 250M LP reserve plus raised ETH net of skim.
3. Skims a fixed migration amount: 0.1 ETH to the creator, 0.2 ETH to the protocol vault.
4. Transfers the V3 position NFT to LPLocker.
5. Marks the pool graduated. Every later trade routes to Uniswap V3.

Because the V3 position opens at the curve's final price, there is zero price dislocation across the transition. Anyone holding through graduation sees no gap up or down.

Why the lock is permanent

LPLocker is a minimal, non-upgradeable contract. It implements onERC721Received to accept the position NFT and collectFees to sweep V3 trading fees into the protocol vault. It does not implement withdraw. It does not implement unlock. It has no admin, no owner, and no upgrade path.

The position cannot leave because no code path exists that would let it leave. The liquidity is locked by absence — not by a timer that could lapse, not by a key in cold storage that could be reused. The key is effectively gone the moment the NFT lands.

Fees & tax

Every swap pays a flat 1.5% base fee on the ETH side, split two ways:

The creator fee is a tradeable asset

At launch a CreatorFeeNFT (ERC-721) is minted to the creator. Whoever holds the NFT claims accrued creator fees by calling claimCreatorFees(tokenId, to). The NFT transfers freely, so selling it sells the future fee stream along with it.

Mechanic fees stack on top

If the selected mechanic charges extra — Tontine +2%, Last Call +3%, Burn +5% — that adds to the 1.5% base. The summed extra-fee budget across mechanics is capped at 10%; the system will not let a launcher attach more.

Buyback & burn

The 1.0% protocol fee accumulates in the on-hook vault. The protocol can spend vault ETH to market-buy any graduated vladpad token directly through its V3 pool, then burn the purchased supply on-chain.

• Source: 1% of every swap on every pool, plus 0.2 ETH per graduation.
• Held as: ETH-side reserves under protocolFees in the hook.
• Action: swap ETH → token via Uniswap V3, then call token.burn(amount).
• Visibility: every claim emits VaultFeesClaimed and every buyback is one or two on-chain transactions. Nothing happens off-chain.

This is a budget, not a promise. Buybacks may be deployed irregularly, aimed at specific tokens, or held as runway. The point is that the vault grows publicly with every trade and any spend is fully auditable.

Mechanics

A pool's mechanic is chosen at deployment and committed to contract storage. No key, multisig, or timelock can alter a live token's configuration. Each mechanic keeps its own per-pool vault, so a bug in one token's accounting can never reach another's. Five mechanics ship at launch, frozen as a set.

Mechanic callbacks run under a fixed 200,000-gas cap. During the curve phase, a reverting callback reverts the whole trade — a mechanic is allowed to halt its own pool, and only its own pool. After graduation the callbacks are wrapped and caught, so a faulty mechanic can never strand a graduated pool: trading on Uniswap V3 continues regardless of what the mechanic does.

Addresses

Every token launched through vladpad is deployed via CREATE2 with a salt mined to produce a deterministic address whose final bytes are 0x01ad. The factory enforces the suffix at deploy time — a salt that yields any other tail reverts.

How the vanity suffix is produced

1. The launcher (or their UI) mines a salt off-chain. The suffix 01ad is two bytes, so on average ~65k candidate salts are tested before one matches — under a second on any modern machine.
2. predictTokenAddress(salt, name, symbol, ...) is a view that returns the deterministic address for any candidate salt without spending gas.
3. Once a matching salt is found, launch(salt, ...) deploys the token at that address. The factory rejects any deploy whose resulting address does not end in 01ad.

The suffix is brand, not privilege. It confers nothing on-chain. The real test of whether an address is a genuine vladpad token is the factory's record of what it deployed, surfaced through the Launched event — integrators should resolve via factory events rather than visual inspection of the tail.

Integrators

vladpad is built to be read from and built on top of, not gated.

Quotes and routing

• All swaps are exact-input. Specify what goes in; the system resolves what comes out.
• During the curve phase, call quoteBuy / quoteSell on the hook for a deterministic figure, then route the fill directly through the hook — only it can fill orders for a token on its curve.
• Post-graduation, routing is standard Uniswap V3. The pool key is (WETH, token, fee = 10000, tickSpacing = 200) with no hook attached after graduation.

Indexing

• Every pool emits the same event set, so an indexer can track the whole system from one contract address.
• Launched is the system of record for which addresses are real vladpad tokens — do not trust the suffix alone.
• Graduated marks the moment the V3 pool exists; later trades are visible on Uniswap V3 directly.

Wallets & UIs

• Quotes are deterministic — show users an exact number, not a range.
• Show the pool phase explicitly; pre-graduation pools route through the hook, post-graduation through a V3 router.
• Surface the mechanic name and any extra fee — anyone buying into a Burn or Last Call pool deserves to know up front.

Contracts

Production deployments will be listed here once testnet integration completes. Addresses are not yet finalized — track the repository for tagged releases.