Documentation

Long Your Longs is a memecoin launchpad on Solana. Every token launched here has two layers running in parallel:

1. A standard bonding curve on Solana. Buy SOL into the curve, get tokens. Sell tokens, get SOL back. Identical mechanic to pump.fun if you have used it before.
2. A leveraged perpetual position on Hyperliquid that grows and shrinks in lockstep with the curve. You pick the asset (BTC, ETH, SOL, anything Hyperliquid lists), the direction (long or short), and the leverage (up to 3x).

Result: the token's economic backing is not "vibes" or "creator credibility". It is a live, mark-to-market position that anyone can verify on Hyperliquid's public block explorer. If you launch a 3x long BTC token and BTC pumps, your token's NAV pumps. If BTC dumps, your token's NAV dumps.

• Find a token on the home page. Connect Phantom or Solflare.
• Buy with SOL. Minimum 0.15 SOL per buy (below that the bridge fees eat too much).
• Your buy mints tokens on the curve and bridges ~99% of your SOL (1% fee) to Hyperliquid, which opens a proportional perp position.
• Watch the chart. Token price tracks the underlying perp.
• Sell anytime. You receive SOL minus a 1% fee. The perp shrinks proportionally.

• Click Launch Token.
• Pick a name, ticker, the perp to back (BTC, ETH, SOL, etc.), direction, and leverage (1x, 2x, 3x).
• Approve the transaction. You pay only Solana rent, around 0.005 SOL.
• Your launch goes live immediately on the home page.
• You earn nothing directly. The 1% curve fee funds operations (bridge costs, gas, slippage).

Most memecoin launchpads pair the token with nothing real. Liquidity is sentiment. Once attention fades, the token round-trips to zero.

Long Your Longs pairs the token with a position on a real perpetual market. That position is liquid, marked to market every second, and visible on a public order book run by a real exchange. You can argue with vibes. You cannot argue with a fill price.

The product is a thin wrapper around three things that already exist and work:

1. Solana for the token, because it is fast and cheap.
2. Hyperliquid for the perp, because it has the deepest non-CEX perp orderbook in crypto.
3. deBridge DLN for the cross-chain glue, because it works at small sizes without trust assumptions.

Everything else in this document explains how these three pieces fit together.

From a trader perspective the experience looks like buying any pump.fun coin, with two differences.

First difference: the chart shows the underlying perp.The token's NAV is mechanically tied to the perp's mark. If you launch a 3x long BTC token at BTC mark $77,000 and BTC moves to $80,000, the curve owns more USD than it started with (3 times the move), and you can sell back for proportionally more SOL.

Second difference: the curve never graduates. Pump.fun-style launches eventually migrate to Raydium and lose the curve mechanic. We never do that. The curve is permanent. The perp runs forever.

What actually happens when you click buy:

1. Your wallet signs one Solana transaction. Tokens land in your wallet in under a second.
2. A backend daemon (the bridge crank) observes the buy event on Solana and ships USDC to Hyperliquid.
3. The perp manager contract on Hyperliquid opens a proportional perp position. Typical end-to-end latency: 30 to 60 seconds.

While the bridge is in flight you already hold the tokens. The perp settling does not block your trade.

Launching a token is a single Solana transaction. You pick:

• Name and ticker. Just metadata. Anything memorable.
• Perp asset. The Hyperliquid market your token tracks. BTC is the default. Anything Hyperliquid lists works.
• Direction. Long or short. Long bets the asset goes up. Short bets it goes down.
• Leverage. 1x, 2x, or 3x. Capped at 3x for safety.

You do not need to seed liquidity. The bonding curve starts with virtual reserves; the first buyer is the first real liquidity. You do not earn anything from the launch directly. The protocol takes 1% from every trade and uses it to fund bridge fees, gas, and rebalance slippage. No tokens are reserved for the creator. There is no team allocation.

Traditional memecoin curves graduate. After a certain SOL threshold, the curve dies and liquidity migrates to a constant-product AMM. We never do that. Three reasons:

1. Graduation breaks the perp link. Once liquidity is on Raydium, our backend has no way to observe trades and adjust the perp. The token would drift away from the perp it was supposed to be backed by.
2. The curve is good liquidity. A constant-product curve gives predictable slippage and unlimited depth at the extremes. There is no reason to migrate.
3. It is the only way to keep the promise. If we tell traders "this token tracks a 3x BTC long forever", then we cannot turn off the mechanism halfway.

So: the curve is permanent, the perp is permanent, and the only way the token dies is if the underlying asset goes to zero (a real perp event).

There are two ways to launch. Most launches use Mode A. Mode B is for creators who want the pump.fun audience.

Mode A (perp-backed direct). The token is a synthetic SPL minted by our Solana program. The bonding curve operates on our program. Every buy and sell flows through us. Every trade triggers a proportional perp adjustment on Hyperliquid. This is the default in the launch form.

Mode B (pump.fun-routed). The token is a real pump.fun token. The launch transaction creates the pump.fun token in the same transaction as our PumpLaunch registration, with our PDA registered as the pump.fun creator. Users trade the token on pump.fun. Pump.fun pays 5 basis points of every trade as creator fees to the registered creator (our PDA). Our harvester bot claims those fees every 2 minutes and bridges them to Hyperliquid to grow the backing perp position.

Mode A is tighter (every trade adjusts the perp immediately). Mode B is looser (perp grows only as creator fees accumulate) but rides pump.fun's distribution.

Verified Mode B launch: Dx6XfGFKWgm6begrwwvx6ntmzfkptnBos5FsvqFKBApq (init tx 5pA9Xf4CrJfPbKaAod3PyQ29aydPeCrbg9jMGo4YDiuCuJK4uULzThfV7Rwd7PgdMCjCsdjryC7fB31mcFHMMFCv).

Three independent layers communicate through asynchronous bridges. There are no synchronous cross-chain calls.

1. Solana bonding curve. An Anchor program (C1q8mGfr8a5rfPbaCJ1mGpocsDJc1xXZxbX1adLAX4r9) holds the constant-product curve, mints synthetic SPL tokens, and emits intent events (BuyIntent, SellIntent, HarvestIntent, LaunchInitialized) on every state transition.
2. Bridge crank (off-chain). A Node daemon subscribes to the Solana program logs and turns each intent into a deBridge DLN order shipping wSOL on Solana into USDC on HyperEVM. It then drives the perp manager via direct EVM calls. Source resides at bot/bridge-crank/index.ts and runs as a pm2 process on the BWICK val3 validator (159.223.173.162).
3. LYL Perp Manager on HyperEVM. A Solidity contract (0x1ddf514644fc66492d39fcb6a452cdcb2a5bf3d5) that deposits USDC into Hyperliquid via CoreDepositWallet (0x6B9E773128f453f5c2C60935Ee2DE2CBc5390A24), places limit orders via CoreWriter (0x3333333333333333333333333333333333333333), and withdraws USDC back to Solana through the sendAsset action (id 13) targeting the USDC system address (0x2000000000000000000000000000000000000000).

The curve is constant-product (Uniswap v2 style) with virtual reserves seeded at launch. Each launch starts with virtual_sol = 30 SOL and virtual_tokens = 1.073B (in 1e9 base units). The invariant k = virtual_sol * virtual_tokens is constant across trades.

Buy. Given sol_in, the program transfers (sol_in * (1 - fee_bps/10000)) into the launch escrow, computes tokens_out via the difference of virtual_tokens before and after, and mints to the user.

Sell. Inverse formula. Given shares_in, the program computes sol_out, applies fee_bps, transfers net_sol_out to the user, then burns the shares.

The curve runs in perpetuity. There is no graduation event. Every trade emits an intent for the bridge crank. Source: programs/lyl/src/instructions/{buy,sell}.rs.

Why is there a 0.15 SOL minimum buy?

Every buy on a perp-backed launch (Mode A) opens a proportional position on Hyperliquid. Doing that requires moving SOL → USDC across chains via deBridge DLN, plus a Solana → HyperEVM hop, plus an L1 deposit, plus a CoreWriter limit order. Each of those steps carries a fixed cost. At small ticket sizes those fixed costs swamp the trade.

• deBridge solvers quote poorly under ~$10. We've observed roughly a 56% haircut at 0.2 SOL when the solver is unhappy with the size.
• HyperEVM gas + CoreWriter dispatch adds a fixed ~$0.20.
• Jupiter slippage on the eventual USDC → wSOL refill adds another small fixed cost.

0.15 SOL (~$13 at current SOL price) is the empirical floor where the position opens cleanly and the curve refills properly. Below that, the perp side either fails to fill or fills at a price that orphans the token from its backing. The frontend hard-caps below this threshold; the rebalance daemon similarly caps at MIN_REBALANCE_USDC = $3 for the same reason.

Why a 1% fee on every trade?

Each launch carries a fee_bps field set at init (default 100, equal to 1%). On every buy, fee_bps × sol_in / 10000 lamports of native SOL are forwarded to the bridge cranker wSOL ATA. On every sell, the same percentage of sol_out in wSOL flows from the launch escrow to that ATA.

The 1% covers the three operational costs the cranker bears on your behalf:

• Solana gas for release_to_bridge and rebalance transactions.
• deBridge protocol fees on each USDC round trip (0.05 HYPE per order plus solver spread).
• Jupiter slippage on the USDC → wSOL conversion that refills launch escrows during rebalance.

None of the 1% goes to a creator or team allocation. Cranker wSOL ATA owner: 5BYyHQHe8CMcAMJogQpz2c9wukSSAZdhrsdnvSFwTVVx. The ATA is the Associated Token Account of NATIVE_MINT under this owner.

The crank is a long-running Node process. On each emitted intent it executes a two-phase bridge. A naive single-tx implementation that embeds a deBridge hook in the DLN order exceeds the Solana 1232-byte transaction limit, so the crank splits the operation into a plain DLN order followed by direct EVM calls to the perp manager.

BuyIntent path:

1. release_to_bridge ix on Solana drains the buy escrow into the cranker wSOL ATA.
2. registerLaunch on the manager (idempotent, no-op if already registered).
3. deBridge create-tx HTTP API constructs a wSOL to USDC DLN order. Cranker signs and submits.
4. Cranker polls the manager EVM USDC balance until the order is filled (typical 10 to 30s).
5. openLaunch on the manager. Approves USDC to CoreDepositWallet, deposits to its L1 perp account, then sends a CoreWriter limit order at mid * 1.005 (long) or mid * 0.995 (short), IOC, with size derived from sol_in * solUsd * leverage / mid.

SellIntent path:

1. closeLaunch on the manager. Reduce-only IOC at price slipped 0.5% from mid.
2. Cranker verifies a fill appeared in userFills.
3. requestBridgeBack on the manager. Two CoreWriter actions: usdClassTransfer (perp to spot) then sendAsset to USDC_SYSTEM_ADDR. Hyperliquid credits the manager EVM USDC balance one L1 block later.
4. sweep(USDC, cranker, amount) on the manager pulls the USDC into the cranker EVM wallet.
5. Rebalance daemon (separate process) picks up the EVM USDC, creates a deBridge DLN order back to Solana, swaps USDC to wSOL via Jupiter, and transfers wSOL into the relevant launch quote ATA so future sells are funded.

deBridge chain IDs: Solana 7565164, HyperEVM 100000022. deBridge DLN source on HyperEVM: 0xeF4fB24aD0916217251F553c0596F8Edc630EB66. Fee for the source token swap is paid in native (HYPE on HyperEVM, SOL on Solana).

The HyperEVM contract that owns all perp activity. Active version is V9 at 0x1ddf514644fc66492d39fcb6a452cdcb2a5bf3d5. The contract is non-upgradeable. Earlier versions (V5 through V8) are deprecated. V6 and V7 hold approximately $27 of stranded USDC each on their L1 accounts due to encoding bugs in spotSend that were fixed in V8 (correct decimal scaling) and V9 (sendAsset action 13 with the system address pattern).

Functions.

• registerLaunch(launchPda, perpAsset, direction, leverage): permissionless. Records a launch with its perp asset, side, and target leverage cap.
• openLaunch(launchPda, limitPx, sz, usdcAmount): approves USDC, deposits to L1 perp account, places IOC limit order.
• closeLaunch(launchPda, limitPx, sz, solanaRecipient): reduce-only IOC.
• requestBridgeBack(launchPda, usdcAmount, solanaRecipient): queues a L1 to EVM USDC withdrawal via usdClassTransfer plus sendAsset.
• sweep(token, to, amount): owner-only ERC20 transfer out of the manager.
• addApiWallet(apiWallet, name): owner-only. Registers an EVM key as a Hyperliquid API wallet for the manager's L1 account.
• sendCoreAction(bytes): owner-only generic CoreWriter passthrough.
• pushUsdcToL1(amount): permissionless. Deposits manager EVM USDC into the manager L1 perp account.
• flushSpotUsdc(spotWeiAmount): owner-only. Pushes a specific L1 spot USDC amount back to EVM.

Manager EVM owner equals cranker EVM key: 0xaEDA0466b386EEa67a16238e2E8d3Caf38acb643. The same key is registered as the manager L1 account's API wallet, giving it authority to sign Hyperliquid REST exchange actions on behalf of the manager. Current L1 leverage: 3x cross on BTC. View live state at 0x1ddf514644fc66492d39fcb6a452cdcb2a5bf3d5.

A third process (sibling to bridge crank and pump fee harvester) maintains the invariant that each launch's quote escrow holds enough wSOL to refund a typical sell.

Every 120 seconds the daemon iterates every Launch account on the program. For each, it compares the on-chain launch_quote_ata wSOL balance to a target ratio of real_sol_reserves (default 50%). If actual is below 60% of target, it computes the deficit in USDC, caps it by the manager L1 withdrawable balance, then executes the five-step refill:

1. requestBridgeBack(launchPda, usdcAmount, cranker).
2. Wait for USDC arrival on manager EVM (one L1 block).
3. sweep(USDC, crankerEvm, amount).
4. Cranker creates a deBridge DLN order from its EVM wallet to its Solana wSOL ATA.
5. Jupiter swap USDC to wSOL, then SPL token transfer into the target launch_quote_ata.

Cold-start funding requirement: the manager L1 perp account must hold at least MIN_REBALANCE_USDC of free margin (default $3) for the daemon to proceed. As cumulative buy volume accumulates margin on the manager, the daemon naturally activates.

The transactions below verify each subsystem against live mainnet state. Click any to open the explorer.

• Cranker key is hot. The bridge cranker EVM key controls the manager (owner of V9) and the Solana cranker key signs release_to_bridge. If either key is compromised the manager USDC and the Solana wSOL transit pool can be drained. There is no multisig in V1.
• Cranker bears bridge fees. Each rebalance round trip costs roughly $2.50 in deBridge protocol fees plus solver spread plus Jupiter slippage. Curve fees (1% per trade) accrue to the cranker to amortize this. For tokens with low volume the fee revenue may not cover operational costs.
• Solver pricing on small bridges. deBridge DLN solvers quote poorly for sub-$10 SOL to USDC bridges (observed roughly 56% haircut at 0.2 SOL). The frontend enforces a minimum buy of 0.15 SOL and the rebalance daemon caps at MIN_REBALANCE_USDC = $3.
• Perp risk passes to token holders.Token NAV moves with the mark of the backing perp times leverage. Liquidations on the manager L1 account would reduce the curve's ability to refund sellers in full. Current default leverage is 3x cross. Default direction is long. Hyperliquid L1 liquidation occurs at maintenance margin breach.
• Stranded funds on retired managers. V6 and V7 hold approximately $15.92 and $11.65 respectively on their L1 accounts. These contracts lack the spot recovery function and the funds cannot be recovered without redeploying logic at the same address (impossible for non-upgradeable contracts). V9 onward includes flushSpotUsdc as a recovery escape hatch.
• No KYC, no warranty. The launchpad is an interface to decentralized protocols. Token launches are conducted by third parties. The operators do not endorse any specific launch.

Is this a pump.fun fork? No. We share the bonding-curve mechanic but add a Hyperliquid perp behind every launch. Mode B can route through pump.fun's curve for distribution.

Why Hyperliquid and not dYdX or another perp DEX? Hyperliquid has the deepest non-CEX perp orderbook, no KYC, and a precompile (CoreWriter) that lets a smart contract place orders programmatically. None of the other perp DEXes have this property today.

Why cap leverage at 3x? Above 3x the perp liquidates too easily on normal market noise, which would orphan the curve from its backing. 3x balances upside with survivability.

Can I launch with my own assets as backing? Only assets Hyperliquid lists. As of writing this is ~150 perps (BTC, ETH, SOL, all majors, all mid-cap memes).

Can the curve be drained? No. The curve is a constant-product invariant. The only way SOL leaves the curve is in exchange for the corresponding token amount.

What if Hyperliquid goes down? The Solana curve keeps trading. New buys queue intents that bridge once Hyperliquid recovers. Sells refund from the existing wSOL escrow.

What if Solana goes down? The Hyperliquid perp keeps running and any open position remains hedgeable. New buys and sells pause until Solana recovers.

What if deBridge goes down? Bridge crank stops. Sells still refund from existing wSOL escrow. Buys still mint tokens. The perp adjustment is delayed until deBridge resumes.