@chainlink/ccip-sdk 1.1.0 → 1.2.0

package/src/evm/index.ts

@@ -12,6 +12,7 @@ import {
   JsonRpcProvider,
   WebSocketProvider,
   ZeroAddress,
+  formatUnits,
   getAddress,
   hexlify,
   isBytesLike,
@@ -19,6 +20,7 @@ import {
   isHexString,
   keccak256,
   toBeHex,
+  toBigInt,
   zeroPadValue,
 } from 'ethers'
 import type { TypedContract } from 'ethers-abitype'
@@ -37,7 +39,6 @@ import {
 } from '../chain.ts'
 import {
   CCIPAddressInvalidEvmError,
-  CCIPApiClientNotAvailableError,
   CCIPBlockNotFoundError,
   CCIPContractNotRouterError,
   CCIPContractTypeInvalidError,
@@ -48,6 +49,7 @@ import {
   CCIPHasherVersionUnsupportedError,
   CCIPLogDataInvalidError,
   CCIPSourceChainUnsupportedError,
+  CCIPTokenDecimalsInsufficientError,
   CCIPTokenNotConfiguredError,
   CCIPTokenPoolChainConfigNotFoundError,
   CCIPTransactionNotFoundError,
@@ -67,7 +69,6 @@ import {
   type ChainLog,
   type ChainTransaction,
   type CommitReport,
-  type ExecutionInput,
   type ExecutionReceipt,
   type ExecutionState,
   type Lane,
@@ -694,7 +695,7 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
         offRampABI = OffRamp_1_6_ABI
       // falls through
       case CCIPVersion.V2_0: {
-        offRampABI = OffRamp_2_0_ABI
+        offRampABI ??= OffRamp_2_0_ABI
         const contract = new Contract(
           offRamp,
           offRampABI,
@@ -1005,9 +1006,16 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
   }
 
   /**
-   * {@inheritDoc Chain.generateUnsignedSendMessage}
-   * @returns Array containing 0 or more unsigned token approvals txs (if needed at the time of
-   *   generation), followed by a ccipSend TransactionRequest
+   * Generates unsigned EVM transactions for sending a CCIP message.
+   *
+   * @param opts - Send message options with sender address for populating transaction fields.
+   * @returns Unsigned EVM transaction set containing 0 or more token approval txs
+   *   (if needed at the time of generation), followed by a ccipSend TransactionRequest.
+   *
+   * @remarks
+   * When a token in `tokenAmounts` has `ZeroAddress` as its address, the corresponding
+   * amount is included as native `value` in the `ccipSend` transaction instead of
+   * going through the ERC-20 approve flow.
    */
   async generateUnsignedSendMessage(
     opts: Parameters<Chain['generateUnsignedSendMessage']>[0],
@@ -1140,13 +1148,7 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
   async generateUnsignedExecute(
     opts: Parameters<Chain['generateUnsignedExecute']>[0],
   ): Promise<UnsignedEVMTx> {
-    let input: ExecutionInput, offRamp: string
-    if (!('input' in opts)) {
-      if (!this.apiClient) throw new CCIPApiClientNotAvailableError()
-      ;({ offRamp, ...input } = await this.apiClient.getExecutionInput(opts.messageId))
-    } else {
-      ;({ offRamp, input } = opts)
-    }
+    const { offRamp, input, gasLimit } = await this.resolveExecuteOpts(opts)
     if ('verifications' in input) {
       const contract = new Contract(
         offRamp,
@@ -1174,14 +1176,14 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
         messageId,
         input.verifications.map(({ destAddress }) => destAddress),
         input.verifications.map(({ ccvData }) => hexlify(ccvData)),
-        BigInt(opts.gasLimit ?? 0),
+        BigInt(gasLimit ?? 0),
         { from: offRamp }, // internal method
       )
       const execTx = await contract.execute.populateTransaction(
         input.encodedMessage,
         input.verifications.map(({ destAddress }) => destAddress),
         input.verifications.map(({ ccvData }) => hexlify(ccvData)),
-        BigInt(opts.gasLimit ?? 0),
+        BigInt(gasLimit ?? 0),
       )
       execTx.gasLimit = txGasLimit + 40000n // plus `execute`'s overhead
       return { family: ChainFamily.EVM, transactions: [execTx] }
@@ -1198,7 +1200,7 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
           interfaces.EVM2EVMOffRamp_v1_2,
           this.provider,
         ) as unknown as TypedContract<typeof EVM2EVMOffRamp_1_2_ABI>
-        const gasOverride = BigInt(opts.gasLimit ?? 0)
+        const gasOverride = BigInt(gasLimit ?? 0)
         manualExecTx = await contract.manuallyExecute.populateTransaction(
           {
             ...input,
@@ -1225,9 +1227,9 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
           },
           [
             {
-              receiverExecutionGasLimit: BigInt(opts.gasLimit ?? 0),
+              receiverExecutionGasLimit: BigInt(gasLimit ?? 0),
               tokenGasOverrides: input.message.tokenAmounts.map(() =>
-                BigInt(opts.tokensGasLimit ?? opts.gasLimit ?? 0),
+                BigInt(opts.tokensGasLimit ?? gasLimit ?? 0),
               ),
             },
           ],
@@ -1280,9 +1282,9 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
           [
             [
               {
-                receiverExecutionGasLimit: BigInt(opts.gasLimit ?? 0),
+                receiverExecutionGasLimit: BigInt(gasLimit ?? 0),
                 tokenGasOverrides: input.message.tokenAmounts.map(() =>
-                  BigInt(opts.tokensGasLimit ?? opts.gasLimit ?? 0),
+                  BigInt(opts.tokensGasLimit ?? gasLimit ?? 0),
                 ),
               },
             ],
@@ -1296,27 +1298,27 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
 
     /* Executing a message for the first time has some hard try/catches on-chain
      * so we need to ensure some lower-bounds gasLimits */
-    let gasLimit = await this.provider.estimateGas(manualExecTx)
+    let txGasLimit = await this.provider.estimateGas(manualExecTx)
     if (
       'gasLimit' in input.message &&
       input.message.gasLimit &&
-      gasLimit < input.message.gasLimit + 100000n
+      txGasLimit < input.message.gasLimit + 100000n
     )
       // if message requested gasLimit, ensure execution more than 100k above requested, otherwise it's clearly a try/catch fail
-      gasLimit = BigInt(input.message.gasLimit) + 200000n
-    else if ('gasLimit' in input.message && !input.message.gasLimit && gasLimit < 240000n)
+      txGasLimit = BigInt(input.message.gasLimit) + 200000n
+    else if ('gasLimit' in input.message && !input.message.gasLimit && txGasLimit < 240000n)
       // if message didn't request gasLimit, ensure execution gasLimit is above 240k (empiric)
-      gasLimit = 240000n
-    manualExecTx.gasLimit = gasLimit
+      txGasLimit = 240000n
+    manualExecTx.gasLimit = txGasLimit
 
     return { family: ChainFamily.EVM, transactions: [manualExecTx] }
   }
 
   /**
    * {@inheritDoc Chain.execute}
-   * @throws {@link CCIPWalletInvalidError} if wallet is not a valid Signer
-   * @throws {@link CCIPExecTxNotConfirmedError} if execution transaction fails to confirm
-   * @throws {@link CCIPExecTxRevertedError} if execution transaction reverts
+   * @throws {@link CCIPWalletInvalidError} if wallet is not a valid Signer.
+   * @throws {@link CCIPExecTxNotConfirmedError} if execution transaction fails to confirm.
+   * @throws {@link CCIPExecTxRevertedError} if execution transaction reverts.
    */
   async execute(opts: Parameters<Chain['execute']>[0]) {
     const wallet = opts.wallet
@@ -1407,7 +1409,16 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
     }
   }
 
-  /** {@inheritDoc Chain.getTokenPoolConfig} */
+  /**
+   * Fetches the token pool configuration for an EVM token pool contract.
+   *
+   * @param tokenPool - Token pool contract address.
+   * @returns Token pool config containing token, router, typeAndVersion, and optionally minBlockConfirmations.
+   *
+   * @remarks
+   * For pools with version \>= 2.0, also returns `minBlockConfirmations` for
+   * Faster-Than-Finality (FTF) support. Pre-2.0 pools omit this field.
+   */
   async getTokenPoolConfig(tokenPool: string): Promise<{
     token: string
     router: string
@@ -1452,7 +1463,22 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
     )
   }
 
-  /** {@inheritDoc Chain.getTokenPoolRemotes} */
+  /**
+   * Fetches remote chain configurations for an EVM token pool contract.
+   *
+   * @param tokenPool - Token pool address on the current chain.
+   * @param remoteChainSelector - Optional chain selector to filter results to a single destination.
+   * @returns Record mapping chain names to {@link TokenPoolRemote} configs.
+   *
+   * @remarks
+   * Handles 3 pool version branches:
+   * - v1.5: single remote pool via `getRemotePool`, standard rate limiters.
+   * - v1.6: multiple remote pools via `getRemotePools`, standard rate limiters.
+   * - v2.0+: multiple remote pools plus FTF (Faster-Than-Finality) rate limiters
+   *   (`customBlockConfirmationsOutboundRateLimiterState` / `customBlockConfirmationsInboundRateLimiterState`).
+   *
+   * @throws {@link CCIPTokenPoolChainConfigNotFoundError} if remote token is not configured for a chain.
+   */
   async getTokenPoolRemotes(
     tokenPool: string,
     remoteChainSelector?: bigint,
@@ -1737,10 +1763,76 @@ export class EVMChain extends Chain<typeof ChainFamily.EVM> {
   override async estimateReceiveExecution(
     opts: Parameters<NonNullable<Chain['estimateReceiveExecution']>>[0],
   ): Promise<number> {
+    const convertAmounts = (
+      tokenAmounts?: readonly ((
+        | { token: string }
+        | { destTokenAddress: string; extraData?: string }
+      ) & {
+        amount: bigint
+      })[],
+    ) =>
+      !tokenAmounts
+        ? undefined
+        : Promise.all(
+            tokenAmounts.map(async (ta) => {
+              if (!('destTokenAddress' in ta)) return ta
+              let amount = ta.amount
+              if (isHexString(ta.extraData, 32)) {
+                // extraData is source token decimals in most pools derived from standard TP contracts;
+                // we can identify for it being exactly 32B and being a small integer; otherwise, assume same decimals
+                const sourceDecimals = toBigInt(ta.extraData)
+                if (0 < sourceDecimals && sourceDecimals <= 36) {
+                  const { decimals: destDecimals } = await this.getTokenInfo(ta.destTokenAddress)
+                  amount =
+                    (amount * BigInt(10) ** BigInt(destDecimals)) /
+                    BigInt(10) ** BigInt(sourceDecimals)
+                  if (amount === 0n)
+                    throw new CCIPTokenDecimalsInsufficientError(
+                      ta.destTokenAddress,
+                      destDecimals,
+                      this.network.name,
+                      formatUnits(amount, sourceDecimals),
+                    )
+                }
+              }
+              return { token: ta.destTokenAddress, amount }
+            }),
+          )
+
+    let opts_
+    if (!('offRamp' in opts)) {
+      const { lane, message, metadata } = await this.getMessageById(opts.messageId)
+
+      const offRamp =
+        ('offRampAddress' in message && message.offRampAddress) ||
+        metadata?.offRamp ||
+        (await this.apiClient!.getExecutionInput(opts.messageId)).offRamp
+
+      opts_ = {
+        offRamp,
+        message: {
+          sourceChainSelector: lane.sourceChainSelector,
+          messageId: message.messageId,
+          receiver: message.receiver,
+          sender: message.sender,
+          data: message.data,
+          destTokenAmounts: await convertAmounts(message.tokenAmounts),
+        },
+      }
+    } else {
+      opts_ = {
+        ...opts,
+        message: {
+          ...opts.message,
+          destTokenAmounts: await convertAmounts(opts.message.destTokenAmounts),
+        },
+      }
+    }
+
     const destRouter = await this.getRouterForOffRamp(
-      opts.offRamp,
-      opts.message.sourceChainSelector,
+      opts_.offRamp,
+      opts_.message.sourceChainSelector,
     )
-    return estimateExecGas({ provider: this.provider, router: destRouter, ...opts })
+    return estimateExecGas({ provider: this.provider, router: destRouter, ...opts_ })
   }
 }

package/src/extra-args.ts

@@ -68,7 +68,7 @@ export type EVMExtraArgsV2 = EVMExtraArgsV1 & {
 export type GenericExtraArgsV3 = {
   /** Gas limit for execution on the destination chain (uint32). */
   gasLimit: bigint
-  /** Number of block confirmations required. */
+  /** Number of source-chain block confirmations to wait before relaying the message. */
   blockConfirmations: number
   /** Cross-chain verifier addresses (EVM addresses). */
   ccvs: string[]
@@ -132,7 +132,17 @@ export type SuiExtraArgsV1 = EVMExtraArgsV2 & {
 }
 
 /**
- * Union type of all supported extra arguments formats.
+ * Union of all supported extra arguments formats for CCIP messages.
+ *
+ * The SDK auto-detects the correct variant based on the fields provided:
+ * - {@link EVMExtraArgsV1} - EVM legacy (gasLimit only)
+ * - {@link EVMExtraArgsV2} - EVM with out-of-order execution support
+ * - {@link GenericExtraArgsV3} - Generic V3 with minimum block confirmations, cross-chain verifiers, custom executor, and per-token receiver/args
+ * - {@link SVMExtraArgsV1} - Solana (compute units, accounts)
+ * - {@link SuiExtraArgsV1} - Sui (gas limit, receiver object IDs)
+ *
+ * @see {@link encodeExtraArgs} - Encode extra arguments for on-chain use.
+ * @see {@link decodeExtraArgs} - Decode extra arguments from bytes.
  */
 export type ExtraArgs =
   | EVMExtraArgsV1
@@ -146,10 +156,10 @@ export type ExtraArgs =
  * The args are *to* a dest network, but are encoded as a message *from* this source chain.
  * E.g. Solana uses Borsh to encode extraArgs in its produced requests, even those targeting EVM.
  *
- * @param args - Extra arguments to encode
- * @param from - Source chain family for encoding format (defaults to EVM)
- * @returns Encoded extra arguments as hex string
- * @throws {@link CCIPChainFamilyUnsupportedError} if chain family not supported
+ * @param args - Extra arguments to encode.
+ * @param from - Source chain family for encoding format (defaults to EVM).
+ * @returns Encoded extra arguments as hex string.
+ * @throws {@link CCIPChainFamilyUnsupportedError} if chain family not supported.
  *
  * @example
  * ```typescript
@@ -175,8 +185,8 @@ export function encodeExtraArgs(args: ExtraArgs, from: ChainFamily = ChainFamily
  * @param data - Extra arguments bytearray data.
  * @param from - Optional chain family to narrow decoding attempts.
  * @returns Extra arguments object if found, undefined otherwise.
- * @throws {@link CCIPChainFamilyUnsupportedError} if specified chain family not supported
- * @throws {@link CCIPExtraArgsParseError} if data cannot be parsed as valid extra args
+ * @throws {@link CCIPChainFamilyUnsupportedError} if specified chain family not supported.
+ * @throws {@link CCIPExtraArgsParseError} if data cannot be parsed as valid extra args.
  *
  * @example
  * ```typescript

package/src/gas.ts

@@ -28,7 +28,7 @@ export type EstimateMessageInput = {
   data?: BytesLike
   /**
    * optional tokenAmounts; `amount` with either source `token` (as in MessageInput) or
-   * `{ sourceTokenAddress?, sourcePoolAddress, destTokenAddress }` (as in v1.5..v1.7 tokenAmounts)
+   * `{ sourceTokenAddress?, sourcePoolAddress, destTokenAddress }` (as in v1.5..v2.0 tokenAmounts)
    * can be provided
    */
   tokenAmounts?: readonly ({
@@ -122,7 +122,12 @@ export async function estimateReceiveExecution({
       const tokenAmount =
         'destTokenAddress' in ta
           ? ta
-          : await sourceToDestTokenAddresses(source, dest.network.chainSelector, onRamp, ta)
+          : await sourceToDestTokenAddresses({
+              source,
+              onRamp,
+              destChainSelector: dest.network.chainSelector,
+              sourceTokenAmount: ta,
+            })
       const sourceTokenAddress =
         'token' in ta
           ? ta.token
@@ -147,10 +152,10 @@ export async function estimateReceiveExecution({
     }),
   )
   return dest.estimateReceiveExecution({
-    receiver: message.receiver,
     offRamp,
     message: {
       messageId: message.messageId ?? hexlify(randomBytes(32)),
+      receiver: message.receiver,
       sender: message.sender,
       data: message.data,
       sourceChainSelector: source.network.chainSelector,

package/src/index.ts

@@ -12,6 +12,9 @@ export type {
   APIErrorResponse,
   CCIPAPIClientContext,
   LaneLatencyResponse,
+  MessageSearchFilters,
+  MessageSearchPage,
+  MessageSearchResult,
 } from './api/index.ts'
 export {
   CCIPAPIClient,
@@ -41,6 +44,7 @@ export {
   type EVMExtraArgsV1,
   type EVMExtraArgsV2,
   type ExtraArgs,
+  type GenericExtraArgsV3,
   type SVMExtraArgsV1,
   type SuiExtraArgsV1,
   decodeExtraArgs,
@@ -100,6 +104,7 @@ export type { UnsignedEVMTx } from './evm/index.ts'
 import { SolanaChain } from './solana/index.ts'
 export type { UnsignedSolanaTx } from './solana/index.ts'
 import { SuiChain } from './sui/index.ts'
+export type { UnsignedSuiTx } from './sui/index.ts'
 import { TONChain } from './ton/index.ts'
 export type { UnsignedTONTx } from './ton/index.ts'
 import { ChainFamily, NetworkType } from './types.ts'

package/src/requests.ts

@@ -89,9 +89,9 @@ function decodeJsonMessage(data: Record<string, unknown> | undefined) {
     k?.match(/(selector|amount|nonce|number|limit|bitmap|juels)$/i)
       ? BigInt(v as string | number | bigint)
       : k?.match(/(^dest.*address)|(receiver|offramp|accounts)/i)
-        ? decodeAddress(v as BytesLike, destFamily)
+        ? decodeAddress((typeof v === 'bigint' ? v.toString() : v) as BytesLike, destFamily)
         : k?.match(/((source.*address)|sender|issuer|origin|onramp|(feetoken$)|(token.*address$))/i)
-          ? decodeAddress(v as BytesLike, sourceFamily)
+          ? decodeAddress((typeof v === 'bigint' ? v.toString() : v) as BytesLike, sourceFamily)
           : v instanceof Uint8Array ||
               (Array.isArray(v) && v.length >= 4 && v.every((e) => typeof e === 'number'))
             ? hexlify(getDataBytes(v as readonly number[]))
@@ -456,10 +456,7 @@ export async function* getMessagesForSender(
  * Resolves token routing by querying the TokenAdminRegistry and TokenPool
  * to find the corresponding destination chain token.
  *
- * @param source - Source chain instance
- * @param destChainSelector - Destination chain selector
- * @param onRamp - OnRamp contract address
- * @param sourceTokenAmount - Token amount object containing `token` and `amount`
+ * @param opts - options to convert source to dest token addresses
  * @returns Extended token amount with `sourcePoolAddress`, `sourceTokenAddress`, and `destTokenAddress`
  *
  * @throws {@link CCIPTokenNotInRegistryError} if token is not registered in TokenAdminRegistry
@@ -479,12 +476,21 @@ export async function* getMessagesForSender(
  * console.log(`Dest token: ${tokenAmount.destTokenAddress}`)
  * ```
  */
-export async function sourceToDestTokenAddresses<S extends { token: string }>(
-  source: Chain,
-  destChainSelector: bigint,
-  onRamp: string,
-  sourceTokenAmount: S,
-): Promise<
+export async function sourceToDestTokenAddresses<S extends { token: string }>({
+  source,
+  onRamp,
+  destChainSelector,
+  sourceTokenAmount,
+}: {
+  /** Source chain instance */
+  source: Chain
+  /** OnRamp contract address */
+  onRamp: string
+  /** Destination chain selector */
+  destChainSelector: bigint
+  /** Token amount object containing `token` and `amount` */
+  sourceTokenAmount: S
+}): Promise<
   S & {
     sourcePoolAddress: string
     sourceTokenAddress: string

package/src/solana/index.ts

@@ -1118,9 +1118,10 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
     payer,
     ...opts
   }: Parameters<Chain['generateUnsignedExecute']>[0]): Promise<UnsignedSolanaTx> {
-    if (!('input' in opts) || !('message' in opts.input) || !('computeUnits' in opts.input.message))
+    const resolved = await this.resolveExecuteOpts(opts)
+    if (!('message' in resolved.input) || !('computeUnits' in resolved.input.message))
       throw new CCIPExecutionReportChainMismatchError('Solana')
-    const { offRamp, input } = opts
+    const { offRamp, input } = resolved
     const execReport_ = input as ExecutionInput<CCIPMessage_V1_6_Solana>
     return generateUnsignedExecuteReport(
       this,

package/src/solana/utils.ts

@@ -27,7 +27,7 @@ import {
   CCIPTransactionNotFinalizedError,
 } from '../errors/index.ts'
 import type { ChainLog, WithLogger } from '../types.ts'
-import { getDataBytes, sleep } from '../utils.ts'
+import { bigIntReplacer, getDataBytes, sleep } from '../utils.ts'
 import type { IDL as BASE_TOKEN_POOL_IDL } from './idl/1.6.0/BASE_TOKEN_POOL.ts'
 import type { UnsignedSolanaTx, Wallet } from './types.ts'
 import type { RateLimiterState } from '../chain.ts'
@@ -347,7 +347,7 @@ export async function simulateTransaction(
     throw new SendTransactionError({
       action: 'simulate',
       signature: '',
-      transactionMessage: JSON.stringify(result.value.err),
+      transactionMessage: JSON.stringify(result.value.err, bigIntReplacer),
       logs: result.value.logs!,
     })
   }

package/src/sui/exec.ts

@@ -0,0 +1,131 @@
+import type { SuiClient } from '@mysten/sui/client'
+import type { Keypair } from '@mysten/sui/cryptography'
+import { Transaction } from '@mysten/sui/transactions'
+
+import {
+  CCIPError,
+  CCIPErrorCode,
+  CCIPExecTxRevertedError,
+  CCIPExecutionReportChainMismatchError,
+} from '../errors/index.ts'
+import { type ExecutionInput, ChainFamily } from '../types.ts'
+import { getCcipStateAddress } from './discovery.ts'
+import {
+  type SuiManuallyExecuteInput,
+  type TokenConfig,
+  buildManualExecutionPTB,
+} from './manuallyExec/index.ts'
+import { fetchTokenConfigs, getObjectRef, getReceiverModule } from './objects.ts'
+import type { CCIPMessage_V1_6_Sui, UnsignedSuiTx } from './types.ts'
+
+/**
+ * Builds a Sui manual-execution PTB and returns it as an {@link UnsignedSuiTx}.
+ *
+ * @param client - Sui RPC client.
+ * @param offRamp - OffRamp object ID / address.
+ * @param input - Execution input (message + proofs).
+ * @param opts - Optional overrides such as `gasLimit` and `receiverObjectIds`.
+ * @returns Serialized unsigned transaction ready to sign and submit.
+ */
+export async function generateUnsignedExecutePTB(
+  client: SuiClient,
+  offRamp: string,
+  input: ExecutionInput<CCIPMessage_V1_6_Sui>,
+  opts?: { gasLimit?: number | bigint; receiverObjectIds?: string[] },
+): Promise<UnsignedSuiTx> {
+  if (!('message' in input)) {
+    throw new CCIPExecutionReportChainMismatchError('Sui')
+  }
+
+  const ccip = await getCcipStateAddress(offRamp, client)
+
+  const ccipObjectRef = await getObjectRef(ccip, client)
+  const [offrampStateObject, receiverConfig] = await Promise.all([
+    getObjectRef(offRamp, client),
+    getReceiverModule(client, ccip, ccipObjectRef, input.message.receiver),
+  ])
+
+  let tokenConfigs: TokenConfig[] = []
+  if (input.message.tokenAmounts.length !== 0) {
+    tokenConfigs = await fetchTokenConfigs(client, ccip, ccipObjectRef, input.message.tokenAmounts)
+  }
+
+  const suiInput: SuiManuallyExecuteInput = {
+    executionReport: input,
+    offrampAddress: offRamp,
+    ccipAddress: ccip,
+    ccipObjectRef,
+    offrampStateObject,
+    receiverConfig,
+    tokenConfigs,
+    ...(opts?.receiverObjectIds ? { overrideReceiverObjectIds: opts.receiverObjectIds } : {}),
+  }
+
+  const tx = buildManualExecutionPTB(suiInput)
+
+  if (opts?.gasLimit) {
+    tx.setGasBudget(opts.gasLimit)
+  }
+
+  return {
+    family: ChainFamily.Sui,
+    transactions: [tx.serialize()],
+  }
+}
+
+/**
+ * Signs and executes a pre-built {@link UnsignedSuiTx} using the provided keypair.
+ *
+ * @param client - Sui RPC client.
+ * @param wallet - Keypair used to sign the transaction.
+ * @param unsignedTx - The unsigned Sui transaction to execute.
+ * @param logger - Optional logger.
+ * @returns The finalized transaction digest string.
+ */
+export async function signAndExecuteSuiTx(
+  client: SuiClient,
+  wallet: Keypair,
+  unsignedTx: UnsignedSuiTx,
+  logger?: { info: (...args: unknown[]) => void },
+): Promise<string> {
+  const tx = Transaction.from(unsignedTx.transactions[0])
+
+  logger?.info('Executing Sui CCIP execute transaction...')
+
+  let digest: string
+  try {
+    const result = await client.signAndExecuteTransaction({
+      signer: wallet,
+      transaction: tx,
+      options: {
+        showEffects: true,
+        showEvents: true,
+      },
+    })
+
+    if (result.effects?.status.status !== 'success') {
+      const errorMsg = result.effects?.status.error ?? 'Unknown error'
+      throw new CCIPExecTxRevertedError(result.digest, { context: { error: errorMsg } })
+    }
+
+    digest = result.digest
+  } catch (e) {
+    if (e instanceof CCIPExecTxRevertedError) throw e
+    throw new CCIPError(
+      CCIPErrorCode.TRANSACTION_NOT_FINALIZED,
+      `Failed to send Sui execute transaction: ${(e as Error).message}`,
+    )
+  }
+
+  logger?.info(`Waiting for Sui transaction ${digest} to be finalized...`)
+
+  await client.waitForTransaction({
+    digest,
+    options: {
+      showEffects: true,
+      showEvents: true,
+    },
+  })
+
+  return digest
+}