@forgedevv/core 0.1.0 → 0.2.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 { ANTI_SNIPER_FEE_SCHEDULE, FORGE_ACTIVATION_TYPE, FORGE_MIGRATION_SETTINGS, FORGE_TOKEN_SETTINGS, forgeFeeSchedulerParam, } from './settings.js';
 import { computeBudgetInstructions } from './tx.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

package/dist/index.d.ts

@@ -5,9 +5,11 @@ export * from './config.js';
 export * from './pool.js';
 export * from './tx.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 { 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_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 { CLAIM_POSITION_FEE_ACCOUNTS, CLAIM_POSITION_FEE_DISCRIMINATOR, DAMM_V2_PROGRAM_ID, buildCreatorPositionFeeClaimTx, buildForgeCreatorPositionFeeClaimTx, dammV2TokenProgram, findCreatorDammV2Positions, getDammV2PoolState, isPositionClaimWorthwhile, migratedDammV2Pool, 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, 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 { 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_PROJECT_DISCRIMINATOR, JUPITER_REFERRAL_ACCOUNT_DISCRIMINATOR, JUPITER_REFERRAL_PROGRAM_ID, JupiterReferralError, buildJupiterCreateAdminTokenAccountIx, buildJupiterReferralClaimIx, buildJupiterReferralClaimTx, decodeJupiterProject, decodeJupiterReferralAccount, deriveJupiterProjectAuthority, deriveJupiterReferralTokenAccount, deriveJupiterReferralTokenAccountV2, type BuildJupiterReferralClaimTxParams, type JupiterClaimAccounts, type JupiterCreateAdminTokenAccountAccounts, type JupiterProject, type JupiterReferralAccount, type JupiterReferralClaimItem, type JupiterReferralClaimSummary, type JupiterReferralClaimTx, type JupiterReferralClaimVersion, type JupiterReferralErrorCode, } from './jupiter-referral.js';

package/dist/index.js

@@ -8,9 +8,14 @@ export * from './tx.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';
+// 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, 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, 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 { 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 multisig vault (jupiter-referral.ts).
+export { JUPITER_CLAIM_DISCRIMINATOR, JUPITER_CLAIM_V2_DISCRIMINATOR, JUPITER_CREATE_ADMIN_TOKEN_ACCOUNT_DISCRIMINATOR, JUPITER_PROJECT_DISCRIMINATOR, JUPITER_REFERRAL_ACCOUNT_DISCRIMINATOR, JUPITER_REFERRAL_PROGRAM_ID, JupiterReferralError, buildJupiterCreateAdminTokenAccountIx, buildJupiterReferralClaimIx, buildJupiterReferralClaimTx, decodeJupiterProject, decodeJupiterReferralAccount, deriveJupiterProjectAuthority, deriveJupiterReferralTokenAccount, deriveJupiterReferralTokenAccountV2, } from './jupiter-referral.js';

package/dist/jupiter-referral.d.ts

@@ -0,0 +1,119 @@
+import { PublicKey, Transaction, TransactionInstruction, type Commitment, type Connection } from '@solana/web3.js';
+import { type RetryOptions } from './reads.js';
+/** Jupiter referral program (mainnet-beta). */
+export declare const JUPITER_REFERRAL_PROGRAM_ID: PublicKey;
+export declare const JUPITER_REFERRAL_ACCOUNT_DISCRIMINATOR: Buffer;
+export declare const JUPITER_PROJECT_DISCRIMINATOR: Buffer;
+export declare const JUPITER_CLAIM_DISCRIMINATOR: Buffer;
+export declare const JUPITER_CLAIM_V2_DISCRIMINATOR: Buffer;
+export declare const JUPITER_CREATE_ADMIN_TOKEN_ACCOUNT_DISCRIMINATOR: Buffer;
+export type JupiterReferralClaimVersion = 'v1' | 'v2';
+export type JupiterReferralErrorCode = 'wrong_cluster' | 'invalid_params' | 'referral_account_not_found' | 'not_a_referral_account' | 'project_not_found' | 'not_a_project' | 'mint_not_found' | 'not_a_mint' | 'partner_mismatch';
+export declare class JupiterReferralError extends Error {
+    readonly code: JupiterReferralErrorCode;
+    constructor(code: JupiterReferralErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+export interface JupiterReferralAccount {
+    /** Receives the claimed fees (FORGE: the multisig vault). */
+    partner: PublicKey;
+    project: PublicKey;
+    shareBps: number;
+    name: string | null;
+}
+export interface JupiterProject {
+    base: PublicKey;
+    admin: PublicKey;
+    name: string;
+    defaultShareBps: number;
+}
+/** `ReferralAccount { partner, project, share_bps: u16, name: Option<String> }`. */
+export declare function decodeJupiterReferralAccount(data: Buffer): JupiterReferralAccount;
+/** `Project { base, admin, name: String, default_share_bps: u16 }`. */
+export declare function decodeJupiterProject(data: Buffer): JupiterProject;
+/** Classic referral token account: PDA `["referral_ata", referral account, mint]`. */
+export declare function deriveJupiterReferralTokenAccount(referralAccount: PublicKey, mint: PublicKey, programId?: PublicKey): PublicKey;
+/** V2 referral token account: the associated token account of the referral account. */
+export declare function deriveJupiterReferralTokenAccountV2(referralAccount: PublicKey, mint: PublicKey, tokenProgram: PublicKey): PublicKey;
+/** Project authority: PDA `["project_authority", project.base]`. */
+export declare function deriveJupiterProjectAuthority(base: PublicKey, programId?: PublicKey): PublicKey;
+export interface JupiterClaimAccounts {
+    /** Signer, pays the network fee (and the partner token account rent, the first time). */
+    payer: PublicKey;
+    project: PublicKey;
+    admin: PublicKey;
+    projectAdminTokenAccount: PublicKey;
+    referralAccount: PublicKey;
+    referralTokenAccount: PublicKey;
+    partner: PublicKey;
+    partnerTokenAccount: PublicKey;
+    mint: PublicKey;
+    tokenProgram: PublicKey;
+}
+/**
+ * `claim` (v1) or `claim_v2`: the IDL's accounts in the IDL's order. The two differ only in the
+ * position of the program accounts at the end (v1: associated token, system, token; v2: system,
+ * token, associated token). No arguments.
+ */
+export declare function buildJupiterReferralClaimIx(accounts: JupiterClaimAccounts, version: JupiterReferralClaimVersion, programId?: PublicKey): TransactionInstruction;
+export interface JupiterCreateAdminTokenAccountAccounts {
+    project: PublicKey;
+    /** Pays the rent of the admin token account (PDA of the project). */
+    projectAuthority: PublicKey;
+    admin: PublicKey;
+    projectAdminTokenAccount: PublicKey;
+    mint: PublicKey;
+    tokenProgram: PublicKey;
+}
+/** `create_admin_token_account`: needed once per mint before the first claim of that mint. */
+export declare function buildJupiterCreateAdminTokenAccountIx(accounts: JupiterCreateAdminTokenAccountAccounts, programId?: PublicKey): TransactionInstruction;
+export interface BuildJupiterReferralClaimTxParams {
+    connection: Connection;
+    /** FORGE_JUPITER_REFERRAL_ACCOUNT (read through addresses.ts by the caller). */
+    referralAccount: PublicKey;
+    /** Currency to claim (e.g. wrapped SOL or USDC). */
+    mint: PublicKey;
+    /** Fee payer and only signer. */
+    payer: PublicKey;
+    /** When given, the referral account's partner must be this key (the FORGE multisig vault). */
+    expectedPartner?: PublicKey;
+    commitment?: Commitment;
+    retry?: RetryOptions;
+    programId?: PublicKey;
+}
+export interface JupiterReferralClaimItem {
+    version: JupiterReferralClaimVersion;
+    referralTokenAccount: PublicKey;
+    /** Raw units held by that referral token account when the transaction was built. */
+    amount: bigint;
+}
+export interface JupiterReferralClaimSummary {
+    referralAccount: PublicKey;
+    partner: PublicKey;
+    partnerTokenAccount: PublicKey;
+    project: PublicKey;
+    /** The project's admin (receives the project's share) and its authority PDA (pays its rent). */
+    admin: PublicKey;
+    projectAuthority: PublicKey;
+    mint: PublicKey;
+    tokenProgram: PublicKey;
+    /** The funded referral token accounts claimed by the transaction (empty: nothing to claim). */
+    claims: JupiterReferralClaimItem[];
+    /** True when the transaction also creates the partner's token account (rent paid by `payer`). */
+    createsPartnerTokenAccount: boolean;
+    /** True when the transaction also creates the project admin's token account (program-paid). */
+    createsAdminTokenAccount: boolean;
+}
+export interface JupiterReferralClaimTx {
+    /** Unsigned legacy transaction (fee payer and blockhash set), or null when nothing is claimable. */
+    transaction: Transaction | null;
+    lastValidBlockHeight: number | null;
+    summary: JupiterReferralClaimSummary;
+}
+/**
+ * Reads the referral account, its project, the mint and the collection accounts, and builds the
+ * claim(s) of every funded collection account of `mint` to the partner's associated token account.
+ * Mainnet-beta only (genesis hash). Returns `transaction: null` when nothing is claimable.
+ */
+export declare function buildJupiterReferralClaimTx(p: BuildJupiterReferralClaimTxParams): Promise<JupiterReferralClaimTx>;