@forgedevv/core 0.1.0 → 0.2.0

package/dist/jupiter-referral.js

@@ -0,0 +1,295 @@
+/**
+ * Jupiter referral fee claim (docs/METEORA.md "The platform fee", after graduation; D7, D8).
+ *
+ * After a coin graduates, trades go through Jupiter and FORGE's 30 bps integrator fee is collected
+ * by the Jupiter referral program into token accounts of FORGE's referral account
+ * (`FORGE_JUPITER_REFERRAL_ACCOUNT`), one per currency Jupiter collects in. Claiming is
+ * permissionless: it moves a token account's balance to the referral account's `partner` (the
+ * owner of the referral account: the FORGE multisig vault), minus the project's share, so the
+ * fees reach the treasury and feed the buyback (D8). The fee payer only pays the network fee and,
+ * the first time, the rent of the partner's token account.
+ *
+ * Built from the referral program's IDL (program `REFER4ZgmyYx9c6He5XfaTMiGfdLwRnkV4RPp9t9iF3`,
+ * `@jup-ag/referral-sdk` 0.3.0) with raw instructions: the SDK pulls Anchor, too heavy for the
+ * transaction core. Two collection accounts exist per mint and both are claimed when funded:
+ * - `claim`: the classic referral token account, PDA `["referral_ata", referral account, mint]`;
+ * - `claimV2`: the associated token account of the referral account (classic or Token-2022).
+ * Account order, PDA seeds and Anchor discriminators are the IDL's; the unit tests pin them.
+ *
+ * Mainnet only: the referral program and Jupiter's fee collection live on mainnet-beta. The
+ * builder checks the connection's genesis hash and refuses any other cluster (`wrong_cluster`).
+ * The partner can be asserted (`expectedPartner` = the vault): a referral account owned by
+ * anyone else is refused (`partner_mismatch`), fees would not reach the treasury.
+ */
+import { createHash } from 'node:crypto';
+import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID, createAssociatedTokenAccountIdempotentInstruction, getAssociatedTokenAddressSync, unpackAccount, } from '@solana/spl-token';
+import { PublicKey, SystemProgram, Transaction, TransactionInstruction, } from '@solana/web3.js';
+import { PaymentError, assertCluster } from './payments.js';
+import { retryRpc } from './reads.js';
+// ---------------------------------------------------------------------------------------------
+// Constants (IDL)
+// ---------------------------------------------------------------------------------------------
+/** Jupiter referral program (mainnet-beta). */
+export const JUPITER_REFERRAL_PROGRAM_ID = new PublicKey('REFER4ZgmyYx9c6He5XfaTMiGfdLwRnkV4RPp9t9iF3');
+function anchorDiscriminator(name) {
+    return createHash('sha256').update(name).digest().subarray(0, 8);
+}
+export const JUPITER_REFERRAL_ACCOUNT_DISCRIMINATOR = anchorDiscriminator('account:ReferralAccount');
+export const JUPITER_PROJECT_DISCRIMINATOR = anchorDiscriminator('account:Project');
+export const JUPITER_CLAIM_DISCRIMINATOR = anchorDiscriminator('global:claim');
+export const JUPITER_CLAIM_V2_DISCRIMINATOR = anchorDiscriminator('global:claim_v2');
+export const JUPITER_CREATE_ADMIN_TOKEN_ACCOUNT_DISCRIMINATOR = anchorDiscriminator('global:create_admin_token_account');
+export class JupiterReferralError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = 'JupiterReferralError';
+        this.code = code;
+    }
+}
+function readString(data, offset) {
+    if (data.length < offset + 4)
+        throw new RangeError('string length out of bounds');
+    const length = data.readUInt32LE(offset);
+    const start = offset + 4;
+    if (data.length < start + length)
+        throw new RangeError('string out of bounds');
+    return { value: data.subarray(start, start + length).toString('utf8'), next: start + length };
+}
+/** `ReferralAccount { partner, project, share_bps: u16, name: Option<String> }`. */
+export function decodeJupiterReferralAccount(data) {
+    const fail = (reason) => new JupiterReferralError('not_a_referral_account', reason);
+    if (data.length < 8 + 32 + 32 + 2 + 1)
+        throw fail('referral account data too short');
+    if (!data.subarray(0, 8).equals(JUPITER_REFERRAL_ACCOUNT_DISCRIMINATOR)) {
+        throw fail('not a Jupiter referral account');
+    }
+    const partner = new PublicKey(data.subarray(8, 40));
+    const project = new PublicKey(data.subarray(40, 72));
+    const shareBps = data.readUInt16LE(72);
+    const tag = data[74];
+    let name = null;
+    if (tag === 1) {
+        try {
+            name = readString(data, 75).value;
+        }
+        catch (error) {
+            throw new JupiterReferralError('not_a_referral_account', 'referral account name invalid', {
+                cause: error,
+            });
+        }
+    }
+    else if (tag !== 0) {
+        throw fail('referral account name tag invalid');
+    }
+    return { partner, project, shareBps, name };
+}
+/** `Project { base, admin, name: String, default_share_bps: u16 }`. */
+export function decodeJupiterProject(data) {
+    const fail = (reason, cause) => new JupiterReferralError('not_a_project', reason, { cause });
+    if (data.length < 8 + 32 + 32 + 4 + 2)
+        throw fail('project data too short');
+    if (!data.subarray(0, 8).equals(JUPITER_PROJECT_DISCRIMINATOR)) {
+        throw fail('not a Jupiter referral project');
+    }
+    const base = new PublicKey(data.subarray(8, 40));
+    const admin = new PublicKey(data.subarray(40, 72));
+    let name;
+    try {
+        name = readString(data, 72);
+    }
+    catch (error) {
+        throw fail('project name invalid', error);
+    }
+    if (data.length < name.next + 2)
+        throw fail('project data too short');
+    return { base, admin, name: name.value, defaultShareBps: data.readUInt16LE(name.next) };
+}
+// ---------------------------------------------------------------------------------------------
+// Addresses
+// ---------------------------------------------------------------------------------------------
+/** Classic referral token account: PDA `["referral_ata", referral account, mint]`. */
+export function deriveJupiterReferralTokenAccount(referralAccount, mint, programId = JUPITER_REFERRAL_PROGRAM_ID) {
+    return PublicKey.findProgramAddressSync([Buffer.from('referral_ata', 'utf8'), referralAccount.toBuffer(), mint.toBuffer()], programId)[0];
+}
+/** V2 referral token account: the associated token account of the referral account. */
+export function deriveJupiterReferralTokenAccountV2(referralAccount, mint, tokenProgram) {
+    return getAssociatedTokenAddressSync(mint, referralAccount, true, tokenProgram);
+}
+/** Project authority: PDA `["project_authority", project.base]`. */
+export function deriveJupiterProjectAuthority(base, programId = JUPITER_REFERRAL_PROGRAM_ID) {
+    return PublicKey.findProgramAddressSync([Buffer.from('project_authority', 'utf8'), base.toBuffer()], programId)[0];
+}
+const ro = (pubkey) => ({ pubkey, isSigner: false, isWritable: false });
+const rw = (pubkey) => ({ pubkey, isSigner: false, isWritable: true });
+function assertTokenProgram(id) {
+    if (!id.equals(TOKEN_PROGRAM_ID) && !id.equals(TOKEN_2022_PROGRAM_ID)) {
+        throw new JupiterReferralError('invalid_params', 'tokenProgram is not a token program');
+    }
+}
+/**
+ * `claim` (v1) or `claim_v2`: the IDL's accounts in the IDL's order. The two differ only in the
+ * position of the program accounts at the end (v1: associated token, system, token; v2: system,
+ * token, associated token). No arguments.
+ */
+export function buildJupiterReferralClaimIx(accounts, version, programId = JUPITER_REFERRAL_PROGRAM_ID) {
+    assertTokenProgram(accounts.tokenProgram);
+    if (version !== 'v1' && version !== 'v2') {
+        throw new JupiterReferralError('invalid_params', 'version must be v1 or v2');
+    }
+    const shared = [
+        { pubkey: accounts.payer, isSigner: true, isWritable: true },
+        ro(accounts.project),
+        ro(accounts.admin),
+        rw(accounts.projectAdminTokenAccount),
+        ro(accounts.referralAccount),
+        rw(accounts.referralTokenAccount),
+        ro(accounts.partner),
+        rw(accounts.partnerTokenAccount),
+        ro(accounts.mint),
+    ];
+    const programs = version === 'v1'
+        ? [ro(ASSOCIATED_TOKEN_PROGRAM_ID), ro(SystemProgram.programId), ro(accounts.tokenProgram)]
+        : [ro(SystemProgram.programId), ro(accounts.tokenProgram), ro(ASSOCIATED_TOKEN_PROGRAM_ID)];
+    return new TransactionInstruction({
+        programId,
+        keys: [...shared, ...programs],
+        data: Buffer.from(version === 'v1' ? JUPITER_CLAIM_DISCRIMINATOR : JUPITER_CLAIM_V2_DISCRIMINATOR),
+    });
+}
+/** `create_admin_token_account`: needed once per mint before the first claim of that mint. */
+export function buildJupiterCreateAdminTokenAccountIx(accounts, programId = JUPITER_REFERRAL_PROGRAM_ID) {
+    assertTokenProgram(accounts.tokenProgram);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            ro(accounts.project),
+            rw(accounts.projectAuthority),
+            ro(accounts.admin),
+            rw(accounts.projectAdminTokenAccount),
+            ro(accounts.mint),
+            ro(SystemProgram.programId),
+            ro(accounts.tokenProgram),
+            ro(ASSOCIATED_TOKEN_PROGRAM_ID),
+        ],
+        data: Buffer.from(JUPITER_CREATE_ADMIN_TOKEN_ACCOUNT_DISCRIMINATOR),
+    });
+}
+function tokenAmount(address, info, tokenProgram) {
+    if (!info || !info.owner.equals(tokenProgram))
+        return 0n;
+    try {
+        const account = unpackAccount(address, info, tokenProgram);
+        return account.isFrozen ? 0n : account.amount;
+    }
+    catch {
+        return 0n;
+    }
+}
+/**
+ * Reads the referral account, its project, the mint and the collection accounts, and builds the
+ * claim(s) of every funded collection account of `mint` to the partner's associated token account.
+ * Mainnet-beta only (genesis hash). Returns `transaction: null` when nothing is claimable.
+ */
+export async function buildJupiterReferralClaimTx(p) {
+    const { connection } = p;
+    const commitment = p.commitment ?? 'confirmed';
+    const programId = p.programId ?? JUPITER_REFERRAL_PROGRAM_ID;
+    const retry = p.retry ?? {};
+    if (p.payer.equals(p.referralAccount) || p.mint.equals(p.referralAccount)) {
+        throw new JupiterReferralError('invalid_params', 'payer, mint and referral account must differ');
+    }
+    try {
+        await assertCluster(connection, 'mainnet-beta', retry);
+    }
+    catch (error) {
+        if (error instanceof PaymentError && error.code === 'wrong_cluster') {
+            throw new JupiterReferralError('wrong_cluster', 'Jupiter referral claims only exist on mainnet-beta', { cause: error });
+        }
+        throw error;
+    }
+    const [referralInfo, mintInfo] = await retryRpc(() => connection.getMultipleAccountsInfo([p.referralAccount, p.mint], commitment), retry);
+    if (!referralInfo) {
+        throw new JupiterReferralError('referral_account_not_found', 'referral account not found');
+    }
+    if (!referralInfo.owner.equals(programId)) {
+        throw new JupiterReferralError('not_a_referral_account', 'referral account is not owned by the Jupiter referral program');
+    }
+    const referral = decodeJupiterReferralAccount(Buffer.from(referralInfo.data));
+    if (p.expectedPartner && !referral.partner.equals(p.expectedPartner)) {
+        throw new JupiterReferralError('partner_mismatch', 'the referral account partner is not the expected receiver');
+    }
+    if (!mintInfo)
+        throw new JupiterReferralError('mint_not_found', 'mint not found');
+    const tokenProgram = mintInfo.owner;
+    if (!tokenProgram.equals(TOKEN_PROGRAM_ID) && !tokenProgram.equals(TOKEN_2022_PROGRAM_ID)) {
+        throw new JupiterReferralError('not_a_mint', 'mint is not owned by a token program');
+    }
+    const projectInfo = await retryRpc(() => connection.getAccountInfo(referral.project, commitment), retry);
+    if (!projectInfo)
+        throw new JupiterReferralError('project_not_found', 'project not found');
+    if (!projectInfo.owner.equals(programId)) {
+        throw new JupiterReferralError('not_a_project', 'project is not owned by the referral program');
+    }
+    const project = decodeJupiterProject(Buffer.from(projectInfo.data));
+    const v1Account = deriveJupiterReferralTokenAccount(p.referralAccount, p.mint, programId);
+    const v2Account = deriveJupiterReferralTokenAccountV2(p.referralAccount, p.mint, tokenProgram);
+    const partnerTokenAccount = getAssociatedTokenAddressSync(p.mint, referral.partner, true, tokenProgram);
+    const adminTokenAccount = getAssociatedTokenAddressSync(p.mint, project.admin, true, tokenProgram);
+    const [v1Info, v2Info, partnerInfo, adminInfo] = await retryRpc(() => connection.getMultipleAccountsInfo([v1Account, v2Account, partnerTokenAccount, adminTokenAccount], commitment), retry);
+    const claims = [];
+    const v1Amount = tokenAmount(v1Account, v1Info ?? null, tokenProgram);
+    if (v1Amount > 0n)
+        claims.push({ version: 'v1', referralTokenAccount: v1Account, amount: v1Amount });
+    const v2Amount = tokenAmount(v2Account, v2Info ?? null, tokenProgram);
+    if (v2Amount > 0n)
+        claims.push({ version: 'v2', referralTokenAccount: v2Account, amount: v2Amount });
+    const projectAuthority = deriveJupiterProjectAuthority(project.base, programId);
+    const summary = {
+        referralAccount: p.referralAccount,
+        partner: referral.partner,
+        partnerTokenAccount,
+        project: referral.project,
+        admin: project.admin,
+        projectAuthority,
+        mint: p.mint,
+        tokenProgram,
+        claims,
+        createsPartnerTokenAccount: claims.length > 0 && !partnerInfo,
+        createsAdminTokenAccount: claims.length > 0 && !adminInfo,
+    };
+    if (claims.length === 0)
+        return { transaction: null, lastValidBlockHeight: null, summary };
+    const transaction = new Transaction();
+    if (summary.createsPartnerTokenAccount) {
+        transaction.add(createAssociatedTokenAccountIdempotentInstruction(p.payer, partnerTokenAccount, referral.partner, p.mint, tokenProgram));
+    }
+    if (summary.createsAdminTokenAccount) {
+        transaction.add(buildJupiterCreateAdminTokenAccountIx({
+            project: referral.project,
+            projectAuthority,
+            admin: project.admin,
+            projectAdminTokenAccount: adminTokenAccount,
+            mint: p.mint,
+            tokenProgram,
+        }, programId));
+    }
+    for (const claim of claims) {
+        transaction.add(buildJupiterReferralClaimIx({
+            payer: p.payer,
+            project: referral.project,
+            admin: project.admin,
+            projectAdminTokenAccount: adminTokenAccount,
+            referralAccount: p.referralAccount,
+            referralTokenAccount: claim.referralTokenAccount,
+            partner: referral.partner,
+            partnerTokenAccount,
+            mint: p.mint,
+            tokenProgram,
+        }, claim.version, programId));
+    }
+    const latest = await retryRpc(() => connection.getLatestBlockhash(commitment), retry);
+    transaction.feePayer = p.payer;
+    transaction.recentBlockhash = latest.blockhash;
+    return { transaction, lastValidBlockHeight: latest.lastValidBlockHeight, summary };
+}

package/dist/launch-metadata.d.ts

@@ -15,7 +15,9 @@
 import type { LaunchpadSpec } from '@forge/shared';
 export type LaunchCoinErrorCode = 'INVALID_INPUT' | 'CONFIG_NOT_FOUND' | 'CONFIG_MISMATCH' | 'POOL_EXISTS' | 'MINT_EXISTS'
 /** A referral was given for the first buy: it would lose the first-swap minimum fee. */
- | 'REFERRAL_UNSUPPORTED' | 'RENT_PAYER_REFUSED' | 'FIRST_BUY_EXCEEDS_CURVE' | 'QUOTE_FAILED' | 'UNEXPECTED_SIGNERS' | 'TX_TOO_LARGE';
+ | 'REFERRAL_UNSUPPORTED' | 'RENT_PAYER_REFUSED' | 'FIRST_BUY_EXCEEDS_CURVE' | 'QUOTE_FAILED' | 'UNEXPECTED_SIGNERS' | 'TX_TOO_LARGE'
+/** FORGE_PLATFORM_FEE_WALLET does not exist or is not rent-exempt (user coin launch). */
+ | 'PLATFORM_FEE_WALLET_NOT_READY';
 /** The launch transaction cannot be built. Nothing has been sent. */
 export declare class LaunchCoinError extends Error {
     readonly code: LaunchCoinErrorCode;

package/dist/pool.d.ts

@@ -33,12 +33,17 @@
  *
  * `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 { type PoolConfig, type SwapQuoteConfig } from '@meteora-ag/dynamic-bonding-curve-sdk';
 import { PublicKey, Transaction, type Connection } from '@solana/web3.js';
-import type { OwnerTransactionSummary } from '@forge/shared';
-import type { AddressEnv } from './addresses.js';
+import type { LaunchpadSpec, OwnerTransactionSummary } from '@forge/shared';
+import { type AddressEnv } from './addresses.js';
+import { type OnchainConfigExpectation } from './config.js';
 export { LAUNCH_METADATA_BUDGET_BYTES, LaunchCoinError, MAX_FIRST_BUY_LAMPORTS, METADATA_LIMITS, assertFirstBuyLamports, assertLaunchMetadata, assertSpecLaunchable, launchMetadataBytes, type LaunchCoinErrorCode, } from './launch-metadata.js';
 /**
  * Compute unit limit of the launch transaction: 190,840 CU measured on devnet with the durable
@@ -96,6 +101,12 @@ export interface BuildLaunchCoinTxParams {
     slippageBps?: number;
     /** Durable nonce: the transaction then stays valid until the nonce advances. */
     durableNonce?: DurableNonceParam;
+    /**
+     * The launchpad spec the coin config was built from. When given, the on-chain config must be
+     * exactly `buildLaunchpadCoinConfig(spec)` (`assertLaunchCoinConfig`); without it, its trading
+     * fee and anti-sniper flag are only bounded. Recommended.
+     */
+    spec?: LaunchpadSpec;
     /**
      * Who pays the pool, mint, metadata and vault accounts and the pool creation fee (default
      * `owner`; `creator` only on a config whose pool creation fee is 0).
@@ -137,6 +148,11 @@ export interface LaunchCoinCosts {
     ownerTemporaryLamports: bigint;
     /** Signature fees + priority fee (paid by the owner, the fee payer). */
     networkFeeLamports: bigint;
+    /**
+     * FORGE platform fee on the first buy (`PLATFORM_FEE_BPS` of it, rounded up), paid by the owner
+     * to `FORGE_PLATFORM_FEE_WALLET`. Only set by `buildUserCoinLaunchTx`.
+     */
+    platformFeeLamports?: bigint;
     /** `cluster` = `getFeeForMessage`; `estimate` = signatures x 5000 + priority fee. */
     networkFeeSource: 'cluster' | 'estimate';
     /** Everything the owner's balance decreases by. */
@@ -193,13 +209,21 @@ export interface LaunchCoinTx {
 }
 /**
  * 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.
+ * 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 declare function assertLaunchCoinConfig(config: PoolConfig, owner: PublicKey): void;
+export declare function assertLaunchCoinConfig(config: PoolConfig, owner: PublicKey, spec?: LaunchpadSpec): void;
 /** The quote inputs of a pool config, for a pool that does not exist yet. */
 export declare function quoteConfigFromPoolConfig(config: PoolConfig): SwapQuoteConfig;
 /**
@@ -229,10 +253,25 @@ export interface BuildUserCoinLaunchTxParams {
     /** Slippage on the first buy (default 100 bps, at most 1000). */
     slippageBps?: number;
     /**
-     * Accepted for symmetry with `buildLaunchCoinTx`; not read: a user coin launch involves no
-     * FORGE address (no referral on the first buy, no platform fee on the creation).
+     * Environment to read `FORGE_PLATFORM_FEE_WALLET` from (defaults to `process.env`; a browser
+     * passes its public copy explicitly). Read only when a platform fee is charged.
      */
     env?: AddressEnv;
+    /**
+     * Charge the FORGE platform fee on the first buy (default `true`): `PLATFORM_FEE_BPS` (30 bps)
+     * of `firstBuyLamports`, rounded up to the lamport (`platformFeeLamports`), as ONE SystemProgram
+     * transfer from the wallet to `FORGE_PLATFORM_FEE_WALLET`, the last instruction. Nothing is
+     * added when there is no first buy. `false` only for tools that must reproduce a launch without
+     * it.
+     */
+    chargePlatformFee?: boolean;
+    /**
+     * What the on-chain launchpad config must be, compared field by field
+     * (`assertUserCoinConfig`): the owner wallet (fee claimer and leftover receiver), the pool
+     * creation fee, or the full spec. Without it, every fixed FORGE setting is still compared and
+     * the spec fields only have to be within the client bounds.
+     */
+    expectedConfig?: OnchainConfigExpectation;
     computeUnitLimit?: number;
     /** Priority fee, micro-lamports per compute unit (default 0). */
     computeUnitPriceMicroLamports?: number;
@@ -252,10 +291,14 @@ export interface UserCoinLaunchSummary {
     expectedTokensOut: bigint;
     minimumTokensOut: bigint;
     slippageBps: number;
+    /** FORGE platform fee transferred by the wallet (0 without a first buy or when not charged). */
+    platformFeeLamports: bigint;
+    /** Recipient of the platform fee transfer, or null when there is none. */
+    platformFeeWallet: PublicKey | null;
     /**
      * Same figures as `LaunchCoinCosts`, read the same way: the `owner*` fields are the wallet's
-     * (it pays everything, including the pool accounts and the pool creation fee);
-     * `creatorTotalLamports` is 0 because no separate creator wallet pays anything.
+     * (it pays everything, including the pool accounts, the pool creation fee and the platform
+     * fee); `creatorTotalLamports` is 0 because no separate creator wallet pays anything.
      */
     costs: LaunchCoinCosts;
     recentBlockhash: string;
@@ -272,20 +315,28 @@ export interface UserCoinLaunchTx {
     summary: UserCoinLaunchSummary;
 }
 /**
- * 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 declare function assertUserCoinConfig(config: PoolConfig): void;
+export declare function assertUserCoinConfig(config: PoolConfig, expected?: OnchainConfigExpectation): void;
 /**
  * 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 declare function buildUserCoinLaunchTx(params: BuildUserCoinLaunchTxParams): Promise<UserCoinLaunchTx>;
 /**