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

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

@@ -0,0 +1,343 @@
+import {
+  address,
+  fetchEncodedAccount,
+  fetchEncodedAccounts,
+  getAddressEncoder,
+  getProgramDerivedAddress,
+  unwrapOption,
+  type Address,
+} from '@solana/kit';
+import { getDefaultSolanaRPC } from '../../../core/solana/client.js';
+import {
+  getBondingCurveDecoder,
+  getGlobalAccountDecoder,
+  getGlobalConfigDecoder,
+  getPumpPoolDataDecoder,
+  type BondingCurve,
+  type GlobalAccount,
+  type GlobalConfig,
+  type PumpPoolData,
+  type TokenAccount,
+} from './models.js';
+import { getTokenDecoder } from '@solana-program/token';
+import { ONE_DAY_MS, TEN_MINUTES_MS, TWO_SECONDS_MS } from '../utils.js';
+
+export const PUMP_FUN_PROGRAM_ADDRESS = address('6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P');
+export const PUMP_FUN_AMM_PROGRAM_ADDRESS = address('pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA');
+export const WRAPPED_NATIVE_TOKEN_PUBKEY = address('So11111111111111111111111111111111111111112');
+export const GLOBAL_CONFIG_AMM = address('ADyA8hdefvWN2dbGGWFotbzWxrAvLW83WG6QCVXvJKqw');
+export const ANCHOR_DISCRIMINATOR_SIZE = 8;
+
+let globalAccountCache: { data: [GlobalAccount, Address]; expiresAt: number } | null = null;
+let globalConfigCache: { data: [GlobalConfig, Address]; expiresAt: number } | null = null;
+const migratedPoolCache = new Map<string, { data: [PumpPoolData, Address]; expiresAt: number }>();
+const poolTokensInfoCache = new Map<string, { data: [TokenAccount, TokenAccount]; expiresAt: number }>();
+
+/**
+ * Finds the PDA for a PumpFun bonding curve
+ */
+async function findBondingCurvePda(tokenMint: Address): Promise<Address> {
+  const [pda] = await getProgramDerivedAddress({
+    programAddress: PUMP_FUN_PROGRAM_ADDRESS,
+    seeds: [new TextEncoder().encode('bonding-curve'), getAddressEncoder().encode(tokenMint)],
+  });
+
+  return pda;
+}
+
+/**
+ * Finds the PDA for the PumpFun global account
+ */
+async function findGlobalAccountPda(): Promise<Address> {
+  const [pda] = await getProgramDerivedAddress({
+    programAddress: PUMP_FUN_PROGRAM_ADDRESS,
+    seeds: [new TextEncoder().encode('global')],
+  });
+
+  return pda;
+}
+
+/**
+ * Finds the PDA for pool authority in the AMM program
+ */
+async function findPoolAuthorityPdaAmm(mint: Address): Promise<Address> {
+  const [pda] = await getProgramDerivedAddress({
+    programAddress: PUMP_FUN_PROGRAM_ADDRESS,
+    seeds: [new TextEncoder().encode('pool-authority'), getAddressEncoder().encode(mint)],
+  });
+
+  return pda;
+}
+
+/**
+ * Finds the PDA for a pool in the AMM program
+ */
+async function findPoolPdaAmm(poolAuthority: Address, baseMint: Address, quoteMint: Address): Promise<Address> {
+  const [pda] = await getProgramDerivedAddress({
+    programAddress: PUMP_FUN_AMM_PROGRAM_ADDRESS,
+    seeds: [
+      new TextEncoder().encode('pool'),
+      new Uint8Array([0, 0]), // Pool type bytes
+      getAddressEncoder().encode(poolAuthority),
+      getAddressEncoder().encode(baseMint),
+      getAddressEncoder().encode(quoteMint),
+    ],
+  });
+
+  return pda;
+}
+
+/**
+ * Fetches and deserializes a PumpFun bonding curve account
+ *
+ * @param tokenMint - The token mint address
+ * @param options - Optional RPC configuration
+ * @returns Tuple of [BondingCurve data, PDA address]
+ * @throws Error if account doesn't exist or deserialization fails
+ */
+export async function getPumpFunBondingCurve(tokenMint: Address): Promise<[BondingCurve, Address]> {
+  const rpc = getDefaultSolanaRPC();
+
+  try {
+    // Derive the PDA for the bonding curve
+    const pda = await findBondingCurvePda(tokenMint);
+
+    // Fetch the account data
+    const encodedAccount = await fetchEncodedAccount(rpc, pda);
+
+    if (!encodedAccount.exists) {
+      throw new Error(`Bonding curve account not found for token mint: ${tokenMint}`);
+    }
+
+    // Anchor accounts have an 8-byte discriminator prefix
+    const dataWithoutDiscriminator = encodedAccount.data.slice(8);
+
+    try {
+      const decoder = getBondingCurveDecoder();
+      const bondingCurve = decoder.decode(dataWithoutDiscriminator);
+
+      return [bondingCurve, pda];
+    } catch (decodingError) {
+      throw new Error(
+        `Failed to deserialize bonding curve: ${decodingError instanceof Error ? decodingError.message : String(decodingError)}`,
+      );
+    }
+  } catch (error) {
+    throw new Error(`Failed to fetch bonding curve account: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+/**
+ * Fetches and deserializes the PumpFun global account
+ *
+ * @returns Tuple of [GlobalAccount data, PDA address]
+ * @throws {Error} if account doesn't exist
+ * @throws {Error} if deserialization fails
+ */
+export async function getPumpFunGlobalAccount(): Promise<[GlobalAccount, Address]> {
+  // Return cached value if valid
+  if (globalAccountCache && Date.now() < globalAccountCache.expiresAt) {
+    return globalAccountCache.data;
+  }
+
+  const rpc = getDefaultSolanaRPC();
+  const pda = await findGlobalAccountPda();
+
+  const encodedAccount = await fetchEncodedAccount(rpc, pda);
+
+  if (!encodedAccount.exists) {
+    throw new Error(`GlobalAccount not found: ${pda}`);
+  }
+
+  // Validate minimum size
+  if (encodedAccount.data.length < ANCHOR_DISCRIMINATOR_SIZE) {
+    throw new Error(
+      `GlobalAccount deserialization failed: Account data too small: ${encodedAccount.data.length} bytes`,
+    );
+  }
+
+  // Skip Anchor's 8-byte discriminator
+  const dataWithoutDiscriminator = encodedAccount.data.slice(ANCHOR_DISCRIMINATOR_SIZE);
+
+  try {
+    const decoder = getGlobalAccountDecoder();
+    const globalAccount = decoder.decode(dataWithoutDiscriminator);
+
+    // Update cache
+    globalAccountCache = {
+      data: [globalAccount, pda],
+      expiresAt: Date.now() + TEN_MINUTES_MS,
+    };
+
+    return [globalAccount, pda];
+  } catch (error) {
+    throw new Error(`GlobalAccount deserialization failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+/**
+ * Fetches and deserializes the PumpFun global config account
+ *
+ * @returns Tuple of [GlobalConfig data, PDA address]
+ * @throws {Error} if account doesn't exist
+ * @throws {Error} if deserialization fails
+ */
+export async function getPumpFunGlobalConfig(): Promise<[GlobalConfig, Address]> {
+  // Return cached value if valid
+  if (globalConfigCache && Date.now() < globalConfigCache.expiresAt) {
+    return globalConfigCache.data;
+  }
+
+  const rpc = getDefaultSolanaRPC();
+
+  const encodedAccount = await fetchEncodedAccount(rpc, GLOBAL_CONFIG_AMM);
+
+  if (!encodedAccount.exists) {
+    throw new Error(`GlobalConfig account not found: ${GLOBAL_CONFIG_AMM}`);
+  }
+
+  // Validate minimum size
+  if (encodedAccount.data.length < ANCHOR_DISCRIMINATOR_SIZE) {
+    throw new Error(`GlobalConfig deserialization failed: Account data too small: ${encodedAccount.data.length} bytes`);
+  }
+
+  // Skip Anchor's 8-byte discriminator
+  const dataWithoutDiscriminator = encodedAccount.data.slice(ANCHOR_DISCRIMINATOR_SIZE);
+
+  try {
+    const decoder = getGlobalConfigDecoder();
+    const globalConfig = decoder.decode(dataWithoutDiscriminator);
+
+    // Update cache
+    globalConfigCache = {
+      data: [globalConfig, GLOBAL_CONFIG_AMM],
+      expiresAt: Date.now() + TEN_MINUTES_MS,
+    };
+
+    return [globalConfig, GLOBAL_CONFIG_AMM];
+  } catch (error) {
+    throw new Error(`GlobalConfig deserialization failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+/**
+ * Fetches the migrated AMM pool for a token
+ *
+ * @param baseMint - The token mint address (NOT WSOL)
+ * @returns Tuple of [PumpPoolData, pool PDA address]
+ * @throws Error if pool doesn't exist or deserialization fails
+ */
+export async function getPumpFunMigratedPool(baseMint: Address): Promise<[PumpPoolData, Address]> {
+  // 2s in-memory cache
+  const cacheKey = String(baseMint);
+  const cached = migratedPoolCache.get(cacheKey);
+  if (cached && Date.now() < cached.expiresAt) {
+    return cached.data;
+  }
+
+  const rpc = getDefaultSolanaRPC();
+
+  try {
+    const poolAuthorityPda = await findPoolAuthorityPdaAmm(baseMint);
+    const poolPda = await findPoolPdaAmm(poolAuthorityPda, baseMint, WRAPPED_NATIVE_TOKEN_PUBKEY);
+
+    const encodedAccount = await fetchEncodedAccount(rpc, poolPda);
+
+    if (!encodedAccount.exists) {
+      throw new Error(`Migrated pool not found for token mint: ${baseMint}`);
+    }
+
+    const dataWithoutDiscriminator = encodedAccount.data.slice(ANCHOR_DISCRIMINATOR_SIZE);
+
+    try {
+      const decoder = getPumpPoolDataDecoder();
+      const poolData = decoder.decode(dataWithoutDiscriminator);
+
+      // Update short-lived cache
+      migratedPoolCache.set(cacheKey, {
+        data: [poolData, poolPda],
+        expiresAt: Date.now() + ONE_DAY_MS,
+      });
+
+      return [poolData, poolPda];
+    } catch (decodingError) {
+      throw new Error(
+        `Failed to deserialize pool data: ${decodingError instanceof Error ? decodingError.message : String(decodingError)}`,
+      );
+    }
+  } catch (error) {
+    throw new Error(`Failed to fetch migrated pool: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+/**
+ * Fetches and deserializes token account information for pool base and quote tokens
+ *
+ * @param poolBaseTokenAccount - Base token account public key
+ * @param poolQuoteTokenAccount - Quote token account public key
+ * @returns Tuple containing [baseTokenAccount, quoteTokenAccount]
+ * @throws Error if accounts don't exist or deserialization fails
+ */
+export async function getPoolTokensInfo(
+  poolBaseTokenAccount: Address,
+  poolQuoteTokenAccount: Address,
+): Promise<[TokenAccount, TokenAccount]> {
+  // 2s in-memory cache
+  const cacheKey = `${poolBaseTokenAccount}-${poolQuoteTokenAccount}`;
+  const cached = poolTokensInfoCache.get(cacheKey);
+  if (cached && Date.now() < cached.expiresAt) {
+    return cached.data;
+  }
+
+  const rpc = getDefaultSolanaRPC();
+
+  const accountsInfo = await fetchEncodedAccounts(rpc, [poolBaseTokenAccount, poolQuoteTokenAccount]);
+
+  // Validate base token account exists
+  const baseAccountInfo = accountsInfo[0];
+  if (!baseAccountInfo || !baseAccountInfo.exists) {
+    throw new Error(`Base token account not found: ${poolBaseTokenAccount}`);
+  }
+
+  // Validate quote token account exists
+  const quoteAccountInfo = accountsInfo[1];
+  if (!quoteAccountInfo || !quoteAccountInfo.exists) {
+    throw new Error(`Quote token account not found: ${poolQuoteTokenAccount}`);
+  }
+
+  const tokenDecoder = getTokenDecoder();
+
+  // Deserialize base token account
+  const baseDecoded = tokenDecoder.decode(baseAccountInfo.data);
+  const baseTokenAccount: TokenAccount = {
+    mint: baseDecoded.mint,
+    owner: baseDecoded.owner,
+    amount: baseDecoded.amount,
+    delegate: unwrapOption(baseDecoded.delegate),
+    state: baseDecoded.state,
+    isNative: unwrapOption(baseDecoded.isNative),
+    delegatedAmount: baseDecoded.delegatedAmount,
+    closeAuthority: unwrapOption(baseDecoded.closeAuthority),
+  };
+
+  // Deserialize quote token account
+  const quoteDecoded = tokenDecoder.decode(quoteAccountInfo.data);
+  const quoteTokenAccount: TokenAccount = {
+    mint: quoteDecoded.mint,
+    owner: quoteDecoded.owner,
+    amount: quoteDecoded.amount,
+    delegate: unwrapOption(quoteDecoded.delegate),
+    state: quoteDecoded.state,
+    isNative: unwrapOption(quoteDecoded.isNative),
+    delegatedAmount: quoteDecoded.delegatedAmount,
+    closeAuthority: unwrapOption(quoteDecoded.closeAuthority),
+  };
+
+  // Update short-lived cache
+  poolTokensInfoCache.set(cacheKey, {
+    data: [baseTokenAccount, quoteTokenAccount],
+    expiresAt: Date.now() + TWO_SECONDS_MS,
+  });
+
+  return [baseTokenAccount, quoteTokenAccount];
+}