@xswap-link/sdk 0.10.8 → 0.10.10

package/src/services/svm/utils/pdas/common.ts

@@ -0,0 +1,15 @@
+/**
+ * Common utilities for PDA derivation
+ */
+
+/**
+ * Converts a u64 to 8-byte little endian buffer
+ * @param n - Number to convert
+ * @returns Buffer representation
+ */
+export function uint64ToLE(n: number | bigint): Buffer {
+  const bn = BigInt(n);
+  const buf = Buffer.alloc(8);
+  buf.writeBigUInt64LE(bn);
+  return buf;
+}

package/src/services/svm/utils/pdas/feeQuoter.ts

@@ -0,0 +1,68 @@
+import { PublicKey } from "@solana/web3.js";
+import { uint64ToLE } from "./common";
+
+/**
+ * Fee Quoter PDA utilities
+ */
+
+/**
+ * Finds the Fee Quoter Config PDA
+ * @param feeQuoter Fee Quoter program ID
+ * @returns [PDA, bump]
+ */
+export function findFqConfigPDA(feeQuoter: PublicKey): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync([Buffer.from("config")], feeQuoter);
+}
+
+/**
+ * Finds the Fee Quoter Dest Chain PDA for a chain selector
+ * @param chainSelector Chain selector
+ * @param feeQuoter Fee Quoter program ID
+ * @returns [PDA, bump]
+ */
+export function findFqDestChainPDA(chainSelector: bigint, feeQuoter: PublicKey): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from("dest_chain"), uint64ToLE(chainSelector)],
+    feeQuoter
+  );
+}
+
+/**
+ * Finds the Fee Quoter Billing Token Config PDA for a mint
+ * @param mint Token mint
+ * @param feeQuoter Fee Quoter program ID
+ * @returns [PDA, bump]
+ */
+export function findFqBillingTokenConfigPDA(mint: PublicKey, feeQuoter: PublicKey): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from("fee_billing_token_config"), mint.toBuffer()],
+    feeQuoter
+  );
+}
+
+/**
+ * Finds the Fee Quoter Per Chain Per Token Config PDA for a chain selector and mint
+ * @param chainSelector Chain selector
+ * @param mint Token mint
+ * @param feeQuoter Fee Quoter program ID
+ * @returns [PDA, bump]
+ */
+export function findFqPerChainPerTokenConfigPDA(chainSelector: bigint, mint: PublicKey, feeQuoter: PublicKey): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from("per_chain_per_token_config"), uint64ToLE(chainSelector), mint.toBuffer()],
+    feeQuoter
+  );
+}
+
+/**
+ * Finds the Fee Quoter Allowed Price Updater PDA for a price updater
+ * @param priceUpdater Price updater public key
+ * @param feeQuoter Fee Quoter program ID
+ * @returns [PDA, bump]
+ */
+export function findFqAllowedPriceUpdaterPDA(priceUpdater: PublicKey, feeQuoter: PublicKey): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from("allowed_price_updater"), priceUpdater.toBuffer()],
+    feeQuoter
+  );
+} 

package/src/services/svm/utils/pdas/index.ts

@@ -0,0 +1,12 @@
+/**
+ * PDA utilities for CCIP and related programs
+ * This module exports all PDA-related functionality in a unified way
+ */
+
+// Export all PDA modules
+export * from "./router";
+export * from "./feeQuoter";
+export * from "./rmnRemote";
+export * from "./common";
+export * from "./receiver";
+export * from "./tokenpool";

package/src/services/svm/utils/pdas/receiver.ts

@@ -0,0 +1,58 @@
+import { PublicKey } from "@solana/web3.js";
+
+/**
+ * CCIP Receiver PDA utilities
+ */
+
+// Seeds for the CCIP receiver program
+export const RECEIVER_SEEDS = {
+  EXTERNAL_EXECUTION_CONFIG: Buffer.from("external_execution_config"),
+  STATE: Buffer.from("state"),
+  CONFIG: Buffer.from("config"),
+  DEST_CHAIN_STATE: Buffer.from("dest_chain_state"),
+  FEE_BILLING_SIGNER: Buffer.from("fee_billing_signer"),
+  NONCE: Buffer.from("nonce"),
+  FEE_BILLING_TOKEN_CONFIG: Buffer.from("fee_billing_token_config"),
+  CURSES: Buffer.from("curses"),
+};
+
+/**
+ * Derives the state PDA for a CCIP receiver program
+ * @param programId Receiver program ID
+ * @returns State PDA
+ */
+export function deriveStatePda(programId: PublicKey): PublicKey {
+  const [statePda] = PublicKey.findProgramAddressSync(
+    [RECEIVER_SEEDS.STATE],
+    programId,
+  );
+  return statePda;
+}
+
+/**
+ * Derives the config PDA for a CCIP receiver program
+ * @param programId Receiver program ID
+ * @returns Config PDA
+ */
+export function deriveConfigPda(programId: PublicKey): PublicKey {
+  const [configPda] = PublicKey.findProgramAddressSync(
+    [RECEIVER_SEEDS.CONFIG],
+    programId,
+  );
+  return configPda;
+}
+
+/**
+ * Derives the external execution config PDA for a CCIP receiver program
+ * @param programId Receiver program ID
+ * @returns External execution config PDA
+ */
+export function deriveExternalExecutionConfigPda(
+  programId: PublicKey,
+): PublicKey {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [RECEIVER_SEEDS.EXTERNAL_EXECUTION_CONFIG],
+    programId,
+  );
+  return pda;
+}

package/src/services/svm/utils/pdas/rmnRemote.ts

@@ -0,0 +1,23 @@
+import { PublicKey } from "@solana/web3.js";
+
+/**
+ * RMN Remote PDA utilities
+ */
+
+/**
+ * Finds the RMN Remote Config PDA for a program
+ * @param programId RMN Remote program ID
+ * @returns [PDA, bump]
+ */
+export function findRMNRemoteConfigPDA(programId: PublicKey): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync([Buffer.from("config")], programId);
+}
+
+/**
+ * Finds the RMN Remote Curses PDA for a program
+ * @param programId RMN Remote program ID
+ * @returns [PDA, bump]
+ */
+export function findRMNRemoteCursesPDA(programId: PublicKey): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync([Buffer.from("curses")], programId);
+} 

package/src/services/svm/utils/pdas/router.ts

@@ -0,0 +1,328 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+import { PublicKey } from "@solana/web3.js";
+import { uint64ToLE } from "./common";
+import { Connection } from "@solana/web3.js";
+import { tokenAdminRegistry } from "../../bindings/accounts";
+
+/**
+ * CCIP Router seeds for PDA derivation
+ */
+export const ROUTER_SEEDS = {
+  CONFIG: "config",
+  FEE_BILLING_SIGNER: "fee_billing_signer",
+  TOKEN_ADMIN_REGISTRY: "token_admin_registry",
+  DEST_CHAIN_STATE: "dest_chain_state",
+  NONCE: "nonce",
+  ALLOWED_OFFRAMP: "allowed_offramp",
+  EXTERNAL_TOKEN_POOLS_SIGNER: "external_token_pools_signer",
+  APPROVED_CCIP_SENDER: "approved_ccip_sender",
+  EXTERNAL_EXECUTION_CONFIG: "external_execution_config",
+  TOKEN_POOL_CHAIN_CONFIG: "ccip_tokenpool_chainconfig",
+} as const;
+
+/**
+ * CCIP Router PDA utilities
+ */
+
+/**
+ * Finds the Config PDA for a program
+ * @param programId Router program ID
+ * @returns [PDA, bump]
+ */
+export function findConfigPDA(programId: PublicKey): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(ROUTER_SEEDS.CONFIG)],
+    programId,
+  );
+}
+
+/**
+ * Finds the Fee Billing Signer PDA for a program
+ * @param programId Router program ID
+ * @returns [PDA, bump]
+ */
+export function findFeeBillingSignerPDA(
+  programId: PublicKey,
+): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(ROUTER_SEEDS.FEE_BILLING_SIGNER)],
+    programId,
+  );
+}
+
+/**
+ * Finds the Token Admin Registry PDA for a mint
+ * @param mint Token mint
+ * @param programId Router program ID
+ * @returns [PDA, bump]
+ */
+export function findTokenAdminRegistryPDA(
+  mint: PublicKey,
+  programId: PublicKey,
+): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(ROUTER_SEEDS.TOKEN_ADMIN_REGISTRY), mint.toBuffer()],
+    programId,
+  );
+}
+
+/**
+ * Finds the Destination Chain State PDA for a chain selector
+ * @param chainSelector Chain selector
+ * @param programId Router program ID
+ * @returns [PDA, bump]
+ */
+export function findDestChainStatePDA(
+  chainSelector: bigint,
+  programId: PublicKey,
+): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(ROUTER_SEEDS.DEST_CHAIN_STATE), uint64ToLE(chainSelector)],
+    programId,
+  );
+}
+
+/**
+ * Finds the Nonce PDA for a chain selector and authority
+ * @param chainSelector Chain selector
+ * @param authority User authority
+ * @param programId Router program ID
+ * @returns [PDA, bump]
+ */
+export function findNoncePDA(
+  chainSelector: bigint,
+  authority: PublicKey,
+  programId: PublicKey,
+): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [
+      Buffer.from(ROUTER_SEEDS.NONCE),
+      uint64ToLE(chainSelector),
+      authority.toBuffer(),
+    ],
+    programId,
+  );
+}
+
+/**
+ * Finds the Approved Sender PDA for a chain selector and source sender
+ * @param chainSelector Chain selector
+ * @param sourceSender Source chain sender address
+ * @param receiverProgram Receiver program ID
+ * @returns [PDA, bump]
+ */
+export function findApprovedSenderPDA(
+  chainSelector: bigint,
+  sourceSender: Buffer,
+  receiverProgram: PublicKey,
+): [PublicKey, number] {
+  const lenPrefix = Buffer.from([sourceSender.length]);
+  return PublicKey.findProgramAddressSync(
+    [
+      Buffer.from(ROUTER_SEEDS.APPROVED_CCIP_SENDER),
+      uint64ToLE(chainSelector),
+      lenPrefix,
+      sourceSender,
+    ],
+    receiverProgram,
+  );
+}
+
+/**
+ * Finds the Allowed Offramp PDA for a chain selector and offramp
+ * @param chainSelector Chain selector
+ * @param offramp Offramp program ID
+ * @param programId Router program ID
+ * @returns [PDA, bump]
+ */
+export function findAllowedOfframpPDA(
+  chainSelector: bigint,
+  offramp: PublicKey,
+  programId: PublicKey,
+): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [
+      Buffer.from(ROUTER_SEEDS.ALLOWED_OFFRAMP),
+      uint64ToLE(chainSelector),
+      offramp.toBuffer(),
+    ],
+    programId,
+  );
+}
+
+/**
+ * Finds the Token Pool Chain Config PDA for a chain selector and token mint
+ * @param chainSelector Chain selector
+ * @param tokenMint Token mint
+ * @param programId Pool program ID
+ * @returns [PDA, bump]
+ */
+export function findTokenPoolChainConfigPDA(
+  chainSelector: bigint,
+  tokenMint: PublicKey,
+  programId: PublicKey,
+): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [
+      Buffer.from(ROUTER_SEEDS.TOKEN_POOL_CHAIN_CONFIG),
+      uint64ToLE(chainSelector),
+      tokenMint.toBuffer(),
+    ],
+    programId,
+  );
+}
+
+/**
+ * Finds the External Token Pools Signer PDA for a program
+ * @param programId Router program ID
+ * @returns [PDA, bump]
+ */
+export function findExternalTokenPoolsSignerPDA(
+  programId: PublicKey,
+): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(ROUTER_SEEDS.EXTERNAL_TOKEN_POOLS_SIGNER)],
+    programId,
+  );
+}
+
+/**
+ * Dynamically finds the correct token pool signer PDA for a specific token by retrieving
+ * its admin registry and pool program from the lookup table.
+ *
+ * This function performs on-chain lookups to determine the exact PDA used for token transfers
+ * in the CCIP protocol, which requires both the external_token_pools_signer seed and the
+ * pool program ID from the token's lookup table.
+ *
+ * @param mint Token mint public key
+ * @param routerProgramId CCIP Router program ID
+ * @param connection Solana connection
+ * @returns Promise with [PDA, bump]
+ */
+export async function findDynamicTokenPoolsSignerPDA(
+  mint: PublicKey,
+  routerProgramId: PublicKey,
+  connection: Connection,
+): Promise<[PublicKey, number]> {
+  // First find the token admin registry PDA
+  const [tokenAdminRegistryPDA] = findTokenAdminRegistryPDA(
+    mint,
+    routerProgramId,
+  );
+
+  // Fetch the token admin registry account
+  const tokenAdminRegistryAccount = await connection.getAccountInfo(
+    tokenAdminRegistryPDA,
+  );
+  if (!tokenAdminRegistryAccount) {
+    throw new Error(
+      `Token admin registry not found for mint: ${mint.toString()}`,
+    );
+  }
+
+  // Decode the token admin registry to get the lookup table
+  const tokenRegistry = tokenAdminRegistry.decode(
+    tokenAdminRegistryAccount.data,
+  );
+  const lookupTableAddress = tokenRegistry.lookupTable;
+
+  // Fetch the lookup table
+  const { value: lookupTableAccount } = await connection.getAddressLookupTable(
+    lookupTableAddress,
+  );
+  if (!lookupTableAccount) {
+    throw new Error(`Lookup table not found: ${lookupTableAddress.toString()}`);
+  }
+
+  // Get the addresses from the lookup table
+  const lookupTableAddresses = lookupTableAccount.state.addresses;
+
+  // The pool program is at index 2 in the lookup table
+  if (lookupTableAddresses.length <= 2) {
+    throw new Error(
+      "Lookup table doesn't have enough entries to determine pool program",
+    );
+  }
+
+  // Extract the pool program from the lookup table (index 2)
+  const poolProgram = lookupTableAddresses[2];
+
+  // Now create the correct PDA using both the external_token_pools_signer seed and the pool program
+  return PublicKey.findProgramAddressSync(
+    [
+      Buffer.from(ROUTER_SEEDS.EXTERNAL_TOKEN_POOLS_SIGNER),
+      poolProgram.toBuffer(),
+    ],
+    routerProgramId,
+  );
+}
+
+/**
+ * Finds the External Execution Config PDA for a program
+ * @param programId Router program ID
+ * @returns [PDA, bump]
+ */
+export function findExternalExecutionConfigPDA(
+  programId: PublicKey,
+): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(ROUTER_SEEDS.EXTERNAL_EXECUTION_CONFIG)],
+    programId,
+  );
+}
+
+/**
+ * Finds the correct token pool signer PDA using the CCIPAccountReader
+ *
+ * This version uses the CCIPAccountReader which already has methods to retrieve
+ * token admin registry accounts, making the process more reliable and consistent
+ * with the rest of the SDK.
+ *
+ * @param mint Token mint public key
+ * @param routerProgramId CCIP Router program ID
+ * @param accountReader CCIPAccountReader instance
+ * @param connection Solana connection
+ * @returns Promise with [PDA, bump]
+ */
+export async function findTokenPoolsSignerWithAccountReader(
+  mint: PublicKey,
+  routerProgramId: PublicKey,
+  accountReader: import("../../core/client/accounts").CCIPAccountReader,
+  connection: Connection,
+): Promise<[PublicKey, number]> {
+  // Use the account reader to get the token admin registry
+  const tokenRegistry = await accountReader.getTokenAdminRegistry(mint);
+
+  // Fetch the lookup table
+  const { value: lookupTableAccount } = await connection.getAddressLookupTable(
+    tokenRegistry.lookupTable,
+  );
+  if (!lookupTableAccount) {
+    throw new Error(
+      `Lookup table not found: ${tokenRegistry.lookupTable.toString()}`,
+    );
+  }
+
+  // Get the addresses from the lookup table
+  const lookupTableAddresses = lookupTableAccount.state.addresses;
+
+  // The pool program is at index 2 in the lookup table
+  if (lookupTableAddresses.length <= 2) {
+    throw new Error(
+      "Lookup table doesn't have enough entries to determine pool program",
+    );
+  }
+
+  // Extract the pool program from the lookup table (index 2)
+  const poolProgram = lookupTableAddresses[2];
+
+  // Now create the correct PDA using both the external_token_pools_signer seed and the pool program
+  return PublicKey.findProgramAddressSync(
+    [
+      Buffer.from(ROUTER_SEEDS.EXTERNAL_TOKEN_POOLS_SIGNER),
+      poolProgram.toBuffer(),
+    ],
+    routerProgramId,
+  );
+}

package/src/services/svm/utils/pdas/tokenpool.ts

@@ -0,0 +1,161 @@
+import { PublicKey } from "@solana/web3.js";
+import { uint64ToLE } from "./common";
+
+/**
+ * Token Pool PDA utilities
+ */
+
+// Token Pool seed constants
+export const TOKEN_POOL_STATE_SEED = "state";
+export const TOKEN_POOL_CHAIN_CONFIG_SEED = "chain_config";
+export const TOKEN_POOL_POOL_SIGNER_SEED = "pool_signer";
+export const TOKEN_POOL_RATE_LIMIT_STATE_SEED = "rate_limit_state";
+export const TOKEN_POOL_CHAIN_RATE_LIMIT_SEED = "chain_rate_limit";
+export const TOKEN_POOL_BURN_TRACKING_SEED = "burn_tracking";
+export const TOKEN_POOL_MINT_TRACKING_SEED = "mint_tracking";
+
+// Solana system program IDs
+// Use the official BPF Loader Upgradeable Program ID
+// This is hardcoded because @solana/web3.js does not export it directly
+export const BPF_LOADER_UPGRADEABLE_PROGRAM_ID = new PublicKey(
+  "BPFLoaderUpgradeab1e11111111111111111111111"
+);
+
+/**
+ * Finds the State PDA for the burn-mint pool (main configuration)
+ * @param mint Token mint
+ * @param programId Burn-mint pool program ID
+ * @returns [PDA, bump]
+ */
+export function findBurnMintPoolConfigPDA(
+  mint: PublicKey,
+  programId: PublicKey
+): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(TOKEN_POOL_STATE_SEED), mint.toBuffer()],
+    programId
+  );
+}
+
+/**
+ * Finds the Chain Config PDA for a chain selector and token mint
+ * @param chainSelector Chain selector
+ * @param tokenMint Token mint
+ * @param programId Burn-mint pool program ID
+ * @returns [PDA, bump]
+ */
+export function findBurnMintPoolChainConfigPDA(
+  chainSelector: bigint,
+  tokenMint: PublicKey,
+  programId: PublicKey
+): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [
+      Buffer.from(TOKEN_POOL_CHAIN_CONFIG_SEED),
+      uint64ToLE(chainSelector),
+      tokenMint.toBuffer(),
+    ],
+    programId
+  );
+}
+
+/**
+ * Finds the Program Data PDA for the burn-mint pool program
+ * @param programId Burn-mint pool program ID
+ * @returns [PDA, bump]
+ */
+export function findProgramDataPDA(programId: PublicKey): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [programId.toBuffer()],
+    BPF_LOADER_UPGRADEABLE_PROGRAM_ID
+  );
+}
+
+/**
+ * Finds the Rate Limit State PDA for a token mint
+ * This is used for global rate limiting
+ * @param tokenMint Token mint
+ * @param programId Burn-mint pool program ID
+ * @returns [PDA, bump]
+ */
+export function findRateLimitStatePDA(
+  tokenMint: PublicKey,
+  programId: PublicKey
+): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(TOKEN_POOL_RATE_LIMIT_STATE_SEED), tokenMint.toBuffer()],
+    programId
+  );
+}
+
+/**
+ * Finds the Chain Rate Limit PDA for a chain selector and token mint
+ * This is used for per-chain rate limiting
+ * @param chainSelector Chain selector
+ * @param tokenMint Token mint
+ * @param programId Burn-mint pool program ID
+ * @returns [PDA, bump]
+ */
+export function findChainRateLimitPDA(
+  chainSelector: bigint,
+  tokenMint: PublicKey,
+  programId: PublicKey
+): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [
+      Buffer.from(TOKEN_POOL_CHAIN_RATE_LIMIT_SEED),
+      uint64ToLE(chainSelector),
+      tokenMint.toBuffer(),
+    ],
+    programId
+  );
+}
+
+/**
+ * Finds the Pool Signer PDA for a mint
+ * Used as the authority for token accounts
+ * @param mint Token mint
+ * @param programId Burn-mint pool program ID
+ * @returns [PDA, bump]
+ */
+export function findPoolSignerPDA(
+  mint: PublicKey,
+  programId: PublicKey
+): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(TOKEN_POOL_POOL_SIGNER_SEED), mint.toBuffer()],
+    programId
+  );
+}
+
+/**
+ * Finds the Burn Tracking PDA for a message ID
+ * @param messageId Message ID as byte array
+ * @param programId Burn-mint pool program ID
+ * @returns [PDA, bump]
+ */
+export function findBurnTrackingPDA(
+  messageId: Uint8Array,
+  programId: PublicKey
+): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(TOKEN_POOL_BURN_TRACKING_SEED), Buffer.from(messageId)],
+    programId
+  );
+}
+
+/**
+ * Finds the Mint Tracking PDA for a message ID
+ * @param messageId Message ID as byte array
+ * @param programId Burn-mint pool program ID
+ * @returns [PDA, bump]
+ */
+export function findMintTrackingPDA(
+  messageId: Uint8Array,
+  programId: PublicKey
+): [PublicKey, number] {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(TOKEN_POOL_MINT_TRACKING_SEED), Buffer.from(messageId)],
+    programId
+  );
+}