@forgedevv/core 0.1.0 → 0.2.0

package/dist/position-claims.js

@@ -0,0 +1,440 @@
+/**
+ * DAMM v2 position fee claims of a migrated DBC pool (docs/METEORA.md "Migration", DECISIONS.md
+ * D6 and D27, devnet test 2).
+ *
+ * When a launchpad coin graduates, `migrateToDammV2` creates the DAMM v2 pool and two locked
+ * positions: the partner's and the creator's. The creator's position (a FORGE creator wallet for
+ * a launchpad coin, permanently locked) keeps earning the migrated pool's trading fees; nothing
+ * but a `claim_position_fee` signed by the position owner moves them. This module:
+ * - finds the migrated DAMM v2 pool of a DBC pool (pure, from the decoded DBC state) and the
+ *   creator's position(s) on it (the position NFT is held by the creator);
+ * - builds the UNSIGNED claim of their fees to a receiver (`@meteora-ag/cp-amm-sdk`, pinned
+ *   1.5.1), the creator signing, with an optional fee payer; shaped like `buildCreatorClaimTx`:
+ *   transaction, summary, costs, skip reasons.
+ *
+ * Transaction (SOL-quoted pools only):
+ *   1. create-idempotent the receiver's coin account (the payer funds its rent, once per pool);
+ *   2. create-idempotent the creator's WSOL associated account (temporary, rent from the payer);
+ *   3. one `claim_position_fee` per position: coin fees to the receiver's coin account, SOL fees
+ *      to the creator's temporary WSOL account;
+ *   4. close the temporary WSOL account to the receiver: the fees AND the account's rent reach
+ *      the receiver as lamports. `claim_position_fee` has no amount cap and fees keep accruing
+ *      until the transaction executes, so the exact forward of the DBC claim is not possible
+ *      here: the rent (~0.002 SOL) moves from the payer to the receiver with every claim.
+ * The transaction never removes liquidity, never closes, locks, splits or transfers the position
+ * or its NFT, and contains no other program.
+ */
+import { ACCOUNT_SIZE, NATIVE_MINT, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID, createAssociatedTokenAccountIdempotentInstruction, createCloseAccountInstruction, getAssociatedTokenAddressSync, unpackAccount, } from '@solana/spl-token';
+import { PublicKey, Transaction, } from '@solana/web3.js';
+import { DAMM_V2_MIGRATION_FEE_ADDRESS, MigrationOption, deriveDammV2PoolAddress, } from '@meteora-ag/dynamic-bonding-curve-sdk';
+import { CP_AMM_PROGRAM_ID, CpAmm, derivePositionNftAccount, getUnClaimLpFee, } from '@meteora-ag/cp-amm-sdk';
+import { getMultisigVault } from './addresses.js';
+import { CLAIM_LAMPORTS_PER_SIGNATURE, ClaimError, assertClaimReceiver, assertSolQuotedPool, } from './claims.js';
+import { READ_COMMITMENT, getDbcPoolState, graduationStatus, retryRpc, toBigint, } from './reads.js';
+/** DAMM v2 (cp-amm) program id, from the pinned SDK. */
+export const DAMM_V2_PROGRAM_ID = CP_AMM_PROGRAM_ID;
+/** Anchor discriminator of `claim_position_fee` (sha256("global:claim_position_fee")[0..8]). */
+export const CLAIM_POSITION_FEE_DISCRIMINATOR = Buffer.from([180, 38, 154, 17, 133, 33, 162, 211]);
+/** Account indexes of `claim_position_fee` (cp-amm SDK 1.5.1 IDL). */
+export const CLAIM_POSITION_FEE_ACCOUNTS = {
+    poolAuthority: 0,
+    pool: 1,
+    position: 2,
+    tokenAAccount: 3,
+    tokenBAccount: 4,
+    tokenAVault: 5,
+    tokenBVault: 6,
+    tokenAMint: 7,
+    tokenBMint: 8,
+    positionNftAccount: 9,
+    owner: 10,
+    tokenAProgram: 11,
+    tokenBProgram: 12,
+    eventAuthority: 13,
+    program: 14,
+};
+/** `tokenAFlag` / `tokenBFlag` of a DAMM v2 pool: 0 = SPL Token, 1 = Token-2022. */
+export function dammV2TokenProgram(flag) {
+    return flag === 1 ? TOKEN_2022_PROGRAM_ID : TOKEN_PROGRAM_ID;
+}
+/**
+ * Pure: the DAMM v2 pool of a migrated DBC pool, derived like the SDK's `migrateToDammV2`
+ * (`deriveDammV2PoolAddress(dammConfig, baseMint, quoteMint)` with the DAMM v2 config the SDK
+ * pins for the config's `migrationFeeOption`, `DAMM_V2_MIGRATION_FEE_ADDRESS`). Null when the
+ * pool has not migrated yet, migrates to DAMM v1, or has a migration fee option the pinned SDK
+ * does not know (FORGE configs use `FixedBps25`, D27).
+ */
+export function migratedDammV2Pool(state) {
+    if (graduationStatus(state) !== 'migrated')
+        return null;
+    if (state.config.migrationOption !== MigrationOption.MET_DAMM_V2)
+        return null;
+    const dammConfig = DAMM_V2_MIGRATION_FEE_ADDRESS[state.config.migrationFeeOption];
+    if (!dammConfig)
+        return null;
+    const p = state.virtualPool.poolState;
+    return {
+        dammPool: deriveDammV2PoolAddress(dammConfig, p.baseMint, state.config.quoteMint),
+        dammConfig,
+    };
+}
+/** Pure: unclaimed fees of a position (SDK `getUnClaimLpFee`), as bigint. */
+export function positionPendingFees(poolState, positionState) {
+    const fees = getUnClaimLpFee(poolState, positionState);
+    return { base: toBigint(fees.feeTokenA), quote: toBigint(fees.feeTokenB) };
+}
+/** Pure: summary of one position of `poolState`. */
+export function summarizePosition(poolState, ref, positionState) {
+    return {
+        ...ref,
+        dammPool: positionState.pool,
+        liquidity: {
+            unlocked: toBigint(positionState.unlockedLiquidity),
+            vested: toBigint(positionState.vestedLiquidity),
+            permanentLocked: toBigint(positionState.permanentLockedLiquidity),
+        },
+        pendingFees: positionPendingFees(poolState, positionState),
+    };
+}
+/** Pure: sum of the pending fees of `positions`. */
+export function sumPendingFees(positions) {
+    let base = 0n;
+    let quote = 0n;
+    for (const p of positions) {
+        base += p.pendingFees.base;
+        quote += p.pendingFees.quote;
+    }
+    return { base, quote };
+}
+// ---------------------------------------------------------------------------------------------
+// Reads
+// ---------------------------------------------------------------------------------------------
+function cpAmm(connection) {
+    return new CpAmm(connection);
+}
+/** Fetches a DAMM v2 pool. @throws ClaimError `damm_pool_not_found` when the account is missing. */
+export async function getDammV2PoolState(connection, dammPool, options = {}) {
+    try {
+        return await retryRpc(() => cpAmm(connection).fetchPoolState(dammPool), options.retry);
+    }
+    catch (err) {
+        if (err instanceof Error && /not found/i.test(err.message)) {
+            throw new ClaimError('damm_pool_not_found', `DAMM v2 pool not found: ${dammPool.toBase58()}`);
+        }
+        throw err;
+    }
+}
+/**
+ * Resolves and checks positions: each must belong to `dammPool`, and its NFT token account
+ * (Token-2022) must be owned by `owner` and hold the NFT. Sorted by position address.
+ * @throws ClaimError `position_not_found`, `position_mismatch` or `position_not_owned`.
+ */
+async function resolvePositions(connection, amm, dammPool, poolState, owner, candidates, options) {
+    const commitment = options.commitment ?? READ_COMMITMENT;
+    const unique = new Map();
+    for (const c of candidates)
+        unique.set(c.position.toBase58(), c);
+    const ordered = [...unique.entries()].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+    if (ordered.length === 0)
+        return [];
+    const resolved = [];
+    for (const [id, candidate] of ordered) {
+        let state = candidate.positionState;
+        if (!state) {
+            try {
+                state = await retryRpc(() => amm.fetchPositionState(candidate.position), options.retry);
+            }
+            catch (err) {
+                if (err instanceof Error && /not found/i.test(err.message)) {
+                    throw new ClaimError('position_not_found', `DAMM v2 position not found: ${id}`);
+                }
+                throw err;
+            }
+        }
+        if (!state.pool.equals(dammPool)) {
+            throw new ClaimError('position_mismatch', `Position ${id} belongs to pool ${state.pool.toBase58()}, not to ${dammPool.toBase58()}`);
+        }
+        resolved.push({
+            ref: {
+                position: candidate.position,
+                nftMint: state.nftMint,
+                positionNftAccount: candidate.positionNftAccount ?? derivePositionNftAccount(state.nftMint),
+            },
+            state,
+        });
+    }
+    const nftInfos = await retryRpc(() => connection.getMultipleAccountsInfo(resolved.map((r) => r.ref.positionNftAccount), commitment), options.retry);
+    resolved.forEach(({ ref }, i) => {
+        const info = nftInfos[i];
+        const problem = nftOwnershipProblem(ref, info ?? null, owner);
+        if (problem) {
+            throw new ClaimError('position_not_owned', `Position ${ref.position.toBase58()} is not held by ${owner.toBase58()}: ${problem}`);
+        }
+    });
+    return resolved.map(({ ref, state }) => summarizePosition(poolState, ref, state));
+}
+/** Why `info` is not a Token-2022 account of `owner` holding the position NFT; null when it is. */
+function nftOwnershipProblem(ref, info, owner) {
+    if (!info)
+        return 'position NFT token account missing';
+    let account;
+    try {
+        account = unpackAccount(ref.positionNftAccount, info, TOKEN_2022_PROGRAM_ID);
+    }
+    catch {
+        return 'position NFT token account is not a Token-2022 account';
+    }
+    if (!account.mint.equals(ref.nftMint))
+        return 'token account mint is not the position NFT';
+    if (account.amount !== 1n)
+        return 'token account does not hold the position NFT';
+    if (!account.owner.equals(owner))
+        return `held by ${account.owner.toBase58()}`;
+    return null;
+}
+/**
+ * Finds the creator's positions on the migrated DAMM v2 pool of a DBC pool (SDK
+ * `getUserPositionByPool`: the Token-2022 accounts of the creator holding one NFT, then the
+ * position of each), checked again (pool, NFT held by the creator) and sorted by address.
+ * Returns null when the pool has not migrated to DAMM v2.
+ * @throws ClaimError `not_pool_creator`, `damm_pool_not_found`, `damm_pool_mismatch`.
+ * @throws DbcReadError when the DBC pool or its config does not exist.
+ */
+export async function findCreatorDammV2Positions(connection, params, options = {}) {
+    const state = params.pool instanceof PublicKey
+        ? await getDbcPoolState(connection, params.pool, options)
+        : params.pool;
+    const poolCreator = state.virtualPool.poolState.creator;
+    if (!poolCreator.equals(params.creator)) {
+        throw new ClaimError('not_pool_creator', `${params.creator.toBase58()} is not the creator of pool ${state.address.toBase58()}`);
+    }
+    const migrated = migratedDammV2Pool(state);
+    if (!migrated)
+        return null;
+    const amm = cpAmm(connection);
+    const poolState = await getDammV2PoolState(connection, migrated.dammPool, options);
+    assertDammPoolMatches(state, migrated.dammPool, poolState);
+    const found = await retryRpc(() => amm.getUserPositionByPool(migrated.dammPool, params.creator), options.retry);
+    const positions = await resolvePositions(connection, amm, migrated.dammPool, poolState, params.creator, found.map((f) => ({
+        position: f.position,
+        positionNftAccount: f.positionNftAccount,
+        positionState: f.positionState,
+    })), options);
+    return {
+        pool: state.address,
+        dammPool: migrated.dammPool,
+        dammConfig: migrated.dammConfig,
+        creator: params.creator,
+        positions,
+        claimable: sumPendingFees(positions),
+    };
+}
+function assertDammPoolMatches(state, dammPool, poolState) {
+    const baseMint = state.virtualPool.poolState.baseMint;
+    if (!poolState.tokenAMint.equals(baseMint) || !poolState.tokenBMint.equals(state.config.quoteMint)) {
+        throw new ClaimError('damm_pool_mismatch', `DAMM v2 pool ${dammPool.toBase58()} is not the ${baseMint.toBase58()} / SOL pool of DBC pool ${state.address.toBase58()}`);
+    }
+}
+const ZERO_COSTS = {
+    networkFeeLamports: 0n,
+    receiverTokenAccountRentLamports: 0n,
+    unwrapAccountRentLamports: 0n,
+    payerTotalLamports: 0n,
+    payerRequiredBalanceLamports: 0n,
+};
+/** True when the claim collects more SOL than it costs, by more than `minNetLamports`. */
+export function isPositionClaimWorthwhile(summary, minNetLamports = 0n) {
+    return summary.claimable.quote > 0n && summary.netLamports > minNetLamports;
+}
+/**
+ * Builds the claim of the creator's DAMM v2 position fees of a migrated DBC pool to `receiver`
+ * (see the module comment for the transaction).
+ * @throws ClaimError when `creator` is not the pool creator, the pool is not SOL-quoted or not
+ *   migrated to DAMM v2 (`not_migrated`), the receiver is invalid or differs from
+ *   `expectedReceiver`, a position is missing, on another pool or not held by the creator, or
+ *   the creator's WSOL account holds WSOL while the receiver is someone else.
+ * @throws DbcReadError when the DBC pool or its config does not exist.
+ */
+export async function buildCreatorPositionFeeClaimTx(connection, params, options = {}) {
+    const commitment = options.commitment ?? READ_COMMITMENT;
+    const readOptions = { commitment, retry: options.retry };
+    assertClaimReceiver(params.receiver);
+    if (params.expectedReceiver && !params.expectedReceiver.equals(params.receiver)) {
+        throw new ClaimError('receiver_mismatch', `Position fees of pool ${params.pool.toBase58()} must go to ${params.expectedReceiver.toBase58()}, not ${params.receiver.toBase58()}`);
+    }
+    const state = await getDbcPoolState(connection, params.pool, readOptions);
+    assertSolQuotedPool(state);
+    const poolCreator = state.virtualPool.poolState.creator;
+    if (!poolCreator.equals(params.creator)) {
+        throw new ClaimError('not_pool_creator', `${params.creator.toBase58()} is not the creator of pool ${params.pool.toBase58()}`);
+    }
+    const migrated = migratedDammV2Pool(state);
+    if (!migrated) {
+        throw new ClaimError('not_migrated', `Pool ${params.pool.toBase58()} has not migrated to DAMM v2: no position to claim`);
+    }
+    const { dammPool, dammConfig } = migrated;
+    const amm = cpAmm(connection);
+    const poolState = await getDammV2PoolState(connection, dammPool, readOptions);
+    assertDammPoolMatches(state, dammPool, poolState);
+    let candidates;
+    if (params.positions) {
+        candidates = params.positions.map((position) => ({
+            position,
+            positionNftAccount: null,
+            positionState: null,
+        }));
+    }
+    else {
+        const found = await retryRpc(() => amm.getUserPositionByPool(dammPool, params.creator), options.retry);
+        candidates = found.map((f) => ({
+            position: f.position,
+            positionNftAccount: f.positionNftAccount,
+            positionState: f.positionState,
+        }));
+    }
+    const positions = await resolvePositions(connection, amm, dammPool, poolState, params.creator, candidates, readOptions);
+    const payer = params.payer ?? params.creator;
+    const receiver = params.receiver;
+    const baseMint = state.virtualPool.poolState.baseMint;
+    const claimable = sumPendingFees(positions);
+    const baseSummary = {
+        kind: 'position',
+        pool: state.address,
+        dammPool,
+        dammConfig,
+        baseMint,
+        claimer: params.creator,
+        receiver,
+        payer,
+        positions,
+        claimable,
+        quoteIsExact: false,
+    };
+    const skip = (skipReason) => ({
+        transaction: null,
+        lastValidBlockHeight: null,
+        skipReason,
+        summary: {
+            ...baseSummary,
+            receiverQuoteLamports: 0n,
+            existingWsolLamports: 0n,
+            costs: ZERO_COSTS,
+            netLamports: 0n,
+        },
+    });
+    if (positions.length === 0)
+        return skip('no_position');
+    if (claimable.base === 0n && claimable.quote === 0n)
+        return skip('nothing_to_claim');
+    // 1. The cp-amm claim instructions, built by the SDK (accounts: receiver's coin account,
+    //    creator's temporary WSOL account). Its pre/post instructions are replaced below.
+    const tokenAProgram = dammV2TokenProgram(poolState.tokenAFlag);
+    const tokenBProgram = dammV2TokenProgram(poolState.tokenBFlag);
+    if (!tokenBProgram.equals(TOKEN_PROGRAM_ID)) {
+        throw new ClaimError('unsupported_quote_mint', 'The SOL side of the pool is not SPL Token WSOL');
+    }
+    const receiverBase = getAssociatedTokenAddressSync(baseMint, receiver, true, tokenAProgram);
+    const creatorWsol = getAssociatedTokenAddressSync(NATIVE_MINT, params.creator, true, TOKEN_PROGRAM_ID);
+    const claimIxs = [];
+    for (const p of positions) {
+        const sdkTx = await retryRpc(() => amm.claimPositionFee({
+            owner: params.creator,
+            position: p.position,
+            pool: dammPool,
+            positionNftAccount: p.positionNftAccount,
+            tokenAMint: poolState.tokenAMint,
+            tokenBMint: poolState.tokenBMint,
+            tokenAVault: poolState.tokenAVault,
+            tokenBVault: poolState.tokenBVault,
+            tokenAProgram,
+            tokenBProgram,
+            receiver,
+            feePayer: payer,
+            tempWSolAccount: params.creator,
+        }), options.retry);
+        const ixs = sdkTx.instructions.filter((ix) => ix.programId.equals(DAMM_V2_PROGRAM_ID));
+        const ix = ixs[0];
+        const at = (i) => ix?.keys[i]?.pubkey;
+        if (ixs.length !== 1 ||
+            !ix ||
+            !CLAIM_POSITION_FEE_DISCRIMINATOR.equals(Buffer.from(ix.data).subarray(0, 8)) ||
+            !at(CLAIM_POSITION_FEE_ACCOUNTS.pool)?.equals(dammPool) ||
+            !at(CLAIM_POSITION_FEE_ACCOUNTS.position)?.equals(p.position) ||
+            !at(CLAIM_POSITION_FEE_ACCOUNTS.tokenAAccount)?.equals(receiverBase) ||
+            !at(CLAIM_POSITION_FEE_ACCOUNTS.tokenBAccount)?.equals(creatorWsol) ||
+            !at(CLAIM_POSITION_FEE_ACCOUNTS.positionNftAccount)?.equals(p.positionNftAccount) ||
+            !at(CLAIM_POSITION_FEE_ACCOUNTS.owner)?.equals(params.creator)) {
+            throw new ClaimError('unexpected_sdk_instructions', 'The SDK position fee claim does not have the expected claim instruction');
+        }
+        claimIxs.push(ix);
+    }
+    // 2. On-chain state: the receiver's coin account, the creator's WSOL account.
+    const [infos, tokenAccountRent] = await Promise.all([
+        retryRpc(() => connection.getMultipleAccountsInfo([receiverBase, creatorWsol], commitment), options.retry),
+        retryRpc(() => connection.getMinimumBalanceForRentExemption(ACCOUNT_SIZE, commitment), options.retry),
+    ]);
+    const [receiverBaseInfo, creatorWsolInfo] = infos;
+    // The temporary account is closed to the receiver: WSOL it already holds (anyone can send
+    // some to it, 1 lamport is enough) simply goes with it, counted as received. Refusing it
+    // would let anyone block a pool's claims for the price of a lamport.
+    let existingWsolLamports = 0n;
+    if (creatorWsolInfo && creatorWsolInfo.owner.equals(TOKEN_PROGRAM_ID)) {
+        try {
+            existingWsolLamports = unpackAccount(creatorWsol, creatorWsolInfo, TOKEN_PROGRAM_ID).amount;
+        }
+        catch {
+            // Not a token account (e.g. lamports sent to the address): the idempotent creation takes it.
+            existingWsolLamports = 0n;
+        }
+    }
+    // 3. Instructions.
+    const instructions = [
+        createAssociatedTokenAccountIdempotentInstruction(payer, receiverBase, receiver, baseMint, tokenAProgram),
+        createAssociatedTokenAccountIdempotentInstruction(payer, creatorWsol, params.creator, NATIVE_MINT, TOKEN_PROGRAM_ID),
+        ...claimIxs,
+        createCloseAccountInstruction(creatorWsol, receiver, params.creator),
+    ];
+    const { blockhash, lastValidBlockHeight } = await retryRpc(() => connection.getLatestBlockhash(commitment), options.retry);
+    const transaction = new Transaction({ feePayer: payer, blockhash, lastValidBlockHeight });
+    transaction.add(...instructions);
+    // 4. Costs and net.
+    const signatures = BigInt(transaction.compileMessage().header.numRequiredSignatures);
+    const networkFeeLamports = signatures * CLAIM_LAMPORTS_PER_SIGNATURE;
+    const receiverTokenAccountRentLamports = receiverBaseInfo ? 0n : BigInt(tokenAccountRent);
+    const unwrapAccountRentLamports = creatorWsolInfo ? 0n : BigInt(tokenAccountRent);
+    const payerTotalLamports = networkFeeLamports + receiverTokenAccountRentLamports + unwrapAccountRentLamports;
+    const costs = {
+        networkFeeLamports,
+        receiverTokenAccountRentLamports,
+        unwrapAccountRentLamports,
+        payerTotalLamports,
+        payerRequiredBalanceLamports: payerTotalLamports,
+    };
+    // The closed account hands the receiver its whole balance: its rent (new or existing).
+    const closedLamports = creatorWsolInfo
+        ? BigInt(creatorWsolInfo.lamports)
+        : unwrapAccountRentLamports;
+    const receiverQuoteLamports = claimable.quote + closedLamports;
+    const summary = {
+        ...baseSummary,
+        receiverQuoteLamports,
+        existingWsolLamports,
+        costs,
+        netLamports: receiverQuoteLamports - payerTotalLamports,
+    };
+    if (options.minNetLamports !== undefined &&
+        !isPositionClaimWorthwhile(summary, options.minNetLamports)) {
+        return { transaction: null, lastValidBlockHeight: null, skipReason: 'not_worthwhile', summary };
+    }
+    return { transaction, lastValidBlockHeight, skipReason: null, summary };
+}
+/**
+ * The position fee claim of a FORGE creator wallet: the receiver is always the FORGE multisig
+ * vault (`FORGE_MULTISIG_VAULT`, SECURITY.md §5), read from `env` (defaults to `process.env`).
+ * @throws ForgeAddressError when `FORGE_MULTISIG_VAULT` is missing or invalid; as
+ *   `buildCreatorPositionFeeClaimTx` otherwise.
+ */
+export async function buildForgeCreatorPositionFeeClaimTx(connection, params, options = {}) {
+    const vault = getMultisigVault(options.env);
+    return buildCreatorPositionFeeClaimTx(connection, { ...params, receiver: vault, expectedReceiver: vault }, options);
+}

package/dist/settings.d.ts

@@ -0,0 +1,73 @@
+/**
+ * The fixed settings of every FORGE config (docs/METEORA.md, "Settings for the two configs").
+ *
+ * They live in their own module so that both the builders (config.ts) and the checks
+ * (validate.ts, the on-chain comparison in config.ts) read the same constants without an import
+ * cycle. `config.ts` re-exports them: they stay part of its public surface.
+ */
+import { ActivationType, BaseFeeMode, MigrationFeeOption, MigrationOption, TokenAuthorityOption, TokenDecimal, TokenType, type BaseFee } from '@meteora-ag/dynamic-bonding-curve-sdk';
+import type BN from 'bn.js';
+/** Token of every coin: SPL token, 1,000,000,000 tokens with 6 decimals, immutable metadata. */
+export declare const FORGE_TOKEN_SETTINGS: {
+    readonly tokenType: TokenType.SPLToken;
+    readonly tokenBaseDecimal: TokenDecimal.SIX;
+    readonly tokenQuoteDecimal: 9;
+    readonly tokenAuthorityOption: TokenAuthorityOption.Immutable;
+    readonly totalTokenSupply: 1000000000;
+    readonly leftover: 0;
+};
+/**
+ * Anti-sniper fee schedule (`spec.antiSniper`): the fee starts at `startingFeeBps` and decreases
+ * linearly, in `numberOfPeriod` equal steps over `totalDurationSeconds`, to `spec.tradingFeeBps`.
+ * validate.ts requires exactly this schedule (or none when `spec.antiSniper` is off).
+ */
+export declare const ANTI_SNIPER_FEE_SCHEDULE: {
+    readonly baseFeeMode: BaseFeeMode.FeeSchedulerLinear;
+    readonly startingFeeBps: 9900;
+    readonly numberOfPeriod: 10;
+    readonly totalDurationSeconds: 60;
+};
+/** Migration: DAMM v2, migrated pool fee 0.25%, no migration fee, 20% of the supply migrated. */
+export declare const FORGE_MIGRATION_SETTINGS: {
+    readonly migrationOption: MigrationOption.MET_DAMM_V2;
+    readonly migrationFeeOption: MigrationFeeOption.FixedBps25;
+    readonly migrationFee: {
+        readonly feePercentage: 0;
+        readonly creatorFeePercentage: 0;
+    };
+    readonly percentageSupplyOnMigration: 20;
+};
+/** Fee scheduler periods are counted in seconds. */
+export declare const FORGE_ACTIVATION_TYPE = ActivationType.Timestamp;
+/** Total supply of every coin in raw base units (1,000,000,000 tokens x 10^6). */
+export declare const FORGE_TOKEN_SUPPLY_RAW: bigint;
+/** The SDK `feeSchedulerParam` of a FORGE config (anti-sniper schedule, or a flat fee). */
+export declare function forgeFeeSchedulerParam(tradingFeeBps: number, antiSniper: boolean): {
+    startingFeeBps: number;
+    endingFeeBps: number;
+    numberOfPeriod: number;
+    totalDuration: number;
+};
+/**
+ * The base fee a FORGE config must carry for this trading fee and anti-sniper flag, computed by
+ * the SDK exactly as `buildCurve` does (cliff, number of periods, period, reduction factor, mode).
+ *
+ * @throws when the SDK refuses the fee (out of its bounds).
+ */
+export declare function forgeBaseFee(tradingFeeBps: number, antiSniper: boolean): BaseFee;
+/** Start price and curve shared by every FORGE config (they only depend on the settings above). */
+export interface ForgeReferenceCurve {
+    sqrtStartPrice: BN;
+    curve: readonly {
+        sqrtPrice: BN;
+        liquidity: BN;
+    }[];
+}
+/**
+ * The curve and start price of every FORGE config. They follow from the token settings, the
+ * migration settings and the 10 SOL threshold only (the SDK's `buildCurve` does not read the
+ * fees or the liquidity split for them), so one reference fits both configs of every launchpad.
+ * The curve decides how the supply is split between the swap, the migration and the leftover
+ * (sent to the leftover receiver): pinning it pins the leftover. Computed once, then cached.
+ */
+export declare function forgeReferenceCurve(): ForgeReferenceCurve;

package/dist/settings.js

@@ -0,0 +1,119 @@
+/**
+ * The fixed settings of every FORGE config (docs/METEORA.md, "Settings for the two configs").
+ *
+ * They live in their own module so that both the builders (config.ts) and the checks
+ * (validate.ts, the on-chain comparison in config.ts) read the same constants without an import
+ * cycle. `config.ts` re-exports them: they stay part of its public surface.
+ */
+import { ActivationType, BaseFeeMode, CollectFeeMode, MigrationFeeOption, MigrationOption, TokenAuthorityOption, TokenDecimal, TokenType, buildCurve, getBaseFeeParams, } from '@meteora-ag/dynamic-bonding-curve-sdk';
+import { CLIENT_BOUNDS, MAX_ANTI_SNIPER_STARTING_FEE_BPS, SOL_DECIMALS } from './constants.js';
+/** Token of every coin: SPL token, 1,000,000,000 tokens with 6 decimals, immutable metadata. */
+export const FORGE_TOKEN_SETTINGS = {
+    tokenType: TokenType.SPLToken,
+    tokenBaseDecimal: TokenDecimal.SIX,
+    tokenQuoteDecimal: SOL_DECIMALS,
+    tokenAuthorityOption: TokenAuthorityOption.Immutable,
+    totalTokenSupply: 1_000_000_000,
+    leftover: 0,
+};
+/**
+ * Anti-sniper fee schedule (`spec.antiSniper`): the fee starts at `startingFeeBps` and decreases
+ * linearly, in `numberOfPeriod` equal steps over `totalDurationSeconds`, to `spec.tradingFeeBps`.
+ * validate.ts requires exactly this schedule (or none when `spec.antiSniper` is off).
+ */
+export const ANTI_SNIPER_FEE_SCHEDULE = {
+    baseFeeMode: BaseFeeMode.FeeSchedulerLinear,
+    startingFeeBps: MAX_ANTI_SNIPER_STARTING_FEE_BPS,
+    numberOfPeriod: 10,
+    totalDurationSeconds: 60,
+};
+/** Migration: DAMM v2, migrated pool fee 0.25%, no migration fee, 20% of the supply migrated. */
+export const FORGE_MIGRATION_SETTINGS = {
+    migrationOption: MigrationOption.MET_DAMM_V2,
+    migrationFeeOption: MigrationFeeOption.FixedBps25,
+    migrationFee: { feePercentage: 0, creatorFeePercentage: 0 },
+    percentageSupplyOnMigration: 20,
+};
+/** Fee scheduler periods are counted in seconds. */
+export const FORGE_ACTIVATION_TYPE = ActivationType.Timestamp;
+/** Total supply of every coin in raw base units (1,000,000,000 tokens x 10^6). */
+export const FORGE_TOKEN_SUPPLY_RAW = BigInt(FORGE_TOKEN_SETTINGS.totalTokenSupply) *
+    10n ** BigInt(FORGE_TOKEN_SETTINGS.tokenBaseDecimal);
+/** The SDK `feeSchedulerParam` of a FORGE config (anti-sniper schedule, or a flat fee). */
+export function forgeFeeSchedulerParam(tradingFeeBps, antiSniper) {
+    const schedule = ANTI_SNIPER_FEE_SCHEDULE;
+    return antiSniper
+        ? {
+            startingFeeBps: schedule.startingFeeBps,
+            endingFeeBps: tradingFeeBps,
+            numberOfPeriod: schedule.numberOfPeriod,
+            totalDuration: schedule.totalDurationSeconds,
+        }
+        : {
+            startingFeeBps: tradingFeeBps,
+            endingFeeBps: tradingFeeBps,
+            numberOfPeriod: 0,
+            totalDuration: 0,
+        };
+}
+/**
+ * The base fee a FORGE config must carry for this trading fee and anti-sniper flag, computed by
+ * the SDK exactly as `buildCurve` does (cliff, number of periods, period, reduction factor, mode).
+ *
+ * @throws when the SDK refuses the fee (out of its bounds).
+ */
+export function forgeBaseFee(tradingFeeBps, antiSniper) {
+    return getBaseFeeParams({
+        baseFeeMode: ANTI_SNIPER_FEE_SCHEDULE.baseFeeMode,
+        feeSchedulerParam: forgeFeeSchedulerParam(tradingFeeBps, antiSniper),
+    });
+}
+let referenceCurve = null;
+/**
+ * The curve and start price of every FORGE config. They follow from the token settings, the
+ * migration settings and the 10 SOL threshold only (the SDK's `buildCurve` does not read the
+ * fees or the liquidity split for them), so one reference fits both configs of every launchpad.
+ * The curve decides how the supply is split between the swap, the migration and the leftover
+ * (sent to the leftover receiver): pinning it pins the leftover. Computed once, then cached.
+ */
+export function forgeReferenceCurve() {
+    if (referenceCurve)
+        return referenceCurve;
+    const built = buildCurve({
+        token: { ...FORGE_TOKEN_SETTINGS },
+        fee: {
+            baseFeeParams: {
+                baseFeeMode: ANTI_SNIPER_FEE_SCHEDULE.baseFeeMode,
+                feeSchedulerParam: forgeFeeSchedulerParam(CLIENT_BOUNDS.tradingFeeBps.min, false),
+            },
+            dynamicFeeEnabled: false,
+            collectFeeMode: CollectFeeMode.QuoteToken,
+            creatorTradingFeePercentage: 0,
+            poolCreationFee: 0,
+            enableFirstSwapWithMinFee: true,
+        },
+        migration: {
+            migrationOption: FORGE_MIGRATION_SETTINGS.migrationOption,
+            migrationFeeOption: FORGE_MIGRATION_SETTINGS.migrationFeeOption,
+            migrationFee: { ...FORGE_MIGRATION_SETTINGS.migrationFee },
+        },
+        liquidityDistribution: {
+            partnerPermanentLockedLiquidityPercentage: 100,
+            partnerLiquidityPercentage: 0,
+            creatorPermanentLockedLiquidityPercentage: 0,
+            creatorLiquidityPercentage: 0,
+        },
+        lockedVesting: {
+            totalLockedVestingAmount: 0,
+            numberOfVestingPeriod: 0,
+            cliffUnlockAmount: 0,
+            totalVestingDuration: 0,
+            cliffDurationFromMigrationTime: 0,
+        },
+        activationType: FORGE_ACTIVATION_TYPE,
+        percentageSupplyOnMigration: FORGE_MIGRATION_SETTINGS.percentageSupplyOnMigration,
+        migrationQuoteThreshold: CLIENT_BOUNDS.migrationThresholdSol,
+    });
+    referenceCurve = { sqrtStartPrice: built.sqrtStartPrice, curve: built.curve };
+    return referenceCurve;
+}