@chainlink/ccip-sdk 0.94.0 → 0.96.0

package/dist/sui/index.js

@@ -1,20 +1,22 @@
-import { Buffer } from 'buffer';
+import { bcs } from '@mysten/sui/bcs';
 import { SuiClient } from '@mysten/sui/client';
 import { SuiGraphQLClient } from '@mysten/sui/graphql';
 import { Transaction } from '@mysten/sui/transactions';
-import { dataLength, hexlify, isBytesLike } from 'ethers';
+import { isValidSuiAddress, isValidTransactionDigest, normalizeSuiAddress } from '@mysten/sui/utils';
+import { dataLength, hexlify, isBytesLike, isHexString } from 'ethers';
 import { AptosChain } from "../aptos/index.js";
-import { Chain } from "../chain.js";
-import { CCIPContractNotRouterError, CCIPDataFormatUnsupportedError, CCIPError, CCIPErrorCode, CCIPExecTxRevertedError, CCIPNotImplementedError, CCIPSuiMessageVersionInvalidError, CCIPVersionFeatureUnavailableError, } from "../errors/index.js";
-import { getSuiLeafHasher } from "./hasher.js";
+import { Chain, } from "../chain.js";
+import { CCIPContractNotRouterError, CCIPDataFormatUnsupportedError, CCIPError, CCIPErrorCode, CCIPExecTxRevertedError, CCIPNotImplementedError, } from "../errors/index.js";
+import { CCIPLogsAddressRequiredError, CCIPSuiLogInvalidError, CCIPTopicsInvalidError, } from "../errors/specialized.js";
+import { decodeMessage, getMessagesInBatch } from "../requests.js";
 import { supportedChains } from "../supported-chains.js";
+import { getSuiLeafHasher } from "./hasher.js";
 import { ChainFamily, } from "../types.js";
-import { discoverCCIP, discoverOfframp } from "./discovery.js";
-import { bytesToBuffer, decodeAddress, networkInfo } from "../utils.js";
-import { getSuiEventsInTimeRange } from "./events.js";
+import { decodeAddress, decodeOnRampAddress, getDataBytes, networkInfo, parseTypeAndVersion, util, } from "../utils.js";
+import { getCcipStateAddress, getOffRampForCcip } from "./discovery.js";
+import { streamSuiLogs } from "./events.js";
 import { buildManualExecutionPTB, } from "./manuallyExec/index.js";
-import { fetchTokenConfigs, getCcipObjectRef, getOffRampStateObject, getReceiverModule, } from "./objects.js";
-export const SUI_EXTRA_ARGS_V1_TAG = '21ea4ca9';
+import { deriveObjectID, fetchTokenConfigs, getLatestPackageId, getObjectRef, getReceiverModule, } from "./objects.js";
 const DEFAULT_GAS_LIMIT = 1000000n;
 /**
  * Sui chain implementation supporting Sui networks.
@@ -29,8 +31,6 @@ export class SuiChain extends Chain {
     network;
     client;
     graphqlClient;
-    // contracts dir <chainSelectorName, SuiContractDir>
-    contractsDir;
     /**
      * Creates a new SuiChain instance.
      * @param client - Sui client for interacting with the Sui network.
@@ -40,7 +40,6 @@ export class SuiChain extends Chain {
         super(network, ctx);
         this.client = client;
         this.network = network;
-        this.contractsDir = {};
         // TODO: Graphql client should come from config
         let graphqlUrl;
         if (this.network.name === 'sui-mainnet') {
@@ -63,6 +62,8 @@ export class SuiChain extends Chain {
      * Creates a SuiChain instance from an RPC URL.
      * @param url - HTTP or WebSocket endpoint URL for the Sui network.
      * @returns A new SuiChain instance.
+     * @throws {@link CCIPDataFormatUnsupportedError} if unable to fetch chain identifier
+     * @throws {@link CCIPError} if chain identifier is not supported
      */
     static async fromUrl(url, ctx) {
         const client = new SuiClient({ url });
@@ -84,13 +85,16 @@ export class SuiChain extends Chain {
             chainId = 'sui:4'; // devnet
         }
         else {
-            throw new CCIPError(CCIPErrorCode.NETWORK_FAMILY_UNSUPPORTED, `Unsupported Sui chain identifier: ${rawChainId}`);
+            throw new CCIPError(CCIPErrorCode.CHAIN_FAMILY_UNSUPPORTED, `Unsupported Sui chain identifier: ${rawChainId}`);
         }
         const network = networkInfo(chainId);
-        return new SuiChain(client, network, ctx);
+        const chain = new SuiChain(client, network, ctx);
+        return Object.assign(chain, { url });
     }
     /** {@inheritDoc Chain.getBlockTimestamp} */
     async getBlockTimestamp(block) {
+        if (typeof block !== 'number' || block <= 0)
+            return Math.floor(Date.now() / 1000);
         const checkpoint = await this.client.getCheckpoint({
             id: String(block),
         });
@@ -113,11 +117,11 @@ export class SuiChain extends Chain {
         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),
@@ -134,89 +138,106 @@ export class SuiChain extends Chain {
             from: txResponse.transaction?.data.sender || '',
         };
     }
-    /** {@inheritDoc Chain.getLogs} */
+    /**
+     * {@inheritDoc Chain.getLogs}
+     * @throws {@link CCIPLogsAddressRequiredError} if address is not provided
+     * @throws {@link CCIPTopicsInvalidError} if topics format is invalid
+     */
     async *getLogs(opts) {
-        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');
-        }
-        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(this.client, this.graphqlClient, `${this.contractsDir.offRamp}::offramp::CommitReportAccepted`, startTime, endTime);
-        for (const event of events) {
-            const eventData = event.contents.json;
+        if (opts.topics?.length !== 1 || typeof opts.topics[0] !== 'string') {
+            throw new CCIPTopicsInvalidError(opts.topics);
+        }
+        const topic = opts.topics[0];
+        for await (const event of streamSuiLogs(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],
             };
         }
     }
-    /** {@inheritDoc Chain.getMessagesInTx} */
-    async getMessagesInTx(_tx) {
-        return Promise.reject(new CCIPNotImplementedError('SuiChain.getMessagesInTx'));
-    }
     /** {@inheritDoc Chain.getMessagesInBatch} */
-    async getMessagesInBatch(_request, _commit, _opts) {
-        return Promise.reject(new CCIPNotImplementedError('SuiChain.getMessagesInBatch'));
+    async getMessagesInBatch(request, commit, opts) {
+        return getMessagesInBatch(this, request, commit, opts);
     }
-    /** {@inheritDoc Chain.typeAndVersion} */
-    async typeAndVersion(_address) {
-        return Promise.reject(new CCIPNotImplementedError('SuiChain.typeAndVersion'));
+    /**
+     * {@inheritDoc Chain.typeAndVersion}
+     * @throws {@link CCIPDataFormatUnsupportedError} if view call fails
+     */
+    async typeAndVersion(address) {
+        // 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, _destChainSelector) {
-        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} */
+    /**
+     * {@inheritDoc Chain.getRouterForOffRamp}
+     * @throws {@link CCIPContractNotRouterError} always (Sui architecture doesn't have separate router)
+     */
     getRouterForOffRamp(offRamp, _sourceChainSelector) {
         throw new CCIPContractNotRouterError(offRamp, 'unknown');
     }
     /** {@inheritDoc Chain.getNativeTokenForRouter} */
-    getNativeTokenForRouter(_router) {
+    getNativeTokenForRouter() {
         // SUI native token is always 0x2::sui::SUI
         return Promise.resolve('0x2::sui::SUI');
     }
     /** {@inheritDoc Chain.getOffRampsForRouter} */
     async getOffRampsForRouter(router, _sourceChainSelector) {
-        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, _destChainSelector) {
-        if (!this.contractsDir.onRamp) {
-            throw new CCIPContractNotRouterError('OnRamp address not set in contracts directory', 'Sui');
-        }
-        return Promise.resolve(this.contractsDir.onRamp);
+    getOnRampForRouter(router, _destChainSelector) {
+        // For Sui, the router is the onramp package address
+        return Promise.resolve(router);
     }
-    /** {@inheritDoc Chain.getOnRampForOffRamp} */
+    /**
+     * {@inheritDoc Chain.getOnRampForOffRamp}
+     * @throws {@link CCIPDataFormatUnsupportedError} if view call fails
+     */
     async getOnRampForOffRamp(offRamp, sourceChainSelector) {
-        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();
         // Add move call to the transaction with OffRampState object and source chain selector
@@ -265,39 +286,142 @@ export class SuiChain extends Chain {
     getCommitStoreForOffRamp(offRamp) {
         return Promise.resolve(offRamp);
     }
-    /** {@inheritDoc Chain.getTokenForTokenPool} */
-    getTokenForTokenPool(_tokenPool) {
-        throw new CCIPNotImplementedError();
+    /**
+     * {@inheritDoc Chain.getTokenForTokenPool}
+     * @throws {@link CCIPError} if token pool type is invalid or state not found
+     * @throws {@link CCIPDataFormatUnsupportedError} if view call fails
+     */
+    async getTokenForTokenPool(tokenPool) {
+        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;
+        for (const obj of objects.data) {
+            const content = obj.data?.content;
+            if (content?.dataType !== 'moveObject')
+                continue;
+            const fields = content.fields;
+            // Look for a pointer field that references the state object
+            stateObjectPointerId = fields[`${tpType}_object_id`];
+        }
+        if (!stateObjectPointerId) {
+            throw new CCIPError(CCIPErrorCode.UNKNOWN, `No token pool state pointer found for ${tokenPool}`);
+        }
+        const stateNamesPerTP = {
+            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} */
+    /**
+     * {@inheritDoc Chain.getTokenInfo}
+     * @throws {@link CCIPError} if token address is invalid or metadata cannot be loaded
+     */
     async getTokenInfo(token) {
-        // 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 });
-            if (coinMetadata) {
-                return {
-                    symbol: coinMetadata.symbol || 'UNKNOWN',
-                    decimals: coinMetadata.decimals,
-                };
+        const objectResponse = await this.client.getObject({
+            id: normalizedTokenAddress,
+            options: { showType: true },
+        });
+        const getCoinFromMetadata = (metadata) => {
+            // Extract the type parameter from CoinMetadata<...>
+            const match = metadata.match(/CoinMetadata<(.+)>$/);
+            if (!match || !match[1]) {
+                throw new CCIPError(CCIPErrorCode.UNKNOWN, `Invalid metadata format: ${metadata}`);
             }
+            return match[1];
+        };
+        let coinType;
+        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');
         }
-        catch (error) {
-            console.log(`Failed to fetch coin metadata for ${token}:`, error);
+        if (!metadata) {
+            throw new CCIPError(CCIPErrorCode.UNKNOWN, 'Error loading Sui token metadata');
         }
-        // Fallback: parse from token type string if possible
-        const parts = token.split('::');
-        const symbol = parts[parts.length - 1] || 'UNKNOWN';
         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) {
+        return Promise.reject(new CCIPNotImplementedError('SuiChain.getBalance'));
+    }
     /** {@inheritDoc Chain.getTokenAdminRegistryFor} */
     getTokenAdminRegistryFor(_address) {
         return Promise.reject(new CCIPNotImplementedError());
@@ -305,11 +429,22 @@ export class SuiChain extends Chain {
     // 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.
+     * @throws {@link CCIPSuiLogInvalidError} if log data format is invalid
      */
-    static decodeMessage(_log) {
-        throw new CCIPNotImplementedError();
+    static decodeMessage(log) {
+        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
+        }
     }
     /**
      * Decodes extra arguments from Sui CCIP messages.
@@ -323,6 +458,7 @@ export class SuiChain extends Chain {
      * Encodes extra arguments for CCIP messages.
      * @param _extraArgs - Extra arguments to encode.
      * @returns Encoded extra arguments as a hex string.
+     * @throws {@link CCIPNotImplementedError} always (not yet implemented)
      */
     static encodeExtraArgs(_extraArgs) {
         throw new CCIPNotImplementedError();
@@ -330,65 +466,52 @@ export class SuiChain extends Chain {
     /**
      * 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, _lane) {
-        if (!log.data || typeof log.data !== 'object' || !('unblessed_merkle_roots' in log.data)) {
+    static decodeCommits({ data, topics }, lane) {
+        // Check if this is an CommitReportAccepted event
+        if (topics?.[0] && topics[0] !== 'CommitReportAccepted')
             return;
-        }
-        const toHexFromBase64 = (b64) => '0x' + Buffer.from(b64, 'base64').toString('hex');
-        const eventData = log.data;
-        const unblessedRoots = eventData.unblessed_merkle_roots;
-        if (!Array.isArray(unblessedRoots) || unblessedRoots.length === 0) {
+        // Basic log data structure validation
+        if (!data || typeof data !== 'object' || !('unblessed_merkle_roots' in data))
             return;
-        }
-        return unblessedRoots.map((root) => {
+        const eventData = data;
+        const rootsRaw = eventData.blessed_merkle_roots.concat(eventData.unblessed_merkle_roots);
+        return rootsRaw
+            .map((root) => {
             return {
                 sourceChainSelector: BigInt(root.source_chain_selector),
-                onRampAddress: toHexFromBase64(root.on_ramp_address),
+                onRampAddress: decodeOnRampAddress(root.on_ramp_address),
                 minSeqNr: BigInt(root.min_seq_nr),
                 maxSeqNr: BigInt(root.max_seq_nr),
-                merkleRoot: toHexFromBase64(root.merkle_root),
+                merkleRoot: hexlify(getDataBytes(root.merkle_root)),
             };
-        });
+        })
+            .filter((r) => lane
+            ? r.sourceChainSelector === lane.sourceChainSelector && r.onRampAddress === lane.onRamp
+            : true);
     }
     /**
      * Decodes an execution receipt from a log entry.
      * @param log - The log entry to decode.
      * @returns Decoded execution receipt or undefined.
      */
-    static decodeReceipt(log) {
+    static decodeReceipt({ data, topics, }) {
         // Check if this is an ExecutionStateChanged event
-        const topic = (Array.isArray(log.topics) ? log.topics[0] : log.topics);
-        if (topic !== 'ExecutionStateChanged') {
-            return undefined;
-        }
-        // Validate log data structure
-        if (!log.data || typeof log.data !== 'object') {
-            return undefined;
-        }
-        const eventData = log.data;
-        // Verify required fields exist
-        if (!eventData.message_id ||
-            !Array.isArray(eventData.message_id) ||
-            eventData.sequence_number === undefined ||
-            eventData.state === undefined) {
-            return undefined;
-        }
-        const toHex = (bytes) => 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;
+        if (topics?.[0] && topics[0] !== 'ExecutionStateChanged')
+            return;
+        // Basic log data structure validation
+        if (!data || typeof data !== 'object' || !('message_id' in data) || !('state' in data)) {
+            return;
+        }
+        const eventData = data;
         return {
-            messageId,
+            messageId: hexlify(getDataBytes(eventData.message_id)),
             sequenceNumber: BigInt(eventData.sequence_number),
-            state: eventData.state,
-            sourceChainSelector: eventData.source_chain_selector
-                ? BigInt(eventData.source_chain_selector)
-                : undefined,
-            messageHash,
+            state: Number(eventData.state),
+            sourceChainSelector: BigInt(eventData.source_chain_selector),
+            messageHash: hexlify(getDataBytes(eventData.message_hash)),
         };
     }
     /**
@@ -402,8 +525,11 @@ export class SuiChain extends Chain {
     /**
      * Validates a transaction hash format for Sui
      */
-    static isTxHash(_v) {
-        return false;
+    static isTxHash(v) {
+        if (typeof v !== 'string')
+            return false;
+        // check in both hex and base58 formats
+        return isHexString(v, 32) || isValidTransactionDigest(v);
     }
     /**
      * Gets the leaf hasher for Sui destination chains.
@@ -427,9 +553,6 @@ export class SuiChain extends Chain {
     }
     /** {@inheritDoc Chain.getOffchainTokenData} */
     getOffchainTokenData(request) {
-        if (!('receiverObjectIds' in request.message)) {
-            throw new CCIPSuiMessageVersionInvalidError();
-        }
         // default offchain token data
         return Promise.resolve(request.message.tokenAmounts.map(() => undefined));
     }
@@ -437,24 +560,27 @@ export class SuiChain extends Chain {
     generateUnsignedExecuteReport(_opts) {
         return Promise.reject(new CCIPNotImplementedError('SuiChain.generateUnsignedExecuteReport'));
     }
-    /** {@inheritDoc Chain.executeReport} */
+    /**
+     * {@inheritDoc Chain.executeReport}
+     * @throws {@link CCIPError} if transaction submission fails
+     * @throws {@link CCIPExecTxRevertedError} if transaction reverts
+     */
     async executeReport(opts) {
-        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;
-        const ccipObjectRef = await getCcipObjectRef(this.client, this.contractsDir.ccip);
-        const offrampStateObject = await getOffRampStateObject(this.client, this.contractsDir.offRamp);
-        const receiverConfig = await getReceiverModule(this.client, this.contractsDir.ccip, ccipObjectRef, execReport.message.receiver);
+        // 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, execReport.message.receiver);
         let tokenConfigs = [];
         if (execReport.message.tokenAmounts.length !== 0) {
-            tokenConfigs = await fetchTokenConfigs(this.client, this.contractsDir.ccip, ccipObjectRef, execReport.message.tokenAmounts);
+            tokenConfigs = await fetchTokenConfigs(this.client, ccip, ccipObjectRef, execReport.message.tokenAmounts);
         }
         const input = {
             executionReport: execReport,
-            offrampAddress: this.contractsDir.offRamp,
-            ccipAddress: this.contractsDir.ccip,
+            offrampAddress: offRamp,
+            ccipAddress: ccip,
             ccipObjectRef,
             offrampStateObject,
             receiverConfig,
@@ -523,9 +649,9 @@ export class SuiChain extends Chain {
     async getRegistryTokenConfig(_address, _tokenName) {
         return Promise.reject(new CCIPNotImplementedError('SuiChain.getRegistryTokenConfig'));
     }
-    /** {@inheritDoc Chain.getTokenPoolConfigs} */
-    async getTokenPoolConfigs(_tokenPool) {
-        return Promise.reject(new CCIPNotImplementedError('SuiChain.getTokenPoolConfigs'));
+    /** {@inheritDoc Chain.getTokenPoolConfig} */
+    async getTokenPoolConfig(_tokenPool) {
+        return Promise.reject(new CCIPNotImplementedError('SuiChain.getTokenPoolConfig'));
     }
     /** {@inheritDoc Chain.getTokenPoolRemotes} */
     async getTokenPoolRemotes(_tokenPool) {
@@ -549,7 +675,8 @@ export class SuiChain extends Chain {
             : true;
         const tokenReceiver = message.extraArgs &&
             'tokenReceiver' in message.extraArgs &&
-            message.extraArgs.tokenReceiver != null
+            message.extraArgs.tokenReceiver != null &&
+            typeof message.extraArgs.tokenReceiver === 'string'
             ? message.extraArgs.tokenReceiver
             : message.tokenAmounts?.length
                 ? this.getAddress(message.receiver)