@chainlink/ccip-sdk 1.1.0 → 1.2.0

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

package/src/ton/index.ts

@@ -3,7 +3,18 @@ import { Buffer } from 'buffer'
 import { type Transaction, Address, Cell, beginCell, toNano } from '@ton/core'
 import { TonClient } from '@ton/ton'
 import { type AxiosAdapter, getAdapter } from 'axios'
-import { type BytesLike, hexlify, isBytesLike, isHexString, toBeArray, toBeHex } from 'ethers'
+import {
+  type BytesLike,
+  concat,
+  dataLength,
+  dataSlice,
+  hexlify,
+  isBytesLike,
+  isHexString,
+  toBeArray,
+  toBeHex,
+  toBigInt,
+} from 'ethers'
 import { type Memoized, memoize } from 'micro-memoize'
 import type { PickDeep } from 'type-fest'
 
@@ -45,6 +56,7 @@ import {
   bytesToBuffer,
   createRateLimitedFetch,
   decodeAddress,
+  getDataBytes,
   networkInfo,
   parseTypeAndVersion,
   sleep,
@@ -64,6 +76,16 @@ function isTvmError(error: unknown): error is Error & { exitCode: number } {
   return error instanceof Error && 'exitCode' in error && typeof error.exitCode === 'number'
 }
 
+function bitsToBytes(bits: string): Uint8Array {
+  return Uint8Array.from(bits.match(/.{1,8}/g)!.map((byte) => parseInt(byte.padEnd(8, '0'), 2)))
+}
+
+function bytesToBits(bytes: Uint8Array): string {
+  return Array.from(bytes)
+    .map((B) => B.toString(2).padStart(8, '0'))
+    .join('')
+}
+
 /**
  * TON chain implementation supporting TON networks.
  *
@@ -702,14 +724,14 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
    */
   static encodeExtraArgs(args: ExtraArgs): string {
     if ('gasLimit' in args && 'allowOutOfOrderExecution' in args) {
-      const cell = beginCell()
-        .storeUint(Number(EVMExtraArgsV2Tag), 32) // magic tag
-        .storeUint(args.gasLimit, 256) // gasLimit
-        .storeBit(args.allowOutOfOrderExecution) // bool
-        .endCell()
-
-      // Return full BOC including headers
-      return '0x' + cell.toBoc().toString('hex')
+      return concat([
+        EVMExtraArgsV2Tag,
+        bitsToBytes(
+          '1' +
+            bytesToBits(toBeArray(args.gasLimit, 32)) +
+            (args.allowOutOfOrderExecution ? '1' : '0'),
+        ),
+      ])
     }
     return '0x'
   }
@@ -729,25 +751,24 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
   static decodeExtraArgs(
     extraArgs: BytesLike,
   ): (EVMExtraArgsV2 & { _tag: 'EVMExtraArgsV2' }) | undefined {
-    const data = bytesToBuffer(extraArgs)
-
-    try {
-      // Parse BOC format to extract cell data
-      const cell = Cell.fromBoc(data)[0]!
-      const slice = cell.beginParse()
+    if (dataSlice(extraArgs, 0, 4) !== EVMExtraArgsV2Tag || dataLength(extraArgs) < 5) return
+    const data = getDataBytes(extraArgs).subarray(4)
+    let bits = bytesToBits(data)
+    let gasLimit = 0n
+    if (bits[0] === '1') {
+      if (bits.length < 1 + 32 * 8) return
+      gasLimit = toBigInt(bitsToBytes(bits.substring(1, 1 + 32 * 8)))
+      bits = bits.substring(1 + 32 * 8)
+    } else {
+      bits = bits.substring(1)
+    }
 
-      // Load and verify magic tag to ensure correct extra args type
-      const magicTag = slice.loadUint(32)
-      if (magicTag !== Number(EVMExtraArgsV2Tag)) return undefined
+    const allowOutOfOrderExecution = bits[0] === '1'
 
-      return {
-        _tag: 'EVMExtraArgsV2',
-        gasLimit: slice.loadUintBig(256),
-        allowOutOfOrderExecution: slice.loadBit(),
-      }
-    } catch {
-      // Return undefined for any parsing errors (invalid BOC, malformed data, etc.)
-      return undefined
+    return {
+      _tag: 'EVMExtraArgsV2',
+      gasLimit,
+      allowOutOfOrderExecution,
     }
   }
 

package/src/utils.ts

@@ -190,10 +190,16 @@ export const networkInfo = memoize(function networkInfo_(
 
 const BLOCK_RANGE = 10_000
 /**
- * Generates exclusive block ranges [fromBlock, toBlock]
- * If startBlock is given, moves forward from there (up to latestBlock),
- * Otherwise, moves backwards down to genesis (you probably want to break/return before that)
- **/
+ * Generates block ranges for paginated log queries.
+ *
+ * @param params - Range parameters:
+ *   - `singleBlock` - yields a single `{ fromBlock, toBlock }` for that block.
+ *   - `endBlock` + optional `startBlock` - if `startBlock` is given, moves forward
+ *     from there up to `endBlock`; otherwise moves backward from `endBlock` to genesis.
+ *   - `page` - step size per range (default 10 000).
+ * @returns Generator of `{ fromBlock, toBlock }` pairs, optionally with a `progress` percentage
+ *   string when iterating forward.
+ */
 export function* blockRangeGenerator(
   params: { page?: number } & ({ endBlock: number; startBlock?: number } | { singleBlock: number }),
 ) {