@forgedevv/core 0.1.0 → 0.3.0

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;
+}

package/dist/swap.d.ts

@@ -5,7 +5,8 @@
  * One transaction contains, in this order:
  *
  *   1. compute budget: `setComputeUnitLimit`, then `setComputeUnitPrice` (only when a priority fee
- *      is given);
+ *      is given: a fixed `priorityFeeMicroLamports`, or a `priority` setting whose price is read
+ *      from the recent fees of the swap's writable accounts and bounded, see priority-fee.ts);
  *   2. token accounts: the user's wrapped SOL ATA is always created (idempotent) and, on a buy, the
  *      user's coin ATA when it does not exist yet;
  *   3. buy only: SOL transfer of `amountInLamports` into the wrapped SOL ATA + `SyncNative` (wrap);
@@ -27,19 +28,26 @@
  * Refusals (typed `SwapError`, never a silent fallback):
  *   - the pool is migrated or its curve is complete (`POOL_GRADUATED`): the template trades through
  *     Jupiter in that case;
+ *   - the pool's config is not in the caller's `allowedConfigs` (`POOL_NOT_ALLOWED`): a launchpad
+ *     site only trades its own coins;
  *   - the platform fee wallet does not exist or is not rent-exempt
  *     (`PLATFORM_FEE_WALLET_NOT_RENT_EXEMPT`): the whole swap would fail on-chain (devnet finding);
- *   - the referral account is not an initialized wrapped SOL token account (`REFERRAL_ACCOUNT_INVALID`);
+ *   - the platform fee wallet is not exactly `FORGE_PLATFORM_FEE_WALLET`, or not a system account,
+ *     or `FORGE_PLATFORM_FEE_WALLET` is not the revenue wallet when the environment has
+ *     `FORGE_REVENUE_WALLET` (`PLATFORM_FEE_WALLET_MISMATCH`);
+ *   - the referral account is not an initialized wrapped SOL token account, or is not held by
+ *     `FORGE_REVENUE_WALLET` when the environment has it (`REFERRAL_ACCOUNT_INVALID`);
  *   - the pool is not a plain SOL-quoted DBC pool (`UNSUPPORTED_POOL`; transfer-hook pools excluded);
  *   - the serialized transaction exceeds 1,232 bytes (`TRANSACTION_TOO_LARGE`).
  *
  * Transaction size: measured on devnet (scripts/devnet-tests/reports/core-swap.md) at 819 bytes for a
  * buy and 797 bytes for a sell with this exact layout, far below the 1,232-byte limit (a buy that
- * also creates the coin ATA adds 10 bytes). If a future layout does not fit, the builders throw
- * `TRANSACTION_TOO_LARGE` unless the caller passes `addressLookupTables` (already fetched
- * `AddressLookupTableAccount`s, e.g. one holding the DBC program, the pool authority, the event
- * authority, the token programs, the wrapped SOL mint and the two FORGE fee accounts); the message
- * is then compiled against those tables and checked again.
+ * also creates the coin ATA adds 10 bytes, a priority fee 12 bytes for `setComputeUnitPrice`). If
+ * a future layout does not fit, the builders throw `TRANSACTION_TOO_LARGE` unless the caller
+ * passes `addressLookupTables` (already fetched `AddressLookupTableAccount`s, e.g. one holding the
+ * DBC program, the pool authority, the event authority, the token programs, the wrapped SOL mint
+ * and the two FORGE fee accounts); the message is then compiled against those tables and checked
+ * again.
  *
  * Layering: `fetchSwapContext` does all the network reads (with retries); everything else is pure
  * and unit-tested without network (`buildSwapTransaction`, `computeSwapQuote`, fee math).
@@ -48,10 +56,11 @@ import { PublicKey, TransactionInstruction, VersionedTransaction, type AddressLo
 import BN from 'bn.js';
 import { type PoolConfig, type VirtualPool } from '@meteora-ag/dynamic-bonding-curve-sdk';
 import { type AddressEnv } from './addresses.js';
+import { type PriorityFeeQuote, type PriorityFeeSetting } from './priority-fee.js';
 /** Platform fee on swaps built by @forge/core, in bps (`FEES.platformFeeBps` from @forge/shared). */
 export declare const PLATFORM_FEE_BPS: number;
-/** Highest slippage tolerance accepted by the builders (50%), whether given in bps or as a minimum. */
-export declare const MAX_SWAP_SLIPPAGE_BPS = 5000;
+/** Highest slippage tolerance accepted by the builders (25%), whether given in bps or as a minimum. */
+export declare const MAX_SWAP_SLIPPAGE_BPS = 2500;
 /**
  * Default compute unit limit. Measured on devnet: ~51,000 CU for a buy (~66,500 when it also creates
  * the coin ATA), ~49,000 CU for a sell; the default leaves about 2x headroom (fee scheduler,
@@ -66,7 +75,7 @@ export declare const MAX_SWAP_PRIORITY_FEE_MICRO_LAMPORTS = 10000000;
 export declare const SWAP_BASE_FEE_LAMPORTS_PER_SIGNATURE = 5000n;
 /** Serialized transaction size limit (`PACKET_DATA_SIZE` = 1,232 bytes). */
 export declare const SWAP_MAX_TRANSACTION_BYTES: number;
-export declare const SWAP_ERROR_CODES: readonly ["INVALID_PARAMS", "POOL_NOT_FOUND", "UNSUPPORTED_POOL", "POOL_GRADUATED", "PLATFORM_FEE_WALLET_NOT_RENT_EXEMPT", "REFERRAL_ACCOUNT_INVALID", "INSUFFICIENT_LIQUIDITY", "QUOTE_FAILED", "AMOUNT_TOO_SMALL", "MIN_AMOUNT_OUT_ABOVE_QUOTE", "SLIPPAGE_TOO_HIGH", "INSUFFICIENT_SOL_BALANCE", "INSUFFICIENT_TOKEN_BALANCE", "TRANSACTION_TOO_LARGE", "RPC_ERROR"];
+export declare const SWAP_ERROR_CODES: readonly ["INVALID_PARAMS", "POOL_NOT_FOUND", "UNSUPPORTED_POOL", "POOL_GRADUATED", "POOL_NOT_ALLOWED", "PLATFORM_FEE_WALLET_NOT_RENT_EXEMPT", "PLATFORM_FEE_WALLET_MISMATCH", "REFERRAL_ACCOUNT_INVALID", "INSUFFICIENT_LIQUIDITY", "QUOTE_FAILED", "AMOUNT_TOO_SMALL", "MIN_AMOUNT_OUT_ABOVE_QUOTE", "SLIPPAGE_TOO_HIGH", "INSUFFICIENT_SOL_BALANCE", "INSUFFICIENT_TOKEN_BALANCE", "TRANSACTION_TOO_LARGE", "RPC_ERROR"];
 export type SwapErrorCode = (typeof SWAP_ERROR_CODES)[number];
 /** Public data attached to a `SwapError` (addresses, amounts as decimal strings). Never secrets. */
 export type SwapErrorDetails = Readonly<Record<string, string | number | boolean>>;
@@ -270,15 +279,43 @@ export interface SwapContext extends SwapPoolState {
     recentBlockhash: string;
     lastValidBlockHeight: number;
 }
-/** Throws unless the platform fee wallet exists and holds at least its rent-exempt minimum. */
-export declare function assertPlatformFeeWalletReady(wallet: PublicKey, account: SwapAccountSnapshot | null, rentExemptMinimum: bigint): void;
-/** Throws unless the referral account is an initialized wrapped SOL token account (SPL Token). */
-export declare function assertReferralAccountReady(address: PublicKey, account: SwapAccountSnapshot | null): void;
+/**
+ * Throws unless the platform fee wallet exists and holds at least its rent-exempt minimum. With
+ * `expectedWallet` (FORGE_PLATFORM_FEE_WALLET, as `buildBuyTx` / `buildSellTx` pass it), the
+ * wallet must be exactly that key and a plain system account: lamports sent to an account owned by
+ * another program could not be spent by FORGE (`PLATFORM_FEE_WALLET_MISMATCH`).
+ */
+export declare function assertPlatformFeeWalletReady(wallet: PublicKey, account: SwapAccountSnapshot | null, rentExemptMinimum: bigint, expectedWallet?: PublicKey | null): void;
+/**
+ * Throws unless the referral account is an initialized wrapped SOL token account (SPL Token).
+ * With `expectedOwner` (FORGE_REVENUE_WALLET, when the environment has it), the token account must
+ * be held by that key: otherwise the referral share would be paid to someone else.
+ */
+export declare function assertReferralAccountReady(address: PublicKey, account: SwapAccountSnapshot | null, expectedOwner?: PublicKey | null): void;
+/** The FORGE fee accounts a swap transaction must pay, as the builders read them from the env. */
+export interface SwapFeeAccountExpectations {
+    /** The platform fee transfer must go to exactly this key (FORGE_PLATFORM_FEE_WALLET). */
+    platformFeeWallet?: PublicKey | null;
+    /** The Meteora referral token account must be held by this key (FORGE_REVENUE_WALLET). */
+    referralOwner?: PublicKey | null;
+}
+/**
+ * Throws `POOL_NOT_ALLOWED` unless the pool's config is one of `allowedConfigs`. Without a list
+ * (`undefined`), any config is accepted; an empty list accepts none.
+ */
+export declare function assertPoolConfigAllowed(pool: PublicKey, config: PublicKey, allowedConfigs: readonly (PublicKey | string)[] | undefined): void;
 export interface SwapBuildOptions {
     /** Compute unit limit (default `DEFAULT_SWAP_COMPUTE_UNIT_LIMIT`). */
     computeUnitLimit?: number;
     /** Priority fee in micro-lamports per CU (default 0: no `setComputeUnitPrice` instruction). */
     priorityFeeMicroLamports?: number;
+    /**
+     * Priority fee read from the cluster (priority-fee.ts): the recent fees of the swap's writable
+     * accounts, bounded by this setting (`{}` = `DEFAULT_PRIORITY_FEE_POLICY`: at most 0.0005 SOL
+     * per swap). Only `buildBuyTx` / `buildSellTx` read it (they hold the connection); not with
+     * `priorityFeeMicroLamports`.
+     */
+    priority?: PriorityFeeSetting;
     /**
      * Address lookup tables to compile the v0 message with, if the transaction would exceed 1,232
      * bytes without them (it does not with the current layout). Fetch them with
@@ -298,6 +335,11 @@ export interface BuiltSwapTransaction {
     sizeBytes: number;
     computeUnitLimit: number;
     priorityFeeMicroLamports: number;
+    /**
+     * The priority fee: price, fee in lamports and its cap (`maxLamports`, the cost guard to show
+     * before signing), and where the price comes from (`fixed` without a `priority` setting).
+     */
+    priorityFee: PriorityFeeQuote;
     /** Base fee + priority fee, in lamports. */
     estimatedNetworkFeeLamports: bigint;
     /** Rent locked in a coin ATA created by a buy (0 when it already existed or on a sell). */
@@ -321,12 +363,19 @@ export declare function compileSwapTransaction(args: {
     sizeBytes: number;
 };
 /**
- * Pure transaction builder: validates the context (pool on its curve, fee accounts ready, balances),
- * quotes, and assembles the instructions in the order documented at the top of this file.
+ * Pure transaction builder: validates the context (pool on its curve, fee accounts ready and, with
+ * `expected`, exactly FORGE's), quotes, and assembles the instructions in the order documented at
+ * the top of this file.
+ */
+export declare function buildSwapTransaction(ctx: SwapContext, request: SwapBuildRequest, expected?: SwapFeeAccountExpectations): BuiltSwapTransaction;
+/**
+ * Reads and decodes a pool and its config, plus the current point. With
+ * `options.allowedConfigs`, a pool whose config is not in the list is refused (`POOL_NOT_ALLOWED`)
+ * before its config is read.
  */
-export declare function buildSwapTransaction(ctx: SwapContext, request: SwapBuildRequest): BuiltSwapTransaction;
-/** Reads and decodes a pool and its config, plus the current point. */
-export declare function fetchSwapPoolState(connection: Connection, poolAddress: PublicKey | string, commitment?: Commitment): Promise<SwapPoolState & {
+export declare function fetchSwapPoolState(connection: Connection, poolAddress: PublicKey | string, commitment?: Commitment, options?: {
+    allowedConfigs?: readonly (PublicKey | string)[];
+}): Promise<SwapPoolState & {
     configAddress: PublicKey;
 }>;
 export interface FetchSwapContextParams {
@@ -336,22 +385,42 @@ export interface FetchSwapContextParams {
     platformFeeWallet: PublicKey;
     referralTokenAccount: PublicKey;
     commitment?: Commitment;
+    /** Configs the pool may belong to; anything else is `POOL_NOT_ALLOWED` (default: any config). */
+    allowedConfigs?: readonly (PublicKey | string)[];
 }
 /** All network reads of a swap build: pool, config, user accounts, fee accounts, rent, blockhash. */
 export declare function fetchSwapContext(p: FetchSwapContextParams): Promise<SwapContext>;
-/** FORGE fee accounts used by the swap, resolved through addresses.ts (never hard-coded). */
+/**
+ * FORGE fee accounts used by the swap, resolved through addresses.ts (never hard-coded), and the
+ * revenue wallet that must hold the referral account (`null` when the environment does not have
+ * `FORGE_REVENUE_WALLET`: the owner check is then skipped). When the environment has it, the
+ * platform fee wallet must be that same wallet (D34: the platform fee is revenue too), otherwise
+ * `PLATFORM_FEE_WALLET_MISMATCH`.
+ */
 export declare function swapFeeAddresses(env?: AddressEnv): {
     platformFeeWallet: PublicKey;
     referralTokenAccount: PublicKey;
+    revenueWallet: PublicKey | null;
 };
 interface SwapCommonParams extends SwapBuildOptions {
     connection: Connection;
     pool: PublicKey | string;
     /** The trader: fee payer, signer and owner of the token accounts. */
     user: PublicKey | string;
-    /** Environment to read the FORGE addresses from (defaults to `process.env`). */
+    /**
+     * Environment to read the FORGE addresses from (defaults to `process.env`):
+     * `FORGE_PLATFORM_FEE_WALLET` and `FORGE_METEORA_REFERRAL_ACCOUNT` (required), and
+     * `FORGE_REVENUE_WALLET` (optional: when set, the referral account must be held by it and the
+     * platform fee wallet must be it).
+     */
     env?: AddressEnv;
     commitment?: Commitment;
+    /**
+     * Configs the pool must belong to (e.g. the two configs of the launchpad whose site builds the
+     * swap). The pool's config is read on-chain; any other pool is refused with `POOL_NOT_ALLOWED`.
+     * Without it, any SOL-quoted DBC pool is accepted.
+     */
+    allowedConfigs?: readonly (PublicKey | string)[];
 }
 export type BuildBuyTxParams = SwapCommonParams & {
     /** SOL into the swap, in lamports. The platform fee is paid on top of it. */
@@ -372,6 +441,8 @@ export type QuoteSwapParams = {
     /** Lamports on a buy, raw coin units on a sell. */
     amountIn: bigint;
     commitment?: Commitment;
+    /** Same as on `buildBuyTx`: configs the pool must belong to (`POOL_NOT_ALLOWED` otherwise). */
+    allowedConfigs?: readonly (PublicKey | string)[];
 } & (SlippageInput | {
     slippageBps?: undefined;
     minAmountOut?: undefined;
@@ -382,8 +453,9 @@ export type QuoteSwapParams = {
  */
 export declare function quoteSwap(params: QuoteSwapParams): Promise<SwapQuote>;
 /**
- * Startup / pre-build check of the FORGE fee accounts: the platform fee wallet must be rent-exempt
- * and the referral account must be a wrapped SOL token account. Throws `SwapError`.
+ * Startup / pre-build check of the FORGE fee accounts: the platform fee wallet must be a
+ * rent-exempt system account and the referral account must be a wrapped SOL token account, held by
+ * `FORGE_REVENUE_WALLET` when the environment has it. Throws `SwapError`.
  */
 export declare function assertSwapFeeAccountsReady(params: {
     connection: Connection;