@forgedevv/core 0.1.0 → 0.3.0

package/dist/pool.js

@@ -33,15 +33,32 @@
  *
  * `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.
+ *
+ * Priority fee (`priority` setting, priority-fee.ts): the price is read from the recent fees of
+ * the launch's writable accounts and bounded by the setting. The compute budget instructions come
+ * right after the nonce advance: `setComputeUnitLimit` then `setComputeUnitPrice`. The launchpad
+ * coin launch is tight (`LAUNCH_METADATA_BUDGET_BYTES`): when both do not fit in 1,232 bytes, the
+ * price goes alone (4 bytes more than the limit it replaces; the fee is then bounded for
+ * `MAX_TRANSACTION_COMPUTE_UNITS`, the most the runtime can apply without a limit), and when even
+ * that does not fit, the launch keeps its shape without a price (`priorityFeePlacement`
+ * `omitted_for_size`): the metadata budget accepted at `/v1/configs` never shrinks. That launch
+ * uses a durable nonce, so it stays valid until it lands. The user coin launch always fits both.
  */
 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_COMPUTE_UNITS, computePriorityFee, fixedPriorityFee, priorityFeeInstructions, readRecentPriorityFees, resolvePriorityFeePolicy, writableAccountsOf, } from './priority-fee.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
 // stay part of this module's public surface.
@@ -84,14 +101,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 +114,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 +126,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('; ')}`);
     }
@@ -229,9 +268,10 @@ 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.
+ * it, the pool is created in the same transaction) and returns how to compose the transaction for
+ * given compute budget instructions: 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, then the trailing instructions.
  */
 async function assembleLaunch(input) {
     const { buyer, nonce } = input;
@@ -260,26 +300,98 @@ async function assembleLaunch(input) {
             }
             : {}),
     });
-    const instructions = [];
+    const head = [];
     if (nonce) {
-        instructions.push(SystemProgram.nonceAdvance({
+        head.push(SystemProgram.nonceAdvance({
             noncePubkey: nonce.nonceAccount,
             authorizedPubkey: nonce.authority,
         }));
     }
-    instructions.push(...computeBudgetInstructions(input.budget));
+    const body = [];
     // The SDK adds the buyer's WSOL account creation only when it is missing at build time.
     const buyerWsol = getAssociatedTokenAddressSync(NATIVE_MINT, buyer, true, TOKEN_PROGRAM_ID);
     if (quote && !createsAssociatedAccount(sdkTx.instructions, buyerWsol)) {
-        instructions.push(createAssociatedTokenAccountIdempotentInstruction(buyer, buyerWsol, buyer, NATIVE_MINT, TOKEN_PROGRAM_ID));
+        body.push(createAssociatedTokenAccountIdempotentInstruction(buyer, buyerWsol, buyer, NATIVE_MINT, TOKEN_PROGRAM_ID));
+    }
+    body.push(...sdkTx.instructions, ...(input.trailingInstructions ?? []));
+    const compose = (budget) => {
+        const transaction = new Transaction({
+            feePayer: buyer,
+            recentBlockhash: input.recentBlockhash,
+        });
+        if (input.lastValidBlockHeight !== null) {
+            transaction.lastValidBlockHeight = input.lastValidBlockHeight;
+        }
+        transaction.add(...head, ...budget, ...body);
+        return { transaction, txBytes: transactionSize(transaction) };
+    };
+    return { quote, compose };
+}
+/**
+ * The compute budget of a launch: the legacy shape (limit, fixed price if any) without a
+ * `priority` setting; otherwise the priced shape that fits (see the top of this file).
+ * `allowPriceOnly`: the price may go without the limit (launchpad coin launch only).
+ */
+async function priceLaunch(input) {
+    const { compose, budget } = input;
+    const legacy = compose(computeBudgetInstructions(budget));
+    const fixed = fixedPriorityFee(budget.units, budget.microLamports);
+    if (input.priority === undefined) {
+        return { ...legacy, priorityFee: fixed, placement: 'limit_and_price', feeBudget: budget };
+    }
+    let recentFees;
+    try {
+        recentFees = await readRecentPriorityFees(input.connection, writableAccountsOf(legacy.transaction.instructions));
+    }
+    catch {
+        // Degraded, reported in the quote (`rpc_unavailable`): the floor still prices the launch.
+        recentFees = null;
+    }
+    const full = computePriorityFee({
+        recentFees,
+        computeUnitLimit: budget.units,
+        policy: input.priority,
+    });
+    const withLimit = compose(priorityFeeInstructions(full));
+    if (withLimit.txBytes <= MAX_TRANSACTION_BYTES) {
+        return {
+            ...withLimit,
+            priorityFee: full,
+            placement: 'limit_and_price',
+            feeBudget: { units: full.computeUnitLimit, microLamports: full.microLamports },
+        };
+    }
+    if (input.allowPriceOnly) {
+        const alone = computePriorityFee({
+            recentFees,
+            computeUnitLimit: MAX_TRANSACTION_COMPUTE_UNITS,
+            policy: input.priority,
+        });
+        const priceOnly = compose(priorityFeeInstructions(alone, { priceOnly: true }));
+        if (priceOnly.txBytes <= MAX_TRANSACTION_BYTES) {
+            return {
+                ...priceOnly,
+                priorityFee: alone,
+                placement: 'price_only',
+                feeBudget: { units: alone.computeUnitLimit, microLamports: alone.microLamports },
+            };
+        }
+    }
+    return { ...legacy, priorityFee: fixed, placement: 'omitted_for_size', feeBudget: budget };
+}
+/** @throws LaunchCoinError `INVALID_INPUT` on a bad setting or one given with a fixed price. */
+function assertPrioritySetting(priority, computeUnitPriceMicroLamports) {
+    if (priority === undefined)
+        return;
+    if (computeUnitPriceMicroLamports !== undefined) {
+        fail('INVALID_INPUT', 'pass either priority or computeUnitPriceMicroLamports, not both');
+    }
+    try {
+        resolvePriorityFeePolicy(priority);
     }
-    instructions.push(...sdkTx.instructions);
-    const transaction = new Transaction({ feePayer: buyer, recentBlockhash: input.recentBlockhash });
-    if (input.lastValidBlockHeight !== null) {
-        transaction.lastValidBlockHeight = input.lastValidBlockHeight;
+    catch (error) {
+        fail('INVALID_INPUT', `priority: ${error instanceof Error ? error.message : String(error)}`);
     }
-    transaction.add(...instructions);
-    return { transaction, quote, txBytes: transactionSize(transaction) };
 }
 /** The required signers, and whether they are exactly `expected` with `feePayer` first. */
 function checkSigners(transaction, expected, feePayer) {
@@ -332,9 +444,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 +460,7 @@ async function computeLaunchCosts(input) {
         ownerTemporaryLamports,
         networkFeeLamports,
         networkFeeSource,
+        ...(input.platformFeeLamports !== undefined ? { platformFeeLamports: platformFee } : {}),
         ownerTotalLamports,
         ownerRequiredBalanceLamports: ownerTotalLamports + ownerTemporaryLamports,
         creatorTotalLamports: input.rentPayerIsOwner ? 0n : rentPayerCosts,
@@ -388,6 +503,7 @@ export async function buildLaunchCoinTx(params) {
         fail('INVALID_INPUT', "rentPayer must be 'owner' or 'creator'");
     }
     assertNoFirstBuyReferral(params.referralTokenAccount);
+    assertPrioritySetting(params.priority, params.computeUnitPriceMicroLamports);
     const keys = [
         ['config', config],
         ['creator', creator],
@@ -406,7 +522,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`);
@@ -426,8 +542,8 @@ export async function buildLaunchCoinTx(params) {
         recentBlockhash = latest.blockhash;
         lastValidBlockHeight = latest.lastValidBlockHeight;
     }
-    // 4. Quote and instructions.
-    const { transaction, quote, txBytes } = await assembleLaunch({
+    // 4. Quote and instructions, then the compute budget that fits.
+    const { quote, compose } = await assembleLaunch({
         client,
         poolConfig,
         config,
@@ -440,11 +556,18 @@ export async function buildLaunchCoinTx(params) {
         metadataUri: params.metadataUri,
         firstBuyLamports: params.firstBuyLamports,
         slippageBps,
-        budget,
         nonce,
         recentBlockhash,
         lastValidBlockHeight,
     });
+    const priced = await priceLaunch({
+        connection,
+        compose,
+        budget,
+        priority: params.priority,
+        allowPriceOnly: true,
+    });
+    const { transaction, txBytes } = priced;
     // 5. Signers: exactly owner, creator, mint (+ the nonce authority). With the owner paying
     //    the rent, the creator wallet must not be debitable at all (read-only signer).
     const expected = [owner, creator, mint];
@@ -466,7 +589,7 @@ export async function buildLaunchCoinTx(params) {
         transaction,
         signatureCount: signers.actual.length,
         nonce,
-        budget,
+        budget: priced.feeBudget,
         quote,
         firstBuyLamports: params.firstBuyLamports,
         poolCreationFeeLamports,
@@ -503,7 +626,9 @@ export async function buildLaunchCoinTx(params) {
             recentBlockhash,
             lastValidBlockHeight,
             computeUnitLimit,
-            computeUnitPriceMicroLamports,
+            computeUnitPriceMicroLamports: priced.priorityFee.microLamports,
+            priorityFee: priced.priorityFee,
+            priorityFeePlacement: priced.placement,
             signerSideSigners,
             ownerSigner: owner,
             txBytes,
@@ -511,34 +636,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;
@@ -566,15 +706,29 @@ export async function buildUserCoinLaunchTx(params) {
         ['wallet', wallet],
         ['mint', mint],
     ]);
+    assertPrioritySetting(params.priority, params.computeUnitPriceMicroLamports);
     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.
-    const { transaction, quote, txBytes } = await assembleLaunch({
+    // 4. Quote and instructions, then the compute budget.
+    const { quote, compose } = await assembleLaunch({
         client,
         poolConfig,
         config,
@@ -587,11 +741,29 @@ export async function buildUserCoinLaunchTx(params) {
         metadataUri: params.metadataUri,
         firstBuyLamports: params.firstBuyLamports,
         slippageBps,
-        budget,
         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,
+                }),
+            ]
+            : [],
     });
+    // The browser verifier wants a limit with any price: never the price alone here.
+    const priced = await priceLaunch({
+        connection,
+        compose,
+        budget,
+        priority: params.priority,
+        allowPriceOnly: false,
+    });
+    const { transaction, txBytes } = priced;
     // 5. Signers: exactly the wallet (fee payer, first) and the mint.
     const signers = checkSigners(transaction, [wallet, baseMint], wallet);
     if (!signers.ok) {
@@ -606,11 +778,12 @@ export async function buildUserCoinLaunchTx(params) {
         transaction,
         signatureCount: signers.actual.length,
         nonce: null,
-        budget,
+        budget: priced.feeBudget,
         quote,
         firstBuyLamports: params.firstBuyLamports,
         poolCreationFeeLamports,
         rentPayerIsOwner: true,
+        platformFeeLamports: platformFee,
     });
     return {
         transaction,
@@ -626,11 +799,15 @@ 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,
             computeUnitLimit,
-            computeUnitPriceMicroLamports,
+            computeUnitPriceMicroLamports: priced.priorityFee.microLamports,
+            priorityFee: priced.priorityFee,
+            priorityFeePlacement: priced.placement,
             signers: signers.actual,
             txBytes,
         },