@forgedevv/core 0.1.0 → 0.2.0

package/dist/pool.js

@@ -33,14 +33,20 @@
  *
  * `buildUserCoinLaunchTx` is the same launch for a coin created by a user on the client's
  * launchpad config: the user is pool creator, rent payer, fee payer and buyer, the mint is the
- * only other signer.
+ * only other signer. Its first buy pays the FORGE platform fee (0.3%, rounded up) like any swap
+ * built by core: one SOL transfer to `FORGE_PLATFORM_FEE_WALLET`, the last instruction.
+ *
+ * Both builders compare the on-chain config with what core builds for it, field by field
+ * (`onchainConfigMismatches` in config.ts), before building anything.
  */
 import { DYNAMIC_BONDING_CURVE_PROGRAM_ID, DynamicBondingCurveClient, MigrationOption, TokenType, deriveDbcPoolAddress, } from '@meteora-ag/dynamic-bonding-curve-sdk';
 import { ACCOUNT_SIZE, ASSOCIATED_TOKEN_PROGRAM_ID, MINT_SIZE, NATIVE_MINT, TOKEN_PROGRAM_ID, createAssociatedTokenAccountIdempotentInstruction, getAssociatedTokenAddressSync, } from '@solana/spl-token';
 import { PublicKey, SystemProgram, Transaction, } from '@solana/web3.js';
 import BN from 'bn.js';
-import { quoteFirstBuyOnConfig } from './config.js';
+import { getPlatformFeeWallet } from './addresses.js';
+import { onchainConfigMismatches, quoteFirstBuyOnConfig, } from './config.js';
 import { FEES, MIGRATION_THRESHOLD_LAMPORTS, SOL_QUOTE_MINT } from './constants.js';
+import { PLATFORM_FEE_BPS, platformFeeLamports } from './swap.js';
 import { LaunchCoinError, assertFirstBuyLamports, assertLaunchMetadata, } from './launch-metadata.js';
 import { MAX_TRANSACTION_BYTES, computeBudgetInstructions, priorityFeeLamports, readNonce, requiredSigners, transactionSize, } from './tx.js';
 // The metadata and first buy checks live in launch-metadata.ts (shared with config.ts); they
@@ -84,14 +90,12 @@ function assertDistinctKeys(entries) {
     }
 }
 /**
- * Checks that an on-chain config is the launchpad coin config of `owner` and that it is safe to
- * launch the coin on it: SOL quote, SPL token, fee claimer = owner, FORGE creator share, creator
- * locked liquidity, first swap at the minimum fee (otherwise the client's first buy would pay
- * the anti-sniper fee), fee scheduler base fee, DAMM v2 migration at exactly 10 SOL.
- *
- * @throws LaunchCoinError `CONFIG_MISMATCH` listing every mismatch.
+ * The essential checks of a config a coin is launched on, with readable messages: SOL quote (SPL),
+ * SPL base token, first swap at the minimum fee (otherwise the first buy pays the anti-sniper
+ * fee), a fee scheduler base fee, DAMM v2 migration at exactly 10 SOL. The full field by field
+ * comparison (`onchainConfigMismatches`) follows them.
  */
-export function assertLaunchCoinConfig(config, owner) {
+function essentialConfigProblems(config) {
     const problems = [];
     if (!config.quoteMint.equals(SOL_QUOTE_MINT))
         problems.push('quote mint is not SOL');
@@ -99,16 +103,6 @@ export function assertLaunchCoinConfig(config, owner) {
         problems.push('quote token is not an SPL token');
     if (config.tokenType !== TokenType.SPLToken)
         problems.push('base token type is not SPL token');
-    if (!config.feeClaimer.equals(owner))
-        problems.push('fee claimer is not the owner wallet');
-    if (!config.leftoverReceiver.equals(owner))
-        problems.push('leftover receiver is not the owner');
-    if (config.creatorTradingFeePercentage !== FEES.forgeCreatorSharePct) {
-        problems.push(`creator trading fee is not ${FEES.forgeCreatorSharePct}%`);
-    }
-    if (!(config.creatorPermanentLockedLiquidityPercentage > 0)) {
-        problems.push('creator has no permanently locked liquidity');
-    }
     if (config.enableFirstSwapWithMinFee !== 1) {
         problems.push('first swap with minimum fee is disabled (the first buy would pay the anti-sniper fee)');
     }
@@ -121,6 +115,40 @@ export function assertLaunchCoinConfig(config, owner) {
     if (BigInt(config.migrationQuoteThreshold.toString()) !== MIGRATION_THRESHOLD_LAMPORTS) {
         problems.push(`migration threshold is not ${MIGRATION_THRESHOLD_LAMPORTS} lamports`);
     }
+    return problems;
+}
+/**
+ * Checks that an on-chain config is the launchpad coin config of `owner` and that it is safe to
+ * launch the coin on it. Besides the essential checks (SOL quote, SPL token, first swap at the
+ * minimum fee, fee scheduler, DAMM v2 at exactly 10 SOL), EVERY field is compared with what core
+ * builds for a launchpad coin config (`onchainConfigMismatches`): fee claimer and leftover
+ * receiver = owner, FORGE creator share, the 75 / 25 permanently locked liquidity, no pool
+ * creation fee, immutable metadata, the exact fee schedule, no migration fee, no locked vesting,
+ * FORGE's supply and curve, timestamp activation.
+ *
+ * With `spec` (the spec the config was built from), the reference is exactly
+ * `buildLaunchpadCoinConfig(spec)`; without it, the trading fee and the anti-sniper flag are read
+ * from the config and only have to be values a FORGE spec can hold (linear schedule, whole fee of
+ * 50..200 bps). Pass the spec whenever it is known.
+ *
+ * @throws LaunchCoinError `CONFIG_MISMATCH` listing every mismatch.
+ */
+export function assertLaunchCoinConfig(config, owner, spec) {
+    const problems = essentialConfigProblems(config);
+    if (!config.feeClaimer.equals(owner))
+        problems.push('fee claimer is not the owner wallet');
+    if (!config.leftoverReceiver.equals(owner))
+        problems.push('leftover receiver is not the owner');
+    if (config.creatorTradingFeePercentage !== FEES.forgeCreatorSharePct) {
+        problems.push(`creator trading fee is not ${FEES.forgeCreatorSharePct}%`);
+    }
+    if (!(config.creatorPermanentLockedLiquidityPercentage > 0)) {
+        problems.push('creator has no permanently locked liquidity');
+    }
+    problems.push(...onchainConfigMismatches(config, 'launchpadCoin', {
+        owner,
+        ...(spec !== undefined ? { spec } : {}),
+    }));
     if (problems.length > 0) {
         fail('CONFIG_MISMATCH', `config is not a valid launchpad coin config: ${problems.join('; ')}`);
     }
@@ -231,7 +259,8 @@ async function loadLaunchState(connection, accounts, checkConfig) {
  * Quotes the first buy on the fresh pool at the minimum fee (exact: nothing else can trade before
  * it, the pool is created in the same transaction) and assembles the transaction: nonce advance,
  * compute budget, the buyer's WSOL account (idempotent), then the SDK instructions of
- * `createPoolWithFirstBuy` (proven call pattern of devnet test 3), without referral.
+ * `createPoolWithFirstBuy` (proven call pattern of devnet test 3), without referral, then the
+ * trailing instructions.
  */
 async function assembleLaunch(input) {
     const { buyer, nonce } = input;
@@ -273,7 +302,7 @@ async function assembleLaunch(input) {
     if (quote && !createsAssociatedAccount(sdkTx.instructions, buyerWsol)) {
         instructions.push(createAssociatedTokenAccountIdempotentInstruction(buyer, buyerWsol, buyer, NATIVE_MINT, TOKEN_PROGRAM_ID));
     }
-    instructions.push(...sdkTx.instructions);
+    instructions.push(...sdkTx.instructions, ...(input.trailingInstructions ?? []));
     const transaction = new Transaction({ feePayer: buyer, recentBlockhash: input.recentBlockhash });
     if (input.lastValidBlockHeight !== null) {
         transaction.lastValidBlockHeight = input.lastValidBlockHeight;
@@ -332,9 +361,11 @@ async function computeLaunchCosts(input) {
     const rentPayerCosts = poolAccountsRentLamports +
         METAPLEX_CREATE_METADATA_FEE_LAMPORTS +
         input.poolCreationFeeLamports;
+    const platformFee = input.platformFeeLamports ?? 0n;
     const ownerTotalLamports = firstBuy +
         networkFeeLamports +
         ownerTokenAccountRentLamports +
+        platformFee +
         (input.rentPayerIsOwner ? rentPayerCosts : 0n);
     return {
         firstBuyLamports: firstBuy,
@@ -346,6 +377,7 @@ async function computeLaunchCosts(input) {
         ownerTemporaryLamports,
         networkFeeLamports,
         networkFeeSource,
+        ...(input.platformFeeLamports !== undefined ? { platformFeeLamports: platformFee } : {}),
         ownerTotalLamports,
         ownerRequiredBalanceLamports: ownerTotalLamports + ownerTemporaryLamports,
         creatorTotalLamports: input.rentPayerIsOwner ? 0n : rentPayerCosts,
@@ -406,7 +438,7 @@ export async function buildLaunchCoinTx(params) {
     const pool = deriveDbcPoolAddress(SOL_QUOTE_MINT, mint, config);
     const rentPayer = rentPayerKind === 'owner' ? owner : creator;
     // 2. On-chain state: config (this owner's launchpad coin config), pool and mint not existing.
-    const { poolConfig, client, program } = await loadLaunchState(connection, { config, pool, mint }, (decoded) => assertLaunchCoinConfig(decoded, owner));
+    const { poolConfig, client, program } = await loadLaunchState(connection, { config, pool, mint }, (decoded) => assertLaunchCoinConfig(decoded, owner, params.spec));
     const poolCreationFeeLamports = toBigInt(poolConfig.poolCreationFee);
     if (rentPayerKind === 'creator' && poolCreationFeeLamports !== 0n) {
         fail('RENT_PAYER_REFUSED', `the creator wallet cannot pay the rent on a config with a pool creation fee (${poolCreationFeeLamports} lamports): it would pay the client's own fee`);
@@ -511,34 +543,49 @@ export async function buildLaunchCoinTx(params) {
     };
 }
 /**
- * Checks that an on-chain config can launch a user coin with a first buy at the minimum fee: SOL
- * quote, SPL token program for both tokens, `enableFirstSwapWithMinFee`. Nothing about who owns
- * the config or the creator share: the template checks the config address itself.
+ * Checks that an on-chain config is a FORGE launchpad config a user coin can be launched on:
+ * the essential checks (SOL quote, SPL token program for both tokens, `enableFirstSwapWithMinFee`,
+ * fee scheduler, DAMM v2 at exactly 10 SOL), then EVERY field compared with what core builds for
+ * a launchpad config (`onchainConfigMismatches`): liquidity split following the creator share,
+ * immutable metadata, the exact fee schedule, no migration fee, no locked vesting, FORGE's supply
+ * and curve, timestamp activation. `expected` pins the owner wallet (fee claimer and leftover
+ * receiver), the pool creation fee, or the whole spec; without it the spec fields only have to be
+ * within the client bounds and the leftover receiver must be the fee claimer.
  *
  * @throws LaunchCoinError `CONFIG_MISMATCH` listing every mismatch.
  */
-export function assertUserCoinConfig(config) {
-    const problems = [];
-    if (!config.quoteMint.equals(SOL_QUOTE_MINT))
-        problems.push('quote mint is not SOL');
-    if (config.quoteTokenFlag !== 0)
-        problems.push('quote token is not an SPL token');
-    if (config.tokenType !== TokenType.SPLToken)
-        problems.push('base token type is not SPL token');
-    if (config.enableFirstSwapWithMinFee !== 1) {
-        problems.push('first swap with minimum fee is disabled (the first buy would pay the anti-sniper fee)');
-    }
+export function assertUserCoinConfig(config, expected = {}) {
+    const problems = [
+        ...essentialConfigProblems(config),
+        ...onchainConfigMismatches(config, 'launchpad', expected),
+    ];
     if (problems.length > 0) {
         fail('CONFIG_MISMATCH', `config cannot launch a user coin: ${problems.join('; ')}`);
     }
 }
+/**
+ * The platform fee wallet must exist and be rent-exempt: a SOL transfer to an account below
+ * its rent-exempt minimum fails, and the whole launch with it.
+ *
+ * @throws LaunchCoinError `PLATFORM_FEE_WALLET_NOT_READY`.
+ */
+async function assertPlatformFeeWalletLive(connection, wallet) {
+    const info = await connection.getAccountInfo(wallet, 'confirmed');
+    const minimum = BigInt(await connection.getMinimumBalanceForRentExemption(info?.data.length ?? 0));
+    if (!info || BigInt(info.lamports) < minimum) {
+        fail('PLATFORM_FEE_WALLET_NOT_READY', 'FORGE_PLATFORM_FEE_WALLET must exist and be rent-exempt, otherwise the launch fails on-chain');
+    }
+}
 /**
  * Builds the launch transaction of a coin created by a user on the client's launchpad config:
  * pool creation + the user's first buy at the minimum fee (no referral), with a compute unit limit
  * (and a priority fee when given) and a recent blockhash. The user is pool creator, rent payer,
- * fee payer and buyer; the mint is the only other signer. Rent is read from the cluster.
+ * fee payer and buyer; the mint is the only other signer. Rent is read from the cluster. With a
+ * first buy, the last instruction transfers the platform fee (`platformFeeLamports(firstBuy)`) to
+ * `FORGE_PLATFORM_FEE_WALLET` (see `chargePlatformFee`).
  *
- * @throws LaunchCoinError (typed `code`).
+ * @throws LaunchCoinError (typed `code`; `PLATFORM_FEE_WALLET_NOT_READY` when the fee wallet is
+ *   not rent-exempt), or ForgeAddressError when `FORGE_PLATFORM_FEE_WALLET` is missing.
  */
 export async function buildUserCoinLaunchTx(params) {
     const { connection, config, wallet } = params;
@@ -568,9 +615,22 @@ export async function buildUserCoinLaunchTx(params) {
     ]);
     const baseMint = mint;
     const pool = deriveDbcPoolAddress(SOL_QUOTE_MINT, baseMint, config);
+    // FORGE platform fee on the first buy (rounded up), to FORGE_PLATFORM_FEE_WALLET only.
+    const platformFee = params.chargePlatformFee === false || params.firstBuyLamports <= 0n
+        ? 0n
+        : platformFeeLamports(params.firstBuyLamports, PLATFORM_FEE_BPS);
+    const platformFeeWallet = platformFee > 0n ? getPlatformFeeWallet(params.env) : null;
+    if (platformFeeWallet &&
+        (platformFeeWallet.equals(baseMint) ||
+            platformFeeWallet.equals(config) ||
+            platformFeeWallet.equals(pool))) {
+        fail('INVALID_INPUT', 'FORGE_PLATFORM_FEE_WALLET must not be the mint, the config or the pool');
+    }
     // 2. On-chain state.
-    const { poolConfig, client, program } = await loadLaunchState(connection, { config, pool, mint: baseMint }, assertUserCoinConfig);
+    const { poolConfig, client, program } = await loadLaunchState(connection, { config, pool, mint: baseMint }, (decoded) => assertUserCoinConfig(decoded, params.expectedConfig));
     const poolCreationFeeLamports = toBigInt(poolConfig.poolCreationFee);
+    if (platformFeeWallet)
+        await assertPlatformFeeWalletLive(connection, platformFeeWallet);
     // 3. Recent blockhash: the user signs right away, no durable nonce.
     const latest = await connection.getLatestBlockhash('confirmed');
     // 4. Quote and instructions.
@@ -591,6 +651,16 @@ export async function buildUserCoinLaunchTx(params) {
         nonce: null,
         recentBlockhash: latest.blockhash,
         lastValidBlockHeight: latest.lastValidBlockHeight,
+        // Last, like on a swap (docs/METEORA.md, "The platform fee").
+        trailingInstructions: platformFeeWallet
+            ? [
+                SystemProgram.transfer({
+                    fromPubkey: wallet,
+                    toPubkey: platformFeeWallet,
+                    lamports: platformFee,
+                }),
+            ]
+            : [],
     });
     // 5. Signers: exactly the wallet (fee payer, first) and the mint.
     const signers = checkSigners(transaction, [wallet, baseMint], wallet);
@@ -611,6 +681,7 @@ export async function buildUserCoinLaunchTx(params) {
         firstBuyLamports: params.firstBuyLamports,
         poolCreationFeeLamports,
         rentPayerIsOwner: true,
+        platformFeeLamports: platformFee,
     });
     return {
         transaction,
@@ -626,6 +697,8 @@ export async function buildUserCoinLaunchTx(params) {
             expectedTokensOut: quote ? quote.tokensOut : 0n,
             minimumTokensOut: quote ? quote.minimumTokensOut : 0n,
             slippageBps,
+            platformFeeLamports: platformFee,
+            platformFeeWallet,
             costs,
             recentBlockhash: latest.blockhash,
             lastValidBlockHeight: latest.lastValidBlockHeight,

package/dist/position-claims.d.ts

@@ -0,0 +1,207 @@
+import { PublicKey, Transaction, type Connection } from '@solana/web3.js';
+import { type PoolState as DammV2PoolState, type PositionState as DammV2PositionState } from '@meteora-ag/cp-amm-sdk';
+import { type AddressEnv } from './addresses.js';
+import { type ClaimOptions } from './claims.js';
+import { type DbcPoolState, type ReadOptions, type TokenAmounts } from './reads.js';
+export type { DammV2PoolState, DammV2PositionState };
+/** DAMM v2 (cp-amm) program id, from the pinned SDK. */
+export declare const DAMM_V2_PROGRAM_ID: PublicKey;
+/** Anchor discriminator of `claim_position_fee` (sha256("global:claim_position_fee")[0..8]). */
+export declare const CLAIM_POSITION_FEE_DISCRIMINATOR: Buffer<ArrayBuffer>;
+/** Account indexes of `claim_position_fee` (cp-amm SDK 1.5.1 IDL). */
+export declare const CLAIM_POSITION_FEE_ACCOUNTS: {
+    readonly poolAuthority: 0;
+    readonly pool: 1;
+    readonly position: 2;
+    readonly tokenAAccount: 3;
+    readonly tokenBAccount: 4;
+    readonly tokenAVault: 5;
+    readonly tokenBVault: 6;
+    readonly tokenAMint: 7;
+    readonly tokenBMint: 8;
+    readonly positionNftAccount: 9;
+    readonly owner: 10;
+    readonly tokenAProgram: 11;
+    readonly tokenBProgram: 12;
+    readonly eventAuthority: 13;
+    readonly program: 14;
+};
+/** `tokenAFlag` / `tokenBFlag` of a DAMM v2 pool: 0 = SPL Token, 1 = Token-2022. */
+export declare function dammV2TokenProgram(flag: number): PublicKey;
+export interface MigratedDammV2Pool {
+    /** The DAMM v2 pool the DBC pool migrated to. */
+    dammPool: PublicKey;
+    /** The DAMM v2 config of the migration fee option (`DAMM_V2_MIGRATION_FEE_ADDRESS`). */
+    dammConfig: PublicKey;
+}
+/**
+ * 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 declare function migratedDammV2Pool(state: Pick<DbcPoolState, 'virtualPool' | 'config'>): MigratedDammV2Pool | null;
+/** A DAMM v2 position: the account, the NFT that owns it and the NFT's token account. */
+export interface DammV2PositionRef {
+    position: PublicKey;
+    nftMint: PublicKey;
+    positionNftAccount: PublicKey;
+}
+export interface DammV2PositionSummary extends DammV2PositionRef {
+    /** DAMM v2 pool of the position. */
+    dammPool: PublicKey;
+    liquidity: {
+        unlocked: bigint;
+        vested: bigint;
+        permanentLocked: bigint;
+    };
+    /** Fees claimable now: `base` = token A (the coin), `quote` = token B (SOL), raw units. */
+    pendingFees: TokenAmounts;
+}
+/** Pure: unclaimed fees of a position (SDK `getUnClaimLpFee`), as bigint. */
+export declare function positionPendingFees(poolState: DammV2PoolState, positionState: DammV2PositionState): TokenAmounts;
+/** Pure: summary of one position of `poolState`. */
+export declare function summarizePosition(poolState: DammV2PoolState, ref: DammV2PositionRef, positionState: DammV2PositionState): DammV2PositionSummary;
+/** Pure: sum of the pending fees of `positions`. */
+export declare function sumPendingFees(positions: readonly DammV2PositionSummary[]): TokenAmounts;
+/** Fetches a DAMM v2 pool. @throws ClaimError `damm_pool_not_found` when the account is missing. */
+export declare function getDammV2PoolState(connection: Connection, dammPool: PublicKey, options?: ReadOptions): Promise<DammV2PoolState>;
+/**
+ * The migrated DAMM v2 pool of a DBC pool and the creator's positions on it, with their fees.
+ * Null when the pool has not migrated (see `migratedDammV2Pool`).
+ */
+export interface CreatorDammV2Positions {
+    /** The DBC pool. */
+    pool: PublicKey;
+    dammPool: PublicKey;
+    dammConfig: PublicKey;
+    creator: PublicKey;
+    /** Positions whose NFT the creator holds, sorted by address. */
+    positions: DammV2PositionSummary[];
+    /** Sum of the positions' pending fees. */
+    claimable: TokenAmounts;
+}
+export interface FindCreatorPositionsParams {
+    /** The DBC pool, or its already-read state. */
+    pool: PublicKey | DbcPoolState;
+    /** The pool creator (must match the pool state). */
+    creator: PublicKey;
+}
+/**
+ * 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 declare function findCreatorDammV2Positions(connection: Connection, params: FindCreatorPositionsParams, options?: ReadOptions): Promise<CreatorDammV2Positions | null>;
+/** Lamport costs of a position fee claim, as bigint. */
+export interface PositionClaimCosts {
+    /** Signature fees (signers x 5000 lamports; no priority fee), paid by the payer. */
+    networkFeeLamports: bigint;
+    /**
+     * Rent of the receiver's coin account, created on the first claim of a pool (paid by the
+     * payer, kept in that account, which the receiver owns). 0 when it already exists.
+     */
+    receiverTokenAccountRentLamports: bigint;
+    /**
+     * Rent of the temporary WSOL account the payer funds: closed to the receiver with the fees, it
+     * reaches the receiver as lamports (not refunded to the payer). 0 when the account exists.
+     */
+    unwrapAccountRentLamports: bigint;
+    /** Everything the payer's balance decreases by: the three amounts above. */
+    payerTotalLamports: bigint;
+    /** Balance the payer needs before signing (same as the total: nothing is refunded). */
+    payerRequiredBalanceLamports: bigint;
+}
+export interface PositionClaimSummary {
+    kind: 'position';
+    /** The DBC pool. */
+    pool: PublicKey;
+    dammPool: PublicKey;
+    dammConfig: PublicKey;
+    baseMint: PublicKey;
+    /** The creator: owner of the positions, signs the claim. */
+    claimer: PublicKey;
+    receiver: PublicKey;
+    /** Fee payer of the transaction. */
+    payer: PublicKey;
+    /** The positions claimed (sorted by address), with their fees when the claim was built. */
+    positions: DammV2PositionSummary[];
+    /** Sum of the positions' pending fees when the claim was built (a lower bound at execution). */
+    claimable: TokenAmounts;
+    /**
+     * SOL the receiver gets from the transaction, lamports: the claimable SOL fees plus the
+     * lamports of the temporary WSOL account closed to it (its rent, and the WSOL it already held).
+     * A lower bound: the claim is uncapped and fees accrue until it executes. Never exact
+     * (`quoteIsExact` is always false).
+     */
+    receiverQuoteLamports: bigint;
+    quoteIsExact: false;
+    /**
+     * WSOL the creator's temporary account already held when the transaction was built (anyone
+     * can send some to it): it reaches the receiver with the close, counted in
+     * `receiverQuoteLamports`. Zero when the account is empty or new.
+     */
+    existingWsolLamports: bigint;
+    /** Zero costs when there is no transaction. */
+    costs: PositionClaimCosts;
+    /** `receiverQuoteLamports - costs.payerTotalLamports`. Coin fees are not valued. */
+    netLamports: bigint;
+}
+export type PositionClaimSkipReason = 'no_position' | 'nothing_to_claim' | 'not_worthwhile';
+export interface PositionClaimTxResult {
+    /** Unsigned claim transaction, or `null` when skipped (see `skipReason`). */
+    transaction: Transaction | null;
+    lastValidBlockHeight: number | null;
+    skipReason: PositionClaimSkipReason | null;
+    summary: PositionClaimSummary;
+}
+export interface CreatorPositionClaimParams {
+    /** The DBC pool (the DAMM v2 pool is derived from it). */
+    pool: PublicKey;
+    /** Pool creator and owner of the positions; signs the claim. */
+    creator: PublicKey;
+    /** Where the fees go. */
+    receiver: PublicKey;
+    /** When set, `receiver` must equal it (`receiver_mismatch` otherwise). */
+    expectedReceiver?: PublicKey;
+    /** Fee payer; defaults to the creator. */
+    payer?: PublicKey;
+    /**
+     * Positions to claim (addresses). Each must belong to the migrated pool and be held by the
+     * creator. Default: every position of the creator on that pool.
+     */
+    positions?: readonly PublicKey[];
+}
+/** True when the claim collects more SOL than it costs, by more than `minNetLamports`. */
+export declare function isPositionClaimWorthwhile(summary: PositionClaimSummary, minNetLamports?: bigint): boolean;
+/**
+ * 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 declare function buildCreatorPositionFeeClaimTx(connection: Connection, params: CreatorPositionClaimParams, options?: ClaimOptions): Promise<PositionClaimTxResult>;
+export interface ForgeCreatorPositionClaimParams {
+    pool: PublicKey;
+    /** FORGE creator wallet of the launchpad (the pool creator); signs the claim. */
+    creator: PublicKey;
+    /** Fee payer; defaults to the creator. */
+    payer?: PublicKey;
+    positions?: readonly PublicKey[];
+}
+/**
+ * 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 declare function buildForgeCreatorPositionFeeClaimTx(connection: Connection, params: ForgeCreatorPositionClaimParams, options?: ClaimOptions & {
+    env?: AddressEnv;
+}): Promise<PositionClaimTxResult>;