@shogun-sdk/intents-sdk 1.3.0 → 1.4.0

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()],
+  ]);
+}