5xpad.
how it actually works.

pump.fun proved bonding curves print money. but every coin launched on it is naked: no underlying, no narrative beyond the meme, no reason for it to pump tomorrow except hope. the floor is whoever rugs first.

perpetuals proved leveraged exposure prints attention. jupiter perps, hyperliquid move billions per day. but they're intimidating to most people. open a position, set the leverage, manage margin, fear the liq.

so: combine them. the curve handles the launch. the perp handles the price action. the user just buys a meme.

2.1 launch

creator picks an underlying (SOL, BTC, ETH), a direction (long or short), and a leverage (2x, 3x, or 5x). pays ~0.05 SOL in rent and protocol fees. the program mints 1B supply, splits it 75% curve / 25% LP reserve, opens a perpetual position on jupiter perpetuals at the chosen leverage. opening MC: $2,400.

2.2 bonding curve

constant-product invariant x · y = k with virtual reserves. as users buy, USDC fills y, tokens drain from x, price rises along the curve. exact opposite on sell.

buy: Δusdc → Δtokens = (x · Δusdc) / (y + Δusdc)
sell: Δtokens → Δusdc = (y · Δtokens) / (x + Δtokens)
price = y / x

2.3 perp coupling

when the curve has collected $>= $10 of USDC, a worker (anyone can run it; 5xpad.fun runs a default cranker) submits a createIncreasePositionMarketRequest to jupiter perpetuals on the curve's behalf. the curve's per-mint perp_owner PDA signs as the position owner via our program's CPI passthrough. ~5-30s later a jupiter keeper fulfils the request and the position opens against the JLP pool.

from then on the chart moves: jupiter holds the underlying exposure, the position's realised PnL is harvested back into the curve's USDC reserve every time the worker crystallises gains, and the bonding-curve repricing makes that flow visible as a token-price move. you don't hold the perp. the program does. you hold a token whose price tracks what the perp is doing.

2.4 liquidity safety

leveraged backing creates a tension: the perp needs collateral parked on jupiter, but sellers expect instant USDC from the curve vault. 5xpad.fun resolves this with a four-layer system designed so anyone can recover their money within ~30s of asking, even mid-curve.

• 70 / 30 split. only 70% of raised USDC goes to jupiter as collateral. the remaining 30% stays in curve.usdc_vault as an instant-liquidity buffer. small sells settle straight from the buffer with zero perp interaction.
• auto-harvest. every 15s the worker checks the per-curve perp_owner USDC ATA; any USDC sitting there (from a fulfilled decrease, realised PnL, etc.) is pulled back into curve.usdc_vault via the program's harvest_perp_funds ix. funds never get stranded on the perp side.
• auto-close on thin buffer. when vault.amount < 15% of raised, the worker submits a createDecreasePositionMarketRequest(entirePosition: true) on jupiter. once the keeper fulfils, the freed collateral (collateral + realised PnL) returns to the curve and large sells become possible without touching jupiter again.
• permissionless /unwind. the frontend pre-flights every sell against the buffer. when a sell would exceed it, the trade panel auto-POSTs the curve's mint to the worker's /unwind/:mint HTTP endpoint, which submits an immediate full-decrease request (rate-limited to one in flight per mint). the user sees a banner with the close request's solscan link and the button re-enables automatically once the vault has enough.

2.5 non-liquidating deleverage

the backing is a 5x position, but it is not a plain perp that gets liquidated on a wick. the worker runs an alt.fun-style leveraged-token rebalance. each ~15s tick it prices the position against pyth and computes effective leverage = sizeUsd / equity, where equity = collateral + unrealised PnL. when a drawdown pushes effective leverage past ~7x (about a 6% adverse move on a 5x long), it shrinks the notional while withdrawing zero collateral, pulling leverage back to 5x.

effLev = sizeUsd / (collateral + unrealisedPnl)
if effLev > 5 × 1.4:                  # ~7x
    deltaNotional = sizeUsd - 5 × equity
    decrease(sizeUsdDelta = deltaNotional,
             collateralUsdDelta = 0)   # leverage drops, equity kept

# a partial close at mark conserves equity, so the position
# decays toward zero on a sustained dump but never reaches
# its liquidation price. example for a 5x long entered at $100:
#   -6%  -> effLev 7.1x -> deleverage back to 5x
#   -15% -> effLev 7.4x -> deleverage back to 5x
#   -20% -> a static 5x is LIQUIDATED here; ours sits at 4.5x, alive

the deleverage only ever shrinks the notional, never grows it. rebalance-up on gains was tried and removed: the keeper-fulfils → harvest → rebalance-up loop bled fees. the cost of being non-liquidating is volatility decay: each deleverage realises a slice of the loss, so choppy or sideways tape erodes the backing even if the underlying round-trips. no liquidation wick, but not a free lunch.

2.6 graduation

when the curve collects $6,400 USDC (which corresponds to ~$32k FDV market cap) OR the curve reserve is drained, graduation triggers. the program:

1. closes the perp position, realizes PnL
2. combines curve USDC + perp PnL + 25% LP token reserve
3. seeds a raydium CPMM pool
4. locks the LP tokens permanently (sent to the burn address)
5. flips status to Graduated

from that point on the token trades on raydium like any other SPL. no more curve. no more perp backing. you're holding a pure SPL with a known liquidity floor.

3.1 curve seeding

token_supply       = 1_000_000_000  (1B)
curve_reserve      = 75% = 750_000_000
lp_reserve         = 25% = 250_000_000
initial_usdc_seed  = $2,400 (virtual, mirrors pump.fun 30 SOL @ $80)
initial_price      = $2,400 / 1B = $0.0000024 / token
initial_mc         = $2,400
graduation_collected = $6,400 USDC real (80 SOL @ $80, pump.fun-like)
graduation_mc      = ~$32,000 FDV at trigger

3.2 perp sizing

PERP_COLLATERAL_BPS  = 7000  (70% of raised goes to jupiter)
BUFFER_BPS           = 3000  (30% stays in curve vault for sells)

at first seed (raised >= $10):
  collateral    = raised × 70%
  notional      = collateral × leverage
  funding_path  = curve.usdc_vault
                    -> prepare_perp_funds (CPI)
                    -> perp_owner USDC ATA (mint-scoped PDA)
                    -> jupiter createIncreasePositionMarketRequest

per-tick worker checks (every 15s):
  equity   = collateralUsd + unrealisedPnl     # mark-to-market
  effLev   = sizeUsd / equity

  if vault.amount < max($0.50, raised × 15%) and position_open:
    submit decrease entirePosition=true        # auto-close (liquidity)
  if effLev > leverage × 1.4:                  # NON-LIQUIDATING deleverage
    delta = sizeUsd - leverage × equity        #   shrink notional, keep
    submit decrease delta, collateralDelta=0   #   collateral -> effLev back to 5x
  if perp_owner_ata > $0.50:
    call harvest_perp_funds                    # auto-harvest gains
  if unrealisedPnl > threshold(raised):
    submit decrease collateralDelta=pnl        # crystallise gains into curve

position_side = chosen direction (long | short)
venue         = jupiter perpetuals (JLP pool)
                 SOL / BTC / ETH only

3.3 fees

trade_fee    = 1% of trade size
              ↓
            0.50% → creator
            0.50% → protocol treasury
graduation   = no extra fee
deploy       = ~0.05 SOL (rent + protocol)

this is a leveraged product. things can break. the program ships with multiple kill switches:

• invisible TVL cap - soft cap on total notional across all curves. once hit, new launches and new buys revert. starts at $100k, lifted by admin governance over time.
• per-curve notional cap - single curve can't exceed $8k notional during the curve phase. prevents one whale from cornering one market post-graduation.
• whitelisted underlyings - v1 only allows SOL, BTC, ETH (the three markets jupiter perpetuals supports). all have deep JLP liquidity and reliable pyth oracles. exotic perps come later as jupiter expands its market list.
• leverage cap - hard-coded 5x maximum. no degen 100x.
• anti-snipe window - 5 slots (~2s) after launch where trades revert. blocks MEV bots from front-running the creator.
• pause switch - admin can pause new entries within one transaction. existing positions stay redeemable.
• stale-oracle guard - buy/sell revert if the pyth price feed is older than 60s.

• liquidation risk: the backing is a 5x position, but the keeper runs an alt.fun-style deleverage. every ~15s tick it reprices the position against pyth and, if effective leverage drifts past ~7x (about a 6% adverse move on a 5x long), shrinks the notional to pull leverage back to 5x. a partial close at mark conserves equity, so the position decays toward zero on a sustained drawdown but never reaches its liquidation price. residual risk: a violent gap that moves the underlying ~18% inside a single keeper cycle, faster than the deleverage can land, could still liquidate. the 30% curve buffer also never leaves the curve, so even a worst-case wipe leaves holders the buffer to redeem pro-rata.
• volatility decay: the deleverage realises a slice of the loss every time it fires. in choppy or sideways markets this is a drag: the backing can erode even if the underlying round-trips back to the same price. this is the structural cost of being non-liquidating, the same tradeoff every leveraged token carries.
• delayed sell-out risk: if you're the first wallet trying to recover more USDC than the curve buffer can cover, you wait one jupiter keeper cycle (~30s) for the auto-unwind to deliver. the frontend handles this transparently with a banner, but if the keeper network is congested the wait can stretch. funds are never lost, just briefly illiquid.
• smart contract risk: the program is pre-audit at launch. bugs can drain the curve. circuit breakers reduce blast radius but don't eliminate it.
• oracle risk: pyth feeds can stall or misprint. the program reverts on stale feeds but cannot detect malicious feeds.
• jupiter perpetuals counterparty risk: the perp position lives on jupiter perpetuals (JLP pool). if jupiter halts, the keeper network stops fulfilling requests, or the JLP pool runs out of liquidity, the position becomes temporarily unmanageable until jupiter resolves.
• graduation slippage: raydium pool seeding executes at one block's prices. expect ~1-3% slippage at graduation.
• regulatory risk: the structure resembles a synthetic. your jurisdiction may treat it as a security. consult your own legal counsel.

• audit by neodyme or ottersec, plus immunefi bounty
• cross-perp routing: pick jupiter perpetuals, hyperliquid bridges, or adrena once drift comes back online post-april 2026 hack
• leverage tiers up to 10x with mandatory longer anti-snipe
• creator fee customization within bounds (0.25% to 1%)
• on-chain governance for whitelist updates and cap lifts
• cross-chain mirror: hyperliquid-backed coins via wormhole