@forgedevv/core 0.2.0 → 0.3.0

package/dist/reads.js

@@ -165,6 +165,19 @@ export async function readCoin(connection, pool, options = {}) {
  * @throws DbcReadError when the config does not exist.
  */
 export async function listCoinsOfConfig(connection, config, options = {}) {
+    return (await listPoolStatesOfConfig(connection, config, options)).map(summarizeCoin);
+}
+/**
+ * The decoded pools of a config with the config itself (what `listCoinsOfConfig` summarizes):
+ * one `getPoolsByConfig` scan (one `getProgramAccounts` per pool account variant, filtered on the
+ * config at offset 72) and one config read. A pool whose decoded `config` is not `config` is
+ * dropped (a wrong RPC answer is never shown). Sorted by pool address.
+ *
+ * The scan returns every pool of the config: callers should cache it (the FORGE RPC relay serves
+ * it to server-token callers only, with a response size cap).
+ * @throws DbcReadError when the config does not exist.
+ */
+export async function listPoolStatesOfConfig(connection, config, options = {}) {
     const state = stateService(connection, options.commitment ?? READ_COMMITMENT);
     const configState = await retryRpc(() => state.getPoolConfig(config), options.retry);
     if (!configState) {
@@ -173,8 +186,32 @@ export async function listCoinsOfConfig(connection, config, options = {}) {
     const pools = await retryRpc(() => state.getPoolsByConfig(config), options.retry);
     return pools
         .filter((p) => p.account.poolState.config.equals(config))
-        .map((p) => summarizeCoin({ address: p.publicKey, virtualPool: p.account, config: configState }))
-        .sort((a, b) => compareStrings(a.pool.toBase58(), b.pool.toBase58()));
+        .map((p) => ({ address: p.publicKey, virtualPool: p.account, config: configState }))
+        .sort((a, b) => compareStrings(a.address.toBase58(), b.address.toBase58()));
+}
+/** 2^128: a pool's `sqrtPrice` is a Q64.64 number, so its square is a Q128.128 price. */
+const Q128 = 1n << 128n;
+/** Fixed-point scale used to turn the bigint price into a float without losing small prices. */
+const SPOT_PRICE_SCALE = 10n ** 18n;
+/**
+ * Pure: spot price of one whole base token (the coin) in whole quote tokens (SOL for FORGE pools),
+ * from the pool's `sqrtPrice`: `sqrtPrice^2 / 2^128` quote units per base unit (the price the
+ * curve is at, before fees), times `10^(baseDecimals - quoteDecimals)`. A float, for display only:
+ * quotes and transactions use the exact bigint math of `quoteSwap`.
+ */
+export function poolSpotPrice(sqrtPrice, baseDecimals, quoteDecimals = 9) {
+    const sqrt = toBigint(sqrtPrice);
+    if (sqrt <= 0n)
+        return 0;
+    const shift = baseDecimals - quoteDecimals;
+    let numerator = sqrt * sqrt * SPOT_PRICE_SCALE;
+    let denominator = Q128;
+    if (shift >= 0)
+        numerator *= 10n ** BigInt(shift);
+    else
+        denominator *= 10n ** BigInt(-shift);
+    const scaled = numerator / denominator;
+    return Number(scaled) / Number(SPOT_PRICE_SCALE);
 }
 /**
  * Byte offset of `creator` in a DBC pool account (`VirtualPool` and `TransferHookPool`: 8-byte

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);
@@ -31,20 +32,22 @@
  *     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 platform fee wallet is not exactly `FORGE_PLATFORM_FEE_WALLET`, or not a system account
- *     (`PLATFORM_FEE_WALLET_MISMATCH`);
+ *   - 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_MULTISIG_VAULT` when the environment has it (`REFERRAL_ACCOUNT_INVALID`);
+ *     `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).
@@ -53,6 +56,7 @@ 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 (25%), whether given in bps or as a minimum. */
@@ -284,7 +288,7 @@ export interface SwapContext extends SwapPoolState {
 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_MULTISIG_VAULT, when the environment has it), the token account must
+ * 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;
@@ -292,7 +296,7 @@ export declare function assertReferralAccountReady(address: PublicKey, account:
 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_MULTISIG_VAULT). */
+    /** The Meteora referral token account must be held by this key (FORGE_REVENUE_WALLET). */
     referralOwner?: PublicKey | null;
 }
 /**
@@ -305,6 +309,13 @@ export interface SwapBuildOptions {
     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
@@ -324,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). */
@@ -376,13 +392,15 @@ export interface FetchSwapContextParams {
 export declare function fetchSwapContext(p: FetchSwapContextParams): Promise<SwapContext>;
 /**
  * FORGE fee accounts used by the swap, resolved through addresses.ts (never hard-coded), and the
- * multisig vault that must hold the referral account (`null` when the environment does not have
- * `FORGE_MULTISIG_VAULT`: the owner check is then skipped).
+ * 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;
-    multisigVault: PublicKey | null;
+    revenueWallet: PublicKey | null;
 };
 interface SwapCommonParams extends SwapBuildOptions {
     connection: Connection;
@@ -392,7 +410,8 @@ interface SwapCommonParams extends SwapBuildOptions {
     /**
      * Environment to read the FORGE addresses from (defaults to `process.env`):
      * `FORGE_PLATFORM_FEE_WALLET` and `FORGE_METEORA_REFERRAL_ACCOUNT` (required), and
-     * `FORGE_MULTISIG_VAULT` (optional: when set, the referral account must be held by it).
+     * `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;
@@ -436,7 +455,7 @@ export declare function quoteSwap(params: QuoteSwapParams): Promise<SwapQuote>;
 /**
  * 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_MULTISIG_VAULT` when the environment has it. Throws `SwapError`.
+ * `FORGE_REVENUE_WALLET` when the environment has it. Throws `SwapError`.
  */
 export declare function assertSwapFeeAccountsReady(params: {
     connection: Connection;

package/dist/swap.js

@@ -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);
@@ -31,20 +32,22 @@
  *     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 platform fee wallet is not exactly `FORGE_PLATFORM_FEE_WALLET`, or not a system account
- *     (`PLATFORM_FEE_WALLET_MISMATCH`);
+ *   - 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_MULTISIG_VAULT` when the environment has it (`REFERRAL_ACCOUNT_INVALID`);
+ *     `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).
@@ -55,6 +58,7 @@ import BN from 'bn.js';
 import { ActivationType, BaseFeeMode, DYNAMIC_BONDING_CURVE_PROGRAM_ID, DynamicBondingCurveIdl, TradeDirection, createDbcProgram, deriveDbcEventAuthority, deriveDbcPoolAuthority, getFeeMode, getTokenProgram, isRateLimiterApplied, swapQuote, } from '@meteora-ag/dynamic-bonding-curve-sdk';
 import { readOptionalAddress, requireAddresses } from './addresses.js';
 import { FEES } from './constants.js';
+import { estimatePriorityFee, fixedPriorityFee, resolvePriorityFeePolicy, } from './priority-fee.js';
 // ---------------------------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------------------------
@@ -454,7 +458,7 @@ export function assertPlatformFeeWalletReady(wallet, account, rentExemptMinimum,
 }
 /**
  * Throws unless the referral account is an initialized wrapped SOL token account (SPL Token).
- * With `expectedOwner` (FORGE_MULTISIG_VAULT, when the environment has it), the token account must
+ * 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 function assertReferralAccountReady(address, account, expectedOwner) {
@@ -478,7 +482,7 @@ export function assertReferralAccountReady(address, account, expectedOwner) {
     if (!token.isInitialized || token.isFrozen)
         throw fail('is not usable (uninitialized or frozen)');
     if (expectedOwner && !token.owner.equals(expectedOwner)) {
-        throw fail('is not held by FORGE_MULTISIG_VAULT');
+        throw fail('is not held by FORGE_REVENUE_WALLET');
     }
 }
 function toConfigKeys(allowedConfigs) {
@@ -529,6 +533,21 @@ function readBuildOptions(o) {
         throw invalid('addressLookupTables must be an array');
     return { computeUnitLimit, priorityFeeMicroLamports, addressLookupTables };
 }
+/** Checks a `priority` setting (INVALID_PARAMS), and that no fixed price is given with it. */
+function readPrioritySetting(o) {
+    if (o.priority === undefined)
+        return undefined;
+    if (o.priorityFeeMicroLamports !== undefined) {
+        throw invalid('Pass either priority or priorityFeeMicroLamports, not both');
+    }
+    try {
+        resolvePriorityFeePolicy(o.priority);
+    }
+    catch (error) {
+        throw invalid(`priority: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return o.priority;
+}
 /**
  * Compiles the instructions into an unsigned v0 transaction paid by `payer` and checks its
  * serialized size (signature placeholders included) against 1,232 bytes.
@@ -573,6 +592,10 @@ export function compileSwapTransaction(args) {
  * the top of this file.
  */
 export function buildSwapTransaction(ctx, request, expected = {}) {
+    if (request.priority !== undefined) {
+        // The price of a `priority` setting is read from the cluster: buildBuyTx / buildSellTx.
+        throw invalid('buildSwapTransaction takes a fixed priorityFeeMicroLamports, not priority');
+    }
     const options = readBuildOptions(request);
     assertPlatformFeeWalletReady(ctx.platformFeeWallet, ctx.platformFeeWalletAccount, ctx.platformFeeWalletRentExemptMinimum, expected.platformFeeWallet);
     assertReferralAccountReady(ctx.referralTokenAccount, ctx.referralTokenAccountInfo, expected.referralOwner);
@@ -669,6 +692,7 @@ export function buildSwapTransaction(ctx, request, expected = {}) {
         sizeBytes,
         computeUnitLimit: options.computeUnitLimit,
         priorityFeeMicroLamports: options.priorityFeeMicroLamports,
+        priorityFee: fixedPriorityFee(options.computeUnitLimit, options.priorityFeeMicroLamports),
         estimatedNetworkFeeLamports,
         newCoinAccountRentLamports,
         requiredLamports,
@@ -833,15 +857,21 @@ export async function fetchSwapContext(p) {
 }
 /**
  * FORGE fee accounts used by the swap, resolved through addresses.ts (never hard-coded), and the
- * multisig vault that must hold the referral account (`null` when the environment does not have
- * `FORGE_MULTISIG_VAULT`: the owner check is then skipped).
+ * 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 function swapFeeAddresses(env) {
     const a = requireAddresses(['FORGE_PLATFORM_FEE_WALLET', 'FORGE_METEORA_REFERRAL_ACCOUNT'], env);
+    const revenueWallet = readOptionalAddress('FORGE_REVENUE_WALLET', env);
+    if (revenueWallet && !a.FORGE_PLATFORM_FEE_WALLET.equals(revenueWallet)) {
+        throw new SwapError('PLATFORM_FEE_WALLET_MISMATCH', 'FORGE_PLATFORM_FEE_WALLET must be the revenue wallet (FORGE_REVENUE_WALLET)', { details: { platformFeeWallet: a.FORGE_PLATFORM_FEE_WALLET.toBase58() } });
+    }
     return {
         platformFeeWallet: a.FORGE_PLATFORM_FEE_WALLET,
         referralTokenAccount: a.FORGE_METEORA_REFERRAL_ACCOUNT,
-        multisigVault: readOptionalAddress('FORGE_MULTISIG_VAULT', env),
+        revenueWallet,
     };
 }
 function slippageOf(p) {
@@ -852,7 +882,8 @@ async function buildSide(side, amountIn, p) {
     assertU64(side === 'buy' ? 'amountInLamports' : 'amountInTokens', amountIn, 1n);
     const slippage = readSlippage(slippageOf(p));
     const options = readBuildOptions(p);
-    const { platformFeeWallet, referralTokenAccount, multisigVault } = swapFeeAddresses(p.env);
+    const priority = readPrioritySetting(p);
+    const { platformFeeWallet, referralTokenAccount, revenueWallet } = swapFeeAddresses(p.env);
     if (p.allowedConfigs !== undefined)
         toConfigKeys(p.allowedConfigs);
     const ctx = await fetchSwapContext({
@@ -864,7 +895,25 @@ async function buildSide(side, amountIn, p) {
         ...(p.commitment ? { commitment: p.commitment } : {}),
         ...(p.allowedConfigs !== undefined ? { allowedConfigs: p.allowedConfigs } : {}),
     });
-    return buildSwapTransaction(ctx, { side, amountIn, slippage, ...options }, { platformFeeWallet, referralOwner: multisigVault });
+    const expected = { platformFeeWallet, referralOwner: revenueWallet };
+    const built = buildSwapTransaction(ctx, { side, amountIn, slippage, ...options }, expected);
+    if (priority === undefined)
+        return built;
+    // Same swap with its price: read for the accounts it write-locks (the pool, its vaults and the
+    // FORGE fee accounts are shared by every trade), bounded by the setting.
+    const quote = await estimatePriorityFee({
+        connection: p.connection,
+        writableAccounts: writableStaticKeys(built.transaction),
+        computeUnitLimit: options.computeUnitLimit,
+        setting: priority,
+    });
+    const priced = buildSwapTransaction(ctx, { side, amountIn, slippage, ...options, priorityFeeMicroLamports: quote.microLamports }, expected);
+    return { ...priced, priorityFee: quote };
+}
+/** Writable static account keys of a compiled v0 transaction, in message order. */
+function writableStaticKeys(transaction) {
+    const message = transaction.message;
+    return message.staticAccountKeys.filter((_, index) => message.isAccountWritable(index));
 }
 /** Unsigned buy transaction (SOL -> coin) with the FORGE referral and the platform fee. */
 export async function buildBuyTx(params) {
@@ -889,13 +938,13 @@ export async function quoteSwap(params) {
 /**
  * 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_MULTISIG_VAULT` when the environment has it. Throws `SwapError`.
+ * `FORGE_REVENUE_WALLET` when the environment has it. Throws `SwapError`.
  */
 export async function assertSwapFeeAccountsReady(params) {
     const commitment = params.commitment ?? DEFAULT_COMMITMENT;
-    const { platformFeeWallet, referralTokenAccount, multisigVault } = swapFeeAddresses(params.env);
+    const { platformFeeWallet, referralTokenAccount, revenueWallet } = swapFeeAddresses(params.env);
     const [platformInfo, referralInfo] = (await rpc('getMultipleAccountsInfo', () => params.connection.getMultipleAccountsInfo([platformFeeWallet, referralTokenAccount], commitment))).map(snapshot);
     const rentMinimum = BigInt(await rpc('getMinimumBalanceForRentExemption', () => params.connection.getMinimumBalanceForRentExemption(platformInfo?.data.length ?? 0, commitment)));
     assertPlatformFeeWalletReady(platformFeeWallet, platformInfo ?? null, rentMinimum, platformFeeWallet);
-    assertReferralAccountReady(referralTokenAccount, referralInfo ?? null, multisigVault);
+    assertReferralAccountReady(referralTokenAccount, referralInfo ?? null, revenueWallet);
 }

package/dist/tx.d.ts

@@ -182,6 +182,8 @@ export declare function readNonce(connection: Pick<Connection, 'getAccountInfo'>
     expectedAuthority?: PublicKey;
     commitment?: Commitment;
 }): Promise<NonceInfo>;
+/** Compute unit limit of the nonce account creations when a priority fee is set. */
+export declare const CREATE_NONCE_ACCOUNT_COMPUTE_UNITS = 10000;
 export interface BuildCreateNonceAccountTxParams {
     connection: Pick<Connection, 'getMinimumBalanceForRentExemption' | 'getLatestBlockhash'>;
     /** Pays the rent and the fee; signs. */

package/dist/tx.js

@@ -390,6 +390,8 @@ export async function readNonce(connection, nonceAccount, options = {}) {
         lamportsPerSignature: BigInt(decoded.feeCalculator.lamportsPerSignature),
     };
 }
+/** Compute unit limit of the nonce account creations when a priority fee is set. */
+export const CREATE_NONCE_ACCOUNT_COMPUTE_UNITS = 10_000;
 /**
  * Unsigned transaction creating and initializing a durable nonce account
  * (`SystemProgram.createNonceAccount`). The rent is read from the cluster.
@@ -404,7 +406,7 @@ export async function buildCreateNonceAccountTx(params) {
     const transaction = new Transaction({ feePayer: params.payer, blockhash, lastValidBlockHeight });
     if (params.computeUnitPriceMicroLamports !== undefined) {
         transaction.add(...computeBudgetInstructions({
-            units: 10_000,
+            units: CREATE_NONCE_ACCOUNT_COMPUTE_UNITS,
             microLamports: params.computeUnitPriceMicroLamports,
         }));
     }
@@ -475,7 +477,7 @@ export async function buildCreateNonceAccountWithSeedTx(params) {
     const nonceAccount = await deriveSeededNonceAccount(base, seed);
     const budget = params.computeUnitPriceMicroLamports !== undefined
         ? computeBudgetInstructions({
-            units: 10_000,
+            units: CREATE_NONCE_ACCOUNT_COMPUTE_UNITS,
             microLamports: params.computeUnitPriceMicroLamports,
         })
         : [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgedevv/core",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "FORGE transaction core: Meteora Dynamic Bonding Curve configs, pools, swaps, claims and on-chain checks. Published on npm as @forgedevv/core.",
   "license": "UNLICENSED",
   "repository": {
@@ -47,7 +47,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@forge/shared": "npm:@forgedevv/shared@0.2.0",
+    "@forge/shared": "npm:@forgedevv/shared@0.3.0",
     "@meteora-ag/cp-amm-sdk": "1.5.1",
     "@meteora-ag/dynamic-bonding-curve-sdk": "1.5.13",
     "@solana/spl-token": "0.4.15",