viem 2.49.2 → 2.50.3

package/tempo/Decorator.ts

@@ -1389,6 +1389,31 @@ export type Decorator<
     ) => () => void
   }
   fee: {
+    /**
+     * Validates that a token can be used as a Tempo fee token.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions } from 'viem/tempo'
+     *
+     * const client = createClient({
+     *   chain: tempo
+     *   transport: http(),
+     * }).extend(tempoActions())
+     *
+     * const { address } = await client.fee.validateToken({
+     *   token: '0x20c0000000000000000000000000000000000001',
+     * })
+     * ```
+     *
+     * @param parameters - Parameters.
+     * @returns The fee token address, ID, and metadata.
+     */
+    validateToken: (
+      parameters: feeActions.validateToken.Parameters,
+    ) => Promise<feeActions.validateToken.ReturnValue>
     /**
      * Gets the user's default fee token.
      *
@@ -4321,6 +4346,8 @@ export function decorator() {
           nonceActions.watchNonceIncremented(client, parameters),
       },
       fee: {
+        validateToken: (parameters) =>
+          feeActions.validateToken(client, parameters),
         // @ts-expect-error
         getUserToken: (parameters) =>
           // @ts-expect-error

package/tempo/Formatters.ts

@@ -72,6 +72,10 @@ export function formatTransactionRequest(
 ): TransactionRequestRpc {
   const request = r as TransactionRequest & {
     account?: viem_Account | Address | undefined
+    feePayerSignature?:
+      | { r: Hex.Hex; s: Hex.Hex; yParity: number; v?: number | undefined }
+      | null
+      | undefined
     keyData?: Hex.Hex | undefined
     keyId?: Address | undefined
     keyType?: 'p256' | 'secp256k1' | 'webAuthn' | undefined
@@ -100,10 +104,17 @@ export function formatTransactionRequest(
       },
     ]
 
-  // If we have marked the transaction as intended to be paid
-  // by a fee payer (feePayer: true), we will not use the fee token
-  // as the fee payer will choose their fee token.
-  if (request.feePayer === true) delete request.feeToken
+  // If we have marked the transaction as intended to be paid by a fee
+  // payer (feePayer: true), we strip the fee token from the sender's
+  // sign payload — per TIP-76 the sender does not commit to it; the fee
+  // payer chooses and commits to the token via its own signature.
+  //
+  // Once the fee payer has signed (`feePayerSignature` is populated),
+  // the relay has chosen a token and signed over it. The broadcast
+  // envelope must therefore include `feeToken` so the chain can verify
+  // the fee payer's signature and identify which token to charge.
+  if (request.feePayer === true && !request.feePayerSignature)
+    delete request.feeToken
 
   const rpc = ox_TransactionRequest.toRpc({
     ...request,

package/tempo/Transaction.ts

@@ -325,10 +325,16 @@ async function serializeTempo(
     ...(nonce ? { nonce: BigInt(nonce) } : {}),
   } satisfies TxTempo.TxEnvelopeTempo
 
-  // If we have marked the transaction as intended to be paid
-  // by a fee payer (feePayer: true), we will not use the fee token
-  // as the fee payer will choose their fee token.
-  if (feePayer === true) delete transaction_ox.feeToken
+  // If we have marked the transaction as intended to be paid by a fee
+  // payer (feePayer: true), we strip the fee token from the sender's
+  // sign payload — per TIP-76 the sender does not commit to it; the fee
+  // payer chooses and commits to the token via its own signature.
+  //
+  // Once the fee payer has signed (`feePayerSignature` is populated),
+  // the relay has chosen a token and signed over it. The broadcast
+  // envelope must therefore include `feeToken` so the chain can verify
+  // the fee payer's signature and identify which token to charge.
+  if (feePayer === true && !feePayerSignature) delete transaction_ox.feeToken
 
   if (signature && typeof transaction.feePayer === 'object') {
     const tx = TxTempo.from(transaction_ox, {
@@ -372,8 +378,12 @@ async function serializeTempo(
 
   return TxTempo.serialize(
     // If we have specified a fee payer, the user will not be signing over the fee token.
-    // Defer the fee token signing to the fee payer.
-    { ...transaction_ox, ...(feePayer ? { feeToken: undefined } : {}) },
+    // Defer the fee token signing to the fee payer. Once the fee payer has signed,
+    // keep `feeToken` so the broadcast envelope carries the token the chain must charge.
+    {
+      ...transaction_ox,
+      ...(feePayer && !feePayerSignature ? { feeToken: undefined } : {}),
+    },
     {
       feePayerSignature: undefined,
       signature,

package/tempo/actions/fee.ts

@@ -11,7 +11,7 @@ import { writeContractSync } from '../../actions/wallet/writeContractSync.js'
 import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import { zeroAddress } from '../../constants/address.js'
-import type { BaseErrorType } from '../../errors/base.js'
+import type { BaseError, BaseErrorType } from '../../errors/base.js'
 import type { Chain } from '../../types/chain.js'
 import type { ExtractAbiItem, GetEventArgs } from '../../types/contract.js'
 import type { Log, Log as viem_Log } from '../../types/log.js'
@@ -19,6 +19,12 @@ import type { Compute, UnionOmit } from '../../types/utils.js'
 import { parseEventLogs } from '../../utils/abi/parseEventLogs.js'
 import * as Abis from '../Abis.js'
 import * as Addresses from '../Addresses.js'
+import {
+  FeeTokenNotTip20Error,
+  FeeTokenNotUsdError,
+  FeeTokenPausedError,
+  InvalidFeeTokenError,
+} from '../errors.js'
 import type {
   GetAccountParameter,
   ReadParameters,
@@ -26,6 +32,116 @@ import type {
 } from '../internal/types.js'
 import { defineCall } from '../internal/utils.js'
 import type { TransactionReceipt } from '../Transaction.js'
+import * as tokenActions from './token.js'
+
+const tip20AddressPrefix = '0x20c0'
+
+/**
+ * Validates that a token can be used as a Tempo fee token.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { tempo } from 'viem/chains'
+ * import { Actions } from 'viem/tempo'
+ *
+ * const client = createClient({
+ *   chain: tempo,
+ *   transport: http(),
+ * })
+ *
+ * const { address, metadata } = await Actions.fee.validateToken(client, {
+ *   token: '0x20c0000000000000000000000000000000000001',
+ * })
+ * ```
+ *
+ * @param client - Client.
+ * @param parameters - Parameters.
+ * @returns The fee token address, ID, and metadata.
+ */
+export async function validateToken<chain extends Chain | undefined>(
+  client: Client<Transport, chain>,
+  parameters: validateToken.Parameters,
+): Promise<validateToken.ReturnValue> {
+  const { token, ...rest } = parameters
+  const token_ = String(token)
+  const address = (() => {
+    try {
+      return TokenId.toAddress(token)
+    } catch (cause) {
+      throw new InvalidFeeTokenError({
+        cause: cause as BaseError | Error,
+        token: token_,
+      })
+    }
+  })()
+
+  if (!address.toLowerCase().startsWith(tip20AddressPrefix))
+    throw new FeeTokenNotTip20Error({ token: address })
+
+  const isPathUsd = address.toLowerCase() === Addresses.pathUsd.toLowerCase()
+  if (!isPathUsd) {
+    const isTip20 = await readContract(client, {
+      ...rest,
+      address: Addresses.tip20Factory,
+      abi: Abis.tip20Factory,
+      functionName: 'isTIP20',
+      args: [address],
+    }).catch((cause) => {
+      throw new InvalidFeeTokenError({
+        cause: cause as BaseError | Error,
+        token: address,
+      })
+    })
+    if (!isTip20) throw new FeeTokenNotTip20Error({ token: address })
+  }
+
+  const metadata = await tokenActions
+    .getMetadata(client, {
+      ...rest,
+      token: address,
+    })
+    .catch((cause) => {
+      throw new InvalidFeeTokenError({
+        cause: cause as BaseError | Error,
+        token: address,
+      })
+    })
+
+  if (metadata.currency !== 'USD')
+    throw new FeeTokenNotUsdError({
+      currency: metadata.currency,
+      token: address,
+    })
+  if (metadata.paused === true)
+    throw new FeeTokenPausedError({ token: address })
+
+  return {
+    address,
+    id: TokenId.fromAddress(address),
+    metadata,
+  }
+}
+
+export declare namespace validateToken {
+  export type Parameters = ReadParameters & {
+    /** Address or ID of the TIP20 token. */
+    token: TokenId.TokenIdOrAddress
+  }
+
+  export type ReturnValue = Compute<{
+    address: Address
+    id: bigint
+    metadata: tokenActions.getMetadata.ReturnValue
+  }>
+
+  export type ErrorType =
+    | FeeTokenNotTip20Error
+    | FeeTokenNotUsdError
+    | FeeTokenPausedError
+    | InvalidFeeTokenError
+    | BaseErrorType
+}
 
 /**
  * Gets the user's default fee token.

package/tempo/actions/wallet.ts

@@ -213,8 +213,8 @@ export declare namespace swap {
  * })
  *
  * const result = await Actions.wallet.deposit(client, {
- *   token: '0x...',
- *   value: '1.5',
+ *   amount: '1.5',
+ *   token: 'pathUsd',
  * })
  * ```
  *
@@ -243,14 +243,17 @@ export declare namespace deposit {
   export type Parameters = {
     /** Deposit address to pre-fill. */
     address?: Address | undefined
+    /** Human-readable amount to pre-fill (for example, "1.5"). */
+    amount?: string | undefined
     /** Source chain ID to pre-fill. */
     chainId?: number | undefined
     /** Human-readable account display name. */
     displayName?: string | undefined
-    /** Token contract address to pre-fill. Omit to let the user choose. */
-    token?: Address | undefined
-    /** Human-readable amount to pre-fill (for example, "1.5"). */
-    value?: string | undefined
+    /**
+     * Token to pre-fill, accepted as either a contract address or a supported
+     * deposit token symbol. Omit to let the user choose.
+     */
+    token?: Address | string | undefined
   }
 
   export type ReturnValue =

package/tempo/chainConfig.ts

@@ -1,6 +1,4 @@
-import * as Address from 'ox/Address'
 import * as Hex from 'ox/Hex'
-import * as PublicKey from 'ox/PublicKey'
 import { SignatureEnvelope, type TokenId } from 'ox/tempo'
 import { getCode } from '../actions/public/getCode.js'
 import { verifyHash } from '../actions/public/verifyHash.js'
@@ -115,9 +113,24 @@ export const chainConfig = {
       // Access key (keychain) signature verification: check the key is
       // authorized, not expired, and not revoked on the AccountKeychain.
       if (envelope?.type === 'keychain' && mode === 'allowAccessKey') {
-        const accessKeyAddress = Address.fromPublicKey(
-          PublicKey.from(envelope.inner.publicKey as PublicKey.PublicKey),
-        )
+        // For v2 keychain envelopes, the inner signature signs
+        // keccak256(0x04 || hash || userAddress).
+        const innerPayload =
+          envelope.version === 'v2'
+            ? keccak256(Hex.concat('0x04', hash, address))
+            : hash
+
+        const accessKeyAddress = (() => {
+          try {
+            return SignatureEnvelope.extractAddress({
+              payload: innerPayload,
+              signature: envelope.inner,
+            })
+          } catch {
+            return undefined
+          }
+        })()
+        if (!accessKeyAddress) return false
 
         const keyInfo = await getMetadata(client, {
           account: address,
@@ -129,13 +142,6 @@ export const chainConfig = {
         if (keyInfo.isRevoked) return false
         if (keyInfo.expiry <= BigInt(Math.floor(Date.now() / 1000)))
           return false
-
-        // For v2 keychain envelopes, the inner signature signs
-        // keccak256(0x04 || hash || userAddress).
-        const innerPayload =
-          envelope.version === 'v2'
-            ? keccak256(Hex.concat('0x04', hash, address))
-            : hash
         return SignatureEnvelope.verify(envelope.inner, {
           address: accessKeyAddress,
           payload: innerPayload,

package/tempo/chains/index.ts

@@ -0,0 +1,9 @@
+// biome-ignore lint/performance/noBarrelFile: entrypoint module
+export {
+  tempo,
+  tempoDevnet,
+  tempoLocalnet,
+  tempoMainnet,
+  tempoModerato,
+  tempoTestnet,
+} from '../Chain.js'

package/tempo/chains/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../../_types/tempo/chains/index.d.ts",
+  "module": "../../_esm/tempo/chains/index.js",
+  "main": "../../_cjs/tempo/chains/index.js"
+}

package/tempo/errors.ts

@@ -0,0 +1,78 @@
+import { BaseError } from '../errors/base.js'
+
+export type InvalidFeeTokenErrorType = InvalidFeeTokenError & {
+  name: 'InvalidFeeTokenError'
+}
+export class InvalidFeeTokenError extends BaseError {
+  constructor({
+    cause,
+    token,
+  }: {
+    cause?: BaseError | Error | undefined
+    token: string
+  }) {
+    super(`Fee token "${token}" is invalid.`, {
+      cause,
+      docsPath: '/tempo/transactions',
+      docsSlug: 'pay-fees-with-stablecoins',
+      metaMessages: [
+        'Fee tokens must be unpaused USD-denominated TIP-20 tokens.',
+        'Use `client.fee.validateToken({ token })` before sending transactions or setting fee preferences.',
+      ],
+      name: 'InvalidFeeTokenError',
+    })
+  }
+}
+
+export type FeeTokenNotTip20ErrorType = FeeTokenNotTip20Error & {
+  name: 'FeeTokenNotTip20Error'
+}
+export class FeeTokenNotTip20Error extends BaseError {
+  constructor({ token }: { token: string }) {
+    super(`Fee token "${token}" is not a TIP-20 token.`, {
+      docsPath: '/tempo/transactions',
+      docsSlug: 'pay-fees-with-stablecoins',
+      metaMessages: [
+        'Fee tokens must be TIP-20 token addresses or token IDs.',
+        'TIP-20 token addresses use the `0x20c0...` address prefix.',
+      ],
+      name: 'FeeTokenNotTip20Error',
+    })
+  }
+}
+
+export type FeeTokenNotUsdErrorType = FeeTokenNotUsdError & {
+  name: 'FeeTokenNotUsdError'
+}
+export class FeeTokenNotUsdError extends BaseError {
+  constructor({
+    currency,
+    token,
+  }: {
+    currency: string
+    token: string
+  }) {
+    super(`Fee token "${token}" is denominated in "${currency}", not "USD".`, {
+      docsPath: '/tempo/transactions',
+      docsSlug: 'pay-fees-with-stablecoins',
+      metaMessages: [
+        'Only USD-denominated TIP-20 tokens can be used as fee tokens.',
+      ],
+      name: 'FeeTokenNotUsdError',
+    })
+  }
+}
+
+export type FeeTokenPausedErrorType = FeeTokenPausedError & {
+  name: 'FeeTokenPausedError'
+}
+export class FeeTokenPausedError extends BaseError {
+  constructor({ token }: { token: string }) {
+    super(`Fee token "${token}" is paused.`, {
+      docsPath: '/tempo/transactions',
+      docsSlug: 'pay-fees-with-stablecoins',
+      metaMessages: ['Paused TIP-20 tokens cannot be used as fee tokens.'],
+      name: 'FeeTokenPausedError',
+    })
+  }
+}

package/tempo/index.ts

@@ -24,11 +24,13 @@ export * as Account from './Account.js'
 export * as Addresses from './Addresses.js'
 export * as Actions from './actions/index.js'
 export * as Capabilities from './Capabilities.js'
+export * as Chain from './Chain.js'
 export {
   type Decorator as TempoActions,
   decorator as tempoActions,
 } from './Decorator.js'
 export * as Expiry from './Expiry.js'
+export * from './errors.js'
 export * as Formatters from './Formatters.js'
 export * as Hardfork from './Hardfork.js'
 export * as P256 from './P256.js'

package/types/block.ts

@@ -69,10 +69,7 @@ export type Block<
   withdrawalsRoot?: Hex | undefined
 }
 
-export type BlockIdentifier<quantity = bigint> = {
-  /** Whether or not to throw an error if the block is not in the canonical chain as described below. Only allowed in conjunction with the blockHash tag. Defaults to false. */
-  requireCanonical?: boolean | undefined
-} & (
+export type BlockIdentifier<quantity = bigint> =
   | {
       /** The block in the canonical chain with this number */
       blockNumber: BlockNumber<quantity>
@@ -80,8 +77,9 @@ export type BlockIdentifier<quantity = bigint> = {
   | {
       /** The block uniquely identified by this hash. The `blockNumber` and `blockHash` properties are mutually exclusive; exactly one of them must be set. */
       blockHash: Hash
+      /** Whether or not to throw an error if the block is not in the canonical chain as described below. Only allowed in conjunction with the blockHash tag. Defaults to false. */
+      requireCanonical?: boolean | undefined
     }
-)
 
 /** Represents a block number in the blockchain. */
 export type BlockNumber<quantity = bigint> = quantity

package/types/eip1193.ts

@@ -974,7 +974,7 @@ export type PublicRpcSchema = [
       address: Address,
       /** An array of storage-keys that should be proofed and included. */
       storageKeys: Hash[],
-      block: BlockNumber | BlockTag,
+      block: BlockNumber | BlockTag | BlockIdentifier,
     ]
     ReturnType: Proof
   },

package/utils/abi/encodeEventTopics.ts

@@ -66,7 +66,22 @@ export type EncodeEventTopicsParameters<
 > &
   (hasEvents extends true ? unknown : never)
 
-export type EncodeEventTopicsReturnType = [Hex, ...(Hex | Hex[] | null)[]]
+export type EncodeEventTopicsReturnType<
+  abi extends Abi | readonly unknown[] = Abi,
+  eventName extends ContractEventName<abi> | undefined = undefined,
+  ///
+  resolvedEvent = abi extends Abi
+    ? eventName extends string
+      ? Extract<ExtractAbiEvents<abi>, { name: eventName }>
+      : abi['length'] extends 1
+        ? abi[0]
+        : ExtractAbiEvents<abi>
+    : unknown,
+> = IsNarrowable<abi, Abi> extends true
+  ? [resolvedEvent] extends [{ anonymous: true }]
+    ? (Hex | Hex[] | null)[]
+    : [Hex, ...(Hex | Hex[] | null)[]]
+  : (Hex | Hex[] | null)[]
 
 export type EncodeEventTopicsErrorType =
   | AbiEventNotFoundErrorType
@@ -81,7 +96,7 @@ export function encodeEventTopics<
   eventName extends ContractEventName<abi> | undefined = undefined,
 >(
   parameters: EncodeEventTopicsParameters<abi, eventName>,
-): EncodeEventTopicsReturnType {
+): EncodeEventTopicsReturnType<abi, eventName> {
   const { abi, eventName, args } = parameters as EncodeEventTopicsParameters
 
   let abiItem = abi[0]
@@ -94,9 +109,6 @@ export function encodeEventTopics<
   if (abiItem.type !== 'event')
     throw new AbiEventNotFoundError(undefined, { docsPath })
 
-  const definition = formatAbiItem(abiItem)
-  const signature = toEventSelector(definition as EventDefinition)
-
   let topics: (Hex | Hex[] | null)[] = []
   if (args && 'inputs' in abiItem) {
     const indexedInputs = abiItem.inputs?.filter(
@@ -121,7 +133,14 @@ export function encodeEventTopics<
         }) ?? []
     }
   }
-  return [signature, ...topics]
+  // Anonymous events are not identified by a signature topic, so the event
+  // selector must not be prepended.
+  if (abiItem.anonymous)
+    return topics as EncodeEventTopicsReturnType<abi, eventName>
+
+  const definition = formatAbiItem(abiItem)
+  const signature = toEventSelector(definition as EventDefinition)
+  return [signature, ...topics] as EncodeEventTopicsReturnType<abi, eventName>
 }
 
 export type EncodeArgErrorType =

package/utils/block/formatBlockParameter.ts

@@ -0,0 +1,63 @@
+import { BaseError, type BaseErrorType } from '../../errors/base.js'
+import type { BlockTag } from '../../types/block.js'
+import type { Hash, Hex } from '../../types/misc.js'
+import type { RpcBlockIdentifier } from '../../types/rpc.js'
+import type { NumberToHexErrorType } from '../encoding/toHex.js'
+import { numberToHex } from '../encoding/toHex.js'
+
+type FormatBlockParameterParameters = {
+  blockHash?: Hash | undefined
+  blockNumber?: bigint | undefined
+  blockTag?: BlockTag | undefined
+  requireCanonical?: boolean | undefined
+}
+
+type RpcBlockHashIdentifier = Extract<RpcBlockIdentifier, { blockHash: Hash }>
+
+type FormatBlockParameterReturnType = Hex | BlockTag | RpcBlockHashIdentifier
+
+export type FormatBlockParameterErrorType = BaseErrorType | NumberToHexErrorType
+
+/**
+ * Formats block parameters for RPC calls according to EIP-1898.
+ *
+ * @param parameters - Block parameters
+ * @returns Formatted block parameter for RPC call
+ *
+ * @example
+ * // Using block tag
+ * formatBlockParameter({ blockTag: 'latest' })
+ * // => 'latest'
+ *
+ * @example
+ * // Using block number
+ * formatBlockParameter({ blockNumber: 69420n })
+ * // => '0x10f2c'
+ *
+ * @example
+ * // Using block hash (EIP-1898)
+ * formatBlockParameter({ blockHash: '0x...' })
+ * // => { blockHash: '0x...' }
+ *
+ * @example
+ * // Using block hash with requireCanonical (EIP-1898)
+ * formatBlockParameter({ blockHash: '0x...', requireCanonical: true })
+ * // => { blockHash: '0x...', requireCanonical: true }
+ */
+export function formatBlockParameter(
+  parameters: FormatBlockParameterParameters,
+): FormatBlockParameterReturnType {
+  const { blockHash, blockNumber, blockTag, requireCanonical } = parameters
+
+  if (requireCanonical !== undefined && !blockHash)
+    throw new BaseError(
+      '`requireCanonical` can only be provided when `blockHash` is set.',
+    )
+
+  if (blockHash)
+    return requireCanonical ? { blockHash, requireCanonical } : { blockHash }
+
+  if (typeof blockNumber === 'bigint') return numberToHex(blockNumber)
+
+  return blockTag ?? 'latest'
+}

package/utils/ccipTunnel.ts

@@ -0,0 +1,67 @@
+import { batchGatewayAbi } from '../constants/abis.js'
+import { solidityError } from '../constants/solidity.js'
+import { HttpRequestError } from '../errors/request.js'
+import { decodeErrorResult } from './abi/decodeErrorResult.js'
+import { decodeFunctionResult } from './abi/decodeFunctionResult.js'
+import { encodeFunctionData } from './abi/encodeFunctionData.js'
+import { ccipRequest as ccipRequest_ } from './ccip.js'
+import { localBatchGatewayUrl } from './ens/localBatchGatewayRequest.js'
+
+export type CcipReadTunnelParameters = {
+  batchGateways: string[]
+  ccipRequest?: typeof ccipRequest_
+}
+
+export function ccipReadTunnel({
+  batchGateways,
+  ccipRequest = ccipRequest_,
+}: CcipReadTunnelParameters): { request: typeof ccipRequest_ } {
+  return {
+    async request({ data, sender, urls }) {
+      if (urls.includes(localBatchGatewayUrl)) {
+        return ccipRequest({
+          data,
+          sender,
+          urls: batchGateways,
+        })
+      } else {
+        const [failures, responses] = decodeFunctionResult({
+          abi: batchGatewayAbi,
+          functionName: 'query',
+          data: await ccipRequest({
+            data: encodeFunctionData({
+              abi: batchGatewayAbi,
+              functionName: 'query',
+              args: [[{ sender, data, urls }]],
+            }),
+            sender,
+            urls: batchGateways,
+          }),
+        })
+        if (failures[0]) {
+          let error: Error | undefined
+          try {
+            const res = decodeErrorResult({
+              abi: [...batchGatewayAbi, solidityError],
+              data: responses[0],
+            })
+            if (res.errorName === 'HttpError') {
+              error = new HttpRequestError({
+                body: { message: res.args[1] },
+                status: res.args[0],
+                url: urls.join(' | '),
+              })
+            } else {
+              const message = res.args[0]
+              if (message) {
+                error = new Error(message)
+              }
+            }
+          } catch {}
+          throw error ?? new Error('An unknown error occurred.')
+        }
+        return responses[0]
+      }
+    },
+  }
+}

package/utils/index.ts

@@ -155,6 +155,10 @@ export {
   offchainLookupAbiItem,
   offchainLookupSignature,
 } from './ccip.js'
+export {
+  type CcipReadTunnelParameters,
+  ccipReadTunnel,
+} from './ccipTunnel.js'
 export {
   type AssertCurrentChainErrorType,
   type AssertCurrentChainParameters,