viem 2.54.1 → 2.54.3

package/tempo/Abis.ts

@@ -2570,6 +2570,54 @@ export const validatorConfig = [
   },
 ] as const
 
+export const storageCredits = [
+  {
+    type: 'error',
+    name: 'DelegateCallNotAllowed',
+    inputs: [],
+  },
+  {
+    type: 'error',
+    name: 'InvalidMode',
+    inputs: [],
+  },
+  {
+    type: 'function',
+    name: 'balanceOf',
+    stateMutability: 'view',
+    inputs: [{ name: 'account', type: 'address' }],
+    outputs: [{ type: 'uint64' }],
+  },
+  {
+    type: 'function',
+    name: 'modeOf',
+    stateMutability: 'view',
+    inputs: [{ name: 'account', type: 'address' }],
+    outputs: [{ type: 'uint8' }],
+  },
+  {
+    type: 'function',
+    name: 'budgetOf',
+    stateMutability: 'view',
+    inputs: [{ name: 'account', type: 'address' }],
+    outputs: [{ type: 'uint64' }],
+  },
+  {
+    type: 'function',
+    name: 'setMode',
+    stateMutability: 'nonpayable',
+    inputs: [{ name: 'newMode', type: 'uint8' }],
+    outputs: [],
+  },
+  {
+    type: 'function',
+    name: 'setBudget',
+    stateMutability: 'nonpayable',
+    inputs: [{ name: 'creditBudget', type: 'uint64' }],
+    outputs: [],
+  },
+] as const
+
 export const validatorConfigV2 = [
   {
     name: 'getActiveValidators',
@@ -2931,6 +2979,7 @@ export const abis = [
   ...receivePolicyGuard,
   ...signatureVerifier,
   ...stablecoinDex,
+  ...storageCredits,
   ...tip20,
   ...tip20ChannelReserve,
   ...tip20Factory,

package/tempo/Addresses.ts

@@ -9,6 +9,8 @@ export const pathUsd = '0x20c0000000000000000000000000000000000000'
 export const receivePolicyGuard = '0xB10C000000000000000000000000000000000000'
 export const signatureVerifier = '0x5165300000000000000000000000000000000000'
 export const stablecoinDex = '0xdec0000000000000000000000000000000000000'
+export const storageCredits = '0x1060000000000000000000000000000000000000'
+export const tip20ChannelReserve = '0x4d50500000000000000000000000000000000000'
 export const tip20Factory = '0x20fc000000000000000000000000000000000000'
 export const tip403Registry = '0x403c000000000000000000000000000000000000'
 export const validator = '0xcccccccc00000000000000000000000000000000'

package/tempo/Decorator.ts

@@ -5129,6 +5129,9 @@ type BoundActionHelpers<action> = (action extends { call: infer helper }
   (action extends { estimateGas: infer helper }
     ? { estimateGas: BoundHelper<helper> }
     : {}) &
+  (action extends { prepare: infer helper }
+    ? { prepare: BoundHelper<helper> }
+    : {}) &
   (action extends { simulate: infer helper }
     ? { simulate: BoundHelper<helper> }
     : {}) &

package/tempo/Formatters.ts

@@ -121,8 +121,12 @@ export function formatTransactionRequest(
   // `multisig` / `signatures` are client-side only (TIP-1061). They drive
   // sender derivation, owner signing, and final envelope assembly, but are
   // never sent as raw RPC fields — the wire payload is the serialized tx.
+  // `multisigInit` / `multisigSignatureCount` are wire fields: the node
+  // prices multisig gas from them during simulation.
   const {
     multisig: _multisig,
+    multisigInit,
+    multisigSignatureCount,
     signatures: _signatures,
     ...rpcRequest
   } = request
@@ -164,6 +168,10 @@ export function formatTransactionRequest(
 
   return {
     ...rpc,
+    ...(multisigInit ? { multisigInit } : {}),
+    ...(typeof multisigSignatureCount !== 'undefined'
+      ? { multisigSignatureCount }
+      : {}),
     ...(request.capabilities ? { capabilities: request.capabilities } : {}),
     ...(keyData ? { keyData } : {}),
     ...(keyId ? { keyId } : {}),

package/tempo/Selectors.ts

@@ -94,6 +94,14 @@ export const stablecoinDex = {
   withdraw: '0x08fab167',
 } as const satisfies FunctionSelectors<typeof Abis.stablecoinDex>
 
+export const storageCredits = {
+  balanceOf: '0x70a08231',
+  budgetOf: '0x7865e71f',
+  modeOf: '0x13668995',
+  setBudget: '0xffe295c3',
+  setMode: '0x21175b4a',
+} as const satisfies FunctionSelectors<typeof Abis.storageCredits>
+
 export const tip20 = {
   BURN_BLOCKED_ROLE: '0x32ad9be8',
   DOMAIN_SEPARATOR: '0x3644e515',

package/tempo/Transaction.ts

@@ -126,6 +126,16 @@ export type TransactionRequestTempo<
     feeToken?: TempoAddress.Address | bigint | undefined
     keyAuthorization?: KeyAuthorization.Signed<quantity, index> | undefined
     multisig?: MultisigConfig.Config<index> | undefined
+    /** Bootstrap multisig config hint for node-side gas modeling (TIP-1061). Attached automatically when `multisig` is present; the node ignores it for registered senders. */
+    multisigInit?:
+      | {
+          salt: Hex.Hex
+          threshold: number
+          owners: readonly { owner: Address; weight: number }[]
+        }
+      | undefined
+    /** Modeled owner approval count for node-side gas modeling (TIP-1061). */
+    multisigSignatureCount?: number | undefined
     nonceKey?: 'expiring' | quantity | undefined
     signatures?: readonly SignatureEnvelope.Serialized[] | undefined
     validBefore?: index | undefined

package/tempo/actions/receivePolicy.ts

@@ -1,5 +1,5 @@
 import type { Address } from 'abitype'
-import type { ReceivePolicyReceipt } from 'ox/tempo'
+import { type ReceivePolicyReceipt, VirtualAddress } from 'ox/tempo'
 import type { Account } from '../../accounts/types.js'
 import { parseAccount } from '../../accounts/utils/parseAccount.js'
 import type { ReadContractReturnType } from '../../actions/public/readContract.js'
@@ -57,6 +57,25 @@ export type BlockedReason = ReceivePolicyReceipt.BlockedReason
 /** @internal */
 const blockedReasons = ['none', 'tokenFilter', 'receivePolicy'] as const
 
+/** @internal 12-byte prefix shared by TIP-20 token addresses. */
+const tip20Prefix = '0x20c000000000000000000000'
+
+/** @internal */
+const systemPrecompiles = [
+  Addresses.accountKeychain,
+  Addresses.accountRegistrar,
+  Addresses.addressRegistry,
+  Addresses.feeManager,
+  Addresses.nonceManager,
+  Addresses.receivePolicyGuard,
+  Addresses.signatureVerifier,
+  Addresses.stablecoinDex,
+  Addresses.tip20ChannelReserve,
+  Addresses.tip20Factory,
+  Addresses.tip403Registry,
+  Addresses.validator,
+] as const
+
 /**
  * Claimer authorized to reclaim blocked funds.
  *
@@ -1253,9 +1272,25 @@ function toPolicyRef(id: bigint): PolicyRef {
 
 /** @internal */
 function resolveClaimer(claimer: Claimer, self: Address): Address {
-  if (claimer === 'sender') return zeroAddress
-  if (claimer === 'self') return self
-  return claimer
+  const recoveryAuthority =
+    claimer === 'sender' ? zeroAddress : claimer === 'self' ? self : claimer
+  assertValidRecoveryAuthority(recoveryAuthority)
+  return recoveryAuthority
+}
+
+/** @internal */
+function assertValidRecoveryAuthority(recoveryAuthority: Address) {
+  if (isAddressEqual(recoveryAuthority, zeroAddress)) return
+  if (VirtualAddress.isVirtual(recoveryAuthority))
+    throw new Error('Recovery authority cannot be a TIP-1022 virtual address.')
+  if (recoveryAuthority.toLowerCase().startsWith(tip20Prefix))
+    throw new Error('Recovery authority cannot be a TIP-20 token address.')
+  if (
+    systemPrecompiles.some((address) =>
+      isAddressEqual(address, recoveryAuthority),
+    )
+  )
+    throw new Error('Recovery authority cannot be a Tempo system precompile.')
 }
 
 /** @internal */

package/tempo/actions/virtualAddress.ts

@@ -1,5 +1,6 @@
 import type { Address } from 'abitype'
 import * as Hex from 'ox/Hex'
+import { VirtualAddress } from 'ox/tempo'
 import type { Account } from '../../accounts/types.js'
 import { readContract } from '../../actions/public/readContract.js'
 import type { WriteContractReturnType } from '../../actions/wallet/writeContract.js'
@@ -121,7 +122,7 @@ export async function resolve<
   client: Client<Transport, chain, account>,
   parameters: resolve.Parameters,
 ): Promise<resolve.ReturnValue> {
-  if (!isVirtual(parameters.address)) return parameters.address
+  if (!VirtualAddress.isVirtual(parameters.address)) return parameters.address
 
   const masterId = Hex.slice(parameters.address, 0, 4)
   return getMasterAddress(client, { ...parameters, masterId })
@@ -328,10 +329,3 @@ export namespace registerMasterSync {
   // TODO: exhaustive error type
   export type ErrorType = BaseErrorType
 }
-
-const virtualMagic = '0xfdfdfdfdfdfdfdfdfdfd'
-
-/** @internal */
-function isVirtual(address: string): boolean {
-  return Hex.slice(address as Hex.Hex, 4, 14).toLowerCase() === virtualMagic
-}

package/tempo/actions/zone.ts

@@ -26,7 +26,7 @@ import type {
   ReadParameters,
   WriteParameters,
 } from '../internal/types.js'
-import { defineCall } from '../internal/utils.js'
+import { defineCall, pickWriteParameters } from '../internal/utils.js'
 import * as Storage from '../Storage.js'
 import type { TransactionReceipt } from '../Transaction.js'
 import * as ZoneAbis from '../zones/Abis.js'
@@ -40,6 +40,23 @@ export type EncryptedPayload = {
   tag: Hex.Hex
 }
 
+export type PreparedEncryptedDeposit = {
+  /** Amount of tokens to deposit. */
+  amount: bigint
+  /** Parent chain ID (e.g. `42431` for moderato). */
+  chainId: number
+  /** Encrypted deposit payload. */
+  encrypted: EncryptedPayload
+  /** Encryption key index from the portal contract. */
+  keyIndex: bigint
+  /** Zone portal address on the parent chain. */
+  portalAddress: Address
+  /** Token address or ID to deposit. */
+  token: TokenId.TokenIdOrAddress
+  /** Zone ID (e.g. `7`). */
+  zoneId: number
+}
+
 /**
  * Deposits tokens into a zone on the parent Tempo chain.
  * Batches approve and deposit into a single transaction.
@@ -269,46 +286,31 @@ export async function encryptedDeposit<
   const account_ = account ? parseAccount(account) : undefined
   if (!account) throw new Error('`account` is required.')
 
-  const recipient = parameters.recipient ?? account_?.address
-  if (!recipient) throw new Error('`recipient` is required.')
-
-  const portalAddress = getPortalAddress(chainId, parameters.zoneId)
-
-  const [publicKey, keyIndex] = await Promise.all([
-    readContract(client, {
-      address: portalAddress,
-      abi: ZoneAbis.zonePortal,
-      functionName: 'sequencerEncryptionKey',
-    }),
-    readContract(client, {
-      address: portalAddress,
-      abi: ZoneAbis.zonePortal,
-      functionName: 'encryptionKeyCount',
-    }),
-  ])
-
-  if (keyIndex === 0n) {
-    throw new Error('No sequencer encryption key configured.')
+  if ('encrypted' in parameters) {
+    if (parameters.chainId !== chainId) {
+      throw new Error(
+        'Prepared encrypted deposit chain ID does not match client chain.',
+      )
+    }
+    return sendTransaction(client, {
+      ...pickWriteParameters(parameters as never),
+      calls: encryptedDeposit.calls(parameters),
+    } as never) as never
   }
 
-  const encrypted = await encryptDepositPayload(
-    { x: publicKey[0], yParity: publicKey[1] },
-    recipient,
-    portalAddress,
-    keyIndex - 1n,
-    parameters.memo,
-  )
+  const recipient = parameters.recipient ?? account_?.address
+  if (!recipient) throw new Error('`recipient` is required.')
 
-  const args = {
-    ...parameters,
-    chainId,
-    encrypted,
-    keyIndex: keyIndex - 1n,
+  const prepared = await encryptedDeposit.prepare(client, {
+    amount: parameters.amount,
+    memo: parameters.memo,
     recipient,
-  }
+    token: parameters.token,
+    zoneId: parameters.zoneId,
+  })
   return sendTransaction(client, {
     ...rest,
-    calls: encryptedDeposit.calls(args),
+    calls: encryptedDeposit.calls(prepared),
   } as never) as never
 }
 
@@ -317,10 +319,13 @@ export namespace encryptedDeposit {
     chain extends Chain | undefined = Chain | undefined,
     account extends Account | undefined = Account | undefined,
   > = WriteParameters<chain, account> &
-    Omit<Args, 'chainId' | 'encrypted' | 'keyIndex' | 'recipient'> & {
-      /** Recipient address in the zone. @default `account.address` */
-      recipient?: Address | undefined
-    }
+    (
+      | (Omit<Args, 'chainId' | 'encrypted' | 'keyIndex' | 'recipient'> & {
+          /** Recipient address in the zone. @default `account.address` */
+          recipient?: Address | undefined
+        })
+      | PreparedEncryptedDeposit
+    )
 
   export type Args = {
     /** Amount of tokens to deposit. */
@@ -346,13 +351,111 @@ export namespace encryptedDeposit {
   // TODO: exhaustive error type
   export type ErrorType = BaseErrorType
 
+  /**
+   * Prepares an encrypted deposit instruction without broadcasting it.
+   *
+   * @example
+   * ```ts
+   * import { createClient, http } from 'viem'
+   * import { tempoModerato } from 'viem/chains'
+   * import { Actions } from 'viem/tempo'
+   *
+   * const client = createClient({
+   *   chain: tempoModerato,
+   *   transport: http(),
+   * })
+   *
+   * const prepared = await Actions.zone.encryptedDeposit.prepare(client, {
+   *   token: '0x20c0...0001',
+   *   amount: 1_000_000n,
+   *   recipient: '0x...',
+   *   zoneId: 7,
+   * })
+   * ```
+   *
+   * @param client - Public client connected to the parent Tempo chain.
+   * @param parameters - Encrypted deposit preparation parameters.
+   * @returns A prepared encrypted deposit instruction.
+   */
+  export async function prepare<
+    chain extends Chain | undefined,
+    account extends Account | undefined,
+  >(
+    client: Client<Transport, chain, account>,
+    parameters: prepare.Parameters,
+  ): Promise<prepare.ReturnValue> {
+    const chainId = client.chain?.id
+    if (!chainId) throw new Error('`chain` is required.')
+
+    const { amount, memo, recipient, token, zoneId, ...rest } = parameters
+    const portalAddress = getPortalAddress(chainId, zoneId)
+
+    const [publicKey, keyIndex] = await Promise.all([
+      readContract(client, {
+        ...rest,
+        address: portalAddress,
+        abi: ZoneAbis.zonePortal,
+        functionName: 'sequencerEncryptionKey',
+      }),
+      readContract(client, {
+        ...rest,
+        address: portalAddress,
+        abi: ZoneAbis.zonePortal,
+        functionName: 'encryptionKeyCount',
+      }),
+    ])
+
+    if (keyIndex === 0n) {
+      throw new Error('No sequencer encryption key configured.')
+    }
+
+    const encrypted = await encryptDepositPayload(
+      { x: publicKey[0], yParity: publicKey[1] },
+      recipient,
+      portalAddress,
+      keyIndex - 1n,
+      memo,
+    )
+
+    return {
+      amount,
+      chainId,
+      encrypted,
+      keyIndex: keyIndex - 1n,
+      portalAddress,
+      token,
+      zoneId,
+    }
+  }
+
+  export namespace prepare {
+    export type Parameters = ReadParameters & Args
+
+    export type Args = {
+      /** Amount of tokens to deposit. */
+      amount: bigint
+      /** Optional deposit memo. @default `0x00...00` */
+      memo?: Hex.Hex | undefined
+      /** Recipient address in the zone. */
+      recipient: Address
+      /** Token address or ID to deposit. */
+      token: TokenId.TokenIdOrAddress
+      /** Zone ID (e.g. `7`). */
+      zoneId: number
+    }
+
+    export type ReturnValue = PreparedEncryptedDeposit
+
+    export type ErrorType = RequestErrorType | BaseErrorType
+  }
+
   /**
    * Defines the calls to approve and deposit tokens into a zone (encrypted).
    *
    * @param args - Arguments.
    * @returns The calls.
    */
-  export function calls(args: Args) {
+  export function calls(args: Args | PreparedEncryptedDeposit) {
     const { amount, chainId, encrypted, keyIndex, token, zoneId } = args
     const portalAddress = getPortalAddress(chainId, zoneId)
     return [
@@ -430,47 +533,34 @@ export async function encryptedDepositSync<
   const account_ = account ? parseAccount(account) : undefined
   if (!account) throw new Error('`account` is required.')
 
-  const recipient = parameters.recipient ?? account_?.address
-  if (!recipient) throw new Error('`recipient` is required.')
-
-  const portalAddress = getPortalAddress(chainId, parameters.zoneId)
-
-  const [publicKey, keyIndex] = await Promise.all([
-    readContract(client, {
-      address: portalAddress,
-      abi: ZoneAbis.zonePortal,
-      functionName: 'sequencerEncryptionKey',
-    }),
-    readContract(client, {
-      address: portalAddress,
-      abi: ZoneAbis.zonePortal,
-      functionName: 'encryptionKeyCount',
-    }),
-  ])
-
-  if (keyIndex === 0n) {
-    throw new Error('No sequencer encryption key configured.')
+  if ('encrypted' in parameters) {
+    if (parameters.chainId !== chainId) {
+      throw new Error(
+        'Prepared encrypted deposit chain ID does not match client chain.',
+      )
+    }
+    const receipt = await sendTransactionSync(client, {
+      ...pickWriteParameters(parameters as never),
+      throwOnReceiptRevert,
+      calls: encryptedDeposit.calls(parameters),
+    } as never)
+    return { receipt }
   }
 
-  const encrypted = await encryptDepositPayload(
-    { x: publicKey[0], yParity: publicKey[1] },
-    recipient,
-    portalAddress,
-    keyIndex - 1n,
-    parameters.memo,
-  )
+  const recipient = parameters.recipient ?? account_?.address
+  if (!recipient) throw new Error('`recipient` is required.')
 
-  const args = {
-    ...parameters,
-    chainId,
-    encrypted,
-    keyIndex: keyIndex - 1n,
+  const prepared = await encryptedDeposit.prepare(client, {
+    amount: parameters.amount,
+    memo: parameters.memo,
     recipient,
-  }
+    token: parameters.token,
+    zoneId: parameters.zoneId,
+  })
   const receipt = await sendTransactionSync(client, {
     ...rest,
     throwOnReceiptRevert,
-    calls: encryptedDeposit.calls(args),
+    calls: encryptedDeposit.calls(prepared),
   } as never)
   return { receipt }
 }

package/tempo/chainConfig.ts

@@ -83,8 +83,17 @@ export const chainConfig = {
           ? (request.account as MultisigAccount).config
           : undefined)
       if (multisig) {
-        request.multisig = multisig
-        request.from = MultisigConfig.getAddress(multisig)
+        const config = MultisigConfig.from(multisig)
+        request.multisig = config
+        request.from = MultisigConfig.getAddress(config)
+        request.multisigInit = {
+          salt: config.salt ?? MultisigConfig.zeroSalt,
+          threshold: Number(config.threshold),
+          owners: config.owners.map((owner) => ({
+            owner: owner.owner,
+            weight: Number(owner.weight),
+          })),
+        }
         // A non-multisig `account` (e.g. the client's default) isn't the sender,
         // so drop it: core then fills nonce/gas/fees for the multisig sender via
         // `request.from`. A multisig account *is* the sender — keep it so the

package/utils/abi/decodeAbiParameters.ts

@@ -75,7 +75,9 @@ export function decodeAbiParameters<
   const values = []
   for (let i = 0; i < params.length; ++i) {
     const param = params[i]
-    cursor.setPosition(consumed)
+    // Zero-width types (e.g. `uint256[0]`, empty tuples) at the end of the
+    // data consume no bytes, so the cursor may already be exhausted.
+    if (consumed < bytes.length) cursor.setPosition(consumed)
     const [data, consumed_] = decodeParameter(cursor, param, {
       staticPosition: 0,
     })
@@ -146,7 +148,8 @@ function decodeArray(
 ) {
   // If the length of the array is not known in advance (dynamic array),
   // this means we will need to wonder off to the pointer and decode.
-  if (!length) {
+  // Note: zero-length fixed arrays (`T[0]`) are not dynamic.
+  if (length === null) {
     // Dealing with a dynamic type, so get the offset of the array data.
     const offset = bytesToNumber(cursor.readBytes(sizeOfOffset))
 
@@ -172,6 +175,12 @@ function decodeArray(
       })
       consumed += consumed_
       value.push(data)
+      // Charge zero-width elements against the read limit to bound work
+      // on huge lengths of zero-width types (e.g. `uint256[0][]`).
+      if (consumed_ === 0) {
+        cursor.assertReadLimit()
+        cursor._touch()
+      }
     }
 
     // As we have gone wondering, restore to the original position + next slot.
@@ -214,6 +223,12 @@ function decodeArray(
     })
     consumed += consumed_
     value.push(data)
+    // Charge zero-width elements against the read limit to bound work
+    // on huge lengths of zero-width types (e.g. `uint256[0][4294967295]`).
+    if (consumed_ === 0) {
+      cursor.assertReadLimit()
+      cursor._touch()
+    }
   }
   return [value, consumed]
 }