@shogun-sdk/intents-sdk 1.2.4 → 1.2.6-test

package/src/utils/quote/pumpfun/estimations_amm.ts

@@ -0,0 +1,165 @@
+import type { GlobalConfig, TokenAccount } from './models.js';
+import { BPS_DEN, PreBondedTradeType } from './estimations.js';
+
+/**
+ * Reserves structure for AMM calculations
+ * X = reserve of the token you pay (input side)
+ * Y = reserve of the token you receive (output side)
+ */
+interface Reserves {
+  xIn: bigint;
+  yOut: bigint;
+  feeBps: bigint;
+}
+
+/**
+ * Ceiling division for bigints
+ * Returns ceil(n / d)
+ */
+function ceilDiv(n: bigint, d: bigint): bigint {
+  if (d === 0n) {
+    throw new Error('Division by zero');
+  }
+  return (n + d - 1n) / d;
+}
+
+/**
+ * Calculate output amount for constant product AMM with exact input
+ * Formula: dy = (dx_effective * y_out) / (x_in + dx_effective)
+ * where dx_effective = dx * BPS_DEN / (BPS_DEN + fee_bps)
+ */
+function amountOutExactIn(dx: bigint, r: Reserves): bigint {
+  if (dx === 0n) {
+    return 0n;
+  }
+  if (r.xIn === 0n || r.yOut === 0n) {
+    throw new Error('Insufficient liquidity: empty reserves');
+  }
+
+  const denom = BPS_DEN + r.feeBps;
+  const dxEff = (dx * BPS_DEN) / denom;
+  const num = dxEff * r.yOut;
+  const den = r.xIn + dxEff;
+
+  return num / den; // floor division
+}
+
+/**
+ * Calculate input amount needed for exact output in constant product AMM
+ * Formula: dx = ceil(dx_effective * (BPS_DEN + fee_bps) / BPS_DEN)
+ * where dx_effective = ceil((x_in * dy) / (y_out - dy))
+ */
+function amountInExactOut(dy: bigint, r: Reserves): bigint {
+  if (dy === 0n) {
+    return 0n;
+  }
+  if (dy >= r.yOut || r.xIn === 0n) {
+    throw new Error('Insufficient liquidity: dy >= reserve or x_in is zero');
+  }
+
+  const dxEff = ceilDiv(r.xIn * dy, r.yOut - dy);
+  const denom = BPS_DEN + r.feeBps;
+
+  return ceilDiv(dxEff * denom, BPS_DEN);
+}
+
+/**
+ * Calculate base tokens received when buying with exact quote amount
+ * @param quoteIn Amount of quote tokens (SOL) to spend
+ * @param baseRes Base token reserve
+ * @param quoteRes Quote token reserve
+ * @param feeBps Fee in basis points
+ * @returns Amount of base tokens received
+ */
+export function buyBaseExactInQuote(quoteIn: bigint, baseRes: bigint, quoteRes: bigint, feeBps: bigint): bigint {
+  return amountOutExactIn(quoteIn, {
+    xIn: quoteRes,
+    yOut: baseRes,
+    feeBps,
+  });
+}
+
+/**
+ * Calculate quote tokens needed to buy exact base amount
+ * @param baseOut Desired amount of base tokens
+ * @param baseRes Base token reserve
+ * @param quoteRes Quote token reserve
+ * @param feeBps Fee in basis points
+ * @returns Amount of quote tokens needed
+ */
+export function buyBaseExactOutQuote(baseOut: bigint, baseRes: bigint, quoteRes: bigint, feeBps: bigint): bigint {
+  return amountInExactOut(baseOut, {
+    xIn: quoteRes,
+    yOut: baseRes,
+    feeBps,
+  });
+}
+
+/**
+ * Calculate quote tokens received when selling exact base amount
+ * @param baseIn Amount of base tokens to sell
+ * @param baseRes Base token reserve
+ * @param quoteRes Quote token reserve
+ * @param feeBps Fee in basis points
+ * @returns Amount of quote tokens received
+ */
+export function sellBaseExactInQuote(baseIn: bigint, baseRes: bigint, quoteRes: bigint, feeBps: bigint): bigint {
+  return amountOutExactIn(baseIn, {
+    xIn: baseRes,
+    yOut: quoteRes,
+    feeBps,
+  });
+}
+
+/**
+ * Calculate base tokens needed to receive exact quote amount
+ * @param quoteOut Desired amount of quote tokens
+ * @param baseRes Base token reserve
+ * @param quoteRes Quote token reserve
+ * @param feeBps Fee in basis points
+ * @returns Amount of base tokens needed
+ */
+export function sellBaseExactOutQuote(quoteOut: bigint, baseRes: bigint, quoteRes: bigint, feeBps: bigint): bigint {
+  return amountInExactOut(quoteOut, {
+    xIn: baseRes,
+    yOut: quoteRes,
+    feeBps,
+  });
+}
+
+/**
+ * Main estimation function for PumpFun AMM
+ * @param baseToken Base token account info
+ * @param quoteToken Quote token account info
+ * @param globalConfig Global configuration with fee settings
+ * @param amount Amount to trade
+ * @param tradeType Type of trade (BuyExactIn, BuyExactOut, SellExactIn, SellExactOut)
+ * @returns Estimated output/input amount
+ */
+export function estimatePumpFunAmm(
+  baseToken: TokenAccount,
+  quoteToken: TokenAccount,
+  globalConfig: GlobalConfig,
+  amount: bigint,
+  tradeType: PreBondedTradeType,
+): bigint {
+  const totalFeeBps =
+    globalConfig.lpFeeBasisPoints + globalConfig.protocolFeeBasisPoints + globalConfig.coinCreatorFeeBasisPoints;
+
+  switch (tradeType) {
+    case PreBondedTradeType.BuyExactIn:
+      return buyBaseExactInQuote(amount, baseToken.amount, quoteToken.amount, totalFeeBps);
+
+    case PreBondedTradeType.BuyExactOut:
+      return buyBaseExactOutQuote(amount, baseToken.amount, quoteToken.amount, totalFeeBps);
+
+    case PreBondedTradeType.SellExactIn:
+      return sellBaseExactInQuote(amount, baseToken.amount, quoteToken.amount, totalFeeBps);
+
+    case PreBondedTradeType.SellExactOut:
+      return sellBaseExactOutQuote(amount, baseToken.amount, quoteToken.amount, totalFeeBps);
+
+    default:
+      throw new Error(`Invalid trade type: ${tradeType}`);
+  }
+}

package/src/utils/quote/pumpfun/index.ts

@@ -0,0 +1,266 @@
+import { address, type Address } from '@solana/kit';
+import { type SimpleQuote } from '../aggregator.js';
+import type { RaydiumPumpQuoteParams } from '../raydium.js';
+import type { BondingCurve } from './models.js';
+import {
+  getPumpFunGlobalAccount,
+  getPumpFunBondingCurve,
+  getPumpFunGlobalConfig,
+  getPumpFunMigratedPool,
+  getPoolTokensInfo,
+} from './utils.js';
+import { NATIVE_SOLANA_TOKEN_ADDRESS, WRAPPED_SOL_MINT_ADDRESS } from '../../../constants.js';
+import { JupiterQuoteProvider, type JupiterQuoteParams } from '../jupiter.js';
+import { estimatePumpFunPrebonded, PreBondedTradeType } from './estimations.js';
+import { estimatePumpFunAmm } from './estimations_amm.js';
+import { applySlippage } from '../utils.js';
+
+export class PumpFunQuoteProvider {
+  public async getQuote(raydiumParams: RaydiumPumpQuoteParams): Promise<SimpleQuote> {
+    // Check which token is pump and if it is in prebonding stage
+    const inputMint = address(raydiumParams.inputMint);
+    const outputMint = address(raydiumParams.outputMint);
+
+    const [inputBondingCurve, outputBondingCurve] = await this.getTokensBondingCurve(inputMint, outputMint);
+
+    const { bondingCurve, isInputPrebonded } = this.ensureSinglePrebondedToken(inputBondingCurve, outputBondingCurve);
+
+    let isInputSol = inputMint === NATIVE_SOLANA_TOKEN_ADDRESS || inputMint === WRAPPED_SOL_MINT_ADDRESS;
+    let isOutputSol = outputMint === NATIVE_SOLANA_TOKEN_ADDRESS || outputMint === WRAPPED_SOL_MINT_ADDRESS;
+
+    if (bondingCurve.complete) {
+      console.log('Bonding curve is complete, using Pump AMM for quote');
+      // We have to estimate prebonded first and then swap from quote token to output token (if needed)
+      // Use Pump AMM logic to get quote
+      let [globalConfig, _] = await getPumpFunGlobalConfig();
+
+      if (isInputPrebonded) {
+        let [migratePoolData, _] = await getPumpFunMigratedPool(inputMint);
+        let [inputTokenAccount, outputTokenAccount] = await getPoolTokensInfo(
+          migratePoolData.poolBaseTokenAccount,
+          migratePoolData.poolQuoteTokenAccount,
+        );
+
+        let pumpAmountOut = estimatePumpFunAmm(
+          inputTokenAccount,
+          outputTokenAccount,
+          globalConfig,
+          BigInt(raydiumParams.amount),
+          PreBondedTradeType.SellExactIn,
+        );
+
+        // Then if output token is SOL or WSOL, return directly
+        if (isOutputSol) {
+          // Apply slippage to amountOut
+          const pumpMinAmountOut = applySlippage(pumpAmountOut, raydiumParams.slippageBps);
+          return {
+            amountIn: BigInt(raydiumParams.amount),
+            amountOut: pumpAmountOut,
+            amountOutMin: pumpMinAmountOut,
+            slippage: raydiumParams.slippageBps / 100, // convert to percentage
+          };
+        } else {
+          // Then if output token is not SOL or WSOL, get a jupiter quote to swap SOL to output token
+          let jupiterQuoteRequest: JupiterQuoteParams = {
+            amount: pumpAmountOut,
+            tokenIn: WRAPPED_SOL_MINT_ADDRESS.toString(),
+            tokenOut: raydiumParams.outputMint,
+            swapMode: 'ExactIn',
+            slippageBps: raydiumParams.slippageBps, // Here we use all slippage to simplify
+          };
+
+          const jupiterQuoter = new JupiterQuoteProvider();
+          const jupiterQuote = await jupiterQuoter.getQuote(jupiterQuoteRequest);
+          if (!jupiterQuote.quote) {
+            throw new Error('Jupiter quote failed');
+          }
+
+          return {
+            amountIn: BigInt(raydiumParams.amount),
+            amountOut: BigInt(jupiterQuote.quote.outAmount),
+            amountOutMin: BigInt(jupiterQuote.quote.otherAmountThreshold),
+            slippage: raydiumParams.slippageBps / 100, // convert to percentage
+          };
+        }
+      } else {
+        let [migratePoolData, _] = await getPumpFunMigratedPool(outputMint);
+        let [inputTokenAccount, outputTokenAccount] = await getPoolTokensInfo(
+          migratePoolData.poolBaseTokenAccount,
+          migratePoolData.poolQuoteTokenAccount,
+        );
+        let amountOutFromInput = BigInt(raydiumParams.amount);
+        let amountOutFromInputMin = applySlippage(BigInt(raydiumParams.amount), raydiumParams.slippageBps);
+        // Buying prebonded token with SOL
+        // If input token is not SOL or WSOL, get a jupiter quote to swap input token to SOL first
+        if (!isInputSol) {
+          let jupiterQuoteRequest: JupiterQuoteParams = {
+            amount: BigInt(raydiumParams.amount),
+            tokenIn: raydiumParams.inputMint,
+            tokenOut: WRAPPED_SOL_MINT_ADDRESS.toString(),
+            swapMode: 'ExactIn',
+            slippageBps: raydiumParams.slippageBps, // Use all slippage to simplify
+          };
+          const jupiterQuoter = new JupiterQuoteProvider();
+          const jupiterQuote = await jupiterQuoter.getQuote(jupiterQuoteRequest);
+          if (!jupiterQuote.quote) {
+            throw new Error('Jupiter quote failed');
+          }
+          amountOutFromInput = BigInt(jupiterQuote.quote.outAmount);
+          amountOutFromInputMin = BigInt(jupiterQuote.quote.otherAmountThreshold);
+        }
+
+        // Slippage is already applied to amountOutFromInputMin
+        let pumpAmountOut = estimatePumpFunAmm(
+          inputTokenAccount,
+          outputTokenAccount,
+          globalConfig,
+          amountOutFromInput,
+          PreBondedTradeType.BuyExactIn,
+        );
+
+        let pumpAmountOutMin = estimatePumpFunAmm(
+          inputTokenAccount,
+          outputTokenAccount,
+          globalConfig,
+          amountOutFromInputMin,
+          PreBondedTradeType.BuyExactIn,
+        );
+        return {
+          amountIn: BigInt(raydiumParams.amount),
+          amountOut: pumpAmountOut,
+          amountOutMin: pumpAmountOutMin,
+          slippage: raydiumParams.slippageBps / 100, // convert to percentage
+        };
+      }
+    } else {
+      // Use Pump logic to get quote during prebonding
+      let globalAccount = await getPumpFunGlobalAccount();
+      if (isInputPrebonded) {
+        // Selling prebonded token for SOL
+        // First get sell estimation from PumpFun
+        const pumpAmountOut = estimatePumpFunPrebonded(
+          bondingCurve,
+          globalAccount[0],
+          BigInt(raydiumParams.amount),
+          PreBondedTradeType.SellExactIn,
+        );
+        console.log('pumpAmountOut', pumpAmountOut);
+
+        // Then if output token is SOL or WSOL, return directly
+        if (isOutputSol) {
+          // Apply slippage to amountOut
+          const pumpMinAmountOut = applySlippage(pumpAmountOut, raydiumParams.slippageBps);
+          return {
+            amountIn: BigInt(raydiumParams.amount),
+            amountOut: pumpAmountOut,
+            amountOutMin: pumpMinAmountOut,
+            slippage: raydiumParams.slippageBps / 100, // convert to percentage
+          };
+        } else {
+          // Then if output token is not SOL or WSOL, get a jupiter quote to swap SOL to output token
+          let jupiterQuoteRequest: JupiterQuoteParams = {
+            amount: pumpAmountOut,
+            tokenIn: WRAPPED_SOL_MINT_ADDRESS.toString(),
+            tokenOut: raydiumParams.outputMint,
+            swapMode: 'ExactIn',
+            slippageBps: raydiumParams.slippageBps, // Here we use all slippage to simplify
+          };
+          const jupiterQuoter = new JupiterQuoteProvider();
+          const jupiterQuote = await jupiterQuoter.getQuote(jupiterQuoteRequest);
+          if (!jupiterQuote.quote) {
+            throw new Error('Jupiter quote failed');
+          }
+
+          return {
+            amountIn: BigInt(raydiumParams.amount),
+            amountOut: BigInt(jupiterQuote.quote.outAmount),
+            amountOutMin: BigInt(jupiterQuote.quote.otherAmountThreshold),
+            slippage: raydiumParams.slippageBps / 100, // convert to percentage
+          };
+        }
+      } else {
+        let amountOutFromInput = BigInt(raydiumParams.amount);
+        let amountOutFromInputMin = applySlippage(BigInt(raydiumParams.amount), raydiumParams.slippageBps);
+        // Buying prebonded token with SOL
+        // If input token is not SOL or WSOL, get a jupiter quote to swap input token to SOL first
+        if (!isInputSol) {
+          let jupiterQuoteRequest: JupiterQuoteParams = {
+            amount: BigInt(raydiumParams.amount),
+            tokenIn: raydiumParams.inputMint,
+            tokenOut: WRAPPED_SOL_MINT_ADDRESS.toString(),
+            swapMode: 'ExactIn',
+            slippageBps: raydiumParams.slippageBps, // Use all slippage to simplify
+          };
+          const jupiterQuoter = new JupiterQuoteProvider();
+          const jupiterQuote = await jupiterQuoter.getQuote(jupiterQuoteRequest);
+          if (!jupiterQuote.quote) {
+            throw new Error('Jupiter quote failed');
+          }
+
+          // Calculate minimum amount with slippage applied
+          amountOutFromInput = BigInt(jupiterQuote.quote.outAmount);
+          amountOutFromInputMin = BigInt(jupiterQuote.quote.otherAmountThreshold);
+        }
+
+        // Slippage is already applied to amountOutFromInputMin
+        const amountOut = estimatePumpFunPrebonded(
+          bondingCurve,
+          globalAccount[0],
+          amountOutFromInput,
+          PreBondedTradeType.BuyExactIn,
+        );
+
+        const minAmountOut = estimatePumpFunPrebonded(
+          bondingCurve,
+          globalAccount[0],
+          amountOutFromInputMin,
+          PreBondedTradeType.BuyExactIn,
+        );
+
+        return {
+          amountIn: BigInt(raydiumParams.amount),
+          amountOut: amountOut,
+          amountOutMin: minAmountOut,
+          slippage: raydiumParams.slippageBps / 100, // convert to percentage
+        };
+      }
+    }
+  }
+
+  async getTokensBondingCurve(
+    inputMint: Address,
+    outputMint: Address,
+  ): Promise<[BondingCurve | null, BondingCurve | null]> {
+    let inputBondingCurve: BondingCurve | null = null;
+    let outputBondingCurve: BondingCurve | null = null;
+
+    try {
+      inputBondingCurve = (await getPumpFunBondingCurve(inputMint))[0];
+    } catch (e) {
+      // No bonding curve for input token
+    }
+
+    try {
+      outputBondingCurve = (await getPumpFunBondingCurve(outputMint))[0];
+    } catch (e) {
+      // No bonding curve for output token
+    }
+
+    return [inputBondingCurve, outputBondingCurve];
+  }
+
+  private ensureSinglePrebondedToken(
+    inputBonding: BondingCurve | null,
+    outputBonding: BondingCurve | null,
+  ): { bondingCurve: BondingCurve; isInputPrebonded: boolean } {
+    if (inputBonding && outputBonding) {
+      throw new Error('Both input and output tokens are prebonded, which is not supported');
+    }
+    if (!inputBonding && !outputBonding) {
+      throw new Error('Neither input nor output token is prebonded, which is not supported');
+    }
+    return inputBonding
+      ? { bondingCurve: inputBonding, isInputPrebonded: true }
+      : { bondingCurve: outputBonding!, isInputPrebonded: false };
+  }
+}

package/src/utils/quote/pumpfun/models.ts

@@ -0,0 +1,163 @@
+import {
+  getAddressDecoder,
+  getArrayDecoder,
+  getBooleanDecoder,
+  getStructDecoder,
+  getU16Decoder,
+  getU64Decoder,
+  getU8Decoder,
+  type Address,
+  type Decoder,
+} from '@solana/kit';
+
+/**
+ * Represents a Solana Token Account
+ */
+export interface TokenAccount {
+  mint: Address;
+  owner: Address;
+  amount: bigint;
+  delegate: Address | null;
+  state: number;
+  isNative: bigint | null;
+  delegatedAmount: bigint;
+  closeAuthority: Address | null;
+}
+
+/**
+ * BondingCurve structure matching the Rust implementation
+ * This mirrors the on-chain account layout
+ */
+export interface BondingCurve {
+  virtualTokenReserves: bigint;
+  virtualSolReserves: bigint;
+  realTokenReserves: bigint;
+  realSolReserves: bigint;
+  tokenTotalSupply: bigint;
+  complete: boolean;
+  creator: Address;
+}
+
+/**
+ * GlobalAccount structure matching the Rust implementation
+ * Contains global configuration for the PumpFun protocol
+ */
+export interface GlobalAccount {
+  initialized: boolean;
+  authority: Address;
+  feeRecipient: Address;
+  initialVirtualTokenReserves: bigint;
+  initialVirtualSolReserves: bigint;
+  initialRealTokenReserves: bigint;
+  tokenTotalSupply: bigint;
+  feeBasisPoints: bigint;
+  withdrawAuthority: Address;
+  enableMigrate: boolean;
+  poolMigrationFee: bigint;
+  creatorFeeBasisPoints: bigint;
+  feeRecipients: Address[]; // Array of 7 Pubkeys
+  setCreatorAuthority: Address;
+  adminSetCreatorAuthority: Address;
+}
+
+/**
+ * GlobalConfig structure matching the Rust implementation
+ * This is the ACTUAL structure used by PumpFun on-chain
+ */
+export interface GlobalConfig {
+  admin: Address;
+  lpFeeBasisPoints: bigint;
+  protocolFeeBasisPoints: bigint;
+  disableFlags: number;
+  protocolFeeRecipients: Address[]; // Array of 8 Pubkeys
+  coinCreatorFeeBasisPoints: bigint;
+  adminSetCoinCreatorAuthority: Address;
+}
+
+/**
+ * PumpPoolData for migrated AMM pools
+ */
+export interface PumpPoolData {
+  poolBump: number;
+  index: number;
+  creator: Address;
+  baseMint: Address;
+  quoteMint: Address;
+  lpMint: Address;
+  poolBaseTokenAccount: Address;
+  poolQuoteTokenAccount: Address;
+  lpSupply: bigint;
+  coinCreator: Address;
+}
+
+/**
+ * Creates a decoder for PumpPoolData
+ */
+export function getPumpPoolDataDecoder(): Decoder<PumpPoolData> {
+  return getStructDecoder([
+    ['poolBump', getU8Decoder()],
+    ['index', getU16Decoder()],
+    ['creator', getAddressDecoder()],
+    ['baseMint', getAddressDecoder()],
+    ['quoteMint', getAddressDecoder()],
+    ['lpMint', getAddressDecoder()],
+    ['poolBaseTokenAccount', getAddressDecoder()],
+    ['poolQuoteTokenAccount', getAddressDecoder()],
+    ['lpSupply', getU64Decoder()],
+    ['coinCreator', getAddressDecoder()],
+  ]);
+}
+
+/**
+ * Creates a decoder for the BondingCurve account structure
+ * The layout must match exactly the Rust struct serialization order
+ */
+export function getBondingCurveDecoder(): Decoder<BondingCurve> {
+  return getStructDecoder([
+    ['virtualTokenReserves', getU64Decoder()],
+    ['virtualSolReserves', getU64Decoder()],
+    ['realTokenReserves', getU64Decoder()],
+    ['realSolReserves', getU64Decoder()],
+    ['tokenTotalSupply', getU64Decoder()],
+    ['complete', getBooleanDecoder()],
+    ['creator', getAddressDecoder()],
+  ]);
+}
+
+/**
+ * Creates a decoder for the GlobalAccount structure
+ */
+export function getGlobalAccountDecoder(): Decoder<GlobalAccount> {
+  return getStructDecoder([
+    ['initialized', getBooleanDecoder()],
+    ['authority', getAddressDecoder()],
+    ['feeRecipient', getAddressDecoder()],
+    ['initialVirtualTokenReserves', getU64Decoder()],
+    ['initialVirtualSolReserves', getU64Decoder()],
+    ['initialRealTokenReserves', getU64Decoder()],
+    ['tokenTotalSupply', getU64Decoder()],
+    ['feeBasisPoints', getU64Decoder()],
+    ['withdrawAuthority', getAddressDecoder()],
+    ['enableMigrate', getBooleanDecoder()],
+    ['poolMigrationFee', getU64Decoder()],
+    ['creatorFeeBasisPoints', getU64Decoder()],
+    ['feeRecipients', getArrayDecoder(getAddressDecoder(), { size: 7 })], // Fixed array of 7 Pubkeys
+    ['setCreatorAuthority', getAddressDecoder()],
+    ['adminSetCreatorAuthority', getAddressDecoder()],
+  ]);
+}
+
+/**
+ * Creates a decoder for the GlobalConfig structure
+ */
+export function getGlobalConfigDecoder(): Decoder<GlobalConfig> {
+  return getStructDecoder([
+    ['admin', getAddressDecoder()],
+    ['lpFeeBasisPoints', getU64Decoder()],
+    ['protocolFeeBasisPoints', getU64Decoder()],
+    ['disableFlags', getU8Decoder()],
+    ['protocolFeeRecipients', getArrayDecoder(getAddressDecoder(), { size: 8 })], // Fixed array of 8 Pubkeys
+    ['coinCreatorFeeBasisPoints', getU64Decoder()],
+    ['adminSetCoinCreatorAuthority', getAddressDecoder()],
+  ]);
+}