@chainlink/ccip-sdk 0.93.0 → 0.95.0

package/src/sui/index.ts

@@ -1,29 +1,40 @@
-import { toHex } from '@mysten/bcs'
+import { bcs } from '@mysten/sui/bcs'
 import { type SuiTransactionBlockResponse, SuiClient } from '@mysten/sui/client'
 import type { Keypair } from '@mysten/sui/cryptography'
 import { SuiGraphQLClient } from '@mysten/sui/graphql'
 import { Transaction } from '@mysten/sui/transactions'
-import { type BytesLike, AbiCoder, hexlify, isBytesLike } from 'ethers'
-import type { PickDeep } from 'type-fest'
+import { isValidSuiAddress, isValidTransactionDigest, normalizeSuiAddress } from '@mysten/sui/utils'
+import { type BytesLike, dataLength, hexlify, isBytesLike, isHexString } from 'ethers'
+import type { PickDeep, SetOptional } from 'type-fest'
 
 import { AptosChain } from '../aptos/index.ts'
-import { type ChainContext, type LogFilter, Chain } from '../chain.ts'
+import {
+  type ChainContext,
+  type ChainStatic,
+  type GetBalanceOpts,
+  type LogFilter,
+  Chain,
+} from '../chain.ts'
 import {
   CCIPContractNotRouterError,
   CCIPDataFormatUnsupportedError,
   CCIPError,
   CCIPErrorCode,
   CCIPExecTxRevertedError,
-  CCIPExtraArgsInvalidError,
   CCIPNotImplementedError,
-  CCIPSuiMessageVersionInvalidError,
-  CCIPVersionFeatureUnavailableError,
 } from '../errors/index.ts'
-import type { ExtraArgs, SuiExtraArgsV1 } from '../extra-args.ts'
-import { getSuiLeafHasher } from './hasher.ts'
+import {
+  CCIPLogsAddressRequiredError,
+  CCIPSuiLogInvalidError,
+  CCIPTopicsInvalidError,
+} from '../errors/specialized.ts'
+import type { EVMExtraArgsV2, ExtraArgs, SVMExtraArgsV1, SuiExtraArgsV1 } from '../extra-args.ts'
 import type { LeafHasher } from '../hasher/common.ts'
+import { decodeMessage, getMessagesInBatch } from '../requests.ts'
 import { supportedChains } from '../supported-chains.ts'
+import { getSuiLeafHasher } from './hasher.ts'
 import {
+  type AnyMessage,
   type CCIPExecution,
   type CCIPMessage,
   type CCIPRequest,
@@ -40,30 +51,31 @@ import {
   type WithLogger,
   ChainFamily,
 } from '../types.ts'
-import { discoverCCIP, discoverOfframp } from './discovery.ts'
-import type { CCIPMessage_V1_6_Sui } from './types.ts'
-import { bytesToBuffer, decodeAddress, getDataBytes, networkInfo } from '../utils.ts'
-import { type CommitEvent, getSuiEventsInTimeRange } from './events.ts'
+import {
+  decodeAddress,
+  decodeOnRampAddress,
+  getDataBytes,
+  networkInfo,
+  parseTypeAndVersion,
+  util,
+} from '../utils.ts'
+import { getCcipStateAddress, getOffRampForCcip } from './discovery.ts'
+import { type CommitEvent, streamSuiLogs } from './events.ts'
 import {
   type SuiManuallyExecuteInput,
   type TokenConfig,
   buildManualExecutionPTB,
 } from './manuallyExec/index.ts'
 import {
+  deriveObjectID,
   fetchTokenConfigs,
-  getCcipObjectRef,
-  getOffRampStateObject,
+  getLatestPackageId,
+  getObjectRef,
   getReceiverModule,
 } from './objects.ts'
+import type { CCIPMessage_V1_6_Sui } from './types.ts'
 
-export const SUI_EXTRA_ARGS_V1_TAG = '21ea4ca9' as const
-
-type SuiContractDir = {
-  ccip?: string
-  onRamp?: string
-  offRamp?: string
-  router?: string
-}
+const DEFAULT_GAS_LIMIT = 1000000n
 
 /**
  * Sui chain implementation supporting Sui networks.
@@ -80,9 +92,6 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
   readonly client: SuiClient
   readonly graphqlClient: SuiGraphQLClient
 
-  // contracts dir <chainSelectorName, SuiContractDir>
-  readonly contractsDir: SuiContractDir
-
   /**
    * Creates a new SuiChain instance.
    * @param client - Sui client for interacting with the Sui network.
@@ -93,7 +102,6 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
 
     this.client = client
     this.network = network
-    this.contractsDir = {}
 
     // TODO: Graphql client should come from config
     let graphqlUrl: string
@@ -138,17 +146,19 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
       chainId = 'sui:4' // devnet
     } else {
       throw new CCIPError(
-        CCIPErrorCode.NETWORK_FAMILY_UNSUPPORTED,
+        CCIPErrorCode.CHAIN_FAMILY_UNSUPPORTED,
         `Unsupported Sui chain identifier: ${rawChainId}`,
       )
     }
 
     const network = networkInfo(chainId) as NetworkInfo<typeof ChainFamily.Sui>
-    return new SuiChain(client, network, ctx)
+    const chain = new SuiChain(client, network, ctx)
+    return Object.assign(chain, { url })
   }
 
   /** {@inheritDoc Chain.getBlockTimestamp} */
-  async getBlockTimestamp(block: number): Promise<number> {
+  async getBlockTimestamp(block: number | 'finalized'): Promise<number> {
+    if (typeof block !== 'number' || block <= 0) return Math.floor(Date.now() / 1000)
     const checkpoint = await this.client.getCheckpoint({
       id: String(block),
     })
@@ -174,12 +184,12 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
     if (txResponse.events?.length) {
       for (const [i, event] of txResponse.events.entries()) {
         const eventType = event.type
-        const packageId = eventType.split('::')[0]
-        const moduleName = eventType.split('::')[1]
-        const eventName = eventType.split('::')[2]!
+        const splitIdx = eventType.lastIndexOf('::')
+        const address = eventType.substring(0, splitIdx)
+        const eventName = eventType.substring(splitIdx + 2)
 
         events.push({
-          address: `${packageId}::${moduleName}`,
+          address: address,
           transactionHash: digest,
           index: i,
           blockNumber: Number(txResponse.checkpoint || 0),
@@ -200,41 +210,21 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
 
   /** {@inheritDoc Chain.getLogs} */
   async *getLogs(opts: LogFilter & { versionAsHash?: boolean }) {
-    if (!this.contractsDir.offRamp) {
-      throw new CCIPContractNotRouterError('OffRamp address not set in contracts directory', 'Sui')
-    }
+    if (!opts.address) throw new CCIPLogsAddressRequiredError()
+
     // Extract the event type from topics
-    const topic = Array.isArray(opts.topics?.[0]) ? opts.topics[0][0] : opts.topics?.[0] || ''
-    if (!topic || topic !== 'CommitReportAccepted') {
-      throw new CCIPVersionFeatureUnavailableError(
-        'Event type',
-        topic || 'unknown',
-        'CommitReportAccepted',
-      )
+    if (opts.topics?.length !== 1 || typeof opts.topics[0] !== 'string') {
+      throw new CCIPTopicsInvalidError(opts.topics!)
     }
+    const topic = opts.topics[0]
 
-    const startTime = opts.startTime ? new Date(opts.startTime * 1000) : new Date(0)
-    const endTime = opts.endBlock
-      ? new Date(opts.endBlock)
-      : new Date(startTime.getTime() + 1 * 24 * 60 * 60 * 1000) // default to +24h
-
-    this.logger.info(
-      `Fetching Sui events of type ${topic} from ${startTime.toISOString()} to ${endTime.toISOString()}`,
-    )
-    const events = await getSuiEventsInTimeRange<CommitEvent>(
-      this.client,
-      this.graphqlClient,
-      `${this.contractsDir.offRamp}::offramp::CommitReportAccepted`,
-      startTime,
-      endTime,
-    )
-
-    for (const event of events) {
-      const eventData = event.contents.json
+    for await (const event of streamSuiLogs<Record<string, unknown>>(this, opts)) {
+      const eventData = event.contents?.json
+      if (!eventData) continue
       yield {
-        address: this.contractsDir.offRamp,
-        transactionHash: event.transaction?.digest || '',
-        index: 0, // Sui events do not have an index, set to 0
+        address: opts.address,
+        transactionHash: event.transaction!.digest,
+        index: Number(event.sequenceNumber) || 0,
         blockNumber: Number(event.transaction?.effects.checkpoint.sequenceNumber || 0),
         data: eventData,
         topics: [topic],
@@ -242,11 +232,6 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
     }
   }
 
-  /** {@inheritDoc Chain.getMessagesInTx} */
-  override async getMessagesInTx(_tx: string | ChainTransaction): Promise<CCIPRequest[]> {
-    return Promise.reject(new CCIPNotImplementedError('SuiChain.getMessagesInTx'))
-  }
-
   /** {@inheritDoc Chain.getMessagesInBatch} */
   override async getMessagesInBatch<
     R extends PickDeep<
@@ -254,25 +239,45 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
       'lane' | `log.${'topics' | 'address' | 'blockNumber'}` | 'message.sequenceNumber'
     >,
   >(
-    _request: R,
-    _commit: Pick<CommitReport, 'minSeqNr' | 'maxSeqNr'>,
-    _opts?: { page?: number },
+    request: R,
+    commit: Pick<CommitReport, 'minSeqNr' | 'maxSeqNr'>,
+    opts?: { page?: number },
   ): Promise<R['message'][]> {
-    return Promise.reject(new CCIPNotImplementedError('SuiChain.getMessagesInBatch'))
+    return getMessagesInBatch(this, request, commit, opts)
   }
 
   /** {@inheritDoc Chain.typeAndVersion} */
-  async typeAndVersion(_address: string) {
-    return Promise.reject(new CCIPNotImplementedError('SuiChain.typeAndVersion'))
+  async typeAndVersion(address: string) {
+    // requires address to have `::<module>` suffix
+    address = await getLatestPackageId(address, this.client)
+    const target = `${address}::type_and_version`
+
+    // Use the Transaction builder to create a move call
+    const tx = new Transaction()
+    // Add move call to the transaction
+    tx.moveCall({ target, arguments: [] })
+
+    // Execute with devInspectTransactionBlock for read-only call
+    const result = await this.client.devInspectTransactionBlock({
+      sender: '0x0000000000000000000000000000000000000000000000000000000000000000',
+      transactionBlock: tx,
+    })
+
+    if (result.effects.status.status !== 'success' || !result.results?.[0]?.returnValues?.[0]) {
+      throw new CCIPDataFormatUnsupportedError(
+        `Failed to call ${target}: ${result.effects.status.error || 'No return value'}`,
+      )
+    }
+
+    const [data] = result.results[0].returnValues[0]
+    const res = bcs.String.parse(getDataBytes(data))
+    return parseTypeAndVersion(res)
   }
 
   /** {@inheritDoc Chain.getRouterForOnRamp} */
   async getRouterForOnRamp(onRamp: string, _destChainSelector: bigint): Promise<string> {
-    this.contractsDir.onRamp = onRamp
-    if (onRamp !== this.contractsDir.onRamp) {
-      this.contractsDir.onRamp = onRamp
-    }
-    return Promise.resolve(this.contractsDir.onRamp)
+    // In Sui, the router is the onRamp package itself
+    return Promise.resolve(onRamp)
   }
 
   /** {@inheritDoc Chain.getRouterForOffRamp} */
@@ -281,40 +286,40 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
   }
 
   /** {@inheritDoc Chain.getNativeTokenForRouter} */
-  getNativeTokenForRouter(_router: string): Promise<string> {
+  getNativeTokenForRouter(): Promise<string> {
     // SUI native token is always 0x2::sui::SUI
     return Promise.resolve('0x2::sui::SUI')
   }
 
   /** {@inheritDoc Chain.getOffRampsForRouter} */
   async getOffRampsForRouter(router: string, _sourceChainSelector: bigint): Promise<string[]> {
-    const ccip = await discoverCCIP(this.client, router)
-    const offramp = await discoverOfframp(this.client, ccip)
-    this.contractsDir.offRamp = offramp
-    this.contractsDir.ccip = ccip
+    router = await getLatestPackageId(router, this.client)
+    const ccip = await getCcipStateAddress(router, this.client)
+    const offramp = await getOffRampForCcip(ccip, this.client)
     return [offramp]
   }
 
   /** {@inheritDoc Chain.getOnRampForRouter} */
-  getOnRampForRouter(_router: string, _destChainSelector: bigint): Promise<string> {
-    if (!this.contractsDir.onRamp) {
-      throw new CCIPContractNotRouterError('OnRamp address not set in contracts directory', 'Sui')
-    }
-    return Promise.resolve(this.contractsDir.onRamp)
+  getOnRampForRouter(router: string, _destChainSelector: bigint): Promise<string> {
+    // For Sui, the router is the onramp package address
+    return Promise.resolve(router)
   }
 
   /** {@inheritDoc Chain.getOnRampForOffRamp} */
   async getOnRampForOffRamp(offRamp: string, sourceChainSelector: bigint): Promise<string> {
-    if (!this.contractsDir.ccip) {
-      throw new CCIPError(CCIPErrorCode.UNKNOWN, 'CCIP address not set in contracts directory')
-    }
-    const offrampPackageId = offRamp
+    offRamp = await getLatestPackageId(offRamp, this.client)
     const functionName = 'get_source_chain_config'
-    const target = `${offrampPackageId}::offramp::${functionName}`
+    // Preserve module suffix if present, otherwise add it
+    const target = offRamp.includes('::')
+      ? `${offRamp}::${functionName}`
+      : `${offRamp}::offramp::${functionName}`
+
+    // Discover the CCIP package from the offramp
+    const ccip = await getCcipStateAddress(offRamp, this.client)
 
     // Get the OffRampState object
-    const offrampStateObject = await getOffRampStateObject(this.client, offrampPackageId)
-    const ccipObjectRef = await getCcipObjectRef(this.client, this.contractsDir.ccip)
+    const offrampStateObject = await getObjectRef(offRamp, this.client)
+    const ccipObjectRef = await getObjectRef(ccip, this.client)
     // Use the Transaction builder to create a move call
     const tx = new Transaction()
 
@@ -379,43 +384,170 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
   }
 
   /** {@inheritDoc Chain.getTokenForTokenPool} */
-  getTokenForTokenPool(_tokenPool: string): Promise<string> {
-    throw new CCIPNotImplementedError()
+  async getTokenForTokenPool(tokenPool: string): Promise<string> {
+    const normalizedTokenPool = normalizeSuiAddress(tokenPool)
+
+    // Get objects owned by this package (looking for state pointers)
+    const objects = await this.client.getOwnedObjects({
+      owner: normalizedTokenPool,
+      options: { showType: true, showContent: true },
+    })
+
+    const tpType = objects.data
+      .find((obj) => obj.data?.type?.includes('token_pool::'))
+      ?.data?.type?.split('::')[1]
+
+    const allowedTps = ['managed_token_pool', 'burn_mint_token_pool', 'lock_release_token_pool']
+    if (!tpType || !allowedTps.includes(tpType)) {
+      throw new CCIPError(CCIPErrorCode.UNKNOWN, `Invalid token pool type: ${tpType}`)
+    }
+
+    // Find the state pointer object
+    let stateObjectPointerId: string | undefined
+    for (const obj of objects.data) {
+      const content = obj.data?.content
+      if (content?.dataType !== 'moveObject') continue
+
+      const fields = content.fields as Record<string, unknown>
+      // Look for a pointer field that references the state object
+      stateObjectPointerId = fields[`${tpType}_object_id`] as string
+    }
+
+    if (!stateObjectPointerId) {
+      throw new CCIPError(
+        CCIPErrorCode.UNKNOWN,
+        `No token pool state pointer found for ${tokenPool}`,
+      )
+    }
+
+    const stateNamesPerTP: Record<string, string> = {
+      managed_token_pool: 'ManagedTokenPoolState',
+      burn_mint_token_pool: 'BurnMintTokenPoolState',
+      lock_release_token_pool: 'LockReleaseTokenPoolState',
+    }
+
+    const poolStateObject = deriveObjectID(
+      stateObjectPointerId,
+      new TextEncoder().encode(stateNamesPerTP[tpType]),
+    )
+
+    // Get object info to get the coin type
+    const info = await this.client.getObject({
+      id: poolStateObject,
+      options: { showType: true, showContent: true },
+    })
+
+    const type = info.data?.type
+    if (!type) {
+      throw new CCIPError(CCIPErrorCode.UNKNOWN, 'Error loading token pool state object type')
+    }
+
+    // Extract the type parameter T from ManagedTokenPoolState<T>
+    const typeMatch = type.match(/(?:Managed|BurnMint|LockRelease)TokenPoolState<(.+)>$/)
+    if (!typeMatch || !typeMatch[1]) {
+      throw new CCIPError(CCIPErrorCode.UNKNOWN, `Invalid pool state type format: ${type}`)
+    }
+    const tokenType = typeMatch[1]
+
+    // Call get_token function from managed_token_pool contract with the type parameter
+    const target = type.split('<')[0]?.split('::').slice(0, 2).join('::') + '::get_token'
+    if (!target) {
+      throw new CCIPError(CCIPErrorCode.UNKNOWN, `Invalid pool state type format: ${type}`)
+    }
+    const tx = new Transaction()
+    tx.moveCall({
+      target,
+      typeArguments: [tokenType],
+      arguments: [tx.object(poolStateObject)],
+    })
+
+    const result = await this.client.devInspectTransactionBlock({
+      sender: '0x0000000000000000000000000000000000000000000000000000000000000000',
+      transactionBlock: tx,
+    })
+
+    if (result.effects.status.status !== 'success' || !result.results?.[0]?.returnValues?.[0]) {
+      throw new CCIPDataFormatUnsupportedError(
+        `Failed to call ${target}: ${result.effects.status.error || 'No return value'}`,
+      )
+    }
+
+    // Parse the return value to get the coin metadata address (32 bytes)
+    const returnValue = result.results[0].returnValues[0]
+    const [data] = returnValue
+    const coinMetadataBytes = new Uint8Array(data)
+    const coinMetadataAddress = normalizeSuiAddress(hexlify(coinMetadataBytes))
+
+    return coinMetadataAddress
   }
 
   /** {@inheritDoc Chain.getTokenInfo} */
   async getTokenInfo(token: string): Promise<{ symbol: string; decimals: number }> {
-    // Handle native SUI token
-    if (token === '0x2::sui::SUI' || token.includes('::sui::SUI')) {
-      return { symbol: 'SUI', decimals: 9 }
+    const normalizedTokenAddress = normalizeSuiAddress(token)
+    if (!isValidSuiAddress(normalizedTokenAddress)) {
+      throw new CCIPError(CCIPErrorCode.UNKNOWN, 'Error loading Sui token metadata')
     }
 
-    try {
-      // For Coin types, try to fetch metadata from the coin metadata object
-      // Format: 0xPACKAGE::module::TYPE
-      const coinMetadata = await this.client.getCoinMetadata({ coinType: token })
+    const objectResponse = await this.client.getObject({
+      id: normalizedTokenAddress,
+      options: { showType: true },
+    })
 
-      if (coinMetadata) {
-        return {
-          symbol: coinMetadata.symbol || 'UNKNOWN',
-          decimals: coinMetadata.decimals,
-        }
+    const getCoinFromMetadata = (metadata: string) => {
+      // Extract the type parameter from CoinMetadata<...>
+      const match = metadata.match(/CoinMetadata<(.+)>$/)
+
+      if (!match || !match[1]) {
+        throw new CCIPError(CCIPErrorCode.UNKNOWN, `Invalid metadata format: ${metadata}`)
       }
-    } catch (error) {
-      console.log(`Failed to fetch coin metadata for ${token}:`, error)
+
+      return match[1]
     }
 
-    // Fallback: parse from token type string if possible
-    const parts = token.split('::')
-    const symbol = parts[parts.length - 1] || 'UNKNOWN'
+    let coinType: string
+    const objectType = objectResponse.data?.type
+
+    // Check if this is a CoinMetadata object or a coin type string
+    if (objectType?.includes('CoinMetadata')) {
+      coinType = getCoinFromMetadata(objectType)
+    } else if (token.includes('::')) {
+      // This is a coin type string (e.g., "0xabc::coin::COIN")
+      coinType = token
+    } else {
+      // This is a package address or unknown format
+      throw new CCIPError(
+        CCIPErrorCode.UNKNOWN,
+        `Token address ${token} is not a CoinMetadata object or coin type. Expected format: package::module::Type`,
+      )
+    }
+
+    if (coinType.split('::').length < 3) {
+      throw new CCIPError(CCIPErrorCode.UNKNOWN, 'Error loading Sui token metadata')
+    }
+
+    let metadata = null
+    try {
+      metadata = await this.client.getCoinMetadata({ coinType })
+    } catch (e) {
+      console.error('Error fetching coin metadata:', e)
+      throw new CCIPError(CCIPErrorCode.UNKNOWN, 'Error loading Sui token metadata')
+    }
+
+    if (!metadata) {
+      throw new CCIPError(CCIPErrorCode.UNKNOWN, 'Error loading Sui token metadata')
+    }
 
     return {
-      symbol: symbol.toUpperCase(),
-      decimals: 9, // Default to 9 decimals (SUI standard)
+      symbol: metadata.symbol,
+      decimals: metadata.decimals,
     }
   }
 
-  /** {@inheritDoc Chain.getTokenAdminRegistryFor} */
+  /** {@inheritDoc Chain.getBalance} */
+  async getBalance(_opts: GetBalanceOpts): Promise<bigint> {
+    return Promise.reject(new CCIPNotImplementedError('SuiChain.getBalance'))
+  }
+
   /** {@inheritDoc Chain.getTokenAdminRegistryFor} */
   getTokenAdminRegistryFor(_address: string): Promise<string> {
     return Promise.reject(new CCIPNotImplementedError())
@@ -424,11 +556,22 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
   // Static methods for decoding
   /**
    * Decodes a CCIP message from a Sui log event.
-   * @param _log - Log event data.
+   * @param log - Log event data.
    * @returns Decoded CCIPMessage or undefined if not valid.
    */
-  static decodeMessage(_log: Log_): CCIPMessage_V1_6_Sui | undefined {
-    throw new CCIPNotImplementedError()
+  static decodeMessage(log: Log_): CCIPMessage | undefined {
+    const { data } = log
+    if (
+      (typeof data !== 'string' || !data.startsWith('{')) &&
+      (typeof data !== 'object' || isBytesLike(data))
+    )
+      throw new CCIPSuiLogInvalidError(util.inspect(log))
+    // offload massaging to generic decodeJsonMessage
+    try {
+      return decodeMessage(data)
+    } catch (_) {
+      // return undefined
+    }
   }
 
   /**
@@ -438,28 +581,11 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
    */
   static decodeExtraArgs(
     extraArgs: BytesLike,
-  ): (SuiExtraArgsV1 & { _tag: 'SuiExtraArgsV1' }) | undefined {
-    const data = getDataBytes(extraArgs)
-    const hexBytes = toHex(data)
-    if (!hexBytes.startsWith(SUI_EXTRA_ARGS_V1_TAG)) {
-      throw new CCIPExtraArgsInvalidError('Sui', hexBytes)
-    }
-
-    const abiData = '0x' + hexBytes.slice(8)
-    const decoded = AbiCoder.defaultAbiCoder().decode(
-      ['tuple(uint256,bool,bytes32,bytes32[])'],
-      abiData,
-    )
-
-    const tuple = decoded[0] as readonly [bigint, boolean, string, string[]]
-
-    return {
-      gasLimit: tuple[0],
-      allowOutOfOrderExecution: tuple[1],
-      tokenReceiver: tuple[2],
-      receiverObjectIds: tuple[3], // Already an array of hex strings
-      _tag: 'SuiExtraArgsV1',
-    }
+  ):
+    | (EVMExtraArgsV2 & { _tag: 'EVMExtraArgsV2' })
+    | (SVMExtraArgsV1 & { _tag: 'SVMExtraArgsV1' })
+    | undefined {
+    return AptosChain.decodeExtraArgs(extraArgs)
   }
 
   /**
@@ -474,30 +600,36 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
   /**
    * Decodes commit reports from a log entry.
    * @param log - The log entry to decode.
-   * @param _lane - Optional lane information.
+   * @param lane - Optional lane information.
    * @returns Array of decoded commit reports or undefined.
    */
-  static decodeCommits(log: Log_, _lane?: Lane): CommitReport[] | undefined {
-    if (!log.data || typeof log.data !== 'object' || !('unblessed_merkle_roots' in log.data)) {
-      return
-    }
-    const toHexFromBase64 = (b64: string) => '0x' + Buffer.from(b64, 'base64').toString('hex')
-
-    const eventData = log.data as CommitEvent
-    const unblessedRoots = eventData.unblessed_merkle_roots
-    if (!Array.isArray(unblessedRoots) || unblessedRoots.length === 0) {
-      return
-    }
-
-    return unblessedRoots.map((root) => {
-      return {
-        sourceChainSelector: BigInt(root.source_chain_selector),
-        onRampAddress: toHexFromBase64(root.on_ramp_address),
-        minSeqNr: BigInt(root.min_seq_nr),
-        maxSeqNr: BigInt(root.max_seq_nr),
-        merkleRoot: toHexFromBase64(root.merkle_root),
-      }
-    })
+  static decodeCommits(
+    { data, topics }: SetOptional<Pick<Log_, 'data' | 'topics'>, 'topics'>,
+    lane?: Lane,
+  ): CommitReport[] | undefined {
+    // Check if this is an CommitReportAccepted event
+    if (topics?.[0] && topics[0] !== 'CommitReportAccepted') return
+
+    // Basic log data structure validation
+    if (!data || typeof data !== 'object' || !('unblessed_merkle_roots' in data)) return
+
+    const eventData = data as CommitEvent
+    const rootsRaw = eventData.blessed_merkle_roots.concat(eventData.unblessed_merkle_roots)
+    return rootsRaw
+      .map((root) => {
+        return {
+          sourceChainSelector: BigInt(root.source_chain_selector),
+          onRampAddress: decodeOnRampAddress(root.on_ramp_address),
+          minSeqNr: BigInt(root.min_seq_nr),
+          maxSeqNr: BigInt(root.max_seq_nr),
+          merkleRoot: hexlify(getDataBytes(root.merkle_root)),
+        }
+      })
+      .filter((r) =>
+        lane
+          ? r.sourceChainSelector === lane.sourceChainSelector && r.onRampAddress === lane.onRamp
+          : true,
+      )
   }
 
   /**
@@ -505,52 +637,32 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
    * @param log - The log entry to decode.
    * @returns Decoded execution receipt or undefined.
    */
-  static decodeReceipt(log: Log_): ExecutionReceipt | undefined {
+  static decodeReceipt({
+    data,
+    topics,
+  }: SetOptional<Pick<Log_, 'data' | 'topics'>, 'topics'>): ExecutionReceipt | undefined {
     // Check if this is an ExecutionStateChanged event
-    const topic = (Array.isArray(log.topics) ? log.topics[0] : log.topics) as string
-    if (topic !== 'ExecutionStateChanged') {
-      return undefined
-    }
-
-    // Validate log data structure
-    if (!log.data || typeof log.data !== 'object') {
-      return undefined
-    }
+    if (topics?.[0] && topics[0] !== 'ExecutionStateChanged') return
 
-    const eventData = log.data as {
-      message_hash?: number[]
-      message_id?: number[]
-      sequence_number?: string
-      source_chain_selector?: string
-      state?: number
+    // Basic log data structure validation
+    if (!data || typeof data !== 'object' || !('message_id' in data) || !('state' in data)) {
+      return
     }
 
-    // Verify required fields exist
-    if (
-      !eventData.message_id ||
-      !Array.isArray(eventData.message_id) ||
-      eventData.sequence_number === undefined ||
-      eventData.state === undefined
-    ) {
-      return undefined
+    const eventData = data as {
+      message_hash: BytesLike
+      message_id: BytesLike
+      sequence_number: string
+      source_chain_selector: string
+      state: number
     }
 
-    const toHex = (bytes: BytesLike | number[]) => hexlify(bytesToBuffer(bytes))
-
-    // Convert message_id bytes array to hex string
-    const messageId = toHex(eventData.message_id)
-
-    // Convert message_hash bytes array to hex string (if present)
-    const messageHash = eventData.message_hash ? toHex(eventData.message_hash) : undefined
-
     return {
-      messageId,
+      messageId: hexlify(getDataBytes(eventData.message_id)),
       sequenceNumber: BigInt(eventData.sequence_number),
-      state: eventData.state as ExecutionState,
-      sourceChainSelector: eventData.source_chain_selector
-        ? BigInt(eventData.source_chain_selector)
-        : undefined,
-      messageHash,
+      state: Number(eventData.state) as ExecutionState,
+      sourceChainSelector: BigInt(eventData.source_chain_selector),
+      messageHash: hexlify(getDataBytes(eventData.message_hash)),
     }
   }
 
@@ -559,15 +671,17 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
    * @param bytes - Bytes to convert.
    * @returns Sui address.
    */
-  static getAddress(bytes: BytesLike): string {
+  static getAddress(bytes: BytesLike | readonly number[]): string {
     return AptosChain.getAddress(bytes)
   }
 
   /**
    * Validates a transaction hash format for Sui
    */
-  static isTxHash(_v: unknown): _v is string {
-    return false
+  static isTxHash(v: unknown): v is string {
+    if (typeof v !== 'string') return false
+    // check in both hex and base58 formats
+    return isHexString(v, 32) || isValidTransactionDigest(v)
   }
 
   /**
@@ -598,9 +712,6 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
 
   /** {@inheritDoc Chain.getOffchainTokenData} */
   getOffchainTokenData(request: CCIPRequest): Promise<OffchainTokenData[]> {
-    if (!('receiverObjectIds' in request.message)) {
-      throw new CCIPSuiMessageVersionInvalidError()
-    }
     // default offchain token data
     return Promise.resolve(request.message.tokenAmounts.map(() => undefined))
   }
@@ -618,19 +729,17 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
       receiverObjectIds?: string[]
     },
   ): Promise<CCIPExecution> {
-    const { execReport } = opts
-    if (!this.contractsDir.offRamp || !this.contractsDir.ccip) {
-      throw new CCIPContractNotRouterError(
-        'OffRamp or CCIP address not set in contracts directory',
-        'Sui',
-      )
-    }
+    const { execReport, offRamp } = opts
     const wallet = opts.wallet as Keypair
-    const ccipObjectRef = await getCcipObjectRef(this.client, this.contractsDir.ccip)
-    const offrampStateObject = await getOffRampStateObject(this.client, this.contractsDir.offRamp)
+
+    // 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,
-      this.contractsDir.ccip,
+      ccip,
       ccipObjectRef,
       execReport.message.receiver,
     )
@@ -638,7 +747,7 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
     if (execReport.message.tokenAmounts.length !== 0) {
       tokenConfigs = await fetchTokenConfigs(
         this.client,
-        this.contractsDir.ccip,
+        ccip,
         ccipObjectRef,
         execReport.message.tokenAmounts as CCIPMessage<typeof CCIPVersion.V1_6>['tokenAmounts'],
       )
@@ -646,8 +755,8 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
 
     const input: SuiManuallyExecuteInput = {
       executionReport: execReport as ExecutionReport<CCIPMessage_V1_6_Sui>,
-      offrampAddress: this.contractsDir.offRamp,
-      ccipAddress: this.contractsDir.ccip,
+      offrampAddress: offRamp,
+      ccipAddress: ccip,
       ccipObjectRef,
       offrampStateObject,
       receiverConfig,
@@ -743,4 +852,52 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
   async getFeeTokens(_router: string): Promise<never> {
     return Promise.reject(new CCIPNotImplementedError('SuiChain.getFeeTokens'))
   }
+
+  /** {@inheritDoc ChainStatic.buildMessageForDest} */
+  static override buildMessageForDest(
+    message: Parameters<ChainStatic['buildMessageForDest']>[0],
+  ): AnyMessage & { extraArgs: SuiExtraArgsV1 } {
+    const gasLimit =
+      message.extraArgs && 'gasLimit' in message.extraArgs && message.extraArgs.gasLimit != null
+        ? message.extraArgs.gasLimit
+        : message.data && dataLength(message.data)
+          ? DEFAULT_GAS_LIMIT
+          : 0n
+    const allowOutOfOrderExecution =
+      message.extraArgs &&
+      'allowOutOfOrderExecution' in message.extraArgs &&
+      message.extraArgs.allowOutOfOrderExecution != null
+        ? message.extraArgs.allowOutOfOrderExecution
+        : true
+    const tokenReceiver =
+      message.extraArgs &&
+      'tokenReceiver' in message.extraArgs &&
+      message.extraArgs.tokenReceiver != null
+        ? message.extraArgs.tokenReceiver
+        : message.tokenAmounts?.length
+          ? this.getAddress(message.receiver)
+          : '0x0000000000000000000000000000000000000000000000000000000000000000'
+    const receiverObjectIds =
+      message.extraArgs &&
+      'receiverObjectIds' in message.extraArgs &&
+      message.extraArgs.receiverObjectIds?.length
+        ? message.extraArgs.receiverObjectIds
+        : message.extraArgs && 'accounts' in message.extraArgs && message.extraArgs.accounts?.length
+          ? message.extraArgs.accounts // populates receiverObjectIds from accounts
+          : []
+    const extraArgs: SuiExtraArgsV1 = {
+      gasLimit,
+      allowOutOfOrderExecution,
+      tokenReceiver,
+      receiverObjectIds,
+    }
+    return {
+      ...message,
+      extraArgs,
+      // if tokenReceiver, then message.receiver can (must?) be default
+      ...(!!message.tokenAmounts?.length && {
+        receiver: '0x0000000000000000000000000000000000000000000000000000000000000000',
+      }),
+    }
+  }
 }