viem 2.57.3 → 2.57.5

package/tempo/Addresses.ts

@@ -32,6 +32,7 @@ export const validator = '0xcccccccc00000000000000000000000000000000'
 export const validatorV2 = '0xcccccccc00000000000000000000000000000001'
 export const zoneFactory = '0x5aF2000000000000000000000000000000000000'
 export const zoneMessenger = '0x5A4d000000000000000000000000000000000000'
+export const zoneInbox = '0x1c00000000000000000000000000000000000001'
 export const zoneOutbox = '0x1c00000000000000000000000000000000000002'
 export const zonePortalImplementation =
   '0x5AD1000000000000000000000000000000000000'

package/tempo/Client.ts

@@ -107,7 +107,7 @@ export type CreateClientErrorType = ErrorType
  * client can be created with `createClient()`. Pass `testnet` to use the
  * Tempo testnet, or `chain` to override the chain entirely. Pass `feeToken`
  * to set a default fee token for every transaction. Use `withRelay` with a
- * `Relay.multisig` plugin to coordinate multisig owner approvals.
+ * `Relay.accounts` plugin to coordinate owner approvals.
  *
  * @example
  * ```ts
@@ -143,10 +143,10 @@ export type CreateClientErrorType = ErrorType
  * ```ts
  * import { createClient, http, Relay, Store, withRelay } from 'viem/tempo'
  *
- * // Multisig coordination with a client-local in-memory store.
+ * // Account coordination with a client-local in-memory store.
  * const client = createClient({
  *   transport: withRelay(http(), {
- *     plugins: [Relay.multisig({ store: Store.memory() })],
+ *     plugins: [Relay.accounts({ store: Store.memory() })],
  *   }),
  * })
  * ```

package/tempo/Decorator.ts

@@ -4,13 +4,13 @@ import { bindActionDecorators, type Client } from '../clients/createClient.js'
 import type { Transport } from '../clients/transports/createTransport.js'
 import type { Chain } from '../types/chain.js'
 import * as accessKeyActions from './actions/accessKey.js'
+import * as accountsActions from './actions/accounts.js'
 import * as ammActions from './actions/amm.js'
 import * as channelActions from './actions/channel.js'
 import * as dexActions from './actions/dex.js'
 import * as earnActions from './actions/earn.js'
 import * as faucetActions from './actions/faucet.js'
 import * as feeActions from './actions/fee.js'
-import * as multisigActions from './actions/multisig.js'
 import * as nonceActions from './actions/nonce.js'
 import * as policyActions from './actions/policy.js'
 import * as propAmmActions from './actions/propAmm.js'
@@ -308,13 +308,41 @@ type DecoratorBase<
       parameters: accessKeyActions.revokeSync.Parameters<chain, account>,
     ) => Promise<accessKeyActions.revokeSync.ReturnValue>
     /**
-     * Signs a key authorization or adds one coordinated multisig approval.
+     * Saves a signed key authorization to a relay with key authorization storage.
+     *
+     * The relay attaches the authorization to the access key's next transaction
+     * until the key is active onchain. Requires a relay running the
+     * `Relay.keyAuthorization` plugin.
+     *
+     * @example
+     * ```ts
+     * import { createClient, http } from 'viem'
+     * import { tempo } from 'viem/chains'
+     * import { tempoActions, withRelay } from 'viem/tempo'
+     *
+     * const client = createClient({
+     *   chain: tempo,
+     *   transport: withRelay(http(), http('https://relay.example.com'), {
+     *     keyAuthorization: true,
+     *   }),
+     * }).extend(tempoActions())
+     *
+     * await client.accessKey.saveAuthorization({ keyAuthorization })
+     * ```
+     *
+     * @param parameters - Parameters.
+     */
+    saveAuthorization: (
+      parameters: accessKeyActions.saveAuthorization.Parameters,
+    ) => Promise<accessKeyActions.saveAuthorization.ReturnValue>
+    /**
+     * Signs a key authorization or adds one coordinated owner approval.
      *
      * @example
      * ```ts
      * const pending = await client.accessKey.signAuthorization({
      *   accessKey,
-     *   account: multisig,
+     *   account: configurable,
      *   owner: owner_1,
      * })
      * const success = await client.accessKey.signAuthorization({
@@ -324,7 +352,7 @@ type DecoratorBase<
      * ```
      *
      * @param parameters - Authorization fields, or a stored operation hash.
-     * @returns A signed key authorization with multisig operation metadata when coordinated.
+     * @returns A signed key authorization with account operation metadata when coordinated.
      */
     signAuthorization: {
       (
@@ -474,6 +502,48 @@ type DecoratorBase<
       parameters: accessKeyActions.watchWitnessBurned.Parameters,
     ) => ReturnType<typeof accessKeyActions.watchWitnessBurned>
   }
+  accounts: {
+    /**
+     * Gets the current cached config for a configurable account.
+     *
+     * @param parameters - Parameters.
+     * @returns The config, or `null` when it is unknown.
+     */
+    getConfig: (
+      parameters: accountsActions.getConfig.Parameters,
+    ) => Promise<accountsActions.getConfig.ReturnValue>
+    /** Gets the current configuration commitment for a configurable account. */
+    getConfigCommitment: (
+      parameters: accountsActions.getConfigCommitment.Parameters,
+    ) => Promise<accountsActions.getConfigCommitment.ReturnValue>
+    /**
+     * Gets a coordinated account operation by its hash.
+     *
+     * @param parameters - Parameters.
+     * @returns The operation, or `null` when it is unknown.
+     */
+    getOperation: (
+      parameters: accountsActions.getOperation.Parameters,
+    ) => Promise<accountsActions.getOperation.ReturnValue>
+    /**
+     * Replaces the current configuration for a configurable account.
+     *
+     * @param parameters - New configuration and transaction parameters.
+     * @returns The transaction hash.
+     */
+    updateConfig: (
+      parameters: accountsActions.updateConfig.Parameters<chain, account>,
+    ) => Promise<accountsActions.updateConfig.ReturnValue>
+    /**
+     * Replaces a configurable account configuration and waits for confirmation.
+     *
+     * @param parameters - New configuration and transaction parameters.
+     * @returns The update event and transaction receipt.
+     */
+    updateConfigSync: (
+      parameters: accountsActions.updateConfigSync.Parameters<chain, account>,
+    ) => Promise<accountsActions.updateConfigSync.ReturnValue>
+  }
   amm: {
     /**
      * Gets the reserves for a liquidity pool.
@@ -2392,48 +2462,6 @@ type DecoratorBase<
       parameters: faucetActions.fundSync.Parameters,
     ) => Promise<faucetActions.fundSync.ReturnValue>
   }
-  multisig: {
-    /**
-     * Gets the current cached config for a multisig account.
-     *
-     * @param parameters - Parameters.
-     * @returns The config, or `null` when it is unknown.
-     */
-    getConfig: (
-      parameters: multisigActions.getConfig.Parameters,
-    ) => Promise<multisigActions.getConfig.ReturnValue>
-    /** Gets the current configuration commitment for a multisig account. */
-    getConfigCommitment: (
-      parameters: multisigActions.getConfigCommitment.Parameters,
-    ) => Promise<multisigActions.getConfigCommitment.ReturnValue>
-    /**
-     * Gets a coordinated multisig operation by its hash.
-     *
-     * @param parameters - Parameters.
-     * @returns The operation, or `null` when it is unknown.
-     */
-    getOperation: (
-      parameters: multisigActions.getOperation.Parameters,
-    ) => Promise<multisigActions.getOperation.ReturnValue>
-    /**
-     * Replaces the current configuration for a native multisig account.
-     *
-     * @param parameters - New configuration and transaction parameters.
-     * @returns The transaction hash.
-     */
-    updateConfig: (
-      parameters: multisigActions.updateConfig.Parameters<chain, account>,
-    ) => Promise<multisigActions.updateConfig.ReturnValue>
-    /**
-     * Replaces a native multisig configuration and waits for confirmation.
-     *
-     * @param parameters - New configuration and transaction parameters.
-     * @returns The update event and transaction receipt.
-     */
-    updateConfigSync: (
-      parameters: multisigActions.updateConfigSync.Parameters<chain, account>,
-    ) => Promise<multisigActions.updateConfigSync.ReturnValue>
-  }
   nonce: {
     /**
      * Gets the nonce for an account and nonce key.
@@ -6064,6 +6092,10 @@ export type Decorator<
     DecoratorBase<chain, account>['accessKey'],
     typeof accessKeyActions
   >
+  accounts: DecorateNamespace<
+    DecoratorBase<chain, account>['accounts'],
+    typeof accountsActions
+  >
   amm: DecorateNamespace<
     DecoratorBase<chain, account>['amm'],
     typeof ammActions
@@ -6084,10 +6116,6 @@ export type Decorator<
     DecoratorBase<chain, account>['faucet'],
     typeof faucetActions
   >
-  multisig: DecorateNamespace<
-    DecoratorBase<chain, account>['multisig'],
-    typeof multisigActions
-  >
   nonce: DecorateNamespace<
     DecoratorBase<chain, account>['nonce'],
     typeof nonceActions
@@ -6166,6 +6194,7 @@ export function decorator() {
         'prepareAuthorization',
         'revoke',
         'revokeSync',
+        'saveAuthorization',
         'signAuthorization',
         'updateLimit',
         'updateLimitSync',
@@ -6174,6 +6203,13 @@ export function decorator() {
         'watchWitness',
         'watchWitnessBurned',
       ]),
+      accounts: bindActions(client, accountsActions, [
+        'getConfig',
+        'getConfigCommitment',
+        'getOperation',
+        'updateConfig',
+        'updateConfigSync',
+      ]),
       amm: bindActions(client, ammActions, [
         'getPool',
         'getLiquidityBalance',
@@ -6262,13 +6298,6 @@ export function decorator() {
         'withdrawExactSync',
       ]),
       faucet: bindActions(client, faucetActions, ['fund', 'fundSync']),
-      multisig: bindActions(client, multisigActions, [
-        'getConfig',
-        'getConfigCommitment',
-        'getOperation',
-        'updateConfig',
-        'updateConfigSync',
-      ]),
       nonce: bindActions(client, nonceActions, [
         'getNonce',
         'watchNonceIncremented',

package/tempo/ExecutionError.ts

@@ -114,7 +114,7 @@ export const messages: Record<`${AbiErrorName}(${string})`, string> = {
   'InvalidMasterAddress()': 'Invalid master address.',
   'InvalidMigrationIndex()': 'Invalid migration index.',
   'InvalidMode()': 'Invalid mode.',
-  'InvalidMultisigOwner()': 'Invalid multisig owner.',
+  'InvalidMultisigOwner()': 'Invalid owner.',
   'InvalidNonceKey()': 'Invalid nonce key.',
   'InvalidOwner()': 'Invalid owner.',
   'InvalidOwnerOrder()': 'Invalid owner order.',

package/tempo/Formatters.ts

@@ -3,7 +3,7 @@
 import type { Address } from 'abitype'
 import * as Hex from 'ox/Hex'
 import {
-  MultisigOperation,
+  AccountOperation,
   Transaction as ox_Transaction,
   TransactionRequest as ox_TransactionRequest,
 } from 'ox/tempo'
@@ -12,7 +12,7 @@ import { parseAccount } from '../accounts/utils/parseAccount.js'
 import { formatTransaction as viem_formatTransaction } from '../utils/formatters/transaction.js'
 import { formatTransactionReceipt as viem_formatTransactionReceipt } from '../utils/formatters/transactionReceipt.js'
 import { formatTransactionRequest as viem_formatTransactionRequest } from '../utils/formatters/transactionRequest.js'
-import type { Account, MultisigAccount } from './Account.js'
+import type { Account, ConfigurableAccount } from './Account.js'
 import {
   isTempo,
   type Transaction,
@@ -33,7 +33,7 @@ export function formatTransaction(
     transaction.blockTimestamp == null
       ? undefined
       : BigInt(transaction.blockTimestamp)
-  const multisig = transaction.multisig
+  const operation = transaction.operation
   const {
     feePayerSignature,
     gasPrice: _,
@@ -53,8 +53,8 @@ export function formatTransaction(
           yParity: feePayerSignature.yParity,
         }
       : undefined,
-    multisig: formatMultisig(multisig),
     nonce: Number(nonce),
+    operation: formatOperation(operation),
     typeHex:
       ox_Transaction.toRpcType[
         tx.type as keyof typeof ox_Transaction.toRpcType
@@ -69,7 +69,7 @@ export function formatTransactionReceipt(
   const transactionReceipt = viem_formatTransactionReceipt(receipt as never)
   return {
     ...transactionReceipt,
-    multisig: formatMultisig(receipt.multisig),
+    operation: formatOperation(receipt.operation),
     ...(receipt.status === 'pending'
       ? { status: 'pending', type: 'tempo' }
       : {}),
@@ -77,11 +77,11 @@ export function formatTransactionReceipt(
 }
 
 /** Formats a transaction operation attached to an RPC result. */
-function formatMultisig(value: MultisigOperation.TransactionRpc | undefined) {
+function formatOperation(value: AccountOperation.TransactionRpc | undefined) {
   if (!value) return undefined
-  const operation = MultisigOperation.fromRpc(value)
+  const operation = AccountOperation.fromRpc(value)
   if (operation.type !== 'transaction')
-    throw new Error('Expected a multisig transaction operation.')
+    throw new Error('Expected an account transaction operation.')
   return operation
 }
 
@@ -98,21 +98,21 @@ export function formatTransactionRequest(
     keyData?: Hex.Hex | undefined
     keyId?: Address | undefined
     keyType?: 'p256' | 'secp256k1' | 'webAuthn' | undefined
-    owner?: viem_Account | MultisigAccount | Address | undefined
+    owner?: viem_Account | ConfigurableAccount | Address | undefined
     signatures?: unknown
   }
   const account = request.account
     ? parseAccount<Account | viem_Account | Address>(request.account)
     : undefined
   const owner = request.owner
-    ? parseAccount<Account | MultisigAccount | viem_Account | Address>(
+    ? parseAccount<Account | ConfigurableAccount | viem_Account | Address>(
         request.owner,
       )
     : undefined
 
   if (owner?.type === 'json-rpc')
     throw new Error(
-      'A local owner account is required to approve a multisig transaction.',
+      'A local owner account is required to approve a configurable account transaction.',
     )
 
   // If the request is not a Tempo transaction, route to Viem formatter.
@@ -147,7 +147,7 @@ export function formatTransactionRequest(
   if (request.feePayer === true && !request.feePayerSignature)
     delete request.feeToken
 
-  // Client-only TIP-1061 fields drive local signing and envelope assembly.
+  // Client-only TIP-1107 fields drive local signing and envelope assembly.
   const { owner: _owner, signatures: _signatures, ...rpcRequest } = request
 
   const rpc = ox_TransactionRequest.toRpc({
@@ -191,7 +191,8 @@ export function formatTransactionRequest(
     ...(keyData ? { keyData } : {}),
     ...(keyId ? { keyId } : {}),
     ...(keyType ? { keyType } : {}),
-    // Keep the key visible to `extract`; the undefined value never reaches JSON-RPC.
+    // Keep client-only keys visible to `extract`; undefined values never reach JSON-RPC.
+    ...(request.accountSimulation ? { accountSimulation: undefined } : {}),
     ...(request.owner ? { owner: undefined } : {}),
     ...(typeof request.feePayer !== 'undefined'
       ? {

package/tempo/KeyAuthorizationManager.ts

@@ -1,49 +1,101 @@
 import type { Address } from 'abitype'
-import type { KeyAuthorization } from 'ox/tempo'
+import { KeyAuthorization } from 'ox/tempo'
 import type { MaybePromise } from '../types/utils.js'
+import * as Store from './Store.js'
 
+/** Identifies a pending key authorization by account, access key, and chain. */
 export type Key = {
+  /** Account the access key acts for. */
   address: Address
+  /** Access key address. */
   accessKey: Address
+  /** Chain the authorization is for. */
   chainId: number
 }
 
+/** Pending key authorizations that the client attaches to an access key's next transaction. */
 export type KeyAuthorizationManager = {
+  /** Reads the pending authorization for a key. */
   get(key: Key): MaybePromise<KeyAuthorization.Signed | undefined>
+  /** Removes the pending authorization for a key. */
   remove(key: Key): MaybePromise<void>
+  /** Stores a pending authorization for a key. */
   set(key: Key, keyAuthorization: KeyAuthorization.Signed): MaybePromise<void>
 }
 
+/**
+ * Creates a key authorization manager backed by a store.
+ *
+ * Entries use the same keys as the `Relay.keyAuthorization` plugin, so both can
+ * share one store.
+ *
+ * @example
+ * ```ts
+ * import { Account, KeyAuthorizationManager, Store } from 'viem/tempo'
+ *
+ * const accessKey = Account.fromP256(privateKey, {
+ *   access: root,
+ *   keyAuthorizationManager: KeyAuthorizationManager.from({
+ *     store: Store.session(),
+ *   }),
+ * })
+ * ```
+ *
+ * @param options - Manager options.
+ * @returns A key authorization manager.
+ */
 export function from(options: from.Options): KeyAuthorizationManager {
-  return options.source
+  const { store } = options
+  return {
+    async get(key) {
+      const value = await store.getItem(getStoreKey(key))
+      if (!value) return undefined
+      try {
+        return KeyAuthorization.deserialize(
+          value as `0x${string}`,
+        ) as KeyAuthorization.Signed
+      } catch {
+        return undefined
+      }
+    },
+    async remove(key) {
+      await store.removeItem(getStoreKey(key))
+    },
+    async set(key, keyAuthorization) {
+      await store.setItem(
+        getStoreKey(key),
+        KeyAuthorization.serialize(keyAuthorization),
+      )
+    },
+  }
 }
 
 export declare namespace from {
   type Options = {
-    source: KeyAuthorizationManager
+    /** Store for pending key authorizations. */
+    store: Store.Store
   }
 }
 
+/**
+ * Creates a key authorization manager backed by a process-local memory store.
+ *
+ * @example
+ * ```ts
+ * import { KeyAuthorizationManager } from 'viem/tempo'
+ *
+ * const keyAuthorizationManager = KeyAuthorizationManager.memory()
+ * ```
+ *
+ * @returns A key authorization manager.
+ */
 export function memory(): KeyAuthorizationManager {
-  const keyAuthorizations = new Map<string, KeyAuthorization.Signed>()
-
-  return from({
-    source: {
-      get(key) {
-        return keyAuthorizations.get(serializeKey(key))
-      },
-      remove(key) {
-        keyAuthorizations.delete(serializeKey(key))
-      },
-      set(key, keyAuthorization) {
-        keyAuthorizations.set(serializeKey(key), keyAuthorization)
-      },
-    },
-  })
+  return from({ store: Store.memory() })
 }
 
-function serializeKey(key: Key) {
+function getStoreKey(key: Key) {
   return [
+    'keyAuthorization',
     key.chainId,
     key.address.toLowerCase(),
     key.accessKey.toLowerCase(),

package/tempo/Relay.ts

@@ -4,9 +4,10 @@ import type { LocalAccount } from '../accounts/types.js'
 import type { Client as Client_ } from '../clients/createClient.js'
 import { ChainNotConfiguredError } from '../clients/createClientResolver.js'
 import type { EIP1193RequestOptions } from '../types/eip1193.js'
+import * as Accounts from './internal/relay/accounts.js'
 import * as Sponsorship from './internal/relay/feePayer.js'
 import * as FeeToken from './internal/relay/feeToken.js'
-import * as Multisig from './internal/relay/multisig.js'
+import * as KeyAuthorization from './internal/relay/keyAuthorization.js'
 import * as Request_ from './internal/relay/request.js'
 import * as Simulate from './internal/relay/simulate.js'
 import * as internal from './internal/relay.js'
@@ -307,13 +308,19 @@ export declare namespace Plugin {
   }
 }
 
-declare const multisigBrand: unique symbol
+declare const accountsBrand: unique symbol
 
 /**
- * Coordinates native multisig approvals using shared atomic storage.
+ * Serves configurable accounts using shared atomic storage.
+ *
+ * The chain stores only a commitment to each account's config, so the plugin
+ * records every config it relays (including configs left by `updateConfig`
+ * calls) and serves them through `account_getConfig`. It also collects owner
+ * approvals until the account's threshold is met, then submits.
  *
  * Memory storage is process-local. Independent clients and multiple server
- * instances must use the same persistent store to share pending approvals.
+ * instances must use the same persistent store to share configs and pending
+ * approvals.
  *
  * @example
  * ```ts
@@ -321,31 +328,31 @@ declare const multisigBrand: unique symbol
  * import { Relay, Store, withRelay } from 'viem/tempo'
  *
  * const transport = withRelay(http(), {
- *   plugins: [Relay.multisig({ store: Store.memory() })],
+ *   plugins: [Relay.accounts({ store: Store.memory() })],
  * })
  * ```
  *
  * @param options - Shared atomic storage.
- * @returns A plugin that coordinates multisig requests and forwards other calls.
+ * @returns A plugin that handles configurable account requests and forwards other calls.
  */
-export function multisig(options: multisig.Options): multisig.ReturnType {
-  return Multisig.create(options)
+export function accounts(options: accounts.Options): accounts.ReturnType {
+  return Accounts.create(options)
 }
 
-export declare namespace multisig {
-  /** Multisig coordination options. */
+export declare namespace accounts {
+  /** Configurable account options. */
   export type Options = {
-    /** Store shared by multisig coordinators, with atomic compare-and-set support. */
+    /** Store shared by relays, with atomic compare-and-set support. */
     store: Store.Atomic
   }
-  /** Middleware advertising native multisig coordination. */
-  export type ReturnType = Plugin & { readonly [multisigBrand]: true }
+  /** Middleware advertising configurable account support. */
+  export type ReturnType = Plugin & { readonly [accountsBrand]: true }
 }
 
 /**
  * Sponsors transactions with a local account or an external fee-payer relay.
  *
- * Place multisig before this plugin and fee-token selection after it.
+ * Place accounts before this plugin and fee-token selection after it.
  *
  * @example
  * ```ts
@@ -400,6 +407,55 @@ export function feeToken(): Plugin {
   return FeeToken.create()
 }
 
+declare const keyAuthorizationBrand: unique symbol
+
+/**
+ * Stores pending key authorizations and attaches them to the next fill that needs them.
+ *
+ * Signing a key authorization with `Actions.accessKey.signAuthorization` through a
+ * relay with this plugin saves it with `relay_saveKeyAuthorization`. Configurable
+ * account key authorizations are saved once they reach quorum. The next `eth_fillTransaction`
+ * from the access key includes the authorization until the key is active onchain.
+ * Remote `withRelay` transports opt in with `keyAuthorization: true`.
+ *
+ * Place this plugin before `Relay.accounts` so it can observe completed configurable
+ * account key authorizations, and before plugins that read the filled transaction.
+ *
+ * A saved authorization only replaces a pending authorization that expires earlier,
+ * so a replayed older authorization cannot replace a newer one.
+ *
+ * Memory storage is process-local. Multiple server instances must use the same
+ * persistent atomic store to share pending authorizations.
+ *
+ * @example
+ * ```ts
+ * import { http } from 'viem'
+ * import { Relay, Store, withRelay } from 'viem/tempo'
+ *
+ * const transport = withRelay(http(), {
+ *   plugins: [Relay.keyAuthorization({ store: Store.memory() })],
+ * })
+ * ```
+ *
+ * @param options - Pending key authorization storage.
+ * @returns A plugin that stores and attaches pending key authorizations.
+ */
+export function keyAuthorization(
+  options: keyAuthorization.Options = {},
+): keyAuthorization.ReturnType {
+  return KeyAuthorization.create(options)
+}
+
+export declare namespace keyAuthorization {
+  /** Key authorization storage options. */
+  export type Options = {
+    /** Store for pending key authorizations, with atomic compare-and-set support. Defaults to a process-local memory store. */
+    store?: Store.Atomic | undefined
+  }
+  /** Middleware advertising pending key authorization storage. */
+  export type ReturnType = Plugin & { readonly [keyAuthorizationBrand]: true }
+}
+
 /**
  * Adds balance changes, estimated fees, and execution errors to fill capabilities.
  *

package/tempo/Selectors.ts

@@ -439,3 +439,16 @@ export const zoneOutbox = {
 export const zoneMessenger = {
   relayMessage: '0x11da5261',
 } as const satisfies FunctionSelectors<typeof Abis.zoneMessenger>
+
+export const zoneInbox = {
+  advanceTempo: '0x86516ec0',
+  advanceTempoHeaders: '0xae58328d',
+  claimRefund: '0xbffa55d5',
+  processedDepositNumber: '0x2d488482',
+  processedDepositQueueHash: '0x82648c3b',
+  processedEnabledTokenCount: '0x1b366d74',
+  processedTokenEnablementHash: '0x8f2e461a',
+  refunds: '0x857e85f8',
+  tempoPortal: '0xa21de6d9',
+  tempoState: '0x1fbb25ad',
+} as const satisfies FunctionSelectors<typeof Abis.zoneInbox>