@xswap-link/sdk 0.10.8 → 0.10.10

package/src/services/svm/bindings/types/index.ts

@@ -0,0 +1,78 @@
+import * as CodeVersion from "./CodeVersion";
+import * as RestoreOnAction from "./RestoreOnAction";
+
+export { RampMessageHeader } from "./RampMessageHeader";
+export type {
+  RampMessageHeaderFields,
+  RampMessageHeaderJSON,
+} from "./RampMessageHeader";
+export { SVM2AnyRampMessage } from "./SVM2AnyRampMessage";
+export type {
+  SVM2AnyRampMessageFields,
+  SVM2AnyRampMessageJSON,
+} from "./SVM2AnyRampMessage";
+export { SVM2AnyTokenTransfer } from "./SVM2AnyTokenTransfer";
+export type {
+  SVM2AnyTokenTransferFields,
+  SVM2AnyTokenTransferJSON,
+} from "./SVM2AnyTokenTransfer";
+export { SVM2AnyMessage } from "./SVM2AnyMessage";
+export type {
+  SVM2AnyMessageFields,
+  SVM2AnyMessageJSON,
+} from "./SVM2AnyMessage";
+export { SVMTokenAmount } from "./SVMTokenAmount";
+export type {
+  SVMTokenAmountFields,
+  SVMTokenAmountJSON,
+} from "./SVMTokenAmount";
+export { CrossChainAmount } from "./CrossChainAmount";
+export type {
+  CrossChainAmountFields,
+  CrossChainAmountJSON,
+} from "./CrossChainAmount";
+export { GetFeeResult } from "./GetFeeResult";
+export type { GetFeeResultFields, GetFeeResultJSON } from "./GetFeeResult";
+export { DestChainState } from "./DestChainState";
+export type {
+  DestChainStateFields,
+  DestChainStateJSON,
+} from "./DestChainState";
+export { DestChainConfig } from "./DestChainConfig";
+export type {
+  DestChainConfigFields,
+  DestChainConfigJSON,
+} from "./DestChainConfig";
+export { CodeVersion };
+
+export type CodeVersionKind = CodeVersion.Default | CodeVersion.V1;
+export type CodeVersionJSON = CodeVersion.DefaultJSON | CodeVersion.V1JSON;
+
+export { RestoreOnAction };
+
+export type RestoreOnActionKind =
+  | RestoreOnAction.None
+  | RestoreOnAction.Upgrade
+  | RestoreOnAction.Rollback;
+export type RestoreOnActionJSON =
+  | RestoreOnAction.NoneJSON
+  | RestoreOnAction.UpgradeJSON
+  | RestoreOnAction.RollbackJSON;
+
+export {
+  RemoteAddress,
+  RemoteAddressFields,
+  RemoteAddressJSON,
+} from "./RemoteAddress";
+export {
+  RemoteConfigFields,
+  RemoteConfigJSON,
+  RemoteConfig,
+} from "./RemoteConfig";
+export {
+  RateLimitTokenBucketFields,
+  RateLimitTokenBucketJSON,
+  RateLimitTokenBucket,
+} from "./RateLimitTokenBucket";
+
+export { RateLimitConfig, RateLimitConfigFields, RateLimitConfigJSON } from "./RateLimitConfig";

package/src/services/svm/core/client/accounts.ts

@@ -0,0 +1,97 @@
+import * as anchor from "@coral-xyz/anchor";
+import { AnchorProvider } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+import { CCIPContext } from "../models";
+import {
+  tokenAdminRegistry,
+  tokenAdminRegistryFields,
+} from "../../bindings/accounts";
+import { findTokenAdminRegistryPDA } from "../../utils/pdas";
+import { createLogger, Logger, LogLevel } from "../../utils/logger";
+import { createErrorEnhancer } from "../../utils/errors";
+
+/**
+ * Token Admin Registry account type
+ */
+export type TokenAdminRegistry = tokenAdminRegistryFields;
+
+/**
+ * Client for reading CCIP-related accounts
+ */
+export class CCIPAccountReader {
+  readonly provider: AnchorProvider;
+  readonly programId: PublicKey;
+  private readonly logger: Logger;
+
+  /**
+   * Creates a new CCIPAccountReader using a context
+   * @param context SDK context with provider, config and logger
+   */
+  constructor(readonly context: CCIPContext) {
+    this.logger =
+      context.logger ??
+      createLogger("account-reader", { level: LogLevel.INFO });
+
+    // Use the provider from the context to create an AnchorProvider
+    this.provider = new AnchorProvider(
+      context.provider.connection,
+      context.provider.wallet as any, // Cast to any to satisfy AnchorProvider
+      {}
+    );
+
+    // Set Anchor provider globally
+    anchor.setProvider(this.provider);
+
+    // Use router from config
+    this.programId = context.config.ccipRouterProgramId;
+
+    this.logger.debug(
+      `CCIPAccountReader initialized: programId=${this.programId.toString()}`
+    );
+  }
+
+  /**
+   * Fetches a token admin registry account
+   * @param mint Token mint
+   * @returns Token admin registry account
+   */
+  async getTokenAdminRegistry(mint: PublicKey): Promise<TokenAdminRegistry> {
+    const enhanceError = createErrorEnhancer(this.logger);
+
+    try {
+      this.logger.debug(
+        `Fetching token admin registry for mint: ${mint.toString()}`
+      );
+      this.logger.trace(`Program ID: ${this.programId.toString()}`);
+      const [pda] = findTokenAdminRegistryPDA(mint, this.programId);
+      this.logger.trace(`Token admin registry PDA: ${pda.toString()}`);
+
+      // Use the generated tokenAdminRegistry.fetch method
+      const tokenRegistry = await tokenAdminRegistry.fetch(
+        this.context.provider.connection,
+        pda,
+        this.programId
+      );
+
+      if (!tokenRegistry) {
+        throw new Error(
+          `Token admin registry not found for mint: ${mint.toString()}`
+        );
+      }
+
+      this.logger.trace("Retrieved token admin registry:", {
+        mint: tokenRegistry.mint.toString(),
+        administrator: tokenRegistry.administrator.toString(),
+        lookupTable: tokenRegistry.lookupTable.toString(),
+      });
+
+      return tokenRegistry;
+    } catch (error) {
+      throw enhanceError(error, {
+        operation: "getTokenAdminRegistry",
+        mint: mint.toString(),
+        programId: this.programId.toString(),
+      });
+    }
+  }
+}

package/src/services/svm/core/client/events.ts

@@ -0,0 +1,95 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+import { createErrorEnhancer } from "../../utils/errors";
+import { CCIPContext } from "../models";
+
+/**
+ * Parses a CCIP message sent event from a transaction
+ *
+ * @param context SDK context with provider, config and logger
+ * @param txSignature Transaction signature
+ * @returns Parsed event data with messageId if available
+ */
+export async function parseCCIPMessageSentEvent(
+  context: CCIPContext,
+  txSignature: string,
+): Promise<{
+  messageId?: string;
+}> {
+  if (!context.logger) {
+    throw new Error("Logger is required for parseCCIPMessageSentEvent");
+  }
+
+  const logger = context.logger;
+  const config = context.config;
+  const connection = context.provider.connection;
+
+  const enhanceError = createErrorEnhancer(logger);
+
+  try {
+    logger.info(
+      `Parsing CCIP message sent event for transaction: ${txSignature}`,
+    );
+
+    // Get transaction details with logs
+    logger.debug(`Fetching transaction details with logs`);
+    const tx = await connection.getParsedTransaction(txSignature, {
+      commitment: "confirmed",
+      maxSupportedTransactionVersion: 0,
+    });
+
+    if (!tx || !tx.meta || !tx.meta.logMessages) {
+      logger.warn(`No transaction logs found for ${txSignature}`);
+      return { messageId: undefined };
+    }
+
+    // Get the router program ID as string for comparison
+    const routerProgramId = config.ccipRouterProgramId.toString();
+    logger.debug(
+      `Looking for program return log from CCIP Router: ${routerProgramId}`,
+    );
+
+    // Log messages in TRACE mode
+    logger.trace("Transaction logs:", tx.meta.logMessages);
+
+    // Look for the program return log from the CCIP Router program
+    const programReturnLog = tx.meta.logMessages.find((log) =>
+      log.includes(`Program return: ${routerProgramId}`),
+    );
+
+    if (programReturnLog) {
+      logger.debug(`Found CCIP program return log`);
+
+      // Extract the base64 data after the program ID
+      const parts = programReturnLog.split(
+        `Program return: ${routerProgramId} `,
+      );
+      if (parts.length > 1) {
+        const base64Data = parts[1].trim();
+        logger.trace(`Extracted base64 data: ${base64Data}`);
+
+        const buffer = Buffer.from(base64Data, "base64");
+
+        // The buffer should contain the messageId (32 bytes)
+        const messageIdHex = "0x" + buffer.toString("hex");
+        logger.info(`Successfully extracted messageId: ${messageIdHex}`);
+
+        return {
+          messageId: messageIdHex,
+        };
+      }
+    }
+
+    logger.warn(
+      `Could not find CCIP Router program return log in transaction logs`,
+    );
+    return { messageId: undefined };
+  } catch (error) {
+    enhanceError(new Error(`Failed to parse message ID from transaction`), {
+      operation: "parseCCIPMessageSentEvent",
+      txSignature,
+      error: error instanceof Error ? error.message : String(error),
+    });
+    return { messageId: undefined };
+  }
+}

package/src/services/svm/core/client/fee.ts

@@ -0,0 +1,279 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+import {
+  PublicKey,
+  TransactionMessage,
+  VersionedTransaction,
+} from "@solana/web3.js";
+import { NATIVE_MINT } from "@solana/spl-token";
+import { AccountMeta } from "@solana/web3.js";
+import { createErrorEnhancer } from "../../utils/errors";
+import { CCIPFeeRequest, CCIPContext, CCIPCoreConfig } from "../models";
+import * as types from "../../bindings/types";
+import { GetFeeResult } from "../../bindings/types/GetFeeResult";
+import {
+  findFqConfigPDA,
+  findFqDestChainPDA,
+  findFqBillingTokenConfigPDA,
+  findFqPerChainPerTokenConfigPDA,
+  findConfigPDA,
+  findDestChainStatePDA,
+} from "../../utils/pdas";
+import {
+  getFee,
+  GetFeeAccounts,
+  GetFeeArgs,
+} from "../../bindings/instructions/getFee";
+
+/**
+ * Calculates the fee for a CCIP message
+ *
+ * @param context SDK context with provider, config and logger
+ * @param request Fee request parameters
+ * @returns Fee result
+ */
+export async function calculateFee(
+  context: CCIPContext,
+  request: CCIPFeeRequest,
+): Promise<types.GetFeeResult> {
+  const logger = context.logger;
+  const config = context.config;
+  const connection = context.provider.connection;
+  const signerPublicKey = context.provider.getAddress();
+
+  if (!logger) {
+    throw new Error("Logger is required for calculateFee");
+  }
+
+  const enhanceError = createErrorEnhancer(logger);
+  const selectorBigInt = BigInt(request.destChainSelector.toString());
+
+  logger.info(
+    `Calculating fee for destination chain ${request.destChainSelector.toString()}`,
+  );
+
+  const feeTokenMint = request.message.feeToken.equals(PublicKey.default)
+    ? NATIVE_MINT
+    : request.message.feeToken;
+
+  logger.debug(
+    `Using fee token: ${feeTokenMint.toString()} (${
+      request.message.feeToken.equals(PublicKey.default)
+        ? "Native SOL"
+        : "SPL Token"
+    })`,
+  );
+
+  // Build the accounts needed for the getFee instruction
+  logger.debug(`Building accounts for getFee instruction`);
+  const accounts = await buildGetFeeAccounts(
+    config,
+    selectorBigInt,
+    feeTokenMint,
+  );
+
+  logger.trace("Fee accounts:", {
+    config: accounts.config.toString(),
+    destChainState: accounts.destChainState.toString(),
+    feeQuoter: accounts.feeQuoter.toString(),
+    feeQuoterConfig: accounts.feeQuoterConfig.toString(),
+    feeQuoterDestChain: accounts.feeQuoterDestChain.toString(),
+    feeQuoterBillingTokenConfig:
+      accounts.feeQuoterBillingTokenConfig.toString(),
+    feeQuoterLinkTokenConfig: accounts.feeQuoterLinkTokenConfig.toString(),
+  });
+
+  // Create the getFee instruction arguments
+  logger.debug(`Creating getFee instruction arguments`);
+  const args: GetFeeArgs = {
+    destChainSelector: request.destChainSelector,
+    message: {
+      receiver: request.message.receiver,
+      data: request.message.data,
+      tokenAmounts: request.message.tokenAmounts,
+      feeToken: request.message.feeToken,
+      extraArgs: request.message.extraArgs,
+    },
+  };
+
+  // Create instruction
+  logger.debug(`Creating getFee instruction`);
+  const instruction = getFee(args, accounts, config.ccipRouterProgramId);
+
+  // Build and add token-specific remaining accounts for each token in tokenAmounts
+  const remainingAccounts: AccountMeta[] = [];
+
+  // Process each token in tokenAmounts
+  logger.debug(
+    `Processing ${request.message.tokenAmounts.length} token amounts for remaining accounts`,
+  );
+  for (const tokenAmount of request.message.tokenAmounts) {
+    try {
+      logger.trace(
+        `Processing token: ${tokenAmount.token.toString()}, amount: ${tokenAmount.amount.toString()}`,
+      );
+
+      // Find the token billing config PDA
+      const [tokenBillingConfig] = findFqBillingTokenConfigPDA(
+        tokenAmount.token,
+        config.feeQuoterProgramId,
+      );
+
+      // Find the per chain per token config PDA
+      const [perChainPerTokenConfig] = findFqPerChainPerTokenConfigPDA(
+        selectorBigInt,
+        tokenAmount.token,
+        config.feeQuoterProgramId,
+      );
+
+      logger.trace(`Found token configs:`, {
+        tokenBillingConfig: tokenBillingConfig.toString(),
+        perChainPerTokenConfig: perChainPerTokenConfig.toString(),
+      });
+
+      // Add these accounts to the remaining accounts
+      remainingAccounts.push(
+        { pubkey: tokenBillingConfig, isWritable: false, isSigner: false },
+        { pubkey: perChainPerTokenConfig, isWritable: false, isSigner: false },
+      );
+    } catch (error) {
+      // Log the error with context but continue with other tokens
+      enhanceError(error, {
+        operation: "getFee:processToken",
+        token: tokenAmount.token.toString(),
+        amount: tokenAmount.amount.toString(),
+        destChainSelector: selectorBigInt.toString(),
+      });
+      // Continue with other tokens if one fails
+    }
+  }
+
+  // Add remaining accounts to the instruction
+  if (remainingAccounts.length > 0) {
+    logger.debug(
+      `Adding ${remainingAccounts.length} remaining accounts to the instruction`,
+    );
+    instruction.keys.push(...remainingAccounts);
+  }
+
+  // Log complete instruction accounts in TRACE mode
+  logger.trace(
+    "Complete instruction accounts:",
+    instruction.keys.map((key, index) => ({
+      index,
+      pubkey: key.pubkey.toString(),
+      isSigner: key.isSigner,
+      isWritable: key.isWritable,
+    })),
+  );
+
+  // Get recent blockhash
+  logger.debug(`Getting recent blockhash for transaction`);
+  const { blockhash } = await connection.getLatestBlockhash("confirmed");
+
+  // Create transaction
+  logger.debug(`Creating versioned transaction for simulation`);
+  const messageV0 = new TransactionMessage({
+    payerKey: signerPublicKey,
+    recentBlockhash: blockhash,
+    instructions: [instruction],
+  }).compileToV0Message();
+
+  const tx = new VersionedTransaction(messageV0);
+  await context.provider.signTransaction(tx);
+
+  // Simulate transaction to get the return data
+  logger.debug(`Simulating transaction to get fee result`);
+  const simulation = await connection.simulateTransaction(tx, {
+    commitment: "confirmed",
+    sigVerify: false,
+  });
+
+  // Parse the return data
+  if (simulation.value.logs) {
+    logger.trace(`Simulation logs:`, simulation.value.logs);
+
+    const ccipReturnLog = simulation.value.logs.find((log) =>
+      log.includes(`Program return: ${config.ccipRouterProgramId.toString()}`),
+    );
+
+    if (ccipReturnLog) {
+      logger.debug(`Found CCIP program return log`);
+      const parts = ccipReturnLog.split(
+        `Program return: ${config.ccipRouterProgramId.toString()} `,
+      );
+      if (parts.length > 1) {
+        const base64Data = parts[1].trim();
+        const buffer = Buffer.from(base64Data, "base64");
+
+        // Use the proper bindings to decode the result
+        logger.debug(`Decoding fee result data`);
+        const feeResultData = GetFeeResult.layout().decode(buffer);
+        const result = GetFeeResult.fromDecoded(feeResultData);
+
+        logger.info(
+          `Fee calculation complete: ${result.amount.toString()} tokens`,
+        );
+        return result;
+      }
+    }
+
+    logger.error(`Could not find CCIP program return log in simulation logs`);
+  } else {
+    logger.error(`Simulation did not return any logs`);
+  }
+
+  throw enhanceError(
+    new Error("Could not parse fee from transaction return data"),
+    {
+      operation: "getFee",
+      destChainSelector: request.destChainSelector.toString(),
+      feeToken: request.message.feeToken.toString(),
+      simulationStatus: simulation?.value?.err || "No specific error",
+      hasLogs: !!simulation?.value?.logs,
+      logCount: simulation?.value?.logs?.length || 0,
+    },
+  );
+}
+
+/**
+ * Build accounts required for the getFee instruction
+ * @param config SDK configuration
+ * @param selectorBigInt Chain selector as BigInt
+ * @param feeTokenMint Fee token mint address
+ * @returns GetFeeAccounts object with all required accounts
+ */
+async function buildGetFeeAccounts(
+  config: CCIPCoreConfig,
+  selectorBigInt: bigint,
+  feeTokenMint: PublicKey,
+): Promise<GetFeeAccounts> {
+  const [configPDA] = findConfigPDA(config.ccipRouterProgramId);
+  const [destChainState] = findDestChainStatePDA(
+    selectorBigInt,
+    config.ccipRouterProgramId,
+  );
+  const [feeQuoterConfig] = findFqConfigPDA(config.feeQuoterProgramId);
+  const [fqDestChain] = findFqDestChainPDA(
+    selectorBigInt,
+    config.feeQuoterProgramId,
+  );
+  const [fqBillingTokenConfig] = findFqBillingTokenConfigPDA(
+    feeTokenMint,
+    config.feeQuoterProgramId,
+  );
+  const [fqLinkBillingTokenConfig] = findFqBillingTokenConfigPDA(
+    config.linkTokenMint,
+    config.feeQuoterProgramId,
+  );
+
+  return {
+    config: configPDA,
+    destChainState: destChainState,
+    feeQuoter: config.feeQuoterProgramId,
+    feeQuoterConfig: feeQuoterConfig,
+    feeQuoterDestChain: fqDestChain,
+    feeQuoterBillingTokenConfig: fqBillingTokenConfig,
+    feeQuoterLinkTokenConfig: fqLinkBillingTokenConfig,
+  };
+}

package/src/services/svm/core/client/index.ts

@@ -0,0 +1,150 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+import { TransactionInstruction } from "@solana/web3.js";
+import { createLogger, Logger, LogLevel } from "../../utils/logger";
+import {
+  CCIPContext,
+  CCIPSendRequest,
+  CCIPSendOptions,
+  CCIPFeeRequest,
+  CCIPSendResult,
+  ExtraArgsOptions,
+  CCIPCoreConfig,
+  CCIPProvider,
+} from "../models";
+import * as types from "../../bindings/types";
+
+// Import functionality from separate modules
+import { calculateFee } from "./fee";
+import { parseCCIPMessageSentEvent } from "./events";
+import { createExtraArgs } from "./utils";
+import { sendCCIPMessage } from "./send";
+import { CCIPAccountReader } from "./accounts";
+
+/**
+ * Main client class for interacting with CCIP on Solana
+ *
+ * Features:
+ * - Message sending with optional skipPreflight for low compute limit transactions
+ * - Fee calculation for CCIP messages
+ * - Message ID parsing from transaction results
+ * - ExtraArgs generation for cross-chain messages
+ */
+export class CCIPClient {
+  private readonly context: CCIPContext;
+  private readonly accountReader: CCIPAccountReader;
+
+  /**
+   * Creates a new CCIP client with context
+   * @param context CCIPContext containing provider, config, and logger
+   */
+  constructor(context: CCIPContext) {
+    // Initialize context
+    this.context = {
+      provider: context.provider,
+      config: context.config,
+      logger:
+        context.logger ?? createLogger("client", { level: LogLevel.INFO }),
+    };
+
+    // Initialize account reader with the same context
+    this.accountReader = new CCIPAccountReader(this.context);
+  }
+
+  /**
+   * Get the provider for this client
+   */
+  get provider(): CCIPProvider {
+    return this.context.provider;
+  }
+
+  /**
+   * Get the configuration for this client
+   */
+  get config(): CCIPCoreConfig {
+    return this.context.config;
+  }
+
+  /**
+   * Get the logger for this client
+   */
+  get logger(): Logger {
+    return this.context.logger;
+  }
+
+  /**
+   * Get the account reader for this client
+   */
+  getAccountReader(): CCIPAccountReader {
+    return this.accountReader;
+  }
+
+  /**
+   * Calculates the fee for a CCIP message
+   * @param request Fee request
+   * @returns Fee result
+   */
+  async getFee(request: CCIPFeeRequest): Promise<types.GetFeeResult> {
+    return calculateFee(this.context, request);
+  }
+
+  /**
+   * Sends a CCIP message
+   * @param request Send request
+   * @param computeBudgetInstruction Optional compute budget instruction
+   * @param sendOptions Optional send options (skipPreflight, etc.)
+   * @returns Transaction signature
+   */
+  async send(
+    request: CCIPSendRequest,
+    computeBudgetInstruction?: TransactionInstruction,
+    sendOptions?: CCIPSendOptions,
+  ): Promise<string> {
+    return sendCCIPMessage(
+      this.context,
+      request,
+      this.accountReader,
+      computeBudgetInstruction,
+      sendOptions,
+    );
+  }
+
+  /**
+   * Sends a CCIP message and returns the message ID
+   * @param request Send request
+   * @param computeBudgetInstruction Optional compute budget instruction
+   * @param sendOptions Optional send options (skipPreflight, etc.)
+   * @returns Send result with transaction signature and message ID
+   */
+  async sendWithMessageId(
+    request: CCIPSendRequest,
+    computeBudgetInstruction?: TransactionInstruction,
+    sendOptions?: CCIPSendOptions,
+  ): Promise<CCIPSendResult> {
+    const txSignature = await this.send(
+      request,
+      computeBudgetInstruction,
+      sendOptions,
+    );
+
+    // Parse the CCIPMessageSent event to get the messageId
+    const eventData = await parseCCIPMessageSentEvent(
+      this.context,
+      txSignature,
+    );
+
+    return {
+      txSignature,
+      messageId: eventData.messageId,
+    };
+  }
+
+  /**
+   * Creates the extra arguments for a CCIP message
+   * @param options Options for creating extra arguments
+   * @returns Extra arguments buffer
+   */
+  createExtraArgs(options?: ExtraArgsOptions): Buffer {
+    return createExtraArgs(options, this.context.logger);
+  }
+}