@chainlink/ccip-sdk 1.1.0 → 1.1.1

package/src/aptos/index.ts

@@ -560,13 +560,11 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     payer,
     ...opts
   }: Parameters<Chain['generateUnsignedExecute']>[0]): Promise<UnsignedAptosTx> {
+    const resolved = await this.resolveExecuteOpts(opts)
     if (
-      !(
-        'input' in opts &&
-        'message' in opts.input &&
-        'allowOutOfOrderExecution' in opts.input.message &&
-        'gasLimit' in opts.input.message
-      )
+      !('message' in resolved.input) ||
+      !('allowOutOfOrderExecution' in resolved.input.message) ||
+      !('gasLimit' in resolved.input.message)
     ) {
       throw new CCIPAptosExtraArgsV2RequiredError()
     }
@@ -574,9 +572,9 @@ export class AptosChain extends Chain<typeof ChainFamily.Aptos> {
     const tx = await generateUnsignedExecuteReport(
       this.provider,
       payer,
-      opts.offRamp,
-      opts.input as ExecutionInput<CCIPMessage_V1_6_EVM>,
-      opts,
+      resolved.offRamp,
+      resolved.input as ExecutionInput<CCIPMessage_V1_6_EVM>,
+      resolved,
     )
     return {
       family: ChainFamily.Aptos,

package/src/chain.ts

@@ -28,6 +28,7 @@ import { getOffchainTokenData } from './offchain.ts'
 import { getMessagesInTx } from './requests.ts'
 import { DEFAULT_GAS_LIMIT } from './shared/constants.ts'
 import type { UnsignedSolanaTx } from './solana/types.ts'
+import type { UnsignedSuiTx } from './sui/types.ts'
 import type { UnsignedTONTx } from './ton/types.ts'
 import {
   type AnyMessage,
@@ -364,7 +365,7 @@ export type UnsignedTx = {
   [ChainFamily.Solana]: UnsignedSolanaTx
   [ChainFamily.Aptos]: UnsignedAptosTx
   [ChainFamily.TON]: UnsignedTONTx
-  [ChainFamily.Sui]: never // TODO
+  [ChainFamily.Sui]: UnsignedSuiTx
   [ChainFamily.Unknown]: never
 }
 
@@ -1011,6 +1012,25 @@ export abstract class Chain<F extends ChainFamily = ChainFamily> {
     return getOffchainTokenData(request, this)
   }
 
+  /**
+   * Resolves {@link ExecuteOpts} that may contain a `messageId` (API shorthand) into the
+   * canonical `{ offRamp, input }` form required by {@link generateUnsignedExecute}.
+   *
+   * When `opts` already contains `input` the method is a no-op and returns it unchanged.
+   * When `opts` contains only a `messageId` it calls `apiClient.getExecutionInput` and merges
+   * the result back with any extra opts fields (e.g. `gasLimit`).
+   *
+   * @throws {@link CCIPApiClientNotAvailableError} if `messageId` is provided but no apiClient
+   */
+  protected async resolveExecuteOpts(
+    opts: ExecuteOpts,
+  ): Promise<Omit<ExecuteOpts, 'messageId'> & { offRamp: string; input: ExecutionInput }> {
+    if ('input' in opts) return opts
+    if (!this.apiClient) throw new CCIPApiClientNotAvailableError()
+    const { offRamp, ...input } = await this.apiClient.getExecutionInput(opts.messageId)
+    return { ...opts, offRamp, input }
+  }
+
   /**
    * Generate unsigned tx to manuallyExecute a message.
    *

package/src/evm/index.ts

@@ -37,7 +37,6 @@ import {
 } from '../chain.ts'
 import {
   CCIPAddressInvalidEvmError,
-  CCIPApiClientNotAvailableError,
   CCIPBlockNotFoundError,
   CCIPContractNotRouterError,
   CCIPContractTypeInvalidError,
@@ -67,7 +66,6 @@ import {
   type ChainLog,
   type ChainTransaction,
   type CommitReport,
-  type ExecutionInput,
   type ExecutionReceipt,
   type ExecutionState,
   type Lane,
@@ -1140,13 +1138,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 } = await this.resolveExecuteOpts(opts)
     if ('verifications' in input) {
       const contract = new Contract(
         offRamp,

package/src/index.ts

@@ -100,6 +100,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/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/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
+}

package/src/sui/index.ts

@@ -1,5 +1,5 @@
 import { bcs } from '@mysten/sui/bcs'
-import { type SuiTransactionBlockResponse, SuiClient } from '@mysten/sui/client'
+import { SuiClient } from '@mysten/sui/client'
 import type { Keypair } from '@mysten/sui/cryptography'
 import { SuiGraphQLClient } from '@mysten/sui/graphql'
 import { Transaction } from '@mysten/sui/transactions'
@@ -17,20 +17,13 @@ import {
 import { getCcipStateAddress, getOffRampForCcip } from './discovery.ts'
 import { type CommitEvent, streamSuiLogs } from './events.ts'
 import { getSuiLeafHasher } from './hasher.ts'
-import {
-  deriveObjectID,
-  fetchTokenConfigs,
-  getLatestPackageId,
-  getObjectRef,
-  getReceiverModule,
-} from './objects.ts'
+import { deriveObjectID, getLatestPackageId, getObjectRef } from './objects.ts'
 import {
   CCIPArgumentInvalidError,
   CCIPContractNotRouterError,
   CCIPDataFormatUnsupportedError,
   CCIPError,
   CCIPErrorCode,
-  CCIPExecTxRevertedError,
   CCIPExecutionReportChainMismatchError,
   CCIPLogsAddressRequiredError,
   CCIPNotImplementedError,
@@ -47,7 +40,6 @@ import {
   type CCIPExecution,
   type CCIPMessage,
   type CCIPRequest,
-  type CCIPVersion,
   type ChainLog,
   type ChainTransaction,
   type CommitReport,
@@ -67,12 +59,9 @@ import {
   parseTypeAndVersion,
   util,
 } from '../utils.ts'
-import {
-  type SuiManuallyExecuteInput,
-  type TokenConfig,
-  buildManualExecutionPTB,
-} from './manuallyExec/index.ts'
-import type { CCIPMessage_V1_6_Sui } from './types.ts'
+import { generateUnsignedExecutePTB, signAndExecuteSuiTx } from './exec.ts'
+import type { CCIPMessage_V1_6_Sui, UnsignedSuiTx } from './types.ts'
+export type { UnsignedSuiTx }
 
 const DEFAULT_GAS_LIMIT = 1000000n
 
@@ -728,11 +717,28 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
     return Promise.reject(new CCIPNotImplementedError('SuiChain.sendMessage'))
   }
 
-  /** {@inheritDoc Chain.generateUnsignedExecute} */
-  override generateUnsignedExecute(
-    _opts: Parameters<Chain['generateUnsignedExecute']>[0],
-  ): Promise<never> {
-    return Promise.reject(new CCIPNotImplementedError('SuiChain.generateUnsignedExecute'))
+  /**
+   * {@inheritDoc Chain.generateUnsignedExecute}
+   * @throws {@link CCIPExecutionReportChainMismatchError} if input is not a Sui v1.6 execution report
+   */
+  override async generateUnsignedExecute(
+    opts: Parameters<Chain['generateUnsignedExecute']>[0],
+  ): Promise<UnsignedSuiTx> {
+    const resolved = await this.resolveExecuteOpts(opts)
+    if (!resolved.offRamp.includes('::')) resolved.offRamp += '::offramp'
+    if (!('message' in resolved.input)) {
+      throw new CCIPExecutionReportChainMismatchError('Sui')
+    }
+
+    return generateUnsignedExecutePTB(
+      this.client,
+      resolved.offRamp,
+      resolved.input as ExecutionInput<CCIPMessage_V1_6_Sui>,
+      {
+        gasLimit: resolved.gasLimit,
+        receiverObjectIds: (resolved as { receiverObjectIds?: string[] }).receiverObjectIds,
+      },
+    )
   }
 
   /**
@@ -745,94 +751,23 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
       receiverObjectIds?: string[]
     },
   ): Promise<CCIPExecution> {
-    if (!('input' in opts && 'message' in opts.input)) {
-      throw new CCIPExecutionReportChainMismatchError('Sui')
-    }
-    const { input, offRamp } = opts
     const wallet = opts.wallet as Keypair
 
-    // Discover the CCIP package from the offramp
-    const ccip = await getCcipStateAddress(offRamp, this.client)
-
-    const ccipObjectRef = await getObjectRef(ccip, this.client)
-    const offrampStateObject = await getObjectRef(offRamp, this.client)
-    const receiverConfig = await getReceiverModule(
-      this.client,
-      ccip,
-      ccipObjectRef,
-      input.message.receiver,
-    )
-    let tokenConfigs: TokenConfig[] = []
-    if (input.message.tokenAmounts.length !== 0) {
-      tokenConfigs = await fetchTokenConfigs(
-        this.client,
-        ccip,
-        ccipObjectRef,
-        input.message.tokenAmounts as CCIPMessage<typeof CCIPVersion.V1_6>['tokenAmounts'],
-      )
-    }
-
-    const suiInput: SuiManuallyExecuteInput = {
-      executionReport: input as ExecutionInput<CCIPMessage_V1_6_Sui>,
-      offrampAddress: offRamp,
-      ccipAddress: ccip,
-      ccipObjectRef,
-      offrampStateObject,
-      receiverConfig,
-      tokenConfigs,
-    }
     if (opts.receiverObjectIds) {
       this.logger.info(
         `Overriding Sui Manual Execution receiverObjectIds with: ${opts.receiverObjectIds.join(', ')}`,
       )
-      suiInput.overrideReceiverObjectIds = opts.receiverObjectIds
     }
-    const tx = buildManualExecutionPTB(suiInput)
 
-    // Set gas budget if provided
-    if (opts.gasLimit) {
-      tx.setGasBudget(opts.gasLimit)
-    }
-
-    this.logger.info(`Executing Sui CCIP execute transaction...`)
-    // Sign and execute the transaction
-    let result: SuiTransactionBlockResponse
-    try {
-      result = await this.client.signAndExecuteTransaction({
-        signer: wallet,
-        transaction: tx,
-        options: {
-          showEffects: true,
-          showEvents: true,
-        },
-      })
-    } catch (e) {
-      throw new CCIPError(
-        CCIPErrorCode.TRANSACTION_NOT_FINALIZED,
-        `Failed to send Sui execute transaction: ${(e as Error).message}`,
-      )
-    }
-
-    // Check if transaction inmediately reverted
-    if (result.effects?.status.status !== 'success') {
-      const errorMsg = result.effects?.status.error || 'Unknown error'
-      throw new CCIPExecTxRevertedError(result.digest, {
-        context: { error: errorMsg },
-      })
-    }
-
-    this.logger.info(`Waiting for Sui transaction ${result.digest} to be finalized...`)
-
-    await this.client.waitForTransaction({
-      digest: result.digest,
-      options: {
-        showEffects: true,
-        showEvents: true,
-      },
+    const unsignedTx = await this.generateUnsignedExecute({
+      ...opts,
+      payer: '',
     })
 
+    const digest = await signAndExecuteSuiTx(this.client, wallet, unsignedTx, this.logger)
+
     // Return the transaction as a ChainTransaction
-    return this.getExecutionReceiptInTx(await this.getTransaction(result.digest))
+    return this.getExecutionReceiptInTx(await this.getTransaction(digest))
   }
 
   /**

package/src/sui/manuallyExec/index.ts

@@ -4,9 +4,7 @@ import { Transaction } from '@mysten/sui/transactions'
 
 import { serializeExecutionReport } from './encoder.ts'
 import { CCIPMessageInvalidError } from '../../errors/specialized.ts'
-import { decodeExtraArgs } from '../../extra-args.ts'
 import type { ExecutionInput } from '../../types.ts'
-import { networkInfo } from '../../utils.ts'
 import type { CCIPMessage_V1_6_Sui } from '../types.ts'
 
 /** Configuration for manually executing a Sui receiver module. */
@@ -56,12 +54,16 @@ export function buildManualExecutionPTB({
 }: SuiManuallyExecuteInput): Transaction {
   const reportBytes = serializeExecutionReport(executionReport)
 
+  // Strip any ::module suffixes to get bare package IDs for move call targets
+  const offrampPackageId = offrampAddress.split('::')[0]!
+  const ccipPackageId = ccipAddress.split('::')[0]!
+
   // Create transaction
   const tx = new Transaction()
 
   // Step 1: Call manually_init_execute to prepare the execution
   const receiverParamsArg = tx.moveCall({
-    target: `${offrampAddress}::offramp::manually_init_execute`,
+    target: `${offrampPackageId}::offramp::manually_init_execute`,
     arguments: [
       tx.object(ccipObjectRef),
       tx.object(offrampStateObject),
@@ -72,7 +74,7 @@ export function buildManualExecutionPTB({
 
   // Get the message from the from the report using the offramp helper
   const messageArg = tx.moveCall({
-    target: `${ccipAddress}::offramp_state_helper::extract_any2sui_message`,
+    target: `${ccipPackageId}::offramp_state_helper::extract_any2sui_message`,
     arguments: [receiverParamsArg],
   })
 
@@ -96,17 +98,9 @@ export function buildManualExecutionPTB({
     }
   }
 
-  // Decode extraArgs to get receiverObjectIds
-  const decodedExtraArgs = decodeExtraArgs(
-    executionReport.message.extraArgs,
-    networkInfo(executionReport.message.destChainSelector).family,
-  )
-
-  if (!decodedExtraArgs || decodedExtraArgs._tag !== 'SuiExtraArgsV1') {
-    throw new CCIPMessageInvalidError('Expected Sui extra args')
-  }
+  const { receiverObjectIds } = executionReport.message
 
-  if (decodedExtraArgs.receiverObjectIds.length === 0) {
+  if (receiverObjectIds.length === 0) {
     throw new CCIPMessageInvalidError('No receiverObjectIds provided in SUIExtraArgsV1')
   }
   // Call the receiver contract
@@ -116,16 +110,16 @@ export function buildManualExecutionPTB({
       tx.pure.vector('u8', Buffer.from(executionReport.message.messageId.slice(2), 'hex')),
       tx.object(ccipObjectRef),
       messageArg,
-      // if overrideReceiverObjectIds is provided, use them; otherwise, use the ones from decodedExtraArgs (original message)
+      // if overrideReceiverObjectIds is provided, use them; otherwise, use the ones from the message
       ...(overrideReceiverObjectIds && overrideReceiverObjectIds.length > 0
         ? overrideReceiverObjectIds.map(tx.object)
-        : decodedExtraArgs.receiverObjectIds.map(tx.object)),
+        : receiverObjectIds.map(tx.object)),
     ],
   })
 
   // Step 2: Call finish_execute to complete the execution
   tx.moveCall({
-    target: `${offrampAddress}::offramp::finish_execute`,
+    target: `${offrampPackageId}::offramp::finish_execute`,
     arguments: [
       tx.object(ccipObjectRef),
       tx.object(offrampStateObject),

package/src/sui/objects.ts

@@ -135,11 +135,12 @@ export async function getReceiverModule(
   ccipObjectRef: string,
   receiverPackageId: string,
 ) {
+  const ccipBarePackageId = ccipPackageId.split('::')[0]!
   // Call get_receiver_config from receiver_registry contract
   const tx = new Transaction()
 
   tx.moveCall({
-    target: `${ccipPackageId}::receiver_registry::get_receiver_config`,
+    target: `${ccipBarePackageId}::receiver_registry::get_receiver_config`,
     arguments: [tx.object(ccipObjectRef), tx.pure.address(receiverPackageId)],
   })
 
@@ -207,12 +208,13 @@ export async function fetchTokenConfigs(
   ]
 
   // Fetch token config for each unique token address
+  const ccipBarePackageId = ccipPackageId.split('::')[0]!
   for (const tokenAddress of tokenAddresses) {
     const tx = new Transaction()
 
     // Call get_token_config_struct from token_admin_registry
     tx.moveCall({
-      target: `${ccipPackageId}::token_admin_registry::get_token_config_struct`,
+      target: `${ccipBarePackageId}::token_admin_registry::get_token_config_struct`,
       arguments: [tx.object(ccipObjectRef), tx.pure.address(tokenAddress)],
     })
 

package/src/sui/types.ts

@@ -2,12 +2,21 @@ import { bcs } from '@mysten/sui/bcs'
 import { concat } from 'ethers'
 
 import { type SuiExtraArgsV1, SuiExtraArgsV1Tag } from '../extra-args.ts'
-import type { CCIPMessage_V1_6 } from '../types.ts'
+import type { CCIPMessage_V1_6, ChainFamily } from '../types.ts'
 import { getAddressBytes, getDataBytes } from '../utils.ts'
 
 /** Sui-specific CCIP v1.6 message type with Sui extra args. */
 export type CCIPMessage_V1_6_Sui = CCIPMessage_V1_6 & SuiExtraArgsV1
 
+/**
+ * Unsigned Sui transaction, serialized via Transaction#serialize().
+ * Reconstruct with Transaction.from(transactions[0]).
+ */
+export type UnsignedSuiTx = {
+  family: typeof ChainFamily.Sui
+  transactions: [string]
+}
+
 export const SuiExtraArgsV1Codec = bcs.struct('SuiExtraArgsV1', {
   gasLimit: bcs.u64(),
   allowOutOfOrderExecution: bcs.bool(),