@forgedevv/core 0.2.0 → 0.3.1

package/dist/meteora-referral.js

@@ -0,0 +1,184 @@
+/**
+ * Meteora referral account setup (docs/METEORA.md "The Meteora referral", docs/DECISIONS.md D34).
+ *
+ * The Meteora referral of every curve swap core builds is a wrapped-SOL token account held by
+ * the FORGE revenue wallet (`FORGE_METEORA_REFERRAL_ACCOUNT`). It must be a STANDALONE token
+ * account, never the wallet's associated token account: the Jupiter referral claims land in the
+ * associated account, and the revenue job books the two separately (`meteora_referral` /
+ * `jupiter_referral`).
+ *
+ * The account lives at an address derived from the fee payer and a fixed seed
+ * (`createAccountWithSeed`: no extra keypair to generate or keep, and the address can be
+ * re-derived at any time), 165 bytes owned by the SPL Token program, then `InitializeAccount3`
+ * sets its mint (wrapped SOL) and its owner (the revenue wallet) from the instruction data. The
+ * only signer is the payer: neither the owner nor the new account signs, so the revenue key never
+ * has to sign its own setup.
+ *
+ * Pure builders (byte-for-byte tested) and pure inspection of what the chain holds; the only
+ * network call is the optional `readMeteoraReferralAccount`. Any cluster: a WSOL token account
+ * exists on devnet too (the devnet proof of the revenue job uses one).
+ */
+import { sha256 } from '@noble/hashes/sha2';
+import { ACCOUNT_SIZE, NATIVE_MINT, TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync, unpackAccount, } from '@solana/spl-token';
+import { PublicKey, SystemProgram, Transaction, TransactionInstruction, } from '@solana/web3.js';
+import { priorityFeeInstructions } from './priority-fee.js';
+import { retryRpc } from './reads.js';
+// ---------------------------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------------------------
+/** Default seed of the referral account address (`createWithSeed(payer, seed, SPL Token)`). */
+export const METEORA_REFERRAL_ACCOUNT_SEED = 'forge-meteora-referral';
+/** Longest seed `createWithSeed` accepts, in bytes (System program limit). */
+export const MAX_METEORA_REFERRAL_SEED_BYTES = 32;
+/**
+ * Compute unit limit of the setup transaction with a priority fee: one `createAccountWithSeed`
+ * and one `InitializeAccount3` (a few thousand units each), with a wide margin.
+ */
+export const METEORA_REFERRAL_SETUP_COMPUTE_UNITS = 30_000;
+/** SPL Token `InitializeAccount3` instruction tag (u8), followed by the 32-byte owner. */
+export const TOKEN_INITIALIZE_ACCOUNT3_TAG = 18;
+export class MeteoraReferralError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = 'MeteoraReferralError';
+        this.code = code;
+    }
+}
+function invalid(message) {
+    throw new MeteoraReferralError('invalid_params', message);
+}
+// ---------------------------------------------------------------------------------------------
+// Address
+// ---------------------------------------------------------------------------------------------
+/** Checks a `createWithSeed` seed: 1 to 32 UTF-8 bytes, no control character. */
+export function assertMeteoraReferralSeed(seed) {
+    if (typeof seed !== 'string' || seed.length === 0)
+        invalid('the seed must be a non-empty string');
+    if (/\p{Cc}/u.test(seed))
+        invalid('the seed must not contain control characters');
+    const bytes = Buffer.byteLength(seed, 'utf8');
+    if (bytes > MAX_METEORA_REFERRAL_SEED_BYTES) {
+        invalid(`the seed is ${bytes} bytes, at most ${MAX_METEORA_REFERRAL_SEED_BYTES} are allowed`);
+    }
+}
+/**
+ * Address of the referral account created by `buildCreateMeteoraReferralAccountTx` for `payer`
+ * and `seed`: `createWithSeed(payer, seed, SPL Token program)`, i.e.
+ * `sha256(payer || seed || program)`, the same derivation as `PublicKey.createWithSeed`
+ * (synchronous here, so the builders stay pure).
+ */
+export function deriveMeteoraReferralAccount(payer, seed = METEORA_REFERRAL_ACCOUNT_SEED) {
+    assertMeteoraReferralSeed(seed);
+    const digest = sha256(Buffer.concat([payer.toBuffer(), Buffer.from(seed, 'utf8'), TOKEN_PROGRAM_ID.toBuffer()]));
+    return new PublicKey(digest);
+}
+/**
+ * The two instructions creating the standalone wrapped-SOL token account of `owner`:
+ * System `createAccountWithSeed` (from = base = payer; exactly the rent of 165 bytes; owner
+ * program = SPL Token) and SPL Token `InitializeAccount3` (account, wrapped SOL mint; owner in
+ * the data, no owner signature). Refuses an owner equal to the payer, a zero rent, and a seed
+ * whose address is the owner's associated wrapped-SOL account (impossible in practice: the
+ * associated account is a PDA, this address is a hash; checked all the same).
+ */
+export function buildCreateMeteoraReferralAccountIxs(p) {
+    const seed = p.seed ?? METEORA_REFERRAL_ACCOUNT_SEED;
+    if (p.payer.equals(p.owner))
+        invalid('the payer must not be the owner of the referral account');
+    if (p.owner.equals(PublicKey.default))
+        invalid('the owner must not be the default key');
+    if (typeof p.rentLamports !== 'bigint' || p.rentLamports <= 0n) {
+        invalid('rentLamports must be a positive bigint');
+    }
+    if (p.rentLamports > BigInt(Number.MAX_SAFE_INTEGER))
+        invalid('rentLamports is too large');
+    const account = deriveMeteoraReferralAccount(p.payer, seed);
+    if (account.equals(getAssociatedTokenAddressSync(NATIVE_MINT, p.owner, true))) {
+        invalid('the derived address is the associated wrapped-SOL account of the owner');
+    }
+    const create = SystemProgram.createAccountWithSeed({
+        fromPubkey: p.payer,
+        basePubkey: p.payer,
+        seed,
+        newAccountPubkey: account,
+        lamports: Number(p.rentLamports),
+        space: ACCOUNT_SIZE,
+        programId: TOKEN_PROGRAM_ID,
+    });
+    const initialize = new TransactionInstruction({
+        programId: TOKEN_PROGRAM_ID,
+        keys: [
+            { pubkey: account, isSigner: false, isWritable: true },
+            { pubkey: NATIVE_MINT, isSigner: false, isWritable: false },
+        ],
+        data: Buffer.concat([Buffer.from([TOKEN_INITIALIZE_ACCOUNT3_TAG]), p.owner.toBuffer()]),
+    });
+    return { account, seed, instructions: [create, initialize] };
+}
+/**
+ * Unsigned transaction creating the Meteora referral account (`buildCreateMeteoraReferralAccountIxs`
+ * after the optional compute budget). It does not check that the address is free: inspect it
+ * first (`readMeteoraReferralAccount`); creating it twice fails on-chain, nothing is lost but
+ * the fee.
+ */
+export function buildCreateMeteoraReferralAccountTx(p) {
+    if (typeof p.blockhash !== 'string' || p.blockhash.length === 0)
+        invalid('blockhash required');
+    if (!Number.isInteger(p.lastValidBlockHeight) || p.lastValidBlockHeight < 0) {
+        invalid('lastValidBlockHeight must be a non-negative integer');
+    }
+    const built = buildCreateMeteoraReferralAccountIxs(p);
+    const transaction = new Transaction({
+        feePayer: p.payer,
+        blockhash: p.blockhash,
+        lastValidBlockHeight: p.lastValidBlockHeight,
+    });
+    if (p.priorityFee && p.priorityFee.microLamports > 0) {
+        transaction.add(...priorityFeeInstructions(p.priorityFee));
+    }
+    transaction.add(...built.instructions);
+    return { ...built, transaction, lastValidBlockHeight: p.lastValidBlockHeight };
+}
+/**
+ * What `address` holds, against the expected shape of the Meteora referral account: absent,
+ * ready (a standalone wrapped-SOL token account of `owner`, neither frozen, delegated nor
+ * closable by someone else), or a mismatch with its reason.
+ */
+export function inspectMeteoraReferralAccount(address, info, expected) {
+    if (!info)
+        return { status: 'absent' };
+    const mismatch = (reason, detail) => ({ status: 'mismatch', reason, detail });
+    if (!info.owner.equals(TOKEN_PROGRAM_ID)) {
+        return mismatch('not_a_token_account', `the address is in use by an account owned by ${info.owner.toBase58()}`);
+    }
+    let account;
+    try {
+        account = unpackAccount(address, info, TOKEN_PROGRAM_ID);
+    }
+    catch {
+        return mismatch('not_a_token_account', 'the account data is not an SPL Token account');
+    }
+    if (!account.mint.equals(NATIVE_MINT)) {
+        return mismatch('wrong_mint', `the token account mint is ${account.mint.toBase58()}`);
+    }
+    if (!account.owner.equals(expected.owner)) {
+        return mismatch('wrong_owner', `the token account owner is ${account.owner.toBase58()}`);
+    }
+    if (address.equals(getAssociatedTokenAddressSync(NATIVE_MINT, expected.owner, true))) {
+        return mismatch('associated_account', 'the account is the associated wrapped-SOL account of the owner, not a standalone one');
+    }
+    if (account.isFrozen)
+        return mismatch('frozen', 'the token account is frozen');
+    if (account.delegate !== null) {
+        return mismatch('delegated', `the token account has a delegate ${account.delegate.toBase58()}`);
+    }
+    if (account.closeAuthority !== null && !account.closeAuthority.equals(expected.owner)) {
+        return mismatch('close_authority', `the token account can be closed by ${account.closeAuthority.toBase58()}`);
+    }
+    return { status: 'ready', lamports: BigInt(info.lamports), amount: account.amount };
+}
+/** Reads `address` and inspects it (`inspectMeteoraReferralAccount`). Any cluster. */
+export async function readMeteoraReferralAccount(p) {
+    const info = await retryRpc(() => p.connection.getAccountInfo(p.address, p.commitment ?? 'confirmed'), p.retry ?? {});
+    return inspectMeteoraReferralAccount(p.address, info, { owner: p.owner });
+}

package/dist/payments.d.ts

@@ -5,6 +5,9 @@
  *   1. a System Program transfer of `lamports` from the payer to `FORGE_CASHBOX_WALLET`;
  *   2. an SPL Memo (v2) instruction, signed by the payer, whose UTF-8 data is
  *      `forge:job:<jobId>` (`jobId` = the job UUID, lowercase). See `paymentMemo`.
+ * With a `priority` option, two compute budget instructions come first (`setComputeUnitLimit`
+ * of `PAYMENT_COMPUTE_UNITS`, then `setComputeUnitPrice`, priced from the recent fees of the
+ * payer and the cashbox and bounded: priority-fee.ts), so a payment still lands under congestion.
  *
  * `verifyPayment` checks a transaction on-chain and returns a typed result; it never throws on a
  * transaction that is "not there yet" (it returns `pending`). It throws only on configuration
@@ -18,6 +21,7 @@
  */
 import { PublicKey, Transaction, TransactionInstruction, type Commitment, type Connection, type Finality, type VersionedTransactionResponse } from '@solana/web3.js';
 import { type AddressEnv } from './addresses.js';
+import { type PriorityFeeQuote, type PriorityFeeSetting } from './priority-fee.js';
 import { type RetryOptions } from './reads.js';
 /** SPL Memo program v2 (the one wallets and explorers decode). */
 export declare const MEMO_PROGRAM_ID: PublicKey;
@@ -30,6 +34,11 @@ export declare const PAYMENT_MEMO_PREFIX = "forge:job:";
  * against a unit mistake upstream.
  */
 export declare const MAX_PAYMENT_LAMPORTS: bigint;
+/**
+ * Compute unit limit of a payment with a priority fee: a System transfer (150 CU) and a memo of
+ * about 46 bytes signed by the payer (a few thousand CU), with a wide margin.
+ */
+export declare const PAYMENT_COMPUTE_UNITS = 50000;
 /** Genesis hashes of the Solana clusters FORGE uses (public network constants). */
 export declare const CLUSTER_GENESIS_HASH: {
     readonly devnet: "EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG";
@@ -61,6 +70,12 @@ export interface PaymentTxOptions {
     env?: AddressEnv;
     commitment?: Commitment;
     retry?: RetryOptions;
+    /**
+     * Priority fee read from the cluster for the payer and the cashbox, bounded by this setting
+     * (`{}` = `DEFAULT_PRIORITY_FEE_POLICY`, at most 0.0005 SOL). Without it the transaction holds
+     * the transfer and the memo only.
+     */
+    priority?: PriorityFeeSetting;
 }
 export interface PaymentTxResult {
     /** Unsigned transaction: fee payer = payer, recent blockhash set. The payer signs it. */
@@ -69,6 +84,8 @@ export interface PaymentTxResult {
     recipient: PublicKey;
     lamports: bigint;
     memo: string;
+    /** The priority fee (price, fee, cap), or null without a `priority` option. */
+    priorityFee: PriorityFeeQuote | null;
 }
 /**
  * Builds the payment transaction of `jobId`. Checks that the cashbox will be rent-exempt after

package/dist/payments.js

@@ -5,6 +5,9 @@
  *   1. a System Program transfer of `lamports` from the payer to `FORGE_CASHBOX_WALLET`;
  *   2. an SPL Memo (v2) instruction, signed by the payer, whose UTF-8 data is
  *      `forge:job:<jobId>` (`jobId` = the job UUID, lowercase). See `paymentMemo`.
+ * With a `priority` option, two compute budget instructions come first (`setComputeUnitLimit`
+ * of `PAYMENT_COMPUTE_UNITS`, then `setComputeUnitPrice`, priced from the recent fees of the
+ * payer and the cashbox and bounded: priority-fee.ts), so a payment still lands under congestion.
  *
  * `verifyPayment` checks a transaction on-chain and returns a typed result; it never throws on a
  * transaction that is "not there yet" (it returns `pending`). It throws only on configuration
@@ -20,6 +23,7 @@ import { PublicKey, SystemProgram, Transaction, TransactionInstruction, } from '
 import { Base58Signature, Uuid } from '@forge/shared';
 import { requireAddresses } from './addresses.js';
 import { LAMPORTS_PER_SOL_BIGINT } from './constants.js';
+import { estimatePriorityFee, priorityFeeInstructions, } from './priority-fee.js';
 import { retryRpc } from './reads.js';
 import { encodeBase58 } from './tx.js';
 /** SPL Memo program v2 (the one wallets and explorers decode). */
@@ -33,6 +37,11 @@ export const PAYMENT_MEMO_PREFIX = 'forge:job:';
  * against a unit mistake upstream.
  */
 export const MAX_PAYMENT_LAMPORTS = 100n * LAMPORTS_PER_SOL_BIGINT;
+/**
+ * Compute unit limit of a payment with a priority fee: a System transfer (150 CU) and a memo of
+ * about 46 bytes signed by the payer (a few thousand CU), with a wide margin.
+ */
+export const PAYMENT_COMPUTE_UNITS = 50_000;
 /** Genesis hashes of the Solana clusters FORGE uses (public network constants). */
 export const CLUSTER_GENESIS_HASH = {
     devnet: 'EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG',
@@ -96,9 +105,17 @@ export async function buildPaymentTx(connection, params, options = {}) {
     const cashbox = resolveCashbox(options.env);
     const instructions = buildPaymentInstructions({ ...params, cashbox });
     const commitment = options.commitment ?? 'confirmed';
-    const [rentExempt, cashboxBalance] = await Promise.all([
+    const [rentExempt, cashboxBalance, priorityFee] = await Promise.all([
         retryRpc(() => connection.getMinimumBalanceForRentExemption(0, commitment), options.retry),
         retryRpc(() => connection.getBalance(cashbox, commitment), options.retry),
+        options.priority === undefined
+            ? Promise.resolve(null)
+            : estimatePriorityFee({
+                connection,
+                writableAccounts: [params.payer, cashbox],
+                computeUnitLimit: PAYMENT_COMPUTE_UNITS,
+                setting: options.priority,
+            }),
     ]);
     if (BigInt(cashboxBalance) + params.lamports < BigInt(rentExempt)) {
         throw new PaymentError('cashbox_not_rent_exempt', 'The cashbox would not be rent-exempt after this payment: fund it first');
@@ -108,13 +125,14 @@ export async function buildPaymentTx(connection, params, options = {}) {
         feePayer: params.payer,
         blockhash,
         lastValidBlockHeight,
-    }).add(...instructions);
+    }).add(...(priorityFee ? priorityFeeInstructions(priorityFee) : []), ...instructions);
     return {
         transaction,
         lastValidBlockHeight,
         recipient: cashbox,
         lamports: params.lamports,
         memo: paymentMemo(params.jobId),
+        priorityFee,
     };
 }
 const genesisCache = new WeakMap();

package/dist/pool.d.ts

@@ -38,12 +38,23 @@
  *
  * 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 { type PoolConfig, type SwapQuoteConfig } from '@meteora-ag/dynamic-bonding-curve-sdk';
 import { PublicKey, Transaction, type Connection } from '@solana/web3.js';
 import type { LaunchpadSpec, OwnerTransactionSummary } from '@forge/shared';
 import { type AddressEnv } from './addresses.js';
 import { type OnchainConfigExpectation } from './config.js';
+import { type PriorityFeeQuote, type PriorityFeeSetting } from './priority-fee.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
@@ -126,7 +137,19 @@ export interface BuildLaunchCoinTxParams {
     computeUnitLimit?: number;
     /** Priority fee, micro-lamports per compute unit (default 0). */
     computeUnitPriceMicroLamports?: number;
+    /**
+     * Priority fee read from the cluster and bounded by this setting (`{}` = the defaults, at most
+     * 0.0005 SOL), see the top of this file for its placement. Not with
+     * `computeUnitPriceMicroLamports`.
+     */
+    priority?: PriorityFeeSetting;
 }
+/**
+ * Where the priority fee went: with the unit limit (`limit_and_price`, also the shape without a
+ * priority fee), alone because both did not fit (`price_only`), or left out because even the
+ * price alone did not fit (`omitted_for_size`).
+ */
+export type PriorityFeePlacement = 'limit_and_price' | 'price_only' | 'omitted_for_size';
 /** Lamport amounts, as bigint. */
 export interface LaunchCoinCosts {
     /** SOL swapped into the pool by the first buy. */
@@ -195,8 +218,15 @@ export interface LaunchCoinSummary {
     recentBlockhash: string;
     /** Null with a durable nonce (it does not expire with block height). */
     lastValidBlockHeight: number | null;
+    /**
+     * Compute unit limit requested; the transaction sets it unless `priorityFeePlacement` is
+     * `price_only` (the runtime default then applies, bounded by `MAX_TRANSACTION_COMPUTE_UNITS`).
+     */
     computeUnitLimit: number;
     computeUnitPriceMicroLamports: number;
+    /** The priority fee (price, fee, cap; `fixed` without a `priority` setting). */
+    priorityFee: PriorityFeeQuote;
+    priorityFeePlacement: PriorityFeePlacement;
     /** Signers on the signer side (creator, mint, nonce authority if distinct), then the owner. */
     signerSideSigners: PublicKey[];
     ownerSigner: PublicKey;
@@ -275,6 +305,12 @@ export interface BuildUserCoinLaunchTxParams {
     computeUnitLimit?: number;
     /** Priority fee, micro-lamports per compute unit (default 0). */
     computeUnitPriceMicroLamports?: number;
+    /**
+     * Priority fee read from the cluster and bounded by this setting (`{}` = the defaults, at most
+     * 0.0005 SOL): `setComputeUnitLimit` then `setComputeUnitPrice`, first. Not with
+     * `computeUnitPriceMicroLamports`.
+     */
+    priority?: PriorityFeeSetting;
 }
 export interface UserCoinLaunchSummary {
     config: PublicKey;
@@ -305,6 +341,10 @@ export interface UserCoinLaunchSummary {
     lastValidBlockHeight: number;
     computeUnitLimit: number;
     computeUnitPriceMicroLamports: number;
+    /** The priority fee (price, fee, cap; `fixed` without a `priority` setting). */
+    priorityFee: PriorityFeeQuote;
+    /** `limit_and_price`, or `omitted_for_size` if a priced launch would not fit (it always does). */
+    priorityFeePlacement: PriorityFeePlacement;
     /** Required signers in message order: the wallet (fee payer) then the mint. */
     signers: PublicKey[];
     txBytes: number;

package/dist/pool.js

@@ -38,6 +38,16 @@
  *
  * 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';
@@ -48,6 +58,7 @@ 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.
@@ -257,10 +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, then the
- * trailing instructions.
+ * 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;
@@ -289,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 },
+            };
+        }
     }
-    instructions.push(...sdkTx.instructions, ...(input.trailingInstructions ?? []));
-    const transaction = new Transaction({ feePayer: buyer, recentBlockhash: input.recentBlockhash });
-    if (input.lastValidBlockHeight !== null) {
-        transaction.lastValidBlockHeight = input.lastValidBlockHeight;
+    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);
+    }
+    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) {
@@ -420,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],
@@ -458,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,
@@ -472,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];
@@ -498,7 +589,7 @@ export async function buildLaunchCoinTx(params) {
         transaction,
         signatureCount: signers.actual.length,
         nonce,
-        budget,
+        budget: priced.feeBudget,
         quote,
         firstBuyLamports: params.firstBuyLamports,
         poolCreationFeeLamports,
@@ -535,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,
@@ -613,6 +706,7 @@ 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.
@@ -633,8 +727,8 @@ export async function buildUserCoinLaunchTx(params) {
         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,
@@ -647,7 +741,6 @@ export async function buildUserCoinLaunchTx(params) {
         metadataUri: params.metadataUri,
         firstBuyLamports: params.firstBuyLamports,
         slippageBps,
-        budget,
         nonce: null,
         recentBlockhash: latest.blockhash,
         lastValidBlockHeight: latest.lastValidBlockHeight,
@@ -662,6 +755,15 @@ export async function buildUserCoinLaunchTx(params) {
             ]
             : [],
     });
+    // 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) {
@@ -676,7 +778,7 @@ export async function buildUserCoinLaunchTx(params) {
         transaction,
         signatureCount: signers.actual.length,
         nonce: null,
-        budget,
+        budget: priced.feeBudget,
         quote,
         firstBuyLamports: params.firstBuyLamports,
         poolCreationFeeLamports,
@@ -703,7 +805,9 @@ export async function buildUserCoinLaunchTx(params) {
             recentBlockhash: latest.blockhash,
             lastValidBlockHeight: latest.lastValidBlockHeight,
             computeUnitLimit,
-            computeUnitPriceMicroLamports,
+            computeUnitPriceMicroLamports: priced.priorityFee.microLamports,
+            priorityFee: priced.priorityFee,
+            priorityFeePlacement: priced.placement,
             signers: signers.actual,
             txBytes,
         },