@forgedevv/core 0.1.0 → 0.3.0

package/dist/config.js

@@ -25,46 +25,20 @@
  * `buildLaunchpadConfig` / `buildLaunchpadCoinConfig` are pure and deterministic. Every result
  * passes `validate.ts` before it is returned; otherwise a `ValidationError` is thrown.
  */
-import { ActivationType, BaseFeeMode, CollectFeeMode, DynamicBondingCurveClient, MigrationFeeOption, MigrationOption, TokenAuthorityOption, TokenDecimal, TokenType, buildCurve, getMigrationThresholdPrice, swapQuoteExactIn, } from '@meteora-ag/dynamic-bonding-curve-sdk';
+import { CollectFeeMode, DynamicBondingCurveClient, FEE_DENOMINATOR, MAX_BASIS_POINT, MAX_CURVE_POINT, buildCurve, getMigrationThresholdPrice, swapQuoteExactIn, } from '@meteora-ag/dynamic-bonding-curve-sdk';
 import { PublicKey, Transaction } from '@solana/web3.js';
 import BN from 'bn.js';
 import { LaunchpadSpec } from '@forge/shared';
-import { CLIENT_BOUNDS, FEES, MAX_ANTI_SNIPER_STARTING_FEE_BPS, SOL_DECIMALS, SOL_QUOTE_MINT, solToLamports, } from './constants.js';
+import { CLIENT_BOUNDS, CLIENT_POOL_CREATION_FEE_LAMPORTS, FEES, LAMPORTS_PER_SOL_BIGINT, SOL_QUOTE_MINT, solToLamports, } from './constants.js';
 import { LaunchCoinError, assertSpecLaunchable } from './launch-metadata.js';
-import { computeBudgetInstructions } from './tx.js';
+import { ANTI_SNIPER_FEE_SCHEDULE, FORGE_ACTIVATION_TYPE, FORGE_MIGRATION_SETTINGS, FORGE_TOKEN_SETTINGS, forgeFeeSchedulerParam, } from './settings.js';
+import { estimatePriorityFee, fixedPriorityFee, priorityFeeInstructions, resolvePriorityFeePolicy, } from './priority-fee.js';
 import { ValidationError, assertValid, validateLaunchpadCoinConfigParams, validateLaunchpadConfigParams, } from './validate.js';
 // ---------------------------------------------------------------------------------------------
 // Settings
 // ---------------------------------------------------------------------------------------------
-/** Token of every coin: SPL token, 1,000,000,000 tokens with 6 decimals, immutable metadata. */
-export const FORGE_TOKEN_SETTINGS = {
-    tokenType: TokenType.SPLToken,
-    tokenBaseDecimal: TokenDecimal.SIX,
-    tokenQuoteDecimal: SOL_DECIMALS,
-    tokenAuthorityOption: TokenAuthorityOption.Immutable,
-    totalTokenSupply: 1_000_000_000,
-    leftover: 0,
-};
-/**
- * Anti-sniper fee schedule (`spec.antiSniper`): the fee starts at `startingFeeBps` and decreases
- * linearly, in `numberOfPeriod` equal steps over `totalDurationSeconds`, to `spec.tradingFeeBps`.
- * Within the validate.ts bounds (starting fee <= 9900 bps, duration <= 300 s).
- */
-export const ANTI_SNIPER_FEE_SCHEDULE = {
-    baseFeeMode: BaseFeeMode.FeeSchedulerLinear,
-    startingFeeBps: MAX_ANTI_SNIPER_STARTING_FEE_BPS,
-    numberOfPeriod: 10,
-    totalDurationSeconds: 60,
-};
-/** Migration: DAMM v2, migrated pool fee 0.25%, no migration fee, 20% of the supply migrated. */
-export const FORGE_MIGRATION_SETTINGS = {
-    migrationOption: MigrationOption.MET_DAMM_V2,
-    migrationFeeOption: MigrationFeeOption.FixedBps25,
-    migrationFee: { feePercentage: 0, creatorFeePercentage: 0 },
-    percentageSupplyOnMigration: 20,
-};
-/** Fee scheduler periods are counted in seconds. */
-export const FORGE_ACTIVATION_TYPE = ActivationType.Timestamp;
+// The fixed settings live in settings.ts (shared with validate.ts) and stay exported from here.
+export { ANTI_SNIPER_FEE_SCHEDULE, FORGE_ACTIVATION_TYPE, FORGE_MIGRATION_SETTINGS, FORGE_TOKEN_SETTINGS, FORGE_TOKEN_SUPPLY_RAW, forgeBaseFee, forgeFeeSchedulerParam, forgeReferenceCurve, } from './settings.js';
 /**
  * Pool creation fee of the launchpad coin config: none. The only pool ever created on it is the
  * client's own coin, paid by the client: a fee would only move the client's SOL to its own fee
@@ -129,28 +103,15 @@ function ownerKeyOf(spec) {
 export function creatorTradingFeePercentageFor(spec, kind) {
     return kind === 'launchpadCoin' ? FEES.forgeCreatorSharePct : spec.coinCreatorSharePct;
 }
-/** The `buildCurve` input for a spec and a config kind (pure). */
+/** The `buildCurve` input for a spec (or just its config fields) and a config kind (pure). */
 export function curveParamsFor(spec, kind) {
     const creatorShare = creatorTradingFeePercentageFor(spec, kind);
-    const schedule = ANTI_SNIPER_FEE_SCHEDULE;
     return {
         token: { ...FORGE_TOKEN_SETTINGS },
         fee: {
             baseFeeParams: {
-                baseFeeMode: schedule.baseFeeMode,
-                feeSchedulerParam: spec.antiSniper
-                    ? {
-                        startingFeeBps: schedule.startingFeeBps,
-                        endingFeeBps: spec.tradingFeeBps,
-                        numberOfPeriod: schedule.numberOfPeriod,
-                        totalDuration: schedule.totalDurationSeconds,
-                    }
-                    : {
-                        startingFeeBps: spec.tradingFeeBps,
-                        endingFeeBps: spec.tradingFeeBps,
-                        numberOfPeriod: 0,
-                        totalDuration: 0,
-                    },
+                baseFeeMode: ANTI_SNIPER_FEE_SCHEDULE.baseFeeMode,
+                feeSchedulerParam: forgeFeeSchedulerParam(spec.tradingFeeBps, spec.antiSniper),
             },
             dynamicFeeEnabled: false,
             collectFeeMode: CollectFeeMode.QuoteToken,
@@ -260,6 +221,263 @@ export function buildLaunchpadConfig(spec) {
 export function buildLaunchpadCoinConfig(spec) {
     return buildConfigParams(spec, 'launchpadCoin');
 }
+const FEE_NUMERATOR_PER_BPS = BigInt(FEE_DENOMINATOR / MAX_BASIS_POINT);
+/** An integer field (BN, number, bigint or boolean) as a bigint, or null. */
+function integerOf(value) {
+    if (typeof value === 'bigint')
+        return value;
+    if (typeof value === 'boolean')
+        return value ? 1n : 0n;
+    if (typeof value === 'number')
+        return Number.isSafeInteger(value) ? BigInt(value) : null;
+    if (BN.isBN(value))
+        return BigInt(value.toString());
+    return null;
+}
+/**
+ * The spec fields of a config read from the chain, when no spec is given. They must be values a
+ * FORGE spec can hold: a linear fee schedule ending on a whole client fee (50..200 bps), a creator
+ * share within the client bounds and a client pool creation fee. Problems are pushed to
+ * `problems`; a placeholder is returned for an impossible field so that every other field is still
+ * compared.
+ */
+function inferSpecFields(config, kind, expectedFeeLamports, problems) {
+    const { tradingFeeBps: feeBounds, coinCreatorSharePct: shareBounds } = CLIENT_BOUNDS;
+    const baseFee = config.poolFees?.baseFee;
+    const cliff = integerOf(baseFee?.cliffFeeNumerator);
+    const periods = integerOf(baseFee?.firstFactor);
+    const reduction = integerOf(baseFee?.thirdFactor);
+    let tradingFeeBps = feeBounds.min;
+    let antiSniper = false;
+    if (baseFee?.baseFeeMode !== ANTI_SNIPER_FEE_SCHEDULE.baseFeeMode ||
+        cliff === null ||
+        periods === null ||
+        reduction === null) {
+        problems.push('base fee is not a linear fee scheduler');
+    }
+    else {
+        antiSniper = periods > 0n;
+        const ending = cliff - periods * reduction;
+        const bps = ending / FEE_NUMERATOR_PER_BPS;
+        if (ending % FEE_NUMERATOR_PER_BPS !== 0n ||
+            bps < BigInt(feeBounds.min) ||
+            bps > BigInt(feeBounds.max)) {
+            problems.push(`trading fee (fee numerator ${ending}) is not a whole fee between ${feeBounds.min} and ${feeBounds.max} bps`);
+        }
+        else {
+            tradingFeeBps = Number(bps);
+        }
+    }
+    let coinCreatorSharePct = shareBounds.default;
+    if (kind === 'launchpad') {
+        const share = config.creatorTradingFeePercentage;
+        if (Number.isInteger(share) && share >= shareBounds.min && share <= shareBounds.max) {
+            coinCreatorSharePct = share;
+        }
+        else {
+            problems.push(`creator trading fee ${share}% is not between ${shareBounds.min}% and ${shareBounds.max}%`);
+        }
+    }
+    let poolCreationFeeLamports = 0n;
+    if (kind === 'launchpad') {
+        const onchain = integerOf(config.poolCreationFee);
+        const { min, max, allowZero } = CLIENT_POOL_CREATION_FEE_LAMPORTS;
+        if (expectedFeeLamports !== undefined) {
+            poolCreationFeeLamports = expectedFeeLamports;
+        }
+        else if (onchain !== null &&
+            ((onchain === 0n && allowZero) || (onchain >= min && onchain <= max))) {
+            poolCreationFeeLamports = onchain;
+        }
+        else {
+            problems.push(`pool creation fee ${String(onchain)} lamports is outside the client bounds`);
+        }
+    }
+    return {
+        fields: {
+            tradingFeeBps,
+            antiSniper,
+            coinCreatorSharePct,
+            poolCreationFeeSol: Number(poolCreationFeeLamports) / Number(LAMPORTS_PER_SOL_BIGINT),
+        },
+        poolCreationFeeLamports,
+    };
+}
+/** Every field of `onchain` that differs from what core sends for `params` (`createConfig`). */
+function compareWithParams(onchain, params) {
+    const problems = [];
+    const same = (field, actual, expected) => {
+        const a = integerOf(actual);
+        const e = integerOf(expected);
+        if (a === null || e === null || a !== e) {
+            problems.push(`${field} is ${String(a ?? actual)}, expected ${String(e ?? expected)}`);
+        }
+    };
+    const sameKey = (field, actual, expected) => {
+        if (!actual.equals(expected))
+            problems.push(`${field} is ${actual.toBase58()}, expected ${expected.toBase58()}`);
+    };
+    // Accounts and token.
+    sameKey('quoteMint', onchain.quoteMint, params.quoteMint);
+    same('quoteTokenFlag', onchain.quoteTokenFlag, 0);
+    sameKey('feeClaimer', onchain.feeClaimer, params.feeClaimer);
+    sameKey('leftoverReceiver', onchain.leftoverReceiver, params.leftoverReceiver);
+    same('tokenType', onchain.tokenType, params.tokenType);
+    same('tokenDecimal', onchain.tokenDecimal, params.tokenDecimal);
+    same('tokenUpdateAuthority', onchain.tokenUpdateAuthority, params.tokenUpdateAuthority);
+    // Fees.
+    const base = onchain.poolFees.baseFee;
+    const expectedBase = params.poolFees.baseFee;
+    same('baseFee.baseFeeMode', base.baseFeeMode, expectedBase.baseFeeMode);
+    same('baseFee.cliffFeeNumerator', base.cliffFeeNumerator, expectedBase.cliffFeeNumerator);
+    same('baseFee.numberOfPeriod', base.firstFactor, expectedBase.firstFactor);
+    same('baseFee.periodFrequency', base.secondFactor, expectedBase.secondFactor);
+    same('baseFee.reductionFactor', base.thirdFactor, expectedBase.thirdFactor);
+    // FORGE never enables the dynamic fee (validate.ts refuses it).
+    same('dynamicFee.initialized', onchain.poolFees.dynamicFee.initialized, 0);
+    same('collectFeeMode', onchain.collectFeeMode, params.collectFeeMode);
+    same('creatorTradingFeePercentage', onchain.creatorTradingFeePercentage, params.creatorTradingFeePercentage);
+    same('poolCreationFee', onchain.poolCreationFee, params.poolCreationFee);
+    same('enableFirstSwapWithMinFee', onchain.enableFirstSwapWithMinFee, params.enableFirstSwapWithMinFee);
+    same('activationType', onchain.activationType, params.activationType);
+    // Liquidity after migration.
+    same('partnerLiquidityPercentage', onchain.partnerLiquidityPercentage, params.partnerLiquidityPercentage);
+    same('partnerPermanentLockedLiquidityPercentage', onchain.partnerPermanentLockedLiquidityPercentage, params.partnerPermanentLockedLiquidityPercentage);
+    same('creatorLiquidityPercentage', onchain.creatorLiquidityPercentage, params.creatorLiquidityPercentage);
+    same('creatorPermanentLockedLiquidityPercentage', onchain.creatorPermanentLockedLiquidityPercentage, params.creatorPermanentLockedLiquidityPercentage);
+    for (const name of ['partnerLiquidityVestingInfo', 'creatorLiquidityVestingInfo']) {
+        const actual = onchain[name];
+        const expected = params[name];
+        const fields = [
+            'vestingPercentage',
+            'bpsPerPeriod',
+            'numberOfPeriods',
+            'frequency',
+            'cliffDurationFromMigrationTime',
+        ];
+        const empty = !expected || fields.every((f) => integerOf(expected[f]) === 0n);
+        same(`${name}.isInitialized`, actual.isInitialized, empty ? 0 : 1);
+        for (const f of fields)
+            same(`${name}.${f}`, actual[f], expected ? expected[f] : 0);
+    }
+    // Migration.
+    same('migrationOption', onchain.migrationOption, params.migrationOption);
+    same('migrationFeeOption', onchain.migrationFeeOption, params.migrationFeeOption);
+    same('migrationQuoteThreshold', onchain.migrationQuoteThreshold, params.migrationQuoteThreshold);
+    same('migrationFeePercentage', onchain.migrationFeePercentage, params.migrationFee.feePercentage);
+    same('creatorMigrationFeePercentage', onchain.creatorMigrationFeePercentage, params.migrationFee.creatorFeePercentage);
+    const migrated = params.migratedPoolFee;
+    same('migratedCollectFeeMode', onchain.migratedCollectFeeMode, migrated?.collectFeeMode ?? 0);
+    same('migratedDynamicFee', onchain.migratedDynamicFee, migrated?.dynamicFee ?? 0);
+    same('migratedPoolFeeBps', onchain.migratedPoolFeeBps, migrated?.poolFeeBps ?? 0);
+    same('migratedPoolBaseFeeMode', onchain.migratedPoolBaseFeeMode, params.migratedPoolBaseFeeMode ?? 0);
+    same('migratedCompoundingFeeBps', onchain.migratedCompoundingFeeBps, params.compoundingFeeBps ?? 0);
+    const marketCap = params.migratedPoolMarketCapFeeSchedulerParams;
+    const marketCapOff = !marketCap ||
+        [
+            marketCap.numberOfPeriod,
+            marketCap.sqrtPriceStepBps,
+            marketCap.schedulerExpirationDuration,
+            marketCap.reductionFactor,
+        ].every((v) => integerOf(v) === 0n);
+    if (!marketCapOff) {
+        problems.push('the expected config has a migrated pool market cap fee scheduler (not supported)');
+    }
+    else if (!onchain.migratedPoolBaseFeeBytes.every((byte) => byte === 0)) {
+        problems.push('migratedPoolBaseFeeBytes is set, expected none (no market cap fee scheduler)');
+    }
+    // Supply: locked vesting, fixed supply, curve.
+    const vesting = onchain.lockedVestingConfig;
+    const expectedVesting = params.lockedVesting;
+    same('lockedVesting.amountPerPeriod', vesting.amountPerPeriod, expectedVesting.amountPerPeriod);
+    same('lockedVesting.cliffDurationFromMigrationTime', vesting.cliffDurationFromMigrationTime, expectedVesting.cliffDurationFromMigrationTime);
+    same('lockedVesting.frequency', vesting.frequency, expectedVesting.frequency);
+    same('lockedVesting.numberOfPeriod', vesting.numberOfPeriod, expectedVesting.numberOfPeriod);
+    same('lockedVesting.cliffUnlockAmount', vesting.cliffUnlockAmount, expectedVesting.cliffUnlockAmount);
+    const supply = params.tokenSupply;
+    same('fixedTokenSupplyFlag', onchain.fixedTokenSupplyFlag, supply ? 1 : 0);
+    same('preMigrationTokenSupply', onchain.preMigrationTokenSupply, supply?.preMigrationTokenSupply ?? 0);
+    same('postMigrationTokenSupply', onchain.postMigrationTokenSupply, supply?.postMigrationTokenSupply ?? 0);
+    same('sqrtStartPrice', onchain.sqrtStartPrice, params.sqrtStartPrice);
+    // The account stores a fixed-size curve (unused points are zero); the params hold at most
+    // MAX_CURVE_POINT points.
+    const curve = onchain.curve;
+    if (curve.length < params.curve.length || params.curve.length > MAX_CURVE_POINT) {
+        problems.push(`curve has ${curve.length} points, expected ${params.curve.length} and zeros`);
+    }
+    else {
+        curve.forEach((point, i) => {
+            const expected = params.curve[i];
+            same(`curve[${i}].sqrtPrice`, point.sqrtPrice, expected ? expected.sqrtPrice : 0);
+            same(`curve[${i}].liquidity`, point.liquidity, expected ? expected.liquidity : 0);
+        });
+    }
+    return problems;
+}
+/**
+ * Compares a config read from the chain with the parameters core builds for it, field by field:
+ * accounts, token, base fee (cliff, periods, period, reduction, mode), dynamic fee, creator share,
+ * pool creation fee, first swap at the minimum fee, activation, liquidity split and vesting,
+ * migration (option, fee option, threshold, migration fee percentages, migrated pool fee), locked
+ * vesting, token supply, start price and curve. The values the program derives from these
+ * (`swapBaseAmount`, `migrationBaseThreshold`, `migrationSqrtPrice`) are not compared.
+ *
+ * With `expected.spec`, the reference is `buildConfigParams(spec, kind)`. Without it, the spec
+ * fields are read from the config itself (`inferSpecFields`: they must be values a FORGE spec can
+ * hold) and every other field must be FORGE's fixed setting; the fee claimer and leftover receiver
+ * must be `expected.owner` (or, without it, the same key).
+ *
+ * @returns every mismatch, as readable messages (on-chain values are public); empty when the config
+ *   is exactly a FORGE config of this kind.
+ */
+export function onchainConfigMismatches(config, kind, expected = {}) {
+    if (kind !== 'launchpad' && kind !== 'launchpadCoin') {
+        throw new TypeError(`unknown config kind: ${String(kind)}`);
+    }
+    const problems = [];
+    let params;
+    if (expected.spec !== undefined) {
+        try {
+            params = buildConfigParams(expected.spec, kind);
+        }
+        catch (error) {
+            return [
+                `the spec does not build a valid ${kind} config: ${error instanceof Error ? error.message : String(error)}`,
+            ];
+        }
+        if (expected.owner && !expected.owner.equals(params.feeClaimer)) {
+            problems.push('the expected owner is not spec.ownerWallet');
+        }
+        if (expected.poolCreationFeeLamports !== undefined &&
+            expected.poolCreationFeeLamports !== integerOf(params.poolCreationFee)) {
+            problems.push('the expected pool creation fee is not the one the spec builds');
+        }
+    }
+    else {
+        const owner = expected.owner ?? config.feeClaimer;
+        const inferred = inferSpecFields(config, kind, expected.poolCreationFeeLamports, problems);
+        let curve;
+        try {
+            curve = buildCurve(curveParamsFor(inferred.fields, kind));
+        }
+        catch (error) {
+            return [
+                ...problems,
+                `SDK buildCurve: ${error instanceof Error ? error.message : String(error)}`,
+            ];
+        }
+        params = {
+            ...curve,
+            // Exact lamports: the SOL figure above only feeds buildCurve.
+            poolCreationFee: new BN(inferred.poolCreationFeeLamports.toString()),
+            feeClaimer: owner,
+            leftoverReceiver: owner,
+            quoteMint: SOL_QUOTE_MINT,
+        };
+    }
+    problems.push(...compareWithParams(config, params));
+    return problems;
+}
 /**
  * Quote of the first buy of a pool that does not exist yet, at the minimum (ending) fee
  * (`enableFirstSwapWithMinFee`), on a config given either as built here (`ConfigParameters`) or
@@ -352,6 +570,12 @@ export class CreateConfigError extends Error {
  */
 export async function buildCreateConfigTx(params) {
     const configAddress = params.config instanceof PublicKey ? params.config : params.config.publicKey;
+    if (params.priority !== undefined) {
+        if (params.computeUnitPriceMicroLamports !== undefined) {
+            throw new RangeError('pass either priority or computeUnitPriceMicroLamports, not both');
+        }
+        resolvePriorityFeePolicy(params.priority);
+    }
     const configParams = buildConfigParams(params.spec, params.kind, params.metadataUri !== undefined ? { metadataUri: params.metadataUri } : {});
     if (configAddress.equals(params.payer) ||
         configAddress.equals(configParams.feeClaimer) ||
@@ -370,11 +594,16 @@ export async function buildCreateConfigTx(params) {
     });
     const rentLamports = BigInt(await connection.getMinimumBalanceForRentExemption(client.partner.getProgram().account.poolConfig.size));
     const { blockhash, lastValidBlockHeight } = params.recentBlockhash ?? (await connection.getLatestBlockhash('confirmed'));
+    const priorityFee = params.priority === undefined
+        ? fixedPriorityFee(CREATE_CONFIG_COMPUTE_UNITS, params.computeUnitPriceMicroLamports ?? 0)
+        : await estimatePriorityFee({
+            connection,
+            writableAccounts: [params.payer, configAddress],
+            computeUnitLimit: CREATE_CONFIG_COMPUTE_UNITS,
+            setting: params.priority,
+        });
     const transaction = new Transaction({ feePayer: params.payer, blockhash, lastValidBlockHeight });
-    transaction.add(...computeBudgetInstructions({
-        units: CREATE_CONFIG_COMPUTE_UNITS,
-        microLamports: params.computeUnitPriceMicroLamports ?? 0,
-    }), ...sdkTx.instructions);
+    transaction.add(...priorityFeeInstructions(priorityFee), ...sdkTx.instructions);
     return {
         transaction,
         configAddress,
@@ -382,5 +611,6 @@ export async function buildCreateConfigTx(params) {
         rentLamports,
         lastValidBlockHeight,
         signers: [params.payer, configAddress],
+        priorityFee,
     };
 }

package/dist/constants.d.ts

@@ -45,3 +45,19 @@ export declare const CLIENT_POOL_CREATION_FEE_LAMPORTS: {
     readonly max: bigint;
     readonly allowZero: true;
 };
+/**
+ * Referral fee range of Jupiter Ultra, in bps. The Jupiter Plugin passes `referralFee` as is to
+ * Ultra `/order`, which refuses any value outside 50..255 ("must be between 50 and 255
+ * (inclusive)", checked on 2026-10-17); Jupiter keeps 20% of the fee.
+ * @see https://developers.jup.ag/docs/swap/fees
+ */
+export declare const JUPITER_REFERRAL_FEE_BPS_RANGE: {
+    readonly min: 50;
+    readonly max: 255;
+};
+/**
+ * Returns `bps` when Jupiter Ultra accepts it as a referral fee: a whole number of bps within
+ * `JUPITER_REFERRAL_FEE_BPS_RANGE`. Throws a `RangeError` otherwise: with such a fee Jupiter
+ * refuses every swap, so it must never reach the plugin.
+ */
+export declare function assertJupiterReferralFeeBps(bps: number): number;

package/dist/constants.js

@@ -68,3 +68,23 @@ export const CLIENT_POOL_CREATION_FEE_LAMPORTS = {
     max: solToLamports(CLIENT_BOUNDS.poolCreationFeeSol.max),
     allowZero: CLIENT_BOUNDS.poolCreationFeeSol.allowZero,
 };
+/**
+ * Referral fee range of Jupiter Ultra, in bps. The Jupiter Plugin passes `referralFee` as is to
+ * Ultra `/order`, which refuses any value outside 50..255 ("must be between 50 and 255
+ * (inclusive)", checked on 2026-10-17); Jupiter keeps 20% of the fee.
+ * @see https://developers.jup.ag/docs/swap/fees
+ */
+export const JUPITER_REFERRAL_FEE_BPS_RANGE = { min: 50, max: 255 };
+/**
+ * Returns `bps` when Jupiter Ultra accepts it as a referral fee: a whole number of bps within
+ * `JUPITER_REFERRAL_FEE_BPS_RANGE`. Throws a `RangeError` otherwise: with such a fee Jupiter
+ * refuses every swap, so it must never reach the plugin.
+ */
+export function assertJupiterReferralFeeBps(bps) {
+    const { min, max } = JUPITER_REFERRAL_FEE_BPS_RANGE;
+    if (!Number.isInteger(bps) || bps < min || bps > max) {
+        throw new RangeError(`Jupiter referral fee must be a whole number of bps between ${min} and ${max} ` +
+            `(Jupiter Ultra refuses any other value), got ${String(bps)}`);
+    }
+    return bps;
+}

package/dist/index.d.ts

@@ -4,10 +4,14 @@ export * from './validate.js';
 export * from './config.js';
 export * from './pool.js';
 export * from './tx.js';
+export * from './priority-fee.js';
 export * from './launch-check.js';
-export { DEFAULT_SWAP_COMPUTE_UNIT_LIMIT, MAX_SWAP_COMPUTE_UNIT_LIMIT, MAX_SWAP_PRIORITY_FEE_MICRO_LAMPORTS, MAX_SWAP_SLIPPAGE_BPS, PLATFORM_FEE_BPS, SWAP_BASE_FEE_LAMPORTS_PER_SIGNATURE, SWAP_ERROR_CODES, SWAP_MAX_TRANSACTION_BYTES, SwapError, assertPlatformFeeWalletReady, assertPoolTradable, assertReferralAccountReady, assertSwapFeeAccountsReady, buildBuyTx, buildDbcSwapInstruction, buildSellTx, buildSwapTransaction, coinTokenProgram, compileSwapTransaction, computeSwapQuote, estimateSwapNetworkFeeLamports, fetchSwapContext, fetchSwapPoolState, minAmountOutForSlippage, needsInstructionsSysvar, platformFeeLamports, poolSwapStatus, quoteSwap, requiredSwapLamports, swapFeeAddresses, swapPriceImpactBps, } from './swap.js';
-export type { BuildBuyTxParams, BuildSellTxParams, BuiltSwapTransaction, DbcSwapInstructionAccounts, FetchSwapContextParams, PoolSwapStatus, PriceImpactInput, QuoteSwapParams, SlippageInput, SwapAccountSnapshot, SwapBuildOptions, SwapBuildRequest, SwapContext, SwapErrorCode, SwapErrorDetails, SwapFeeBreakdown, SwapPoolState, SwapQuote, SwapQuoteRequest, SwapSide, SwapSolRequirementInput, } from './swap.js';
-export { CLAIM_LAMPORTS_PER_SIGNATURE, ClaimError, PARTNER_POOL_CREATION_FEE_CLAIMED_BIT, buildCreatorClaimTx, buildForgeCreatorClaimTx, buildPartnerClaimTx, buildPartnerPoolCreationFeeClaimTx, isClaimWorthwhile, minimumWorthwhileClaimLamports, partnerPoolCreationFeeShare, type ClaimCosts, type ClaimErrorCode, type ClaimKind, type ClaimOptions, type ClaimSkipReason, type ClaimSummary, type ClaimTxResult, type CreatorClaimParams, type ForgeCreatorClaimParams, type PartnerClaimParams, type PartnerPoolCreationFeeClaimParams, type PoolCreationFeeClaimSummary, type PoolCreationFeeClaimTxResult, type PoolCreationFeeSkipReason, } from './claims.js';
-export { CURVE_PROGRESS_FULL_BPS, DBC_MIGRATION_PROGRESS, DBC_POOL_CONFIG_OFFSET, DBC_POOL_CREATOR_OFFSET, DbcReadError, PROTOCOL_POOL_CREATION_FEE_CLAIMED_BIT, READ_COMMITMENT, curveProgress, feeMetrics, getDbcPoolState, graduationStatus, isGraduated, isTransientRpcError, listCoinsOfConfig, listCoinsOfCreator, poolCreationFeeStatus, readCoin, retryRpc, summarizeCoin, type CoinOfConfig, type CurveProgress, type DbcPoolState, type DbcReadErrorCode, type FeeMetrics, type GraduationStatus, type PoolCreationFeeStatus, type ReadOptions, type RetryOptions, type TokenAmounts, } from './reads.js';
-export { CLUSTER_GENESIS_HASH, MAX_PAYMENT_LAMPORTS, MEMO_PROGRAM_ID, MEMO_V1_PROGRAM_ID, PAYMENT_MEMO_PREFIX, PaymentError, assertCluster, buildPaymentInstructions, buildPaymentTx, checkPaymentTransaction, paymentMemo, verifyPayment, type ExpectedPayment, type PaymentCheck, type PaymentCluster, type PaymentErrorCode, type PaymentParams, type PaymentPendingReason, type PaymentRejectReason, type PaymentTxOptions, type PaymentTxResult, type PaymentVerification, type VerifyPaymentOptions, } from './payments.js';
+export { DEFAULT_SWAP_COMPUTE_UNIT_LIMIT, MAX_SWAP_COMPUTE_UNIT_LIMIT, MAX_SWAP_PRIORITY_FEE_MICRO_LAMPORTS, MAX_SWAP_SLIPPAGE_BPS, PLATFORM_FEE_BPS, SWAP_BASE_FEE_LAMPORTS_PER_SIGNATURE, SWAP_ERROR_CODES, SWAP_MAX_TRANSACTION_BYTES, SwapError, assertPlatformFeeWalletReady, assertPoolConfigAllowed, assertPoolTradable, assertReferralAccountReady, assertSwapFeeAccountsReady, buildBuyTx, buildDbcSwapInstruction, buildSellTx, buildSwapTransaction, coinTokenProgram, compileSwapTransaction, computeSwapQuote, estimateSwapNetworkFeeLamports, fetchSwapContext, fetchSwapPoolState, minAmountOutForSlippage, needsInstructionsSysvar, platformFeeLamports, poolSwapStatus, quoteSwap, requiredSwapLamports, swapFeeAddresses, swapPriceImpactBps, } from './swap.js';
+export type { BuildBuyTxParams, BuildSellTxParams, BuiltSwapTransaction, DbcSwapInstructionAccounts, FetchSwapContextParams, PoolSwapStatus, PriceImpactInput, QuoteSwapParams, SlippageInput, SwapAccountSnapshot, SwapBuildOptions, SwapBuildRequest, SwapContext, SwapErrorCode, SwapErrorDetails, SwapFeeAccountExpectations, SwapFeeBreakdown, SwapPoolState, SwapQuote, SwapQuoteRequest, SwapSide, SwapSolRequirementInput, } from './swap.js';
+export { CLAIM_COMPUTE_UNITS, CLAIM_LAMPORTS_PER_SIGNATURE, ClaimError, PARTNER_POOL_CREATION_FEE_CLAIMED_BIT, POOL_CREATION_FEE_CLAIM_COMPUTE_UNITS, buildCreatorClaimTx, buildForgeCreatorClaimTx, buildPartnerClaimTx, buildPartnerPoolCreationFeeClaimTx, isClaimWorthwhile, minimumWorthwhileClaimLamports, partnerPoolCreationFeeShare, type ClaimCosts, type ClaimErrorCode, type ClaimKind, type ClaimOptions, type ClaimSkipReason, type ClaimSummary, type ClaimTxResult, type CreatorClaimParams, type ForgeCreatorClaimParams, type PartnerClaimParams, type PartnerPoolCreationFeeClaimParams, type PoolCreationFeeClaimSummary, type PoolCreationFeeClaimTxResult, type PoolCreationFeeSkipReason, } from './claims.js';
+export { CLAIM_POSITION_FEE_ACCOUNTS, CLAIM_POSITION_FEE_DISCRIMINATOR, DAMM_V2_PROGRAM_ID, buildCreatorPositionFeeClaimTx, buildForgeCreatorPositionFeeClaimTx, dammV2TokenProgram, findCreatorDammV2Positions, getDammV2PoolState, isPositionClaimWorthwhile, migratedDammV2Pool, positionClaimComputeUnits, positionPendingFees, sumPendingFees, summarizePosition, type CreatorDammV2Positions, type CreatorPositionClaimParams, type DammV2PoolState, type DammV2PositionRef, type DammV2PositionState, type DammV2PositionSummary, type FindCreatorPositionsParams, type ForgeCreatorPositionClaimParams, type MigratedDammV2Pool, type PositionClaimCosts, type PositionClaimSkipReason, type PositionClaimSummary, type PositionClaimTxResult, } from './position-claims.js';
+export { CURVE_PROGRESS_FULL_BPS, DBC_MIGRATION_PROGRESS, DBC_POOL_CONFIG_OFFSET, DBC_POOL_CREATOR_OFFSET, DbcReadError, PROTOCOL_POOL_CREATION_FEE_CLAIMED_BIT, READ_COMMITMENT, curveProgress, feeMetrics, getDbcPoolState, graduationStatus, isGraduated, isTransientRpcError, listCoinsOfConfig, listCoinsOfCreator, listPoolStatesOfConfig, poolCreationFeeStatus, poolSpotPrice, readCoin, retryRpc, summarizeCoin, type CoinOfConfig, type CurveProgress, type DbcPoolState, type DbcReadErrorCode, type FeeMetrics, type GraduationStatus, type PoolCreationFeeStatus, type ReadOptions, type RetryOptions, type TokenAmounts, } from './reads.js';
+export { CLUSTER_GENESIS_HASH, MAX_PAYMENT_LAMPORTS, MEMO_PROGRAM_ID, MEMO_V1_PROGRAM_ID, PAYMENT_COMPUTE_UNITS, PAYMENT_MEMO_PREFIX, PaymentError, assertCluster, buildPaymentInstructions, buildPaymentTx, checkPaymentTransaction, paymentMemo, verifyPayment, type ExpectedPayment, type PaymentCheck, type PaymentCluster, type PaymentErrorCode, type PaymentParams, type PaymentPendingReason, type PaymentRejectReason, type PaymentTxOptions, type PaymentTxResult, type PaymentVerification, type VerifyPaymentOptions, } from './payments.js';
 export { GatingError, getForgeBalance, passesForgeGate, type ForgeBalance, type GatingErrorCode, type GatingOptions, } from './gating.js';
+export { JUPITER_CLAIM_DISCRIMINATOR, JUPITER_CLAIM_V2_DISCRIMINATOR, JUPITER_CREATE_ADMIN_TOKEN_ACCOUNT_DISCRIMINATOR, JUPITER_INITIALIZE_REFERRAL_ACCOUNT_WITH_NAME_DISCRIMINATOR, JUPITER_PROJECT_DISCRIMINATOR, JUPITER_REFERRAL_ACCOUNT_SIZE, JUPITER_REFERRAL_CLAIM_COMPUTE_UNITS, JUPITER_REFERRAL_ACCOUNT_DISCRIMINATOR, JUPITER_REFERRAL_NAME_MAX_BYTES, JUPITER_REFERRAL_NAME_MAX_CHARS, JUPITER_REFERRAL_PROGRAM_ID, JUPITER_REFERRAL_SETUP_COMPUTE_UNITS, JUPITER_ULTRA_REFERRAL_PROJECT, JupiterReferralError, assertJupiterReferralName, buildJupiterCreateAdminTokenAccountIx, buildJupiterInitializeReferralAccountWithNameIx, buildJupiterReferralClaimIx, buildJupiterReferralClaimTx, buildJupiterReferralSetupTx, buildJupiterReferralTokenAccountV2Ix, decodeJupiterProject, decodeJupiterReferralAccount, deriveJupiterProjectAuthority, deriveJupiterReferralAccount, deriveJupiterReferralTokenAccount, deriveJupiterReferralTokenAccountV2, encodeJupiterReferralName, inspectJupiterReferralAccount, inspectJupiterReferralTokenAccountV2, readJupiterReferralSetup, type BuildJupiterReferralClaimTxParams, type BuildJupiterReferralSetupTxParams, type JupiterClaimAccounts, type JupiterCreateAdminTokenAccountAccounts, type JupiterInitializeReferralAccountWithNameAccounts, type JupiterProject, type JupiterReferralAccount, type JupiterReferralAccountExpectation, type JupiterReferralAccountMismatch, type JupiterReferralAccountStatus, type JupiterReferralClaimItem, type JupiterReferralClaimSummary, type JupiterReferralClaimTx, type JupiterReferralClaimVersion, type JupiterReferralErrorCode, type JupiterReferralSetupMint, type JupiterReferralSetupState, type JupiterReferralSetupTokenAccount, type JupiterReferralSetupTokenAccountState, type JupiterReferralSetupTx, type JupiterReferralTokenAccountMismatch, type JupiterReferralTokenAccountStatus, type JupiterReferralTokenAccountV2Ix, type JupiterReferralTokenAccountV2Params, type ReadJupiterReferralSetupParams, } from './jupiter-referral.js';
+export { MAX_METEORA_REFERRAL_SEED_BYTES, METEORA_REFERRAL_ACCOUNT_SEED, METEORA_REFERRAL_SETUP_COMPUTE_UNITS, MeteoraReferralError, TOKEN_INITIALIZE_ACCOUNT3_TAG, assertMeteoraReferralSeed, buildCreateMeteoraReferralAccountIxs, buildCreateMeteoraReferralAccountTx, deriveMeteoraReferralAccount, inspectMeteoraReferralAccount, readMeteoraReferralAccount, type BuildCreateMeteoraReferralAccountTxParams, type CreateMeteoraReferralAccountParams, type CreateMeteoraReferralAccountTx, type MeteoraReferralAccountInstructions, type MeteoraReferralAccountStatus, type MeteoraReferralErrorCode, type MeteoraReferralExpectation, type MeteoraReferralMismatch, type ReadMeteoraReferralAccountParams, } from './meteora-referral.js';

package/dist/index.js

@@ -5,12 +5,23 @@ export * from './validate.js';
 export * from './config.js';
 export * from './pool.js';
 export * from './tx.js';
+// Priority fees: price from the recent fees, bounded, and the matching policy check.
+export * from './priority-fee.js';
 // Launch transaction check before the owner signs (browser-safe: only @solana/web3.js).
 export * from './launch-check.js';
 // Swap: buy / sell with the FORGE Meteora referral and the platform fee (swap.ts).
-export { DEFAULT_SWAP_COMPUTE_UNIT_LIMIT, MAX_SWAP_COMPUTE_UNIT_LIMIT, MAX_SWAP_PRIORITY_FEE_MICRO_LAMPORTS, MAX_SWAP_SLIPPAGE_BPS, PLATFORM_FEE_BPS, SWAP_BASE_FEE_LAMPORTS_PER_SIGNATURE, SWAP_ERROR_CODES, SWAP_MAX_TRANSACTION_BYTES, SwapError, assertPlatformFeeWalletReady, assertPoolTradable, assertReferralAccountReady, assertSwapFeeAccountsReady, buildBuyTx, buildDbcSwapInstruction, buildSellTx, buildSwapTransaction, coinTokenProgram, compileSwapTransaction, computeSwapQuote, estimateSwapNetworkFeeLamports, fetchSwapContext, fetchSwapPoolState, minAmountOutForSlippage, needsInstructionsSysvar, platformFeeLamports, poolSwapStatus, quoteSwap, requiredSwapLamports, swapFeeAddresses, swapPriceImpactBps, } from './swap.js';
+export { DEFAULT_SWAP_COMPUTE_UNIT_LIMIT, MAX_SWAP_COMPUTE_UNIT_LIMIT, MAX_SWAP_PRIORITY_FEE_MICRO_LAMPORTS, MAX_SWAP_SLIPPAGE_BPS, PLATFORM_FEE_BPS, SWAP_BASE_FEE_LAMPORTS_PER_SIGNATURE, SWAP_ERROR_CODES, SWAP_MAX_TRANSACTION_BYTES, SwapError, assertPlatformFeeWalletReady, assertPoolConfigAllowed, assertPoolTradable, assertReferralAccountReady, assertSwapFeeAccountsReady, buildBuyTx, buildDbcSwapInstruction, buildSellTx, buildSwapTransaction, coinTokenProgram, compileSwapTransaction, computeSwapQuote, estimateSwapNetworkFeeLamports, fetchSwapContext, fetchSwapPoolState, minAmountOutForSlippage, needsInstructionsSysvar, platformFeeLamports, poolSwapStatus, quoteSwap, requiredSwapLamports, swapFeeAddresses, swapPriceImpactBps, } from './swap.js';
 // Claims, reads, payments, gating.
-export { CLAIM_LAMPORTS_PER_SIGNATURE, ClaimError, PARTNER_POOL_CREATION_FEE_CLAIMED_BIT, buildCreatorClaimTx, buildForgeCreatorClaimTx, buildPartnerClaimTx, buildPartnerPoolCreationFeeClaimTx, isClaimWorthwhile, minimumWorthwhileClaimLamports, partnerPoolCreationFeeShare, } from './claims.js';
-export { CURVE_PROGRESS_FULL_BPS, DBC_MIGRATION_PROGRESS, DBC_POOL_CONFIG_OFFSET, DBC_POOL_CREATOR_OFFSET, DbcReadError, PROTOCOL_POOL_CREATION_FEE_CLAIMED_BIT, READ_COMMITMENT, curveProgress, feeMetrics, getDbcPoolState, graduationStatus, isGraduated, isTransientRpcError, listCoinsOfConfig, listCoinsOfCreator, poolCreationFeeStatus, readCoin, retryRpc, summarizeCoin, } from './reads.js';
-export { CLUSTER_GENESIS_HASH, MAX_PAYMENT_LAMPORTS, MEMO_PROGRAM_ID, MEMO_V1_PROGRAM_ID, PAYMENT_MEMO_PREFIX, PaymentError, assertCluster, buildPaymentInstructions, buildPaymentTx, checkPaymentTransaction, paymentMemo, verifyPayment, } from './payments.js';
+export { CLAIM_COMPUTE_UNITS, CLAIM_LAMPORTS_PER_SIGNATURE, ClaimError, PARTNER_POOL_CREATION_FEE_CLAIMED_BIT, POOL_CREATION_FEE_CLAIM_COMPUTE_UNITS, buildCreatorClaimTx, buildForgeCreatorClaimTx, buildPartnerClaimTx, buildPartnerPoolCreationFeeClaimTx, isClaimWorthwhile, minimumWorthwhileClaimLamports, partnerPoolCreationFeeShare, } from './claims.js';
+// DAMM v2 position fee claims of migrated pools (position-claims.ts).
+export { CLAIM_POSITION_FEE_ACCOUNTS, CLAIM_POSITION_FEE_DISCRIMINATOR, DAMM_V2_PROGRAM_ID, buildCreatorPositionFeeClaimTx, buildForgeCreatorPositionFeeClaimTx, dammV2TokenProgram, findCreatorDammV2Positions, getDammV2PoolState, isPositionClaimWorthwhile, migratedDammV2Pool, positionClaimComputeUnits, positionPendingFees, sumPendingFees, summarizePosition, } from './position-claims.js';
+export { CURVE_PROGRESS_FULL_BPS, DBC_MIGRATION_PROGRESS, DBC_POOL_CONFIG_OFFSET, DBC_POOL_CREATOR_OFFSET, DbcReadError, PROTOCOL_POOL_CREATION_FEE_CLAIMED_BIT, READ_COMMITMENT, curveProgress, feeMetrics, getDbcPoolState, graduationStatus, isGraduated, isTransientRpcError, listCoinsOfConfig, listCoinsOfCreator, listPoolStatesOfConfig, poolCreationFeeStatus, poolSpotPrice, readCoin, retryRpc, summarizeCoin, } from './reads.js';
+export { CLUSTER_GENESIS_HASH, MAX_PAYMENT_LAMPORTS, MEMO_PROGRAM_ID, MEMO_V1_PROGRAM_ID, PAYMENT_COMPUTE_UNITS, PAYMENT_MEMO_PREFIX, PaymentError, assertCluster, buildPaymentInstructions, buildPaymentTx, checkPaymentTransaction, paymentMemo, verifyPayment, } from './payments.js';
 export { GatingError, getForgeBalance, passesForgeGate, } from './gating.js';
+// Jupiter referral fee claim (mainnet-beta only): the integrator fees collected after graduation
+// go to the referral account's partner, the FORGE revenue wallet (jupiter-referral.ts); and the
+// one-off setup of that referral account (named, Ultra project) with its v2 collection accounts.
+export { JUPITER_CLAIM_DISCRIMINATOR, JUPITER_CLAIM_V2_DISCRIMINATOR, JUPITER_CREATE_ADMIN_TOKEN_ACCOUNT_DISCRIMINATOR, JUPITER_INITIALIZE_REFERRAL_ACCOUNT_WITH_NAME_DISCRIMINATOR, JUPITER_PROJECT_DISCRIMINATOR, JUPITER_REFERRAL_ACCOUNT_SIZE, JUPITER_REFERRAL_CLAIM_COMPUTE_UNITS, JUPITER_REFERRAL_ACCOUNT_DISCRIMINATOR, JUPITER_REFERRAL_NAME_MAX_BYTES, JUPITER_REFERRAL_NAME_MAX_CHARS, JUPITER_REFERRAL_PROGRAM_ID, JUPITER_REFERRAL_SETUP_COMPUTE_UNITS, JUPITER_ULTRA_REFERRAL_PROJECT, JupiterReferralError, assertJupiterReferralName, buildJupiterCreateAdminTokenAccountIx, buildJupiterInitializeReferralAccountWithNameIx, buildJupiterReferralClaimIx, buildJupiterReferralClaimTx, buildJupiterReferralSetupTx, buildJupiterReferralTokenAccountV2Ix, decodeJupiterProject, decodeJupiterReferralAccount, deriveJupiterProjectAuthority, deriveJupiterReferralAccount, deriveJupiterReferralTokenAccount, deriveJupiterReferralTokenAccountV2, encodeJupiterReferralName, inspectJupiterReferralAccount, inspectJupiterReferralTokenAccountV2, readJupiterReferralSetup, } from './jupiter-referral.js';
+// Meteora referral account setup: the standalone wrapped-SOL token account of the revenue wallet
+// that every curve swap built by core names as referral (meteora-referral.ts).
+export { MAX_METEORA_REFERRAL_SEED_BYTES, METEORA_REFERRAL_ACCOUNT_SEED, METEORA_REFERRAL_SETUP_COMPUTE_UNITS, MeteoraReferralError, TOKEN_INITIALIZE_ACCOUNT3_TAG, assertMeteoraReferralSeed, buildCreateMeteoraReferralAccountIxs, buildCreateMeteoraReferralAccountTx, deriveMeteoraReferralAccount, inspectMeteoraReferralAccount, readMeteoraReferralAccount, } from './meteora-referral.js';