@chainlink/ccip-sdk 1.0.0 → 1.1.1

package/src/solana/exec.ts

@@ -198,7 +198,7 @@ async function buildLookupTableIxs(
     lookupTable: new AddressLookupTableAccount({
       key: altAddr,
       state: {
-        deactivationSlot: 2n ** 64n - 1n,
+        deactivationSlot: BigInt(2) ** BigInt(64) - BigInt(1),
         lastExtendedSlot: recentSlot,
         lastExtendedSlotStartIndex: 0,
         addresses,

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,
@@ -1590,6 +1591,23 @@ export class SolanaChain extends Chain<typeof ChainFamily.Solana> {
   static override buildMessageForDest(
     message: Parameters<ChainStatic['buildMessageForDest']>[0],
   ): AnyMessage & { extraArgs: SVMExtraArgsV1 } {
+    /** Valid field names for SVMExtraArgsV1, including recognised aliases. */
+    const SVM_EXTRA_ARGS_FIELDS = new Set([
+      'computeUnits',
+      'gasLimit', // alias for computeUnits
+      'allowOutOfOrderExecution',
+      'tokenReceiver',
+      'accounts',
+      'accountIsWritableBitmap',
+    ])
+    if (message.extraArgs) {
+      const unknown = Object.keys(message.extraArgs).filter((k) => !SVM_EXTRA_ARGS_FIELDS.has(k))
+      if (unknown.length)
+        throw new CCIPArgumentInvalidError(
+          'extraArgs',
+          `unknown field(s) for SVMExtraArgsV1: ${unknown.map((k) => JSON.stringify(k)).join(', ')}`,
+        )
+    }
     if (
       !(
         message.extraArgs &&

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,19 +17,13 @@ import {
 import { getCcipStateAddress, getOffRampForCcip } from './discovery.ts'
 import { type CommitEvent, streamSuiLogs } from './events.ts'
 import { getSuiLeafHasher } from './hasher.ts'
+import { deriveObjectID, getLatestPackageId, getObjectRef } from './objects.ts'
 import {
-  deriveObjectID,
-  fetchTokenConfigs,
-  getLatestPackageId,
-  getObjectRef,
-  getReceiverModule,
-} from './objects.ts'
-import {
+  CCIPArgumentInvalidError,
   CCIPContractNotRouterError,
   CCIPDataFormatUnsupportedError,
   CCIPError,
   CCIPErrorCode,
-  CCIPExecTxRevertedError,
   CCIPExecutionReportChainMismatchError,
   CCIPLogsAddressRequiredError,
   CCIPNotImplementedError,
@@ -46,7 +40,6 @@ import {
   type CCIPExecution,
   type CCIPMessage,
   type CCIPRequest,
-  type CCIPVersion,
   type ChainLog,
   type ChainTransaction,
   type CommitReport,
@@ -66,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
 
@@ -727,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,
+      },
+    )
   }
 
   /**
@@ -744,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))
   }
 
   /**
@@ -881,6 +817,22 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
   static override buildMessageForDest(
     message: Parameters<ChainStatic['buildMessageForDest']>[0],
   ): AnyMessage & { extraArgs: SuiExtraArgsV1 } {
+    /** Valid field names for SuiExtraArgsV1, including recognised aliases. */
+    const SUI_EXTRA_ARGS_FIELDS = new Set([
+      'gasLimit',
+      'allowOutOfOrderExecution',
+      'tokenReceiver',
+      'receiverObjectIds',
+      'accounts', // alias for receiverObjectIds
+    ])
+    if (message.extraArgs) {
+      const unknown = Object.keys(message.extraArgs).filter((k) => !SUI_EXTRA_ARGS_FIELDS.has(k))
+      if (unknown.length)
+        throw new CCIPArgumentInvalidError(
+          'extraArgs',
+          `unknown field(s) for SuiExtraArgsV1: ${unknown.map((k) => JSON.stringify(k)).join(', ')}`,
+        )
+    }
     const gasLimit =
       message.extraArgs && 'gasLimit' in message.extraArgs && message.extraArgs.gasLimit != null
         ? message.extraArgs.gasLimit

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(),

package/src/ton/index.ts

@@ -319,7 +319,11 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
       if (msg.info.type !== 'external-out') continue
       const topics = []
       // logs are external messages where dest "address" is the uint32 topic (e.g. crc32("ExecutionStateChanged"))
-      if (msg.info.dest && msg.info.dest.value > 0n && msg.info.dest.value < 2n ** 32n)
+      if (
+        msg.info.dest &&
+        msg.info.dest.value > 0n &&
+        msg.info.dest.value < BigInt(2) ** BigInt(32)
+      )
         topics.push(toBeHex(msg.info.dest.value, 4))
       let data = ''
       try {