# Contracts and programs: the full reference

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.

Every address here was read on chain on 2026-11-03: each factory's own getters name its parts, and each part names its factory back. The four EVM chains' factory stacks are in the table below; the parts that are the same address on all four follow.

| Chain | Factory v3 | Fee collector | Pair registry | Pangea DVN (v3) | Uniswap v4 PoolManager |
| --- | --- | --- | --- | --- | --- |
| Ethereum | `0x228CF77d91f7EdD0C69538336196CA0AcACcA30e` | `0x79d9a01B6ADB4938761e7D4fb29a802ea709F0Ec` | `0x9219c27EF6895736B96Cc8F4087414a0Bf04E937` | `0x6a9f3126C0EA3EEB9cBE53205175c9673Da6565f` | `0x000000000004444c5dc75cB358380D2e3dE08A90` |
| Base | `0x84d32eDdFE50E6C243B8f3Be963eA8A5eA7Adb1e` | `0x7cb08218648433bbC9671f885E15954756717BCa` | `0x7808344Fc0A43e6a5D0E9cB565A13eF9618d61b5` | `0xfEA7bEcb49269336dC5D824f774Fd784511CE8F9` | `0x498581fF718922c3f8e6A244956aF099B2652b2b` |
| BSC | `0x2209E0d4a9a1B6E293da6B9c4651747425161F32` | `0xcDB037B5B4b58e3C89d632463656D889123a7c04` | `0xcA35Ecbfa0e8C7319Cb6337774b6c9d79185e0fE` | `0x7372267975C3606ae86febD7059235addc8aA02C` | `0x28e2Ea090877bF75740558f6BFB36A5ffeE9e9dF` |
| Robinhood Chain | `0xAa7A943666b72A305A53962dd5B28c5F9D8A37a7` | `0xcDB037B5B4b58e3C89d632463656D889123a7c04` | `0xcA35Ecbfa0e8C7319Cb6337774b6c9d79185e0fE` | `0x41a49427e0CfE99d157Dd24070a99c6746077804` | `0x8366a39CC670B4001A1121B8F6A443A643e40951` |

- TokenDeployerV3 (all four EVM chains): `0x7650b19794D59b2CDF04eBb8351784Db6529ff04`
- LiquidityLocker (all four): `0xbebe68fBfB62E18FBFEbf4365970D192C5f34DC1`
- Fee hook, PangeaFeeHook (all four): `0x15e5E7206C661a1E881F5CD33A94eAF2328FA8cc`
- TokenomicsFactory v2.3 (all four): `0x5AC934Debabb814f2193a6a0cB0dd144386e58aB`
- Tokenomics vault implementation, version 2.3 (all four): `0xF372B9454f71412c00D2D599d03Fa467C35c4a57`
- Tokenomics liquidity adder, version 2.3 (all four): `0xabe68F9Dc309BbF4f9eafa44d42dba55a82Dd4Ef`
- Tokenomics reward swapper, version 2.3 (all four): `0xd982FCE1C6A7faA0C78cF3c88e87Ab07c7e3C577`
- RoutePayment, a Solana route's setup payment (all four): `0xD1281cF6FA4f15871f21260c9E443dAdc0d311e8`

The price attestor, gap registry and launch-buys addresses are in [Factories →](https://www.pangea.trade/app/docs#v3-factories); the LayerZero endpoints, libraries, executors and outside DVNs in [Routes →](https://www.pangea.trade/app/docs?v=2#routes)

## Who can change what

- No EVM contract here is a proxy (the EIP-1967 implementation slot is empty on every one), and none can be paused or upgraded. The platform admin is `0x93620a4A7d45A770ff2e801eB84b03a7630ae8B6` on every chain.
- Nobody can withdraw locked liquidity, mint a coin on an EVM chain, change a launched pool's fee or splitter, or point a launched token's bridge at other verifiers: there is no function that does it.
- What the admin can set, each within bounds the contracts hold and each with an event: the minimum opening market cap ($600 to $3,000 a chain; a raise waits an hour), the hooks new launches may name, the launchers, the gap registry's margin (at most 10%), bridge fee (at most 0.5%) and price routes, and a fee receiver change (two steps: the admin proposes, the new address accepts).
- The Solana programs are upgradeable: their upgrade authority is `848jBDi9bJWoDwxhLGXsX3aXjSmdxsawSN3Tb32DyNgL`, and none is marked final. Their admin settings are held by `7rYog4JusTy4CpwvFGPrRvWtcDrWatnA3SN3DRPuf6kM`, within the same bounds as on EVM.

## Factory v3 (UniswapLaunchFactoryV3)

One per EVM chain. One call launches a coin's leg there: it deploys the token at an address ending in 6ea, makes the launch's fee splitter and LaunchOwner, opens a single-sided Uniswap v4 pool on the fee hook and hands the whole slice to the LiquidityLocker, settles the prepaid fee and runs the launch buys. The signed price snapshot binds each chain's token address, price, fee, pair asset, hook and buys. Only the creator (with a signature), a listed launcher or the admin can call it.

| Function or event | What it is |
| --- | --- |
| `launch(LaunchParams p, LaunchTermsV3 terms, Snapshot snap, bytes signature)` | Launches the leg; payable. The Launch API builds its arguments. |
| `launchAuthorized(..., bytes creatorAuth)` | The same, sent by a wallet the creator signed for. |
| `launches(bytes32 launchId) → (token, splitter, launchOwner, locker, liquidity)` | A launch's parts on this chain. |
| `launchV3(bytes32 launchId) → (payee, supplyMode, hook, locked)` | Its v3 terms. |
| `predictToken(LaunchParams, Leg[]) → address` | The token address before launch. |
| `launchBuys(), launchHook(), feeHook(), isLaunchHook(address), isLauncher(address)` | Its wiring. |
| `event Launched(bytes32 indexed launchId, address indexed token, address splitter, address launchOwner, address locker, uint128 liquidity, uint256 dust)` | One per launch per chain: index this to find every coin. |
| `event LaunchTermsSet(bytes32 indexed launchId, address indexed payee, uint8 supplyMode, bytes32 termsHash, uint32 feeEid, uint256 feeMin)` | The terms it launched with. |
| `event LaunchBuysFailed(bytes32 indexed), LaunchBuysSkipped(bytes32 indexed, address)` | Launch buys that did not run; the launch still landed. |

## The token (PangeaOFTV3) and TokenDeployerV3

One token per launch per chain, a LayerZero OFT with 9 decimals. Each chain's slice is minted when it is deployed and nothing mints after; a transfer between chains burns on one side and mints on the other. Every transfer pays the bridge fee, and a cheap-to-dear transfer the price-gap fee, burned at the destination. The TokenDeployer deploys it by CREATE2 for the factory; only the factory can call it.

| Function or event | What it is |
| --- | --- |
| `send(SendParam, MessagingFee, address refundAddress), quoteSend(SendParam, bool), quoteOFT(SendParam)` | LayerZero’s OFT calls. For a v3 token `SendParam.oftCmd` carries the minimum credited after the gap fee: take it from the bridge quote. [Bridging from code →](https://www.pangea.trade/app/docs?v=2#bridge-code) |
| `gapSendQuote(uint32 dstEid, uint64 amountSD), gapMaxSend(), gapBurnedLD()` | The gap fee a send would pay, the largest single send, and everything burned by it so far. |
| `totalSupply(), localSupply(), launchTotal(), launchSlice(), metadataURI(), creator()` | Supply and metadata. |
| `event OFTSent, OFTReceived` | LayerZero's own: every transfer out and in. |
| `event GapCharged(...), GapSkipped(bytes32 indexed guid, uint32 indexed srcEid, uint8 reason)` | An arrival's gap fee, or why none was charged. |
| `event Deployed(address indexed token, bytes32 indexed salt, uint256 slice)` | TokenDeployerV3: every token it deployed. |

Each token is owned by its launch's LaunchOwnerV3, sealed at launch: its admin can only move a route's gas floor (each capped at 1,400,000 gas), and only the factory can add a peer for a chain the token has none on. The token's LayerZero delegate, which sets its verifiers, is the factory, and nothing can change it.

## Fee hook (PangeaFeeHook) and the fee splitter (FeeSplitterV3)

The hook takes the whole trading fee in the pair asset on every swap of a Pangea pool and owes it to the pool's registered splitter. A pool's fee is set once, when it is registered, between 0.3% and 5%, and cannot change. The splitter, one per launch per chain, divides what it receives: the platform the larger of a fifth of the fee or 0.2% of volume, the creator or fee receiver the rest. The split itself cannot change.

| Function or event | What it is |
| --- | --- |
| `hook.redeem(PoolKey)` | Anyone: sends a pool's waiting fees to its splitter. |
| `hook.configs(PoolId) → (splitter, quoteIsCurrency0, feeBps, registered, edgeTick)` | A pool's fee and splitter. |
| `event FeeTaken(PoolId indexed id, Currency currency, uint256 amount)` | Every fee taken. |
| `splitter.releaseNative(), splitter.release(address token)` | Anyone: pays the waiting fees out to both sides. |
| `splitter.pending(address token) → (toCreator, toPlatform), pendingNative()` | What is waiting. |
| `splitter.claimNative(address to), claimToken(address token, address to)` | A receiver collects a payout that was set aside for it. |
| `splitter.acceptCreator()` | The new fee receiver accepts a change the admin proposed. |
| `event Released(address indexed token, uint256 toCreator, uint256 toPlatform)` | Every payout. |

A launch's splitter is the `splitter` of its `Launched` event, or `factory.launches(launchId).splitter`.

## LiquidityLocker

One per chain, the same address on all four. It owns every launch's pool position. There is no function that removes or moves liquidity: the lock is the absence of that code, not a timer. The admin can only add factories (never remove one).

| Function or event | What it is |
| --- | --- |
| `poolOf(address token) → PoolId, poolKeyOf(address token), positionLiquidity(PoolId)` | A coin's pool and the liquidity locked in it. |
| `collect(PoolId)` | Anyone: collects the position's fees to the registered splitter. |
| `event Seeded(PoolId indexed id, address indexed token, address splitter, uint160 sqrtPriceX96, int24 tickLower, int24 tickUpper, uint128 liquidity, uint256 tokensUsed, uint256 quoteDust)` | A pool opened and locked. |

## LaunchFeeCollector and LaunchBuys

The fee collector holds a launch's fee from payment until the launch settles it; a payer can reclaim a fee whose launch never landed after 7 days. LaunchBuys holds the money for launch buys and spends only the creator's line, in the launch transaction.

| Function or event | What it is |
| --- | --- |
| `collector.pay(bytes32 launchId), payFor(bytes32, address)` | Pays a launch's fee (the Launch API's pay builds it). |
| `collector.payments(bytes32) → (amount, at, settled), reclaim(bytes32)` | A fee's state, and taking an unspent one back. |
| `event Paid(bytes32 indexed launchId, address indexed payer, uint256 amount, uint256 total), Settled(bytes32 indexed, uint256)` | Paid, and taken by the launch. |
| `buys.deposit(bytes32 launchId), depositToken(bytes32, address asset, uint256)` | Funds launch buys, in the native coin or the pair token. |
| `buys.reclaim(bytes32, address asset), reclaimableAt(bytes32, address payer, address asset), close(bytes32 launchId, address factory)` | Takes back what was not spent: at once after the buys ran (close first if the launch landed without them), or 7 days after the last deposit. |
| `event Bought(bytes32 indexed launchId, uint256 indexed index, address indexed recipient, uint256 amount, uint256 tokens)` | Each launch buy made. |

## Price attestor, pair registry, gap registry and price readers

- PriceAttestorV3 checks the platform’s signed price snapshot for a launch (each used once, valid at most an hour) and holds the minimum opening market cap: `minMarketCapUsd()`. Event `Attested(bytes32 indexed launchId, uint256 usdPerQuote, uint256 quotePerToken)`.
- The pair registry lists the assets a pool may pair with, each with a US dollar band: `terms(asset) → (decimals, minUsdPerQuote, maxUsdPerQuote)`, `isListed(asset)`; event `AssetSet`.
- The gap registry holds each token's official pool, the on-chain price routes from each pair asset to US dollars, the margin and the bridge fee, which tokens read to price the gap fee: `officialPool(token)`, `route(quote)`, `usdPerQuoteE18(quote, roundUp)`, `poolFeePpm(token)`.
- Price readers the routes go through, each one a flash loan cannot move: a Uniswap v3 time-weighted reader, a v2 pair reader that ignores a pair touched in the same block, and a RecordedPoolReader for stock pools without an oracle, which answers only inside a band built from sibling pools (Ethereum `0x5d77b7733bf85b476326d1f584a21ac68ee548e2`, Base `0xb060183a7ea8eafc34be737dd6790d67567d311c`).

## TokenomicsFactory v2.3

Makes each coin's tokenomics vault: an EIP-1167 clone of the vault implementation, at the same address on every chain, made from the config's hash. The vault is the fee splitter's payee and spends what it receives by its config, through the liquidity adder and the reward swapper. Vaults cannot be upgraded. Pangea's runner calls execute; after 7 days without it, anyone may.

| Function or event | What it is |
| --- | --- |
| `factory.predict(config), isVault(address)` | A vault's address before launch, and whether an address is one. |
| `event VaultCreated(address indexed vault, bytes32 indexed launchId, address indexed owner, bytes32 configHash, bool ownLeg)` | Every vault made. |
| `vault.info(), leg(), due(), books()` | Its config, what each bucket holds, and its totals. |
| `vault.execute(uint256 gasHint)` | Spends what is due. |
| `vault.claimHolder(uint8 index, uint256 cumulative, bytes sig)` | A holder claims a reward with the voucher GET /api/tokenomics/v2/holder gives. |
| `event Burned, SentToTreasury, LiquidityAdded, WalletPaid, HolderPaid, HolderClaimed, BurnTokensBought` | What each run did. |

## Bridge: LayerZero and Pangea's DVN

- Every v3 transfer is verified by any 2 of the route's verifiers: between Ethereum, Base and BSC, LayerZero Labs, Nethermind, Horizen, Canary and Pangea's DVN; on routes with Robinhood Chain, LayerZero Labs, Nethermind and Pangea's DVN. One confirmation.
- Pangea's DVN (v3, per chain in the table above) verifies only Pangea's own coins and charges nothing for it. Its admin can set its fee cap per destination, never above a maximum fixed at deploy.
- The fast bridge for v3 coins: `0x9c385c829e751d2ab9bca17233f0357da7607aa4` on Ethereum, Base and BSC and `0x6c62e2f482f590c0a0144f4266256cfaba44b98c` on Robinhood Chain: `quoteOrder`, `postOrder`, `fillOrder`, `refund`. [Relayers →](https://www.pangea.trade/app/docs?v=2#relayers)

## Solana programs

| Program | What it does, and what to call |
| --- | --- |
| `Hb5uTppRbNxc3RjVRqTWqfdU3E3GiZyGYKccxYf9tUej` | The splitter: Pangea’s launch program on Solana. One instruction makes the whole Solana leg (the mint ending in 6ea, its metadata and OFT store, the Meteora pool, locked with a permanent lock), settles the prepaid fee, holds the pool position and pays its fees (`claim_fees`, `claim_fees_native`: anyone, paying only the creator and the platform), and runs tokenomics on Solana. Events `LaunchedV2`, `FeesClaimed`, `FeePaid`. |
| `SNyKyiZYU4R54SF9sYLmjCaCUsa1sC6QouNAj3x3Zzf` | Pangea’s deployment of LayerZero’s OFT program, with the v3 price-gap fee added: every Pangea coin’s bridge on Solana. `quote_send`, `send`, `record_price`; events `OFTSent`, `OFTReceived`, `GapCharged`. |
| `HwNU4xXd7GVuTcjWTtWdT83d27ACJtwSGiFFWDxaELkn` | Pangea’s DVN on Solana, the same signing key as on the EVM chains. Routes name its config account. |
| `HQ6RgB3GGJvrkpj4dRiVMEQJAcEq4bAwtmaH6swnvDQC` | Runs a Cheapest chain trade whose best pool is on Solana: the buy and the send back in one transaction, so it lands whole or not at all; `refund` after its deadline. |
| `7YNA5pg5sxmKxma7XiKDJnpWgyF5VPc7SaqyuzNhqZtw` | The fast bridge on Solana, one program for every Pangea coin: `post_order`, `fill_order`, `claim`. |
| `cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG` | Meteora DAMM v2, where each Solana pool is (Meteora’s, not Pangea’s). |

> **Note:** The five Pangea programs above are upgradeable by `848jBDi9bJWoDwxhLGXsX3aXjSmdxsawSN3Tb32DyNgL`. The locks on liquidity are Meteora’s permanent lock, which no program of Pangea’s can undo.

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