@chainlink/ccip-sdk 0.94.0 → 0.96.0

package/src/sui/objects.ts

@@ -5,9 +5,17 @@ import type { SuiClient } from '@mysten/sui/client'
 import { Transaction } from '@mysten/sui/transactions'
 import { normalizeSuiAddress } from '@mysten/sui/utils'
 import { blake2b } from '@noble/hashes/blake2.js'
+import { hexlify, toUtf8Bytes } from 'ethers'
+import { memoize } from 'micro-memoize'
 
 import { CCIPDataFormatUnsupportedError } from '../errors/index.ts'
 import type { CCIPMessage, CCIPVersion } from '../types.ts'
+import { toLeArray } from '../utils.ts'
+
+const bcsBytes = (bytes: Uint8Array) => bcs.vector(bcs.u8()).serialize(bytes).toBytes()
+
+const HASHING_INTENT_SCOPE_CHILD_OBJECT_ID = 0xf0
+const SUI_FRAMEWORK_ADDRESS = '0x2'
 
 /**
  * Derive a dynamic field object ID using the Sui algorithm
@@ -19,27 +27,24 @@ export function deriveObjectID(parentAddress: string, keyBytes: Uint8Array): str
   const parentBytes = bcs.Address.serialize(normalizedParent).toBytes()
 
   // BCS serialize the key (vector<u8>)
-  const bcsKeyBytes = bcs.vector(bcs.u8()).serialize(Array.from(keyBytes)).toBytes()
+  const bcsKeyBytes = bcsBytes(keyBytes)
+  const keyLenBytes = toLeArray(bcsKeyBytes.length, 8) // uint64
 
   // Construct TypeTag for DerivedObjectKey<vector<u8>>
-  const suiFrameworkAddress = bcs.Address.serialize('0x2').toBytes()
+  const suiFrameworkAddress = bcs.Address.serialize(SUI_FRAMEWORK_ADDRESS).toBytes()
   const typeTagBytes = new Uint8Array([
     0x07, // TypeTag::Struct
     ...suiFrameworkAddress,
-    0x0e, // module length
-    ...new TextEncoder().encode('derived_object'),
-    0x10, // struct name length
-    ...new TextEncoder().encode('DerivedObjectKey'),
+    ...bcsBytes(toUtf8Bytes('derived_object')), //module
+    ...bcsBytes(toUtf8Bytes('DerivedObjectKey')), // struct name
     0x01, // type params count
-    ...[0x06, 0x01], // vector<u8> TypeTag
+    0x06, // TypeTag::Vector
+    0x01, // TypeTag::U8
   ])
 
   // Build the hash input
-  const keyLenBytes = new Uint8Array(8)
-  new DataView(keyLenBytes.buffer).setBigUint64(0, BigInt(bcsKeyBytes.length), true)
-
   const hashInput = new Uint8Array([
-    0xf0, // HashingIntentScope::ChildObjectId
+    HASHING_INTENT_SCOPE_CHILD_OBJECT_ID,
     ...parentBytes,
     ...keyLenBytes,
     ...bcsKeyBytes,
@@ -49,101 +54,72 @@ export function deriveObjectID(parentAddress: string, keyBytes: Uint8Array): str
   // Hash with Blake2b-256
   const hash = blake2b(hashInput, { dkLen: 32 })
 
-  // Convert to address string
-  return normalizeSuiAddress('0x' + Buffer.from(hash).toString('hex'))
+  return hexlify(hash)
 }
 
 /**
- * Get the CCIPObjectRef ID for a CCIP package
+ * Finds the StatePointer object owned by a package.
+ * The StatePointer contains a reference to the parent object used for derivation.
  */
-export async function getCcipObjectRef(client: SuiClient, ccipPackageId: string): Promise<string> {
-  // Get the pointer to find the CCIPObject ID
-  const pointerResponse = await client.getOwnedObjects({
-    owner: ccipPackageId,
-    filter: {
-      StructType: `${ccipPackageId}::state_object::CCIPObjectRefPointer`,
-    },
-  })
-
-  if (!pointerResponse.data.length) {
-    throw new CCIPDataFormatUnsupportedError(
-      'No CCIPObjectRefPointer found for the given packageId',
-    )
-  }
-
-  // Get the pointer object to extract ccip_object_id
-  const pointerId = pointerResponse.data[0]!.data?.objectId
-  if (!pointerId) {
-    throw new CCIPDataFormatUnsupportedError('Pointer does not have objectId')
-  }
-
-  const pointerObject = await client.getObject({
-    id: pointerId,
-    options: { showContent: true },
-  })
-
-  if (pointerObject.data?.content?.dataType !== 'moveObject') {
-    throw new CCIPDataFormatUnsupportedError('Pointer object is not a Move object')
-  }
-
-  const ccipObjectId = (pointerObject.data.content.fields as Record<string, unknown>)[
-    'ccip_object_id'
-  ] as string
-
-  if (!ccipObjectId) {
-    throw new CCIPDataFormatUnsupportedError('Could not find ccip_object_id in pointer')
-  }
+export const getObjectRef = memoize(
+  async function getPackageIds_(address: string, client: SuiClient): Promise<string> {
+    let stateObjectName
+    if (address.endsWith('::onramp')) stateObjectName = 'OnRampState'
+    else if (address.endsWith('::offramp')) stateObjectName = 'OffRampState'
+    else stateObjectName = 'CCIPObjectRef'
+
+    const fullStatePointerType = `${address}::${stateObjectName}Pointer`
+
+    const ownedObjects = await client.getOwnedObjects({
+      owner: address.split('::')[0]!,
+      filter: { StructType: fullStatePointerType },
+      options: { showContent: true },
+    })
 
-  // Derive the CCIPObjectRef ID from the parent CCIPObject ID
-  return deriveObjectID(ccipObjectId, new TextEncoder().encode('CCIPObjectRef'))
-}
+    const pointer = ownedObjects.data[0]?.data
+    if (!pointer?.objectId || pointer.content!.dataType !== 'moveObject')
+      throw new CCIPDataFormatUnsupportedError(
+        'No CCIP ObjectRef Pointer found for the given packageId',
+        { context: { fullStatePointerType, pointer } },
+      )
+    // const statePointerObjectId = pointer.objectId
+    const parentObjectId = Object.entries(pointer.content!.fields).find(([key]) =>
+      key.endsWith('_object_id'),
+    )?.[1]
+    if (typeof parentObjectId !== 'string')
+      throw new CCIPDataFormatUnsupportedError('No parent object id found inthe given pointer', {
+        context: { fullStatePointerType, pointer },
+      })
+    return deriveObjectID(parentObjectId, toUtf8Bytes(stateObjectName))
+  },
+  { maxArgs: 1, expires: 300e3, async: true },
+)
 
 /**
- * Get the OffRampState object ID for an offramp package
+ * Finds the StatePointer object owned by a package.
+ * The StatePointer contains a reference to the parent object used for derivation.
  */
-export async function getOffRampStateObject(
-  client: SuiClient,
-  offrampPackageId: string,
-): Promise<string> {
-  const offrampPointerResponse = await client.getOwnedObjects({
-    owner: offrampPackageId,
-    filter: {
-      StructType: `${offrampPackageId}::offramp::OffRampStatePointer`,
-    },
-  })
-
-  if (!offrampPointerResponse.data.length) {
-    throw new CCIPDataFormatUnsupportedError(
-      'No OffRampStatePointer found for the given offramp package',
-    )
-  }
-
-  const offrampPointerId = offrampPointerResponse.data[0]!.data?.objectId
-
-  if (!offrampPointerId) {
-    throw new CCIPDataFormatUnsupportedError('OffRampStatePointer does not have a valid objectId')
-  }
-
-  const offrampPointerObject = await client.getObject({
-    id: offrampPointerId,
-    options: { showContent: true },
-  })
-
-  if (offrampPointerObject.data?.content?.dataType !== 'moveObject') {
-    throw new CCIPDataFormatUnsupportedError('OffRamp pointer object is not a Move object')
-  }
-
-  const offrampObjectId = (offrampPointerObject.data.content.fields as Record<string, unknown>)[
-    'off_ramp_object_id'
-  ] as string
-
-  if (!offrampObjectId) {
-    throw new CCIPDataFormatUnsupportedError('Could not find off_ramp_object_id in pointer')
-  }
-
-  // Derive the OffRampState ID from the parent OffRamp Object ID
-  return deriveObjectID(offrampObjectId, new TextEncoder().encode('OffRampState'))
-}
+export const getLatestPackageId = memoize(
+  async function getLatestPackageId_(address: string, client: SuiClient): Promise<string> {
+    const suffix = address.split('::')[1]
+    try {
+      const stateObjectId = await getObjectRef(address, client)
+      const stateObject = await client.getObject({
+        id: stateObjectId,
+        options: { showContent: true },
+      })
+      const stateContent = stateObject.data?.content
+      if (stateContent?.dataType !== 'moveObject') return address
+      const packageIdsField = (stateContent.fields as Record<string, unknown>)['package_ids']
+      if (!Array.isArray(packageIdsField) || packageIdsField.length === 0) return address
+      const latest = packageIdsField[packageIdsField.length - 1] as string
+      return suffix ? `${latest}::${suffix}` : latest
+    } catch {
+      return address
+    }
+  },
+  { maxArgs: 1, expires: 60e3, async: true },
+)
 
 /**
  * Get the receiver module configuration from the receiver registry.

package/src/sui/types.ts

@@ -15,6 +15,16 @@ export const SuiExtraArgsV1Codec = bcs.struct('SuiExtraArgsV1', {
   receiverObjectIds: bcs.vector(bcs.vector(bcs.u8())),
 })
 
+/** Token amount data structure for Sui CCIP messages. */
+export type SuiTokenAmount = {
+  source_pool_address?: string
+  dest_token_address?: number[]
+  extra_data?: number[]
+  amount?: string | number
+  dest_exec_data?: number[]
+  dest_gas_amount?: string | number
+}
+
 /**
  * Encodes Sui v1 extra arguments using BCS encoding.
  * @param args - Sui extra arguments to encode.
@@ -26,3 +36,28 @@ export function encodeSuiExtraArgsV1(args: SuiExtraArgsV1): string {
   const bcsData = SuiExtraArgsV1Codec.serialize({ ...args, tokenReceiver, receiverObjectIds })
   return concat([SuiExtraArgsV1Tag, bcsData.toBytes()])
 }
+
+/**
+ * Sui-specific CCIP message log structure from events.
+ */
+export type SuiCCIPMessageLog = {
+  dest_chain_selector: string
+  message: {
+    data: number[]
+    extra_args: number[]
+    fee_token: string
+    fee_token_amount: string
+    fee_value_juels: string
+    header: {
+      dest_chain_selector: string
+      message_id: number[]
+      nonce: string
+      sequence_number: string
+      source_chain_selector: string
+    }
+    receiver: number[]
+    sender: string
+    token_amounts: SuiTokenAmount[]
+  }
+  sequence_number: string
+}

package/src/ton/index.ts

@@ -8,7 +8,8 @@ import { type Memoized, memoize } from 'micro-memoize'
 import type { PickDeep } from 'type-fest'
 
 import { streamTransactionsForAddress } from './logs.ts'
-import { type ChainContext, type LogFilter, Chain } from '../chain.ts'
+import { generateUnsignedCcipSend, getFee as getFeeImpl } from './send.ts'
+import { type ChainContext, type GetBalanceOpts, type LogFilter, Chain } from '../chain.ts'
 import {
   CCIPArgumentInvalidError,
   CCIPExtraArgsInvalidError,
@@ -21,7 +22,8 @@ import {
   CCIPWalletInvalidError,
 } from '../errors/specialized.ts'
 import { type EVMExtraArgsV2, type ExtraArgs, EVMExtraArgsV2Tag } from '../extra-args.ts'
-import { getMessagesInTx } from '../requests.ts'
+import type { LeafHasher } from '../hasher/common.ts'
+import { buildMessageForDest } from '../requests.ts'
 import { supportedChains } from '../supported-chains.ts'
 import {
   type CCIPExecution,
@@ -35,6 +37,7 @@ import {
   type NetworkInfo,
   type OffchainTokenData,
   type WithLogger,
+  CCIPVersion,
   ChainFamily,
   ExecutionState,
 } from '../types.ts'
@@ -50,7 +53,6 @@ import { generateUnsignedExecuteReport as generateUnsignedExecuteReportImpl } fr
 import { getTONLeafHasher } from './hasher.ts'
 import { type CCIPMessage_V1_6_TON, type UnsignedTONTx, isTONWallet } from './types.ts'
 import { crc32, lookupTxByRawHash, parseJettonContent } from './utils.ts'
-import type { LeafHasher } from '../hasher/common.ts'
 export type { TONWallet, UnsignedTONTx } from './types.ts'
 
 /**
@@ -164,13 +166,13 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
     ctx?: ChainContext & { fetchFn?: typeof fetch },
   ): Promise<TONChain> {
     // Verify connection by getting the latest block
-    const isTestnet =
+    const isMainnet =
       (
         await client.getContractState(
           Address.parse('EQCxE6mUtQJKFnGfaROTKOt1lZbDiiX1kCixRv7Nw2Id_sDs'), // mainnet USDT
         )
-      ).state !== 'active'
-    return new TONChain(client, networkInfo(isTestnet ? 'ton-testnet' : 'ton-mainnet'), ctx)
+      ).state === 'active'
+    return new TONChain(client, networkInfo(isMainnet ? 'ton-mainnet' : 'ton-testnet'), ctx)
   }
 
   /**
@@ -180,6 +182,7 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
    * @param url - RPC endpoint URL for TonClient (v2).
    * @param ctx - Context containing logger.
    * @returns A new TONChain instance.
+   * @throws {@link CCIPHttpError} if connection to the RPC endpoint fails
    */
   static async fromUrl(url: string, ctx?: ChainContext): Promise<TONChain> {
     const { logger = console } = ctx ?? {}
@@ -220,6 +223,7 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
    *
    * @param block - Logical time (lt) as number, or 'finalized' for latest block timestamp
    * @returns Unix timestamp in seconds
+   * @throws {@link CCIPNotImplementedError} if lt is not in cache
    */
   async getBlockTimestamp(block: number | 'finalized'): Promise<number> {
     if (typeof block != 'number') {
@@ -247,6 +251,8 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
    * @param tx - Transaction identifier in either format
    * @returns ChainTransaction with transaction details
    *          Note: `blockNumber` contains logical time (lt), not block seqno
+   * @throws {@link CCIPArgumentInvalidError} if hash format is invalid
+   * @throws {@link CCIPTransactionNotFoundError} if transaction not found
    */
   async getTransaction(tx: string | Transaction): Promise<ChainTransaction> {
     let address
@@ -264,7 +270,7 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
           )
         const txInfo = await lookupTxByRawHash(
           cleanHash,
-          this.network.isTestnet,
+          this.network.networkType,
           this.rateLimitedFetch,
           this,
         )
@@ -341,6 +347,7 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
    * not block sequence numbers. This is because TON transaction APIs are indexed by lt.
    *
    * @param opts - Log filter options (startBlock/endBlock are interpreted as lt values)
+   * @throws {@link CCIPTopicsInvalidError} if topics format is invalid
    */
   async *getLogs(opts: LogFilter): AsyncIterableIterator<Log_> {
     let topics
@@ -363,12 +370,10 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
     }
   }
 
-  /** {@inheritDoc Chain.getMessagesInTx} */
-  override async getMessagesInTx(tx: string | ChainTransaction): Promise<CCIPRequest[]> {
-    return getMessagesInTx(this, typeof tx === 'string' ? await this.getTransaction(tx) : tx)
-  }
-
-  /** {@inheritDoc Chain.getMessagesInBatch} */
+  /**
+   * {@inheritDoc Chain.getMessagesInBatch}
+   * @throws {@link CCIPNotImplementedError} always (not implemented for TON)
+   */
   override async getMessagesInBatch<
     R extends PickDeep<
       CCIPRequest,
@@ -426,9 +431,14 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
     return stack.readAddress().toRawString()
   }
 
-  /** {@inheritDoc Chain.getNativeTokenForRouter} */
+  /**
+   * {@inheritDoc Chain.getNativeTokenForRouter}
+   * @throws {@link CCIPNotImplementedError} always (not implemented for TON)
+   */
   getNativeTokenForRouter(_router: string): Promise<string> {
-    return Promise.reject(new CCIPNotImplementedError('getNativeTokenForRouter'))
+    // TON native token is represented as address 0:0...01 (workchain 0, hash = 1)
+    // This is a convention for representing native TON in CCIP
+    return Promise.resolve('0:0000000000000000000000000000000000000000000000000000000000000001')
   }
 
   /** {@inheritDoc Chain.getOffRampsForRouter} */
@@ -451,7 +461,10 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
     return stack.readAddress().toRawString()
   }
 
-  /** {@inheritDoc Chain.getOnRampForOffRamp} */
+  /**
+   * {@inheritDoc Chain.getOnRampForOffRamp}
+   * @throws {@link CCIPSourceChainUnsupportedError} if source chain is not configured
+   */
   async getOnRampForOffRamp(offRamp: string, sourceChainSelector: bigint): Promise<string> {
     try {
       const offRampContract = this.provider.provider(Address.parse(offRamp))
@@ -497,7 +510,10 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
     return Promise.resolve(offRamp)
   }
 
-  /** {@inheritDoc Chain.getTokenForTokenPool} */
+  /**
+   * {@inheritDoc Chain.getTokenForTokenPool}
+   * @throws {@link CCIPNotImplementedError} always (not implemented for TON)
+   */
   async getTokenForTokenPool(_tokenPool: string): Promise<string> {
     return Promise.reject(new CCIPNotImplementedError('getTokenForTokenPool'))
   }
@@ -525,7 +541,45 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
     }
   }
 
-  /** {@inheritDoc Chain.getTokenAdminRegistryFor} */
+  /**
+   * {@inheritDoc Chain.getBalance}
+   * @throws {@link CCIPNotImplementedError} always (not implemented for TON)
+   */
+  async getBalance(opts: GetBalanceOpts): Promise<bigint> {
+    const { holder, token } = opts
+    const holderAddress = Address.parse(holder)
+
+    if (!token) {
+      // Get native TON balance
+      const state = await this.provider.getContractState(holderAddress)
+      return state.balance
+    }
+
+    // For jetton balance, we need to:
+    // 1. Derive the jetton wallet address for this holder
+    // 2. Query the balance from that wallet contract
+    const jettonMaster = Address.parse(token)
+    const { stack } = await this.provider.runMethod(jettonMaster, 'get_wallet_address', [
+      { type: 'slice', cell: beginCell().storeAddress(holderAddress).endCell() },
+    ])
+    const jettonWalletAddress = stack.readAddress()
+
+    try {
+      const { stack: balanceStack } = await this.provider.runMethod(
+        jettonWalletAddress,
+        'get_wallet_data',
+      )
+      return balanceStack.readBigNumber() // First value is balance
+    } catch {
+      // Wallet doesn't exist yet = 0 balance
+      return 0n
+    }
+  }
+
+  /**
+   * {@inheritDoc Chain.getTokenAdminRegistryFor}
+   * @throws {@link CCIPNotImplementedError} always (not implemented for TON)
+   */
   getTokenAdminRegistryFor(_address: string): Promise<string> {
     return Promise.reject(new CCIPNotImplementedError('getTokenAdminRegistryFor'))
   }
@@ -833,6 +887,7 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
    * and raw format strings ("workchain:hash").
    * @param bytes - Bytes or string to convert.
    * @returns TON raw address string in format "workchain:hash".
+   * @throws {@link CCIPArgumentInvalidError} if bytes length is invalid
    */
   static getAddress(bytes: BytesLike): string {
     // If it's already a string address, try to parse and return raw format
@@ -952,20 +1007,107 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
   }
 
   /** {@inheritDoc Chain.getFee} */
-  async getFee(_opts: Parameters<Chain['getFee']>[0]): Promise<bigint> {
-    return Promise.reject(new CCIPNotImplementedError('getFee'))
+  async getFee({
+    router,
+    destChainSelector,
+    message,
+  }: Parameters<Chain['getFee']>[0]): Promise<bigint> {
+    return getFeeImpl(
+      this,
+      router,
+      destChainSelector,
+      buildMessageForDest(message, networkInfo(destChainSelector).family),
+    )
   }
 
   /** {@inheritDoc Chain.generateUnsignedSendMessage} */
-  generateUnsignedSendMessage(
-    _opts: Parameters<Chain['generateUnsignedSendMessage']>[0],
-  ): Promise<never> {
-    return Promise.reject(new CCIPNotImplementedError('generateUnsignedSendMessage'))
+  async generateUnsignedSendMessage({
+    router,
+    destChainSelector,
+    message,
+    sender,
+  }: Parameters<Chain['generateUnsignedSendMessage']>[0]): Promise<UnsignedTONTx> {
+    // Convert MessageInput to AnyMessage with defaults
+    const populatedMessage = buildMessageForDest(message, networkInfo(destChainSelector).family)
+
+    // Calculate fee if not provided
+    const fee =
+      message.fee ??
+      (await this.getFee({
+        router,
+        destChainSelector,
+        message: populatedMessage,
+      }))
+
+    const unsigned = generateUnsignedCcipSend(this, sender, router, destChainSelector, {
+      ...populatedMessage,
+      fee,
+    })
+
+    return {
+      family: ChainFamily.TON,
+      ...unsigned,
+    }
   }
 
   /** {@inheritDoc Chain.sendMessage} */
-  async sendMessage(_opts: Parameters<Chain['sendMessage']>[0]): Promise<CCIPRequest> {
-    return Promise.reject(new CCIPNotImplementedError('sendMessage'))
+  async sendMessage({
+    router,
+    destChainSelector,
+    message,
+    wallet,
+  }: Parameters<Chain['sendMessage']>[0]): Promise<CCIPRequest> {
+    if (!isTONWallet(wallet)) {
+      throw new CCIPWalletInvalidError(wallet)
+    }
+
+    const sender = await wallet.getAddress()
+
+    // Generate unsigned transaction with fee calculation if needed
+    const { family: _, ...unsigned } = await this.generateUnsignedSendMessage({
+      router,
+      destChainSelector,
+      message,
+      sender,
+    })
+
+    // Send transaction
+    const startTime = Math.floor(Date.now() / 1000)
+    const seqno = await wallet.sendTransaction(unsigned)
+
+    this.logger.info('CCIP send transaction submitted, seqno:', seqno)
+
+    // Wait for CCIPMessageSent event and extract the request
+    // Query the OnRamp for the CCIPMessageSent event
+    const onRamp = await this.getOnRampForRouter(router, destChainSelector)
+
+    // Poll for the message in recent logs
+    for await (const log of this.getLogs({
+      address: onRamp,
+      topics: [crc32('CCIPMessageSent')],
+      startTime,
+      watch: sleep(5 * 60e3 /* 5m timeout */),
+    })) {
+      const msg = TONChain.decodeMessage(log)
+      if (!msg) continue
+
+      // Found our message: construct and return the CCIPRequest
+      const tx = log.tx ?? (await this.getTransaction(log.transactionHash))
+
+      return {
+        lane: {
+          sourceChainSelector: this.network.chainSelector,
+          destChainSelector,
+          onRamp,
+          version: CCIPVersion.V1_6,
+        },
+        message: msg,
+        log,
+        tx,
+      }
+    }
+
+    throw new CCIPTransactionNotFoundError(seqno.toString())
   }
 
   /** {@inheritDoc Chain.getOffchainTokenData} */
@@ -973,7 +1115,10 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
     return Promise.resolve(request.message.tokenAmounts.map(() => undefined))
   }
 
-  /** {@inheritDoc Chain.generateUnsignedExecuteReport} */
+  /**
+   * {@inheritDoc Chain.generateUnsignedExecuteReport}
+   * @throws {@link CCIPExtraArgsInvalidError} if extra args are not EVMExtraArgsV2 format
+   */
   generateUnsignedExecuteReport({
     offRamp,
     execReport,
@@ -995,7 +1140,11 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
     })
   }
 
-  /** {@inheritDoc Chain.executeReport} */
+  /**
+   * {@inheritDoc Chain.executeReport}
+   * @throws {@link CCIPWalletInvalidError} if wallet is not a valid TON wallet
+   * @throws {@link CCIPReceiptNotFoundError} if execution receipt not found within timeout
+   */
   async executeReport(opts: Parameters<Chain['executeReport']>[0]): Promise<CCIPExecution> {
     const { offRamp, wallet } = opts
     if (!isTONWallet(wallet)) {
@@ -1040,27 +1189,42 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
     }
   }
 
-  /** {@inheritDoc Chain.getSupportedTokens} */
+  /**
+   * {@inheritDoc Chain.getSupportedTokens}
+   * @throws {@link CCIPNotImplementedError} always (not implemented for TON)
+   */
   async getSupportedTokens(_address: string): Promise<string[]> {
     return Promise.reject(new CCIPNotImplementedError('getSupportedTokens'))
   }
 
-  /** {@inheritDoc Chain.getRegistryTokenConfig} */
+  /**
+   * {@inheritDoc Chain.getRegistryTokenConfig}
+   * @throws {@link CCIPNotImplementedError} always (not implemented for TON)
+   */
   async getRegistryTokenConfig(_address: string, _tokenName: string): Promise<never> {
     return Promise.reject(new CCIPNotImplementedError('getRegistryTokenConfig'))
   }
 
-  /** {@inheritDoc Chain.getTokenPoolConfigs} */
-  async getTokenPoolConfigs(_tokenPool: string): Promise<never> {
-    return Promise.reject(new CCIPNotImplementedError('getTokenPoolConfigs'))
+  /**
+   * {@inheritDoc Chain.getTokenPoolConfig}
+   * @throws {@link CCIPNotImplementedError} always (not implemented for TON)
+   */
+  async getTokenPoolConfig(_tokenPool: string): Promise<never> {
+    return Promise.reject(new CCIPNotImplementedError('getTokenPoolConfig'))
   }
 
-  /** {@inheritDoc Chain.getTokenPoolRemotes} */
+  /**
+   * {@inheritDoc Chain.getTokenPoolRemotes}
+   * @throws {@link CCIPNotImplementedError} always (not implemented for TON)
+   */
   async getTokenPoolRemotes(_tokenPool: string): Promise<never> {
     return Promise.reject(new CCIPNotImplementedError('getTokenPoolRemotes'))
   }
 
-  /** {@inheritDoc Chain.getFeeTokens} */
+  /**
+   * {@inheritDoc Chain.getFeeTokens}
+   * @throws {@link CCIPNotImplementedError} always (not implemented for TON)
+   */
   async getFeeTokens(_router: string): Promise<never> {
     return Promise.reject(new CCIPNotImplementedError('getFeeTokens'))
   }