# Gap v4 settings

Pangea v3: every new launch, stock pairs and questions. Every launch since 2026-11-02 is a v3 launch, made by factory v3 on all five chains. This tab is everything new in v3: the factories, the fee hook, launch buys, stock pairs, the bridge price-gap fee, Solana, the security model, and plain-language questions and answers at the end. Bridging, routes and the APIs are in the V2 tab and hold for v3 except where this tab says otherwise. A Gap v4 coin lives on up to six worlds: Robinhood Chain, Base, Ethereum, BNB Chain (BSC), Solana and Elysium. The four EVM chains and Solana carry LayerZero and Hyperlane; Elysium (chain id 99901, gas in HYPE) carries Hyperlane only.

Every v4 parameter is an admin setting per chain, most with a per-coin override, with no built-in range. The only refusals are arithmetic and the message format: a bridge fee of 10,000 bps or more, a pool fee of 1e6 or more, a zero address where an address is a key. Each setter takes effect at once and emits an event; there is no timelock. A setting that makes no sense, such as a floor above its ceiling, resolves the same way every time: the ceiling wins.

## What no setting can change

- An arrival is never credited more than the amount sent.
- No admin function can move, mint or seize anyone's tokens or pool liquidity.
- A pause stops only new sends: a message already sent can always be received: credited, or held and later released or refunded.
- No admin can change a coin's supply, balances or mint authority (on Solana it stays with the frozen program).

## The shared bridge program (Solana)

| Setting | Scope | Units | Default | Effect |
| --- | --- | --- | --- | --- |
| `margin_k_e6, margin_min_ppm, margin_max_ppm` | program, coin override | K x 1e6; ppm | 1e6; 1,000; 100,000 | the destination margin curve |
| `k_on, kk_e6, k_min_ppm, k_max_ppm` | program, coin override | on/off; K x 1e6; ppm | on; 2e6; 15,000; 200,000 | the backstop k |
| `lookback_sec` | program, coin override | seconds | 30 | the plain path's look-back |
| `record_min_age_slots, need_record_on` | program, coin override | slots; on/off | 3; on | a send, and a price-path arrival, needs a record at least N slots old (GapNeedRecord); keep N x 0.4 s below the look-back, or every send and arrival holds |
| `lock_on` | program, coin override | on/off | on | the buy's same-transaction sale lock; the check of every other instruction touching the pool or its hop pools is always on |
| `fee_cap_ppm, min_liquidity` | program, coin override | ppm; DAMM liquidity | 10,000; 0 | fee counted in the price paid and at the destination; least in-range liquidity read |
| `send_lamports, send_cu, swap_lamports, swap_cu, priority_micro_lamports` | program, coin override | lamports, compute units, micro-lamports per unit | 0 | the gas part of the cost cover |
| `sol_usd_min_e18, sol_usd_max_e18, cover_cap_usd_e18` | program, coin override | USD x 1e18 | unset; unset; $10 | the SOL price band and the cover cap |
| `burn_on` | program, coin override | on/off | on | on: the withheld part is burned. Off: nothing is withheld, the arrival is credited in full |
| `sends_paused; SendPaused per destination` | program; coin and route | on/off | off | refuses new sends; arrivals always land |
| `Escape` | coin | on/off | off | an emergency switch: arrivals credited in full |
| `BridgeFee, Delivery, Composers` | program | as v3 | as v3 | the bridge fee of new stores (below 10,000 bps; fixed in a store at its start), delivery keys, listed composers |
| `UsdAnchors` | program, 4 slots | mints | set at deploy | the tokens counted as exactly $1, where a coin's price path may end. A parameter: it allows or refuses no pair token. A USD anchor prices at $1 with no path, wrapped SOL by its path, any other token in dollars only |
| `Venue(kind, program)` | program, 6 reader kinds | program id | the mainnet programs | which program each price-path reader reads: Meteora DAMM v2, Orca Whirlpool, Raydium CLMM, Meteora DLMM, Raydium CPMM, Raydium AMM v4. Re-pointing a kind makes its paths unreadable until anyone replaces them |
| `RentMarkupBps` | program | bps | 1,000 | the markup on the token-account rent our delivery key pays when an arrival opens the recipient's account (rent x 1.10) |
| `LaunchesStopped` | program | on/off | off | stops new v4 coins |
| `init_gap_delivery (the gap admin)` | program | accounts | none | creates our delivery account (GapDeliveryV4) once: markup 1,000 bps, max age 900 s, LayerZero gas 1, no chain listed |
| `set_gap_delivery: Keepers, FeeTo` | program | two keys; account | none; unset | who may refresh the cost figures (and the admin); where swept charges go |
| `set_gap_delivery: MarkupBps, MaxAgeSec` | program | bps; seconds | 1,000; 900 | our charge = cost x (1 + markup), rounded up; how long a figure counts |
| `set_gap_delivery: StaleMode` | program | 0 refuse / 1 LayerZero | 1 (owner, 11-06) | what a send does when the figure is stale, never set or above its cap: 1 goes LayerZero's own way with no charge of ours; 0 refuses (6047, nothing moved) |
| `set_gap_delivery: LzGas` | program | gas | 1 | the lzReceive gas LayerZero's executor is asked for toward a chain our keys deliver |
| `set_gap_delivery: Eid, Cost, ComposeCost, Cap` | destination chain (8 slots) | endpoint id; lamports | none listed; 0 = no cap | which chains our keys deliver to, a figure set by hand, the compose figure, and the most a refresh may write (above it: 6050, nothing written; a figure above a lowered cap counts as stale) |
| `refresh_delivery_cost, refresh_compose_cost (keeper or admin)` | destination chain | lamports | none | the live cost figures, refreshed every minute by our keeper |
| `sweep_delivery_fees (anyone)` | program | none | none | pays every charge above the account's rent to the fee recipient; nobody can choose another payee |
| `Alt` | program | lookup table | none (required before launches) | the one shared address lookup table LayerZero's executor is handed; a wrong one only delays deliveries |
| `the coin's price path (passed in its launch)` | coin | 1 or 2 pools | found by the launch page | the pair token's dollar path: pools of the six venues above ending in a USD anchor, checked only to read at launch; of those that read, the deepest (the dollars a 2% move takes on its thinnest pool), never the shortest. No admin picks or approves it; the coin and bridge pages judge the path as stored (a thin one shows a weak price path badge, one that does not read is shown so), the risk is the creator's. Anyone may replace a stored path once it stops reading (never merely because a pool was touched that same second); the launch tooling first raises every v3 pool of the path to two price observations (increaseObservationCardinalityNext(2), charged in the fee), so a touch cannot make it stop reading. A path replaced since launch shows a “price path replaced since launch” badge, and anyone can put the launch path back whenever it reads (replaceCoinPath with the launch hops). On Solana the stored route's depth is not measured yet: its badge says “depth not measured”, not weak |
| `replace_quote_route (anyone)` | coin | 1 or 2 pools | none | once a coin's stored path stops reading, anyone may replace it with one that reads (the same checks); refused while the stored one still reads |
| `set_launcher, add_route (the deploy key)` | program | program id; RouteV4 per eid | the launcher; none | not admin settings: only the program's deploy key, before the program is frozen, and impossible after |
| `init_gap_config, propose_gap_admin, accept_gap_admin` | program | accounts | the owner at deploy | the gap config once, by the program's deploy key before the program is frozen; the admin in two steps |
| `withdraw_fee (the gap admin)` | coin | amount | none | the store's bridge fees (its escrow beyond what is locked), never a user's tokens; paid only to the platform's own account for the coin (the launcher's fee recipient), never to an account the admin names |
| `wire_peer(eid) (anyone); add_route (before the freeze)` | coin; program | endpoint id | none | a peer only from the route table written before the freeze, forced to the coin's EVM token address; no key can set a peer, the delegate, a library or a DVN |

## The launcher program (Solana)

| Setting | Scope | Units | Default | Effect |
| --- | --- | --- | --- | --- |
| `set_paused(paused)` | program | on/off | off | stops every launch at once; launched coins are untouched |
| `set_pool_fee_bps(bps)` | program | bps | 100 (1%) | the flat base fee every new pool opens with |
| `set_version(slot, version)` | program, 4 slots | program id, kind, on/off | empty | lists an OFT program version, or stops launching on it |
| `set_quote(slot, mint)` | program, 4 slots | mint | slot 0 wrapped SOL | the quote mints a pool may pair against |
| `propose_fee_recipient(key), accept_fee_recipient` | program | account | unset (no claim) | the platform's share of the LP fees, in two steps: the admin proposes, the new recipient accepts |
| `add_operator, remove_operator` | program | account | none | who may call launch |
| `clear_tokenomics (the platform admin only)` | coin, on Solana | none | none | clears a wrongly pinned tokenomics account (a stale creator role's pin): unlike turning tokenomics off, no fee claim runs first and nothing more is paid to the cleared account; this chain is off again, so the fee claim pays the coin's current creator role, which may then turn tokenomics on again |
| `claim_fees (anyone)` | coin | none | none | pays a launch's LP fees by v3's split to the fee recipient and the launch's creator; neither can be chosen by the caller |
| `launch_with_buys (a listed operator)` | launch | no list | a list of at most 32 | launch, plus the buys of a sealed list of the creator's, spending at most the quoted cap; a list that cannot be used is skipped and never fails the launch |
| `create_buy_list, add_buy_entries (the payer)` | list | none | 1 to 32 entries | opens and seals one payer's list for one launch; the money stays in the payer's own token account, with the list as delegate; nothing edits a sealed list |
| `claim_buy (anyone)` | list entry | none | none | pays one bought entry to its named wallet; the sender is repaid the token account's rent; the caller cannot change who is paid |
| `close_buy_list (the payer)` | list | none | once every bought entry is claimed | returns the list's lamports to the payer; the money needs no instruction of ours, plain SPL takes it back |
| `open_v4; stage_open_v4 then open_v4_staged (the opener)` | coin, on Solana | a frozen coin id, the opener's price, an optional opening buy and buy list | none | opens a shared-bridge coin on Solana: its 1B minted into its own pool at the opener's price, the opening buy and the list's buys in the same open; staged only when one transaction cannot hold the arguments |
| `co_buys (every payer signs the transaction)` | launch transaction, on Solana | 1 to 3 other payers; up to 32 entries, each a wallet, amount, minimum and deadline | none | right after the open in the same transaction, buys from each payer's own quote account; an entry past its deadline, under its minimum or beyond what its payer holds is skipped alone and never fails the launch; the web caps the entries so the one launch transaction fits Solana's size limit |
| `init_cobuy_pot (anyone)` | quote mint | none | none | creates the account co-signed buys of one quote pass through (empty between uses), once per quote; the caller pays its rent |
| `claim_cobuy (anyone)` | co-signed buy | none | none | pays one co-signed buy's coins to the wallet its entry named; the sender fronts that wallet's token account rent and cannot change who is paid |
| `enable_tokenomics (the coin's current creator)` | coin, on Solana | the chain's tokenomics account | off unless chosen at the open | turns this chain's tokenomics on, once: from then on the creator share of the LP fees goes to the coin's tokenomics account; this launch's fee claim runs right before it in the same transaction |
| `admin_enable_tokenomics (the platform admin only)` | coin, on Solana | the chain's tokenomics account | none | turns this chain's tokenomics on, or points it at another tokenomics account, at any time, whether or not the creator role is renounced; this launch's fee claim runs right before it in the same transaction |
| `disable_tokenomics (the platform admin only)` | coin, on Solana | none | none | turns this chain's tokenomics off again; this launch's fee claim runs right before it in the same transaction |
| `admin_enable_tokenomics (the platform admin only)` | coin, on Solana | the chain's tokenomics account | none | turns this chain's tokenomics on, or re-points it to another tokenomics account while on, at any time, renounced or not; this launch's fee claim runs right before it in the same transaction |
| `clear_tokenomics (the platform admin only)` | coin, on Solana | none | none | clears a wrongly pinned tokenomics account (not an off: nothing is claimed to the cleared account first); the coin's current creator may then turn it on again |
| `add_opener_liquidity_v4 (the opener, for itself)` | coin's official pool, on Solana | coin and quote amounts, a minimum liquidity | none | adds the opener's own two-sided position at the pool's current price, right after the open in the same transaction (or later): the coins from its opening buy, the quote from its own account; the position is the opener's, not locked, and can be withdrawn; refused under the opener's minimum (slippage bound); what is not used stays in its accounts |
| `close_staged_open (who staged)` | staged open | none | none | gives back the rent of staged open arguments that were never used |
| `acquire_quote_unit (anyone, for themselves)` | launch transaction | lamports to wrap; a Jupiter v6 or pool swap | 1 lamport for wrapped SOL | right before a launch, buys the one pair-token unit the pool's creation takes from the operator (wraps its SOL, swaps it into its own pair-token account, then checks that account holds at least one unit), so the operator holds no float; nobody but the caller's own money moves. Our launches charge the unit's quoted cost, cap what the swap may spend at 1.5 times that charge, and check the swap's accounts before the operator signs it |

## Off-chain switches

| Setting | Scope | Units | Default | Effect |
| --- | --- | --- | --- | --- |
| `NEXT_PUBLIC_GAP_V4` | web | on/off | off | shows the v4 bridge card, the v4 launch option and these docs |
| `PANGEA_GAP_V4` | backend | on/off | off | lets the launch worker launch v4 coins and runs the v4 watchdog; existing v4 coins are recorded and swept either way |
| `FACTORY_V4, FACTORY_V4_BLOCK` | per chain env | address; block | unset | the chain's immutable v4 factory: the launch worker, the registry, list-launch, the EVM fee sweep, the gas keeper and the supply mirror read it (v3's delivery, DVN and arb do not) |
| `FEE_COLLECTOR_V4` | per chain env | address | unset | a v4 collector apart from v3's, if any: the launch-id-in-use check and the stranger-payment check read it; it never marks a launch paid (the ticket's own collector does) |
| `GAP_V4_HOLD_ALERT_S, GAP_V4_REPEAT_S` | v4 watchdog | seconds | 900; 21,600 | how long a send may go without an arrival before it is raised, and how often a lasting alert repeats |
| `GAP_V4_COVER_BLOCKS, GAP_V4_WATCH_STATE_FILE` | v4 watchdog | blocks; path | 2,000; the unit's state directory | how far back a coin with no cursor starts the cover check; where what was said is kept |
| `SWEEP_V4_MIN_QUOTE` | v4 Solana sweep | quote base units | 100,000 | the least LP fee claim worth sending |
| `SWEEP_V4_GAP_ADMIN_KEY_FILE` | v4 Solana sweep | must stay unset | unset | set = the sweeper refuses to start (G-OFF L-20: the GapConfigV4 admin key never goes on the sweeper host); the v4 bridge fee is reported, and withdrawing it is a manual owner step |
| `PANGEA_KEEPER_MAX_STEP_BPS` | deviation keeper, web build, SDK, bots | bps, whole, 500 to 5,000 | 5,000 | the largest raise the deviation keeper may post for one cost figure in one post (a bigger move goes in steps); every paid send adds max(15%, this) to its quoted fee and gets the unused part back in the same transaction; an invalid value: the keeper refuses to start |
| `DELIVERY_V4_MIN_BACKUP_S` | delivery bot | seconds | 20 | the least wait before our keys back up LayerZero's executor on a v4 arrival |
| `DELIVERY_PRIVATE_RPC_ETHEREUM, DELIVERY_PRIVATE_RPC_BSC` | delivery bot | provider list | unset | send deliveries through private relays on Ethereum and BSC |
| `GAP_V4_DELIVERY_WARN_S, GAP_V4_DELIVERY_PAGE_S` | v4 watchdog | seconds | 300; 600 | the age of a Solana delivery figure at which the watchdog warns, then pages (read off the delivery account itself, beside the keeper's own alerts); it also says when the mode refuses, when charges wait to be swept and when no fee recipient is set |
| `KEEPER_V4, KEEPER_V4_ALLOWANCE_PPM` | optional keeper | on/off; ppm | off; 22,000 | records only coins with an open gap beyond the allowance, at most once per third of the look-back, within a lamport budget for each 24 hours |

Part of the Pangea documentation, V3 (every new launch) tab: https://www.pangea.trade/app/docs.md