@chainlink/ccip-sdk 0.92.0 → 0.93.0

package/src/ton/index.ts

@@ -1,25 +1,28 @@
-import { Address, Cell, beginCell, toNano } from '@ton/core'
-import { TonClient4, internal } from '@ton/ton'
-import { type BytesLike, getAddress as checksumAddress, isBytesLike } from 'ethers'
-import { memoize } from 'micro-memoize'
+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 Memoized, memoize } from 'micro-memoize'
 import type { PickDeep } from 'type-fest'
 
-import { type LogDecoders, fetchLogs } from './logs.ts'
-import { type LogFilter, Chain } from '../chain.ts'
+import { streamTransactionsForAddress } from './logs.ts'
+import { type ChainContext, type LogFilter, Chain } from '../chain.ts'
 import {
   CCIPArgumentInvalidError,
   CCIPExtraArgsInvalidError,
   CCIPHttpError,
   CCIPNotImplementedError,
+  CCIPReceiptNotFoundError,
   CCIPSourceChainUnsupportedError,
+  CCIPTopicsInvalidError,
   CCIPTransactionNotFoundError,
   CCIPWalletInvalidError,
 } from '../errors/specialized.ts'
 import { type EVMExtraArgsV2, type ExtraArgs, EVMExtraArgsV2Tag } from '../extra-args.ts'
-import { fetchCCIPRequestsInTx } from '../requests.ts'
+import { getMessagesInTx } from '../requests.ts'
 import { supportedChains } from '../supported-chains.ts'
 import {
-  type AnyMessage,
+  type CCIPExecution,
   type CCIPRequest,
   type ChainTransaction,
   type CommitReport,
@@ -31,23 +34,22 @@ import {
   type OffchainTokenData,
   type WithLogger,
   ChainFamily,
+  ExecutionState,
 } from '../types.ts'
 import {
   bytesToBuffer,
   createRateLimitedFetch,
   decodeAddress,
-  getDataBytes,
   networkInfo,
   parseTypeAndVersion,
+  sleep,
 } from '../utils.ts'
-import { OffRamp } from './bindings/offramp.ts'
-import { OnRamp } from './bindings/onramp.ts'
-import { Router } from './bindings/router.ts'
 import { generateUnsignedExecuteReport as generateUnsignedExecuteReportImpl } from './exec.ts'
 import { getTONLeafHasher } from './hasher.ts'
 import { type CCIPMessage_V1_6_TON, type UnsignedTONTx, isTONWallet } from './types.ts'
-import { lookupTxByRawHash, parseJettonContent, waitForTransaction } from './utils.ts'
+import { crc32, lookupTxByRawHash, parseJettonContent } from './utils.ts'
 import type { LeafHasher } from '../hasher/common.ts'
+export type { TONWallet, UnsignedTONTx } from './types.ts'
 
 /**
  * Type guard to check if an error is a TVM error with an exit code.
@@ -74,13 +76,8 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
   }
   static readonly family = ChainFamily.TON
   static readonly decimals = 9 // TON uses 9 decimals (nanotons)
-  private readonly rateLimitedFetch: typeof fetch
-  readonly provider: TonClient4
-  /**
-   * Cache mapping logical time (lt) to Unix timestamp.
-   * Populated during getLogs iteration for later getBlockTimestamp lookups.
-   */
-  private readonly ltTimestampCache: Map<number, number> = new Map()
+  readonly rateLimitedFetch: typeof fetch
+  readonly provider: TonClient
 
   /**
    * Creates a new TONChain instance.
@@ -88,74 +85,128 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
    * @param network - Network information for this chain.
    * @param ctx - Context containing logger.
    */
-  constructor(client: TonClient4, network: NetworkInfo, ctx?: WithLogger) {
+  constructor(
+    client: TonClient,
+    network: NetworkInfo,
+    ctx?: ChainContext & { fetchFn?: typeof fetch },
+  ) {
     super(network, ctx)
     this.provider = client
 
-    // Rate-limited fetch for TonCenter API (public tier: ~1 req/sec)
-    const rateLimitedFetch = createRateLimitedFetch(
-      { maxRequests: 1, windowMs: 1500, maxRetries: 5 },
-      ctx,
-    )
-    this.rateLimitedFetch = (input, init) => {
-      this.logger.warn?.(
-        'Public TONCenter API calls are rate-limited to ~1 req/sec, some commands may be slow',
-      )
-      return rateLimitedFetch(input, init)
+    const txCache = new Map<string, Transaction[]>()
+    const txDepleted: Record<string, boolean> = {}
+    const origGetTransactions = this.provider.getTransactions.bind(this.provider)
+    // cached getTransactions, used for getLogs
+    this.provider.getTransactions = async (
+      address: Address,
+      opts: Parameters<typeof this.provider.getTransactions>[1],
+    ): Promise<Transaction[]> => {
+      const key = address.toString()
+      let allTxs
+      if (txCache.has(key)) {
+        allTxs = txCache.get(key)!
+      } else {
+        allTxs = [] as Transaction[]
+        txCache.set(key, allTxs)
+      }
+      let txs
+      if (!opts.hash) {
+        // if no cursor, always fetch most recent transactions
+        txs = await origGetTransactions(address, opts)
+      } else {
+        const hash = opts.hash
+        // otherwise, look to see if we have it already cached
+        let idx = allTxs.findIndex((tx) => tx.hash().toString('base64') === hash)
+        if (idx >= 0 && !opts.inclusive) idx++ // skip first if not inclusive
+        // if found, and we have more than requested limit in cache, or we'd previously reached bottom of address
+        if (idx >= 0 && (allTxs.length - idx >= opts.limit || txDepleted[key])) {
+          return allTxs.slice(idx, idx + opts.limit) // return cached
+        }
+        // otherwise, fetch after end
+        txs = await origGetTransactions(address, opts)
+      }
+      // add/merge unique/new/unseen txs to allTxs
+      const allTxsHashes = new Set(allTxs.map((tx) => tx.hash().toString('base64')))
+      allTxs.push(...txs.filter((tx) => !allTxsHashes.has(tx.hash().toString('base64'))))
+      allTxs.sort((a, b) => Number(b.lt - a.lt)) // merge sorted inverse order
+      if (txs.length < opts.limit) txDepleted[key] = true // bottom reached
+      return txs
     }
 
+    // Rate-limited fetch for TonCenter API (public tier: ~1 req/sec)
+    this.rateLimitedFetch =
+      ctx?.fetchFn ?? createRateLimitedFetch({ maxRequests: 1, windowMs: 1500, maxRetries: 5 }, ctx)
+
     this.getTransaction = memoize(this.getTransaction.bind(this), {
       maxSize: 100,
     })
+
+    this.getBlockTimestamp = memoize(this.getBlockTimestamp.bind(this), {
+      async: true,
+      maxArgs: 1,
+      maxSize: 100,
+      forceUpdate: ([k]) => typeof k !== 'number' || k <= 0,
+    })
+
+    this.typeAndVersion = memoize(this.typeAndVersion.bind(this), {
+      maxArgs: 1,
+      async: true,
+    })
+  }
+
+  /**
+   * Detect client network and instantiate a TONChain instance.
+   */
+  static async fromClient(
+    client: TonClient,
+    ctx?: ChainContext & { fetchFn?: typeof fetch },
+  ): Promise<TONChain> {
+    // Verify connection by getting the latest block
+    const isTestnet =
+      (
+        await client.getContractState(
+          Address.parse('EQCxE6mUtQJKFnGfaROTKOt1lZbDiiX1kCixRv7Nw2Id_sDs'), // mainnet USDT
+        )
+      ).state !== 'active'
+    return new TONChain(client, networkInfo(isTestnet ? 'ton-testnet' : 'ton-mainnet'), ctx)
   }
 
   /**
    * Creates a TONChain instance from an RPC URL.
    * Verifies the connection and detects the network.
    *
-   * @param url - RPC endpoint URL for TonClient4.
+   * @param url - RPC endpoint URL for TonClient (v2).
    * @param ctx - Context containing logger.
    * @returns A new TONChain instance.
    */
-  static async fromUrl(url: string, ctx?: WithLogger): Promise<TONChain> {
+  static async fromUrl(url: string, ctx?: ChainContext): Promise<TONChain> {
     const { logger = console } = ctx ?? {}
+    if (!url.endsWith('/jsonRPC')) url += '/jsonRPC'
 
-    // Parse URL for validation
-    let parsedUrl: URL
-    try {
-      parsedUrl = new URL(url)
-    } catch {
-      throw new CCIPArgumentInvalidError('url', `Invalid URL format: ${url}`)
+    let fetchFn
+    let httpAdapter
+    if (['toncenter.com', 'tonapi.io'].some((d) => url.includes(d))) {
+      logger.warn(
+        'Public TONCenter API calls are rate-limited to ~1 req/sec, some commands may be slow',
+      )
+      fetchFn = createRateLimitedFetch({ maxRequests: 1, windowMs: 1500, maxRetries: 5 }, ctx)
+      httpAdapter = (getAdapter as (name: string, config: object) => AxiosAdapter)('fetch', {
+        env: { fetch: fetchFn },
+      })
     }
 
-    const hostname = parsedUrl.hostname.toLowerCase()
-    const client = new TonClient4({ endpoint: url })
-
-    // Verify connection by getting the latest block
+    const client = new TonClient({ endpoint: url, httpAdapter })
     try {
-      await client.getLastBlock()
-      logger.debug?.(`Connected to TON V4 endpoint: ${url}`)
+      const chain = await this.fromClient(client, {
+        ...ctx,
+        fetchFn,
+      })
+      logger.debug(`Connected to TON V2 endpoint: ${url}`)
+      return chain
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error)
-      throw new CCIPHttpError(0, `Failed to connect to TON V4 endpoint ${url}: ${message}`)
+      throw new CCIPHttpError(0, `Failed to connect to TONv2 endpoint ${url}: ${message}`)
     }
-
-    // Detect network from hostname
-    let networkId: string
-    if (hostname.includes('testnet')) {
-      networkId = 'ton-testnet'
-    } else if (
-      hostname === 'localhost' ||
-      hostname === '127.0.0.1' ||
-      hostname.includes('sandbox')
-    ) {
-      networkId = 'ton-localnet'
-    } else {
-      // Default to mainnet for production endpoints
-      networkId = 'ton-mainnet'
-    }
-
-    return new TONChain(client, networkInfo(networkId), ctx)
   }
 
   /**
@@ -169,16 +220,8 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
    * @returns Unix timestamp in seconds
    */
   async getBlockTimestamp(block: number | 'finalized'): Promise<number> {
-    if (block === 'finalized') {
-      // Get the latest block timestamp from V4 API
-      const lastBlock = await this.provider.getLastBlock()
-      return lastBlock.now
-    }
-
-    // Check lt → timestamp cache
-    const cached = this.ltTimestampCache.get(block)
-    if (cached !== undefined) {
-      return cached
+    if (typeof block != 'number') {
+      return Promise.resolve(Math.floor(Date.now() / 1000))
     }
 
     // For TON, we cannot look up timestamp by lt alone without the account address.
@@ -196,97 +239,97 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
    * 1. Composite format: "workchain:address:lt:hash" (e.g., "0:abc123...def:12345:abc123...def")
    * 2. Raw hash format: 64-character hex string resolved via TonCenter V3 API
    *
-   * Note: TON's V4 API requires (address, lt, hash) for lookups. Raw hash lookups
+   * Note: TonClient requires (address, lt, hash) for lookups. Raw hash lookups
    * use TonCenter's V3 index API to resolve the hash to a full identifier first.
    *
-   * @param hash - Transaction identifier in either format
+   * @param tx - Transaction identifier in either format
    * @returns ChainTransaction with transaction details
    *          Note: `blockNumber` contains logical time (lt), not block seqno
    */
-  async getTransaction(hash: string): Promise<ChainTransaction> {
-    const parts = hash.split(':')
-
-    // If not composite format (4 parts), check if it's a raw 64-char hex hash
-    if (parts.length !== 4) {
-      const cleanHash = hash.startsWith('0x') || hash.startsWith('0X') ? hash.slice(2) : hash
-
-      if (/^[a-fA-F0-9]{64}$/.test(cleanHash)) {
-        const isTestnet = this.network.name?.includes('testnet') ?? false
+  async getTransaction(tx: string | Transaction): Promise<ChainTransaction> {
+    let address
+    if (typeof tx === 'string') {
+      let parts = tx.split(':')
+
+      // If not composite format (4 parts), check if it's a raw 64-char hex hash
+      if (parts.length !== 4) {
+        const cleanHash = tx.startsWith('0x') || tx.startsWith('0X') ? tx.slice(2) : tx
+
+        if (!/^[a-fA-F0-9]{64}$/.test(cleanHash))
+          throw new CCIPArgumentInvalidError(
+            'hash',
+            `Invalid TON transaction hash format: "${tx}". Expected "workchain:address:lt:hash" or 64-char hex hash`,
+          )
         const txInfo = await lookupTxByRawHash(
           cleanHash,
-          isTestnet,
+          this.network.isTestnet,
           this.rateLimitedFetch,
-          this.logger,
+          this,
         )
 
-        const compositeHash = `${txInfo.account}:${txInfo.lt}:${cleanHash}`
-        this.logger.debug?.(`Resolved raw hash to composite: ${compositeHash}`)
-
-        return this.getTransaction(compositeHash)
+        tx = `${txInfo.account}:${txInfo.lt}:${cleanHash}`
+        this.logger.debug(`Resolved raw hash to composite: ${tx}`)
+        parts = tx.split(':')
       }
 
-      throw new CCIPArgumentInvalidError(
-        'hash',
-        `Invalid TON transaction hash format: "${hash}". Expected "workchain:address:lt:hash" or 64-char hex hash`,
-      )
-    }
-
-    // Parse composite format: workchain:address:lt:hash
-    const address = Address.parseRaw(`${parts[0]}:${parts[1]}`)
-    const lt = parts[2]
-    const txHash = parts[3]
+      // Parse composite format: workchain:address:lt:hash
+      address = Address.parseRaw(`${parts[0]}:${parts[1]}`)
+      const [, , lt, txHash] = parts as [string, string, string, string]
 
-    // Get the latest block to use as reference
-    const lastBlock = await this.provider.getLastBlock()
-
-    // Get account transactions using V4 API
-    const account = await this.provider.getAccountLite(lastBlock.last.seqno, address)
-    if (!account.account.last) {
-      throw new CCIPTransactionNotFoundError(hash)
-    }
-
-    // Fetch transactions and find the one we're looking for
-    const txs = await this.provider.getAccountTransactions(
-      address,
-      BigInt(lt),
-      Buffer.from(txHash, 'hex'),
-    )
-
-    if (!txs || txs.length === 0) {
-      throw new CCIPTransactionNotFoundError(hash)
+      // Fetch transactions and find the one we're looking for
+      const tx_ = await this.provider.getTransaction(
+        address,
+        lt,
+        Buffer.from(txHash, 'hex').toString('base64'),
+      )
+      if (!tx_) throw new CCIPTransactionNotFoundError(tx)
+      tx = tx_
+    } else {
+      address = new Address(0, Buffer.from(toBeArray(tx.address, 32)))
     }
 
-    const tx = txs[0].tx
-    const txLt = Number(tx.lt)
-
     // Cache lt → timestamp for later getBlockTimestamp lookups
-    this.ltTimestampCache.set(txLt, tx.now)
+    ;(this.getBlockTimestamp as Memoized<typeof this.getBlockTimestamp, { async: true }>).cache.set(
+      [Number(tx.lt)],
+      Promise.resolve(tx.now),
+    )
 
     // Extract logs from outgoing external messages
-    const logs: Log_[] = []
-    const outMessages = tx.outMessages.values()
-    let index = 0
-    for (const msg of outMessages) {
-      if (msg.info.type === 'external-out') {
-        logs.push({
-          address: address.toRawString(),
-          topics: [],
-          data: msg.body.toBoc().toString('base64'),
-          blockNumber: txLt, // Note: This is lt (logical time), not block seqno
-          transactionHash: hash,
-          index: index,
-        })
-      }
-      index++
-    }
-
-    return {
-      hash,
-      logs,
-      blockNumber: txLt, // Note: This is lt (logical time), not block seqno
+    // Build composite hash format: workchain:address:lt:hash
+    const compositeHash = `${address.toRawString()}:${tx.lt}:${tx.hash().toString('hex')}`
+    const res = {
+      hash: compositeHash,
+      logs: [] as Log_[],
+      blockNumber: Number(tx.lt), // Note: This is lt (logical time), not block seqno
       timestamp: tx.now,
       from: address.toRawString(),
+      tx,
     }
+    const logs: Log_[] = []
+    for (const [index, msg] of tx.outMessages) {
+      if (msg.info.type !== 'external-out') continue
+      const topics = []
+      // logs are external messages where dest "address" is the uint32 topic (e.g. crc32("ExecutionStateChanged"))
+      if (msg.info.dest && msg.info.dest.value > 0n && msg.info.dest.value < 2n ** 32n)
+        topics.push(toBeHex(msg.info.dest.value, 4))
+      let data = ''
+      try {
+        data = msg.body.toBoc().toString('base64')
+      } catch (_) {
+        // ignore
+      }
+      logs.push({
+        address: msg.info.src.toRawString(),
+        topics,
+        data,
+        blockNumber: res.blockNumber, // Note: This is lt (logical time), not block seqno
+        transactionHash: res.hash,
+        index,
+        tx: res,
+      })
+    }
+    res.logs = logs
+    return res
   }
 
   /**
@@ -297,21 +340,34 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
    *
    * @param opts - Log filter options (startBlock/endBlock are interpreted as lt values)
    */
-  async *getLogs(opts: LogFilter & { versionAsHash?: boolean }): AsyncIterableIterator<Log_> {
-    const decoders: LogDecoders = {
-      tryDecodeAsMessage: (log) => TONChain.decodeMessage(log),
-      tryDecodeAsCommit: (log) => TONChain.decodeCommits(log as Log_),
+  async *getLogs(opts: LogFilter): AsyncIterableIterator<Log_> {
+    let topics
+    if (opts.topics?.length) {
+      if (!opts.topics.every((topic) => typeof topic === 'string'))
+        throw new CCIPTopicsInvalidError(opts.topics)
+      // append events discriminants (if not 0x-8B already), but keep OG topics
+      topics = new Set([
+        ...opts.topics,
+        ...opts.topics.filter((t) => !isHexString(t, 8)).map((t) => crc32(t)),
+      ])
+    }
+    for await (const tx of streamTransactionsForAddress(opts, this)) {
+      const logs =
+        opts.startBlock == null && opts.startTime == null ? tx.logs.toReversed() : tx.logs
+      for (const log of logs) {
+        if (topics && !topics.has(log.topics[0]!)) continue
+        yield log
+      }
     }
-    yield* fetchLogs(this.provider, opts, this.ltTimestampCache, decoders)
   }
 
-  /** {@inheritDoc Chain.fetchRequestsInTx} */
-  override async fetchRequestsInTx(tx: string | ChainTransaction): Promise<CCIPRequest[]> {
-    return fetchCCIPRequestsInTx(this, typeof tx === 'string' ? await this.getTransaction(tx) : tx)
+  /** {@inheritDoc Chain.getMessagesInTx} */
+  override async getMessagesInTx(tx: string | ChainTransaction): Promise<CCIPRequest[]> {
+    return getMessagesInTx(this, typeof tx === 'string' ? await this.getTransaction(tx) : tx)
   }
 
-  /** {@inheritDoc Chain.fetchAllMessagesInBatch} */
-  override async fetchAllMessagesInBatch<
+  /** {@inheritDoc Chain.getMessagesInBatch} */
+  override async getMessagesInBatch<
     R extends PickDeep<
       CCIPRequest,
       'lane' | `log.${'topics' | 'address' | 'blockNumber'}` | 'message.sequenceNumber'
@@ -321,28 +377,20 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
     _commit: Pick<CommitReport, 'minSeqNr' | 'maxSeqNr'>,
     _opts?: { page?: number },
   ): Promise<R['message'][]> {
-    return Promise.reject(new CCIPNotImplementedError('fetchAllMessagesInBatch'))
+    return Promise.reject(new CCIPNotImplementedError('getMessagesInBatch'))
   }
 
   /** {@inheritDoc Chain.typeAndVersion} */
-  async typeAndVersion(
-    address: string,
-  ): Promise<
-    | [type_: string, version: string, typeAndVersion: string]
-    | [type_: string, version: string, typeAndVersion: string, suffix: string]
-  > {
+  async typeAndVersion(address: string) {
     const tonAddress = Address.parse(address)
 
-    // Get current block for state lookup
-    const lastBlock = await this.provider.getLastBlock()
-
     // Call the typeAndVersion getter method on the contract
-    const result = await this.provider.runMethod(lastBlock.last.seqno, tonAddress, 'typeAndVersion')
+    const result = await this.provider.runMethod(tonAddress, 'typeAndVersion')
 
     // Parse the two string slices returned by the contract
     // TON contracts return strings as cells with snake format encoding
-    const typeCell = result.reader.readCell()
-    const versionCell = result.reader.readCell()
+    const typeCell = result.stack.readCell()
+    const versionCell = result.stack.readCell()
 
     // Load strings from cells using snake format
     const contractType = typeCell.beginParse().loadStringTail()
@@ -355,31 +403,25 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
     // Format as "Type Version" and use the common parser
     const typeAndVersionStr = `${shortType} ${version}`
 
-    return parseTypeAndVersion(typeAndVersionStr) as
-      | [type_: string, version: string, typeAndVersion: string]
-      | [type_: string, version: string, typeAndVersion: string, suffix: string]
+    return parseTypeAndVersion(typeAndVersionStr)
   }
 
   /** {@inheritDoc Chain.getRouterForOnRamp} */
   async getRouterForOnRamp(onRamp: string, destChainSelector: bigint): Promise<string> {
-    const rawAddress = TONChain.getAddress(onRamp)
-    const onRampAddress = Address.parseRaw(rawAddress)
-
-    const onRampContract = OnRamp.createFromAddress(onRampAddress)
-    const openedContract = this.provider.open(onRampContract)
-    const destConfig = await openedContract.getDestChainConfig(destChainSelector)
-
-    return destConfig.router.toString()
+    const { stack: destConfig } = await this.provider.runMethod(
+      Address.parse(onRamp),
+      'destChainConfig',
+      [{ type: 'int', value: destChainSelector }],
+    )
+    return destConfig.readAddress().toRawString()
   }
 
   /** {@inheritDoc Chain.getRouterForOffRamp} */
   async getRouterForOffRamp(offRamp: string, sourceChainSelector: bigint): Promise<string> {
-    const offRampAddress = Address.parse(offRamp)
-    const offRampContract = OffRamp.createFromAddress(offRampAddress)
-    const openedContract = this.provider.open(offRampContract)
-
-    const sourceConfig = await openedContract.getSourceChainConfig(sourceChainSelector)
-    return sourceConfig.router.toString()
+    const { stack } = await this.provider.runMethod(Address.parse(offRamp), 'sourceChainConfig', [
+      { type: 'int', value: sourceChainSelector },
+    ])
+    return stack.readAddress().toRawString()
   }
 
   /** {@inheritDoc Chain.getNativeTokenForRouter} */
@@ -389,42 +431,54 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
 
   /** {@inheritDoc Chain.getOffRampsForRouter} */
   async getOffRampsForRouter(router: string, sourceChainSelector: bigint): Promise<string[]> {
-    const routerAddress = Address.parse(router)
-    const routerContract = Router.createFromAddress(routerAddress)
-    const openedContract = this.provider.open(routerContract)
-
-    try {
-      // Get the specific OffRamp for the source chain selector
-      const offRamp = await openedContract.getOffRamp(sourceChainSelector)
-      return [offRamp.toString()]
-    } catch (error) {
-      if (isTvmError(error) && error.exitCode === 261) {
-        return [] // Return empty array if no OffRamp configured for this source chain
-      }
-      throw error
-    }
+    const routerContract = this.provider.provider(Address.parse(router))
+    // Get the specific OffRamp for the source chain selector
+    const { stack } = await routerContract.get('offRamp', [
+      { type: 'int', value: sourceChainSelector },
+    ])
+    return [stack.readAddress().toRawString()]
   }
 
   /** {@inheritDoc Chain.getOnRampForRouter} */
   async getOnRampForRouter(router: string, destChainSelector: bigint): Promise<string> {
-    const routerAddress = Address.parse(router)
-    const routerContract = Router.createFromAddress(routerAddress)
-    const openedContract = this.provider.open(routerContract)
-
-    const onRamp = await openedContract.getOnRamp(destChainSelector)
-    return onRamp.toString()
+    const routerContract = this.provider.provider(Address.parse(router))
+    // Get the specific OnRamp for the source chain selector
+    const { stack } = await routerContract.get('onRamp', [
+      { type: 'int', value: destChainSelector },
+    ])
+    return stack.readAddress().toRawString()
   }
 
   /** {@inheritDoc Chain.getOnRampForOffRamp} */
   async getOnRampForOffRamp(offRamp: string, sourceChainSelector: bigint): Promise<string> {
-    const offRampAddress = Address.parse(offRamp)
-    const offRampContract = OffRamp.createFromAddress(offRampAddress)
-    const openedContract = this.provider.open(offRampContract)
-
     try {
-      const sourceConfig = await openedContract.getSourceChainConfig(sourceChainSelector)
-      // Convert CrossChainAddress (buffer) to checksummed EVM address
-      return checksumAddress('0x' + sourceConfig.onRamp.toString('hex'))
+      const offRampContract = this.provider.provider(Address.parse(offRamp))
+
+      const { stack } = await offRampContract.get('sourceChainConfig', [
+        { type: 'int', value: sourceChainSelector },
+      ])
+      stack.readAddress() // router
+      stack.readBoolean() // isEnabled
+      stack.readBigNumber() // minSeqNr
+      stack.readBoolean() // isRMNVerificationDisabled
+
+      // onRamp is stored as CrossChainAddress cell
+      const onRampCell = stack.readCell()
+      const onRampSlice = onRampCell.beginParse()
+
+      // Check if length-prefixed or raw format based on cell bit length
+      const cellBits = onRampCell.bits.length
+      let onRamp: Buffer
+
+      if (cellBits === 160) {
+        // Raw 20-byte EVM address (no length prefix)
+        onRamp = onRampSlice.loadBuffer(20)
+      } else {
+        // Length-prefixed format: 8-bit length + data
+        const onRampLength = onRampSlice.loadUint(8)
+        onRamp = onRampSlice.loadBuffer(onRampLength)
+      }
+      return decodeAddress(onRamp, networkInfo(sourceChainSelector).family)
     } catch (error) {
       if (isTvmError(error) && error.exitCode === 266) {
         throw new CCIPSourceChainUnsupportedError(sourceChainSelector, {
@@ -449,25 +503,23 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
   /** {@inheritDoc Chain.getTokenInfo} */
   async getTokenInfo(token: string): Promise<{ symbol: string; decimals: number }> {
     const tokenAddress = Address.parse(token)
-    const lastBlock = await this.provider.getLastBlock()
+    if (tokenAddress.toRawString().match(/^[0:]+1$/)) {
+      return { symbol: 'TON', decimals: (this.constructor as typeof TONChain).decimals }
+    }
 
     try {
-      const result = await this.provider.runMethod(
-        lastBlock.last.seqno,
-        tokenAddress,
-        'get_jetton_data',
-      )
+      const { stack } = await this.provider.runMethod(tokenAddress, 'get_jetton_data')
 
       // skips
-      result.reader.readBigNumber() // total_supply
-      result.reader.readBigNumber() // mintable
-      result.reader.readAddress() // admin_address
+      stack.readBigNumber() // total_supply
+      stack.readBigNumber() // mintable
+      stack.readAddress() // admin_address
 
-      const contentCell = result.reader.readCell()
+      const contentCell = stack.readCell()
       return parseJettonContent(contentCell, this.rateLimitedFetch, this.logger)
     } catch (error) {
-      this.logger.debug?.(`Failed to get jetton data for ${token}:`, error)
-      return { symbol: '', decimals: 9 }
+      this.logger.debug(`Failed to get jetton data for ${token}:`, error)
+      return { symbol: '', decimals: (this.constructor as typeof TONChain).decimals }
     }
   }
 
@@ -481,20 +533,27 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
    * @param log - Log with data field.
    * @returns Decoded CCIPMessage or undefined if not valid.
    */
-  static decodeMessage(log: Pick<Log_, 'data'>): CCIPMessage_V1_6_TON | undefined {
-    if (!log.data || typeof log.data !== 'string') return undefined
+  static decodeMessage({
+    data,
+    topics,
+  }: {
+    data: unknown
+    topics?: readonly string[]
+  }): CCIPMessage_V1_6_TON | undefined {
+    if (!data || typeof data !== 'string') return
+    if (topics?.length && topics[0] !== crc32('CCIPMessageSent')) return
 
     try {
       // Parse BOC from base64
-      const boc = Buffer.from(log.data, 'base64')
-      const cell = Cell.fromBoc(boc)[0]
+      const boc = bytesToBuffer(data)
+      const cell = Cell.fromBoc(boc)[0]!
       const slice = cell.beginParse()
 
       // Load header fields directly (no topic prefix)
       // Structure from TVM2AnyRampMessage:
       // header: RampMessageHeader + sender: address + body: Cell + feeValueJuels: uint96
       const header = {
-        messageId: '0x' + slice.loadUintBig(256).toString(16).padStart(64, '0'),
+        messageId: toBeHex(slice.loadUintBig(256), 32),
         sourceChainSelector: slice.loadUintBig(64),
         destChainSelector: slice.loadUintBig(64),
         sequenceNumber: slice.loadUintBig(64),
@@ -502,7 +561,7 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
       }
 
       // Load sender address
-      const sender = slice.loadAddress()?.toString() ?? ''
+      const sender = slice.loadAddress().toString()
 
       // Load body cell ref
       const bodyCell = slice.loadRef()
@@ -532,7 +591,6 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
       // Load data from ref 1
       const dataSlice = bodySlice.loadRef().beginParse()
       const dataBytes = dataSlice.loadBuffer(dataSlice.remainingBits / 8)
-      const data = '0x' + dataBytes.toString('hex')
 
       // Load extraArgs from ref 2
       const extraArgsCell = bodySlice.loadRef()
@@ -569,7 +627,7 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
         ...header,
         sender,
         receiver,
-        data,
+        data: hexlify(dataBytes),
         tokenAmounts,
         feeToken,
         feeTokenAmount,
@@ -594,7 +652,6 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
    * @returns Hex string of BOC-encoded extra args (0x-prefixed)
    */
   static encodeExtraArgs(args: ExtraArgs): string {
-    if (!args) return '0x'
     if ('gasLimit' in args && 'allowOutOfOrderExecution' in args) {
       const cell = beginCell()
         .storeUint(Number(EVMExtraArgsV2Tag), 32) // magic tag
@@ -623,11 +680,11 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
   static decodeExtraArgs(
     extraArgs: BytesLike,
   ): (EVMExtraArgsV2 & { _tag: 'EVMExtraArgsV2' }) | undefined {
-    const data = Buffer.from(getDataBytes(extraArgs))
+    const data = bytesToBuffer(extraArgs)
 
     try {
       // Parse BOC format to extract cell data
-      const cell = Cell.fromBoc(data)[0]
+      const cell = Cell.fromBoc(data)[0]!
       const slice = cell.beginParse()
 
       // Load and verify magic tag to ensure correct extra args type
@@ -652,35 +709,37 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
    * @param lane - Optional lane info for filtering.
    * @returns Array of CommitReport or undefined if not a valid commit event.
    */
-  static decodeCommits(log: Log_, lane?: Lane): CommitReport[] | undefined {
-    if (!log.data || typeof log.data !== 'string') return undefined
-
+  static decodeCommits(
+    { data, topics }: { data: unknown; topics?: readonly string[] },
+    lane?: Lane,
+  ): CommitReport[] | undefined {
+    if (!data || typeof data !== 'string') return
+    if (topics?.length && topics[0] !== crc32('CommitReportAccepted')) return
     try {
-      const boc = Buffer.from(log.data, 'base64')
-      const cell = Cell.fromBoc(boc)[0]
+      const boc = bytesToBuffer(data)
+      const cell = Cell.fromBoc(boc)[0]!
       const slice = cell.beginParse()
 
       // Cell body starts directly with hasMerkleRoot (topic is in message header)
       const hasMerkleRoot = slice.loadBit()
 
-      if (!hasMerkleRoot) {
-        // No merkle root: could be price-only update, skip for now
-        return undefined
-      }
+      // No merkle root: could be price-only update, skip for now
+      if (!hasMerkleRoot) return
 
       // Read MerkleRoot fields inline
       const sourceChainSelector = slice.loadUintBig(64)
       const onRampLen = slice.loadUint(8)
 
-      if (onRampLen === 0 || onRampLen > 32) {
-        // Invalid onRamp length
-        return undefined
-      }
+      // Invalid onRamp length
+      if (onRampLen === 0 || onRampLen > 32) return
 
-      const onRampBytes = slice.loadBuffer(onRampLen)
+      const onRampAddress = decodeAddress(
+        slice.loadBuffer(onRampLen),
+        networkInfo(sourceChainSelector).family,
+      )
       const minSeqNr = slice.loadUintBig(64)
       const maxSeqNr = slice.loadUintBig(64)
-      const merkleRoot = '0x' + slice.loadUintBig(256).toString(16).padStart(64, '0')
+      const merkleRoot = hexlify(slice.loadBuffer(32))
 
       // Read hasPriceUpdates (1 bit): we don't need the data but should consume it
       if (slice.remainingBits >= 1) {
@@ -692,7 +751,7 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
 
       const report: CommitReport = {
         sourceChainSelector,
-        onRampAddress: '0x' + onRampBytes.toString('hex'),
+        onRampAddress,
         minSeqNr,
         maxSeqNr,
         merkleRoot,
@@ -700,23 +759,66 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
 
       // Filter by lane if provided
       if (lane) {
-        if (report.sourceChainSelector !== lane.sourceChainSelector) return undefined
-        if (report.onRampAddress?.toLowerCase() !== lane.onRamp?.toLowerCase()) return undefined
+        if (report.sourceChainSelector !== lane.sourceChainSelector) return
+        if (report.onRampAddress !== lane.onRamp) return
       }
 
       return [report]
     } catch {
-      return undefined
+      return
     }
   }
 
   /**
    * Decodes an execution receipt from a TON log event.
-   * @param _log - Log with data field.
+   *
+   * The ExecutionStateChanged event structure (topic is in message header, not body):
+   * - sourceChainSelector: uint64 (8 bytes)
+   * - sequenceNumber: uint64 (8 bytes)
+   * - messageId: uint256 (32 bytes)
+   * - state: uint8 (1 byte) - Untouched=0, InProgress=1, Success=2, Failure=3
+   *
+   * @param log - Log with data field (base64-encoded BOC).
    * @returns ExecutionReceipt or undefined if not valid.
    */
-  static decodeReceipt(_log: Log_): ExecutionReceipt | undefined {
-    throw new CCIPNotImplementedError('decodeReceipt')
+  static decodeReceipt({
+    data,
+    topics,
+  }: {
+    data: unknown
+    topics?: readonly string[]
+  }): ExecutionReceipt | undefined {
+    if (!data || typeof data !== 'string') return
+    if (topics?.length && topics[0] !== crc32('ExecutionStateChanged')) return
+
+    try {
+      const boc = bytesToBuffer(data)
+      const cell = Cell.fromBoc(boc)[0]!
+      const slice = cell.beginParse()
+
+      // ExecutionStateChanged has no refs
+      if (cell.refs.length > 0) return
+
+      // Cell body contains only the struct fields
+      // ExecutionStateChanged: sourceChainSelector(64) + sequenceNumber(64) + messageId(256) + state(8)
+      const sourceChainSelector = slice.loadUintBig(64)
+      const sequenceNumber = slice.loadUintBig(64)
+      const messageId = toBeHex(slice.loadUintBig(256), 32)
+      const state = slice.loadUint(8)
+
+      // Validate state is a valid ExecutionState (2-3)
+      // TON has intermediary txs with state 1 (InProgress), but we filter them here
+      if (state !== ExecutionState.Success && state !== ExecutionState.Failed) return
+
+      return {
+        messageId,
+        sequenceNumber,
+        sourceChainSelector,
+        state: state as ExecutionState,
+      }
+    } catch {
+      // ignore
+    }
   }
 
   /**
@@ -799,7 +901,7 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
     const parts = hash.split(':')
     if (parts.length === 4) {
       // Composite format: workchain:address:lt:hash - return just the hash part
-      return parts[3]
+      return parts[3]!
     }
     // Already raw format or unknown - return as-is
     return hash
@@ -823,7 +925,7 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
     // Check for composite format: workchain:address:lt:hash
     const parts = v.split(':')
     if (parts.length === 4) {
-      const [workchain, address, lt, hash] = parts
+      const [workchain, address, lt, hash] = parts as [string, string, string, string]
       // workchain should be a number (typically 0 or -1)
       if (!/^-?\d+$/.test(workchain)) return false
       // address should be 64-char hex
@@ -848,43 +950,33 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
   }
 
   /** {@inheritDoc Chain.getFee} */
-  async getFee(_router: string, _destChainSelector: bigint, _message: AnyMessage): Promise<bigint> {
+  async getFee(_opts: Parameters<Chain['getFee']>[0]): Promise<bigint> {
     return Promise.reject(new CCIPNotImplementedError('getFee'))
   }
 
   /** {@inheritDoc Chain.generateUnsignedSendMessage} */
   generateUnsignedSendMessage(
-    _sender: string,
-    _router: string,
-    _destChainSelector: bigint,
-    _message: AnyMessage & { fee?: bigint },
-    _opts?: { approveMax?: boolean },
+    _opts: Parameters<Chain['generateUnsignedSendMessage']>[0],
   ): Promise<never> {
     return Promise.reject(new CCIPNotImplementedError('generateUnsignedSendMessage'))
   }
 
   /** {@inheritDoc Chain.sendMessage} */
-  async sendMessage(
-    _router: string,
-    _destChainSelector: bigint,
-    _message: AnyMessage & { fee: bigint },
-    _opts?: { wallet?: unknown; approveMax?: boolean },
-  ): Promise<CCIPRequest> {
+  async sendMessage(_opts: Parameters<Chain['sendMessage']>[0]): Promise<CCIPRequest> {
     return Promise.reject(new CCIPNotImplementedError('sendMessage'))
   }
 
-  /** {@inheritDoc Chain.fetchOffchainTokenData} */
-  fetchOffchainTokenData(request: CCIPRequest): Promise<OffchainTokenData[]> {
+  /** {@inheritDoc Chain.getOffchainTokenData} */
+  getOffchainTokenData(request: CCIPRequest): Promise<OffchainTokenData[]> {
     return Promise.resolve(request.message.tokenAmounts.map(() => undefined))
   }
 
   /** {@inheritDoc Chain.generateUnsignedExecuteReport} */
-  generateUnsignedExecuteReport(
-    _payer: string,
-    offRamp: string,
-    execReport: ExecutionReport,
-    opts?: { gasLimit?: number },
-  ): Promise<UnsignedTONTx> {
+  generateUnsignedExecuteReport({
+    offRamp,
+    execReport,
+    ...opts
+  }: Parameters<Chain['generateUnsignedExecuteReport']>[0]): Promise<UnsignedTONTx> {
     if (!('allowOutOfOrderExecution' in execReport.message && 'gasLimit' in execReport.message)) {
       throw new CCIPExtraArgsInvalidError('TON')
     }
@@ -897,57 +989,41 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
 
     return Promise.resolve({
       family: ChainFamily.TON,
-      to: unsigned.to,
-      body: unsigned.body,
+      ...unsigned,
     })
   }
 
   /** {@inheritDoc Chain.executeReport} */
-  async executeReport(
-    offRamp: string,
-    execReport: ExecutionReport,
-    opts: { wallet: unknown; gasLimit?: number },
-  ): Promise<ChainTransaction> {
-    const wallet = opts.wallet
+  async executeReport(opts: Parameters<Chain['executeReport']>[0]): Promise<CCIPExecution> {
+    const { offRamp, wallet } = opts
     if (!isTONWallet(wallet)) {
       throw new CCIPWalletInvalidError(wallet)
     }
+    const payer = await wallet.getAddress()
 
-    const unsigned = await this.generateUnsignedExecuteReport(
-      wallet.contract.address.toString(),
-      offRamp,
-      execReport as ExecutionReport<CCIPMessage_V1_6_TON>,
-      opts,
-    )
+    const { family: _, ...unsigned } = await this.generateUnsignedExecuteReport({
+      ...opts,
+      payer,
+    })
 
+    const startTime = Math.floor(Date.now() / 1000)
     // Open wallet and send transaction using the unsigned data
-    const openedWallet = this.provider.open(wallet.contract)
-    const seqno = await openedWallet.getSeqno()
-
-    await openedWallet.sendTransfer({
-      seqno,
-      secretKey: wallet.keyPair.secretKey,
-      messages: [
-        internal({
-          to: unsigned.to,
-          value: toNano('0.2'), // TODO: FIXME: estimate proper value for execution costs instead of hardcoding.
-          body: unsigned.body,
-        }),
-      ],
+    const seqno = await wallet.sendTransaction({
+      value: toNano('0.3'),
+      ...unsigned,
     })
 
-    // Wait for transaction to be confirmed
-    const offRampAddress = Address.parse(offRamp)
-    const txInfo = await waitForTransaction(
-      this.provider,
-      wallet.contract.address,
-      seqno,
-      offRampAddress,
-    )
-
-    // Return composite hash in format "workchain:address:lt:hash"
-    const hash = `${wallet.contract.address.toRawString()}:${txInfo.lt}:${txInfo.hash}`
-    return this.getTransaction(hash)
+    const message = opts.execReport.message as CCIPMessage_V1_6_TON
+    for await (const exec of this.getExecutionReceipts({
+      offRamp,
+      messageId: message.messageId,
+      sourceChainSelector: message.sourceChainSelector,
+      startTime,
+      watch: sleep(10 * 60e3 /* 10m */),
+    })) {
+      return exec // break and return on first yield
+    }
+    throw new CCIPReceiptNotFoundError(seqno.toString())
   }
 
   /**