Genesis - Launch Pool | Fair Token Distribution

Launch Pools provide organic price discovery for token launches. Users deposit during a window and receive tokens proportional to their share of total deposits - no sniping, no front-running, fair distribution for everyone.

What You'll Learn

This guide covers:

How Launch Pool pricing and distribution works
Setting up deposit and claim windows
Configuring end behaviors for fund collection
User operations: Deposit, withdraw, and claim

Summary

Launch Pools accept deposits during a defined window, then distribute tokens proportionally. The final token price is determined by total deposits divided by token allocation.

Users deposit SOL during the deposit window (2% fee applies)
Withdrawals allowed during deposit period (2% fee)
Token distribution is proportional to deposit share
End behaviors route collected SOL to treasury buckets

Out of Scope

Fixed-price sales (see Presale), bid-based auctions (see Uniform Price Auction), and liquidity pool creation (use Raydium/Orca).

Quick Start

How It Works

A specific quantity of tokens is allocated to the Launch Pool bucket
Users deposit SOL during the deposit window (withdrawals allowed with fee)
When the window closes, tokens distribute proportionally based on deposit share

Price Discovery

The token price emerges from total deposits:

tokenPrice = totalDeposits / tokenAllocation
userTokens = (userDeposit / totalDeposits) * tokenAllocation

Example: 1,000,000 tokens allocated, 100 SOL total deposits = 0.0001 SOL per token

Lifecycle

Deposit Period - Users deposit SOL during a defined window
Transition - End behaviors execute (e.g., send collected SOL to another bucket)
Claim Period - Users claim tokens proportional to their deposit weight

Fees

Instruction	Solana
Deposit	2%
Withdraw	2%
Graduation	5%

Deposit Fee Example: A user deposit of 10 SOL results in 9.8 SOL credited to the user's deposit account.

Setup Guide

Prerequisites

npm install @metaplex-foundation/genesis @metaplex-foundation/umi @metaplex-foundation/umi-bundle-defaults @metaplex-foundation/mpl-toolbox

1. Initialize the Genesis Account

The Genesis Account creates your token and coordinates all distribution buckets.

initializeV2.ts
1import {
2  findGenesisAccountV2Pda,
3  genesis,
4  initializeV2,
5} from '@metaplex-foundation/genesis'
6import { mplToolbox } from '@metaplex-foundation/mpl-toolbox'
7import { generateSigner, keypairIdentity } from '@metaplex-foundation/umi'
8import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
9
10const umi = createUmi('https://api.mainnet-beta.solana.com')
11  .use(mplToolbox())
12  .use(genesis())
13
14// umi.use(keypairIdentity(yourKeypair));
15
16const baseMint = generateSigner(umi)
17const TOTAL_SUPPLY = 1_000_000_000_000_000n // 1 million tokens (9 decimals)
18
19// Store this account address for later or recreate it when needed.
20const [genesisAccount] = findGenesisAccountV2Pda(umi, {
21  baseMint: baseMint.publicKey,
22  genesisIndex: 0,
23})
24
25await initializeV2(umi, {
26  baseMint,
27  fundingMode: 0,
28  totalSupplyBaseToken: TOTAL_SUPPLY,
29  name: 'My Token',
30  symbol: 'MTK',
31  uri: 'https://example.com/metadata.json',
32}).sendAndConfirm(umi)

The totalSupplyBaseToken should equal the sum of all bucket allocations.

2. Add the Launch Pool Bucket

The Launch Pool bucket collects deposits and distributes tokens proportionally. Configure timing here.

addLaunchPoolBucket.ts
1import {
2  genesis,
3  addLaunchPoolBucketV2,
4  findLaunchPoolBucketV2Pda,
5  findUnlockedBucketV2Pda,
6} from '@metaplex-foundation/genesis'
7import { mplToolbox } from '@metaplex-foundation/mpl-toolbox'
8import { keypairIdentity, publicKey } from '@metaplex-foundation/umi'
9import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
10
11const umi = createUmi('https://api.mainnet-beta.solana.com')
12  .use(mplToolbox())
13  .use(genesis())
14
15// umi.use(keypairIdentity(yourKeypair));
16
17// Assumes genesisAccount, baseMint, and TOTAL_SUPPLY from the Initialize step.
18
19const [launchPoolBucket] = findLaunchPoolBucketV2Pda(umi, { genesisAccount, bucketIndex: 0 })
20const [unlockedBucket] = findUnlockedBucketV2Pda(umi, { genesisAccount, bucketIndex: 0 })
21
22const now = BigInt(Math.floor(Date.now() / 1000))
23const depositStart = now
24const depositEnd = now + 86400n // 24 hours
25const claimStart = depositEnd + 1n
26const claimEnd = claimStart + 604800n // 1 week
27
28await addLaunchPoolBucketV2(umi, {
29  genesisAccount,
30  baseMint: baseMint.publicKey,
31  baseTokenAllocation: TOTAL_SUPPLY,
32
33  // Timing
34  depositStartCondition: {
35    __kind: 'TimeAbsolute',
36    padding: Array(47).fill(0),
37    time: depositStart,
38    triggeredTimestamp: null,
39  },
40  depositEndCondition: {
41    __kind: 'TimeAbsolute',
42    padding: Array(47).fill(0),
43    time: depositEnd,
44    triggeredTimestamp: null,
45  },
46  claimStartCondition: {
47    __kind: 'TimeAbsolute',
48    padding: Array(47).fill(0),
49    time: claimStart,
50    triggeredTimestamp: null,
51  },
52  claimEndCondition: {
53    __kind: 'TimeAbsolute',
54    padding: Array(47).fill(0),
55    time: claimEnd,
56    triggeredTimestamp: null,
57  },
58
59  // Optional: Minimum deposit
60  minimumDepositAmount: null, // or { amount: sol(0.1).basisPoints }
61
62  // Where collected SOL goes after transition
63  endBehaviors: [
64    {
65      __kind: 'SendQuoteTokenPercentage',
66      padding: Array(4).fill(0),
67      destinationBucket: publicKey(unlockedBucket),
68      percentageBps: 10000, // 100%
69      processed: false,
70    },
71  ],
72}).sendAndConfirm(umi)

3. Add the Unlocked Bucket

The Unlocked bucket receives SOL from the Launch Pool after the transition.

addUnlockedBucket.ts
1import {
2  addUnlockedBucketV2,
3  genesis,
4} from '@metaplex-foundation/genesis'
5import { mplToolbox } from '@metaplex-foundation/mpl-toolbox'
6import { generateSigner, keypairIdentity } from '@metaplex-foundation/umi'
7import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
8
9const umi = createUmi('https://api.mainnet-beta.solana.com')
10  .use(mplToolbox())
11  .use(genesis())
12
13// umi.use(keypairIdentity(yourKeypair));
14
15// Assumes genesisAccount, baseMint, claimStart, and claimEnd from previous steps.
16
17await addUnlockedBucketV2(umi, {
18  genesisAccount,
19  baseMint: baseMint.publicKey,
20  baseTokenAllocation: 0n,
21  recipient: umi.identity.publicKey,
22  claimStartCondition: {
23    __kind: 'TimeAbsolute',
24    padding: Array(47).fill(0),
25    time: claimStart,
26    triggeredTimestamp: null,
27  },
28  claimEndCondition: {
29    __kind: 'TimeAbsolute',
30    padding: Array(47).fill(0),
31    time: claimEnd,
32    triggeredTimestamp: null,
33  },
34  backendSigner: null,
35}).sendAndConfirm(umi)

4. Finalize

Once all buckets are configured, finalize to activate the launch. This is irreversible.

finalize.ts
1import {
2  genesis,
3  finalizeV2,
4} from '@metaplex-foundation/genesis'
5import { mplToolbox } from '@metaplex-foundation/mpl-toolbox'
6import { keypairIdentity } from '@metaplex-foundation/umi'
7import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
8
9const umi = createUmi('https://api.mainnet-beta.solana.com')
10  .use(mplToolbox())
11  .use(genesis())
12
13// umi.use(keypairIdentity(yourKeypair));
14
15// Assumes genesisAccount and baseMint from the Initialize step.
16
17await finalizeV2(umi, {
18  baseMint: baseMint.publicKey,
19  genesisAccount,
20}).sendAndConfirm(umi)

User Operations

Wrapping SOL

Users must wrap SOL to wSOL before depositing.

wrapSol.ts
1import {
2  findAssociatedTokenPda,
3  createTokenIfMissing,
4  transferSol,
5  syncNative,
6  mplToolbox,
7} from '@metaplex-foundation/mpl-toolbox'
8import { WRAPPED_SOL_MINT, genesis } from '@metaplex-foundation/genesis'
9import { keypairIdentity, publicKey, sol } from '@metaplex-foundation/umi'
10import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
11
12const umi = createUmi('https://api.mainnet-beta.solana.com')
13  .use(mplToolbox())
14  .use(genesis())
15
16// umi.use(keypairIdentity(yourKeypair));
17
18const userWsolAccount = findAssociatedTokenPda(umi, {
19  owner: umi.identity.publicKey,
20  mint: WRAPPED_SOL_MINT,
21})
22
23await createTokenIfMissing(umi, {
24  mint: WRAPPED_SOL_MINT,
25  owner: umi.identity.publicKey,
26  token: userWsolAccount,
27})
28  .add(
29    transferSol(umi, {
30      destination: publicKey(userWsolAccount),
31      amount: sol(10),
32    })
33  )
34  .add(syncNative(umi, { account: userWsolAccount }))
35  .sendAndConfirm(umi)

Depositing

depositLaunchPool.ts
1import {
2  genesis,
3  depositLaunchPoolV2,
4  findLaunchPoolDepositV2Pda,
5  fetchLaunchPoolDepositV2,
6} from '@metaplex-foundation/genesis'
7import { mplToolbox } from '@metaplex-foundation/mpl-toolbox'
8import { keypairIdentity, sol } from '@metaplex-foundation/umi'
9import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
10
11const umi = createUmi('https://api.mainnet-beta.solana.com')
12  .use(mplToolbox())
13  .use(genesis())
14
15// umi.use(keypairIdentity(yourKeypair));
16
17// Assumes genesisAccount, launchPoolBucket, and baseMint from previous steps.
18
19await depositLaunchPoolV2(umi, {
20  genesisAccount,
21  bucket: launchPoolBucket,
22  baseMint: baseMint.publicKey,
23  amountQuoteToken: sol(10).basisPoints,
24}).sendAndConfirm(umi)
25
26// Verify
27const [depositPda] = findLaunchPoolDepositV2Pda(umi, {
28  bucket: launchPoolBucket,
29  recipient: umi.identity.publicKey,
30})
31const deposit = await fetchLaunchPoolDepositV2(umi, depositPda)
32
33console.log('Deposited (after fee):', deposit.amountQuoteToken)

Multiple deposits from the same user accumulate into a single deposit account.

Withdrawing

Users can withdraw during the deposit period. A 2% fee applies.

withdrawLaunchPool.ts
1import {
2  genesis,
3  withdrawLaunchPoolV2,
4} from '@metaplex-foundation/genesis'
5import { mplToolbox } from '@metaplex-foundation/mpl-toolbox'
6import { keypairIdentity, sol } from '@metaplex-foundation/umi'
7import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
8
9const umi = createUmi('https://api.mainnet-beta.solana.com')
10  .use(mplToolbox())
11  .use(genesis())
12
13// umi.use(keypairIdentity(yourKeypair));
14
15// Assumes genesisAccount, launchPoolBucket, and baseMint from previous steps.
16
17await withdrawLaunchPoolV2(umi, {
18  genesisAccount,
19  bucket: launchPoolBucket,
20  baseMint: baseMint.publicKey,
21  amountQuoteToken: sol(3).basisPoints,
22}).sendAndConfirm(umi)

If a user withdraws their entire balance, the deposit PDA is closed.

Claiming Tokens

After the deposit period ends and claims open:

claimLaunchPool.ts
1import {
2  genesis,
3  claimLaunchPoolV2,
4} from '@metaplex-foundation/genesis'
5import { mplToolbox } from '@metaplex-foundation/mpl-toolbox'
6import { keypairIdentity } from '@metaplex-foundation/umi'
7import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
8
9const umi = createUmi('https://api.mainnet-beta.solana.com')
10  .use(mplToolbox())
11  .use(genesis())
12
13// umi.use(keypairIdentity(yourKeypair));
14
15// Assumes genesisAccount, launchPoolBucket, and baseMint from previous steps.
16
17await claimLaunchPoolV2(umi, {
18  genesisAccount,
19  bucket: launchPoolBucket,
20  baseMint: baseMint.publicKey,
21  recipient: umi.identity.publicKey,
22}).sendAndConfirm(umi)

Token allocation: userTokens = (userDeposit / totalDeposits) * bucketTokenAllocation

Admin Operations

Executing the Transition

After deposits close, execute the transition to move collected SOL to the unlocked bucket.

transitionLaunchPool.ts
1import {
2  genesis,
3  transitionV2,
4  WRAPPED_SOL_MINT,
5} from '@metaplex-foundation/genesis'
6import {
7  findAssociatedTokenPda,
8  mplToolbox,
9} from '@metaplex-foundation/mpl-toolbox'
10import { keypairIdentity } from '@metaplex-foundation/umi'
11import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
12
13const umi = createUmi('https://api.mainnet-beta.solana.com')
14  .use(mplToolbox())
15  .use(genesis())
16
17// umi.use(keypairIdentity(yourKeypair));
18
19// Assumes genesisAccount, launchPoolBucket, unlockedBucket, and baseMint from previous steps.
20
21const [unlockedBucketQuoteTokenAccount] = findAssociatedTokenPda(umi, {
22  owner: unlockedBucket,
23  mint: WRAPPED_SOL_MINT,
24})
25
26await transitionV2(umi, {
27  genesisAccount,
28  primaryBucket: launchPoolBucket,
29  baseMint: baseMint.publicKey,
30})
31  .addRemainingAccounts([
32    { pubkey: unlockedBucket, isSigner: false, isWritable: true },
33    { pubkey: unlockedBucketQuoteTokenAccount, isSigner: false, isWritable: true },
34  ])
35  .sendAndConfirm(umi)

Why this matters: Without transition, collected SOL stays locked in the Launch Pool bucket. Users can still claim tokens, but the team cannot access the raised funds.

Reference

Time Conditions

Four conditions control Launch Pool timing:

Condition	Purpose
`depositStartCondition`	When deposits open
`depositEndCondition`	When deposits close
`claimStartCondition`	When claims open
`claimEndCondition`	When claims close

Use TimeAbsolute with a Unix timestamp:

const condition = {
  __kind: 'TimeAbsolute',
  padding: Array(47).fill(0),
  time: BigInt(Math.floor(Date.now() / 1000) + 3600), // 1 hour from now
  triggeredTimestamp: null,
};

End Behaviors

Define what happens to collected SOL after the deposit period:

endBehaviors: [
  {
    __kind: 'SendQuoteTokenPercentage',
    padding: Array(4).fill(0),
    destinationBucket: publicKey(unlockedBucket),
    percentageBps: 10000, // 100% = 10000 basis points
    processed: false,
  },
]

You can split funds across multiple buckets:

endBehaviors: [
  {
    __kind: 'SendQuoteTokenPercentage',
    padding: Array(4).fill(0),
    destinationBucket: publicKey(treasuryBucket),
    percentageBps: 2000, // 20%
    processed: false,
  },
  {
    __kind: 'SendQuoteTokenPercentage',
    padding: Array(4).fill(0),
    destinationBucket: publicKey(liquidityBucket),
    percentageBps: 8000, // 80%
    processed: false,
  },
]

Fetching State

Bucket state:

import { fetchLaunchPoolBucketV2 } from '@metaplex-foundation/genesis';

const bucket = await fetchLaunchPoolBucketV2(umi, launchPoolBucket);
console.log('Total deposits:', bucket.quoteTokenDepositTotal);
console.log('Deposit count:', bucket.depositCount);
console.log('Claim count:', bucket.claimCount);
console.log('Token allocation:', bucket.bucket.baseTokenAllocation);

Deposit state:

import { fetchLaunchPoolDepositV2, safeFetchLaunchPoolDepositV2 } from '@metaplex-foundation/genesis';

const deposit = await fetchLaunchPoolDepositV2(umi, depositPda); // throws if not found
const maybeDeposit = await safeFetchLaunchPoolDepositV2(umi, depositPda); // returns null

if (deposit) {
  console.log('Amount deposited:', deposit.amountQuoteToken);
  console.log('Claimed:', deposit.claimed);
}

Notes

The 2% protocol fee applies to both deposits and withdrawals
Multiple deposits from the same user accumulate in one deposit account
If a user withdraws their entire balance, the deposit PDA closes
Transitions must be executed after deposits close for end behaviors to process
Users must have wSOL (wrapped SOL) to deposit

FAQ

How is the token price determined in a Launch Pool?

The price is discovered organically based on total deposits. Final price equals total SOL deposited divided by tokens allocated. More deposits means higher implied price per token.

Can users withdraw their deposits?

Yes, users can withdraw during the deposit period. A 2% withdrawal fee applies to discourage gaming the system.

What happens if I deposit multiple times?

Multiple deposits from the same wallet accumulate into a single deposit account. Your total share is based on your combined deposits.

When can users claim their tokens?

After the deposit period ends and the claim window opens (defined by claimStartCondition). The transition must be executed first to process end behaviors.

What's the difference between Launch Pool and Presale?

Launch Pool discovers price organically based on deposits with proportional distribution. Presale has a fixed price set upfront with first-come-first-served allocation up to the cap.

Glossary

Term	Definition
Launch Pool	Deposit-based distribution where price is discovered at close
Deposit Window	Time period when users can deposit and withdraw SOL
Claim Window	Time period when users can claim their proportional tokens
End Behavior	Automated action executed after deposit period ends
Transition	Instruction that processes end behaviors and routes funds
Proportional Distribution	Token allocation based on user's share of total deposits
Quote Token	The token users deposit (usually wSOL)
Base Token	The token being distributed

Next Steps

Presale - Fixed-price token sales
Uniform Price Auction - Bid-based allocation
Aggregation API - Query launch data via API