Documentation

What this is

A launchpad on Robinhood Chain (chain ID 4663) where every token is denominated in a leveraged perpetual position instead of ETH. You pick the market. Supply, curve shape and graduation point are the same for every launch.

The launch itself is a single transaction. It deploys an ERC-20, creates a Uniswap V3 pool against your chosen quote asset, mints two liquidity positions covering the whole supply, and hands both to a locker contract that has no withdraw function. Nobody holds the tokens afterward, including us.

Trading starts immediately at roughly $3,500 fully diluted. There is no presale, no allocation, no vesting schedule and no team wallet.

Why leveraged quotes

Most launchpads price tokens in the chain's native asset. That makes the token's chart a function of one thing: whether people are buying the token.

Denominating in a 3x long instead means the chart moves with two things at once. If the underlying rallies and the token holds its value in quote terms, the position gains on both. If the underlying falls, the quote loses value faster than spot would, and holders feel it.

That is the product. It is more volatile than a normal launch by construction, not by accident.

The curve

The price curve is built from Uniswap V3 range orders rather than a custom bonding curve contract. A concentrated liquidity position that sits entirely above the current price holds only the token being sold. As buyers arrive, price walks up through the range and the position converts token into quote asset. That is the same constant-product behaviour a bonding curve gives you, using an AMM that already exists.

What this avoids

A bonding curve contract has to custody buyer funds and then migrate them into a pool when the curve fills. That migration is a step someone has to trigger, and a step that can fail. Range orders remove it:

Two positions are minted per launch. The lower one is the curve. The upper one starts exactly where the lower one ends. Price crosses from one to the other with no intervention, which is why there is no graduation event to wait for or trust anyone with.

Band geometry

Every launch uses identical proportions. The only input that varies is the quote asset's price, which sets where the bands sit.

Why the widths are constants

Uniswap prices are stored as ticks, where each tick is a fixed 0.01% step. A 14.58x rise is therefore always the same number of ticks regardless of what anything costs: 26,800 of them. The 9.97x band above is 23,000.

That property makes the standard cheap to enforce on chain. The contract does not need any tick math. It checks that the band widths equal those two constants, and separately that the opening price multiplied by supply lands within 5% of $3,500 using the registry's reference price. Two integer comparisons and one multiplication.

Starting price

The pool is initialised one tick spacing below the curve band, never at it. At exactly equal, Uniswap treats the position as straddling the current price and sizes liquidity as the minimum of what each side contributes. A single sided position contributes no quote asset, so that minimum is zero and the mint fails. The contract rejects any configuration that would do this.

Locked liquidity

Both position NFTs are transferred to a LiquidityLocker deployed for that launch. The locker exposes exactly one function that touches the positions, collectFees(), which claims accrued trading fees and splits them between the creator and the platform.

There is no decreaseLiquidity, no burn, no transfer, no owner and no upgrade path. The liquidity is locked by the absence of code rather than by a timelock or a promise.

collectFees() is callable by anyone. Proceeds always go to the two addresses recorded at construction, so there is no privileged caller and no way to redirect the payout. Anyone can pay the gas to trigger a creator's payout, which is harmless.

Fees

Swaps in the launch pool pay the 1% Uniswap fee. That accrues inside the locked positions until someone calls collectFees(), at which point it splits between the token's creator and the platform according to the ratio recorded when the locker was deployed.

Creators can see what each of their tokens has earned, and collect early rather than waiting for the periodic sweep, at leveraged.lol/fees.

The split is immutable per launch. Changing the platform share affects future launches only. A token launched under one ratio keeps that ratio forever, which means creators can check what they signed up for and rely on it.

Fees only accrue on volume inside the launch pool. A buyer paying with ETH crosses other pools on the way in, and those fees go to their respective liquidity providers, not here.

pTokens

The quote assets are Arcus pTokens. Each one is an ERC-20 representing a pro rata share of an externally managed perpetual account. pBTC3x targets 3x long BTC, sBTC3x targets 3x short, pHOOD3x targets 3x long HOOD.

The accounts rebalance on leverage drift rather than on a schedule. When leverage moves past a threshold, the managed account trades back toward target, which resets its distance from liquidation. A gradual decline therefore triggers several deleveraging events rather than being experienced as one continuously compounding position.

The registry

QuoteRegistry holds the list of quote assets that may be used, their decimals, and a USD reference price for each. The factory reads it on every launch.

The registry exists for one reason: to stop launches against a token pretending to be a pToken. An arbitrary quote asset could be pausable, take a fee on transfer, or be controlled by whoever is launching against it. Any of those breaks or drains every pool built on top of it.

Decimals are read from the token contract rather than accepted as input. Everything is keyed by contract address, never symbol, because the same asset appears under different tickers in different interfaces.

Price staleness

Each price carries a timestamp, and launches are refused if it is older than maxPriceAge. This is not a formality. These are 3x instruments. During development a stored pHOOD3x price drifted 15% from NAV in a few hours, which would have opened a token near $4,100 instead of $3,500. The guard caught it.

Price keeper

A background service refreshes the registry every 15 minutes, and always before a price is halfway to expiring.

It reads convertToAssets(1e18) on each vault, which returns the value of one whole share in the vault's underlying asset. It verifies asset() is USDG first and refuses the reading otherwise, because a number denominated in something else would be wrong in a way that is hard to notice.

NAV rather than market price

Vault NAV is the intrinsic value of a share. It cannot be moved by trading. The pToken's own market can be, and those markets are thin, so a few thousand dollars would otherwise be enough to change the opening price of every launch that followed.

The consequence worth stating plainly: launches open at $3,500 of intrinsic value. pTokens can trade above or below NAV, and pHOOD3x has traded at a double digit premium while Arcus deposits were capped. When it does, a buyer acquiring the quote asset pays more than NAV, so the effective opening valuation in money actually spent is higher than $3,500.

The keeper also refuses any reading more than 40% from the stored price. A real move that large is accepted on a later pass once it has been seen consistently.

Buying with ETH

Nobody should have to go and acquire a leveraged pToken before they can buy a memecoin. Buying with ETH is one transaction. The routing happens behind the scenes:

ETH
  wrapped to WETH
  WETH  -> USDG      Uniswap V3, 0.01% fee
  USDG  -> pToken    Uniswap V4, 0.85% fee
  pToken -> token    Uniswap V3, 1% fee, the launch pool
  delivered to the buyer

Selling works the same way in reverse, or you can trade the pToken directly if you already hold it.

Before every buy the whole route is simulated with a static call. That returns the real expected output, which becomes the slippage floor and is shown in the interface. No price oracle or quoter contract is involved. The route quotes itself.

Route construction

The pToken markets live on Uniswap V4. SwapRouter02 cannot traverse a V4 pool at any fee tier, so the route is composed one level up through Arcus's settlement contract, which chains executors that each speak a different venue.

Intermediate hops pass amountIn = 0, which is the settlement contract's sentinel for draining whatever the previous hop produced. That is what makes the chain composable without knowing intermediate amounts in advance.

Currency ordering

Uniswap V4 sorts a pool's two currencies by address, and the swap direction flag depends on which side you are paying in. pBTC3x sorts below USDG. pHOOD3x and sBTC3x sort above it. Hop two always runs USDG into the pToken, so the direction flag differs between them.

This is worth documenting because it is invisible until it bites. A route built by copying a working pBTC3x transaction will fail for the other two, and the failure surfaces as a settlement error inside V4 rather than anything that names ordering.

Scanners and reported liquidity

Third party scanners will report close to zero liquidity on a fresh launch, and some will warn about extreme price impact. Both are artifacts of how those tools estimate depth.

Most scanners approximate liquidity as twice the quote side of a pool. A single sided position holds no quote asset at all until people buy, so that estimate starts at zero and grows only as the curve absorbs quote. It measures how much has been bought, not how much can be.

Actual price impact is small. Measured on a live pool: a $5 buy at the opening price moves it about 0.27%, while a scanner reading $2 of liquidity warned of 94%. Two consecutive real trades executed within 0.05% of each other, which is not possible in a pool as thin as that warning implies.

The curve band holds roughly $10,600 of capacity at launch. The interface shows percentage along the curve, quote raised and capacity remaining, all computed from tick position, because conventional TVL is the wrong measure for this design.

Indexing launches

For data providers, indexers and anyone building on top. Everything below is readable on chain with no API key and no permission.

Discovering tokens

Every launch emits one event from the factory:

event Launched(
    address indexed token,
    address indexed quote,
    address indexed creator,
    address pool,
    address locker,
    int24   curveTickLower
)

Watching that event on 0x6a6dBa380Ad564AAd983d37Ba4c7c2305b739D99 gives you every token, its pool and its quote asset at the moment of creation. There is no other way to create a token through this launchpad, so the event is complete by construction.

For backfill, launchCount() and launches(uint256) enumerate the same records without log queries.

Pool shape

Every pool is Uniswap V3 at the 1% fee tier, tick spacing 200. The launched token is always token0. This is enforced at launch by mining a CREATE2 salt until the token address sorts below the quote address, so you never need to check ordering. amount0 negative in a Swap event means tokens left the pool, which is a buy.

Token contract

Plain ERC-20, 18 decimals, fixed supply of 1,000,000,000. No owner, no mint, no pause, no blocklist, no transfer hook, no proxy. Nothing to special case.

Deriving USD price

This is the part that differs from a normal launchpad. Pools are quoted in Arcus pTokens rather than in an asset most pricing engines already track, so price comes out in two steps.

Step one: token price in quote terms

Standard V3, and since the token is always token0 there is no inversion to handle:

priceInQuote = (sqrtPriceX96 / 2**96) ** 2

Both sides are 18 decimals on every current quote asset, so no decimal adjustment is needed. If a future quote asset is not 18 decimals, multiply by 10 ** (quoteDecimals - 18).

Step two: quote price in USD

Two options, and we suggest the first.

Vault NAV, recommended

Each pToken is a share of a managed account and reports its own value:

vault.asset()                 // expect USDG, verify this
vault.convertToAssets(1e18)   // USD value of one pToken, 6 decimals

This is intrinsic value and cannot be moved by trading. The pToken's own market is thin enough that a few thousand dollars shifts it, so NAV is the more stable input. It is also what the launchpad itself uses.

Registry mirror

If you would rather read one contract than three, the registry holds the same figure, refreshed roughly every 15 minutes:

registry.quotes(quoteAddress)
  -> (enabled, decimals, referencePriceE18, priceUpdatedAt, label)

referencePriceE18 is USD per whole quote token scaled 1e18. Check priceUpdatedAt if you care about freshness.

Putting it together

tokenUsd  = priceInQuote * quoteUsd
marketCap = tokenUsd * 1_000_000_000     // supply is fixed, FDV equals cap

Curve progress

Conventional TVL misreads this design. A single sided position holds no quote asset until people buy, so any estimate based on reserves reads near zero on a fresh launch regardless of how much can actually be traded. Details in scanners.

Position along the curve is the meaningful figure, and it comes straight from the tick:

curveTickLower            // from the Launched event
CURVE_SPAN = 26800        // constant, roughly 14.58x

tick = pool.slot0().tick
progress = (tick - curveTickLower) / CURVE_SPAN     // clamp to 0..1

At progress >= 1 price has crossed into the upper band. That is the closest analogue to graduation, though nothing happens on chain when it does. There is no migration and no state change, only a price level.

Total curve capacity is fixed at launch and works out around $10,600 in quote terms.

ABIs

A single JSON file covers the factory, registry, locker, launched token and the vault call needed for pricing, along with every address and constant:

leveraged-abi.json

Contracts are verified on chain. Source is readable on the explorer for the factory and registry, and the locker and token source are contained in the same file.

Anything missing, or a field you need that is not exposed, is worth telling us about. Adding a view function is cheap.

Risks

The quote asset can go to zero

A liquidated pToken keeps existing as a transferable ERC-20 while being worth nothing. The pool does not break, it keeps pricing its two assets normally. What breaks is the denomination. Anyone holding a pile of the dead pToken can swap it in and take the launched token's supply for nothing. This is not a gradual decline in value, it is a drain.

Liquidity cannot be rescued

There is deliberately no migration function. Adding one would mean every launch carried a live admin power over its liquidity forever, to hedge a risk that is the entire point of the product. Locked means locked, including when that hurts.

Leverage

3x instruments lose value faster than the underlying and can be liquidated. Nothing here changes that, and denominating a memecoin in one compounds it.

Addresses

Robinhood Chain, chain ID 4663.

Platform

Factory       0x6a6dBa380Ad564AAd983d37Ba4c7c2305b739D99
QuoteRegistry 0x797F3EcE090850a7c7702F0E2e2D3b931a083be2

Quote assets

pBTC3x   BTC 3x long    0x4472C69d299382F8847ebCE4FC6Ed8e295510E3e
pHOOD3x  HOOD 3x long   0xe24CABDf76DD1c2576049167eB1755C84b985C36
sBTC3x   BTC 3x short   0xaDccEee8e422050F890522FA798F8A93a4857083

Infrastructure

Uniswap V3 factory   0x1f7d7550B1b028f7571E69A784071F0205FD2EfA
Position manager     0x73991a25C818Bf1f1128dEAaB1492D45638DE0D3
SwapRouter02         0xCaf681a66D020601342297493863E78C959E5cb2
Uniswap V4 pools     0x8366a39CC670B4001A1121B8F6A443A643e40951
WETH                 0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73
USDG                 0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168

FAQ

Can the creator rug?

Not through liquidity. The whole supply goes into locked positions at launch and the locker has no withdraw function. The creator can buy their own token like anyone else, and can sell what they bought.

What does the launched token contract do?

Nothing beyond ERC-20. No owner, no mint function, no pause, no blocklist, no transfer hook, no proxy. Fixed supply, set once at deployment. It is short enough to read in a couple of minutes and worth doing.

What happens when the curve fills?

Price crosses into the second position and keeps going. Nothing has to happen and nobody has to do anything. The distinction between "on the curve" and "graduated" is a price level, not a state change.

Why is Dexscreener showing $0 liquidity?

See scanners. It is measuring the quote side of a position that starts with none.

Can I launch against ETH instead?

Not currently. It is a small change and is planned. Everything in the factory is quote agnostic already.

Who can collect the fees?

Anyone can call collectFees(). The proceeds always go to the creator and the platform in the recorded ratio, regardless of who paid the gas.