viem 2.55.1 → 2.55.4

package/tempo/actions/zone.ts

@@ -12,6 +12,12 @@ import {
   multicall,
 } from '../../actions/public/multicall.js'
 import { readContract } from '../../actions/public/readContract.js'
+import {
+  type PrepareTransactionRequestErrorType,
+  type PrepareTransactionRequestRequest,
+  type PrepareTransactionRequestReturnType,
+  prepareTransactionRequest,
+} from '../../actions/wallet/prepareTransactionRequest.js'
 import {
   type SendTransactionReturnType,
   sendTransaction,
@@ -21,7 +27,7 @@ import type { Client } from '../../clients/createClient.js'
 import type { Transport } from '../../clients/transports/createTransport.js'
 import { zeroHash } from '../../constants/bytes.js'
 import type { BaseErrorType } from '../../errors/base.js'
-import type { Chain } from '../../types/chain.js'
+import type { Chain, GetChainParameter } from '../../types/chain.js'
 import type { Compute, UnionOmit } from '../../types/utils.js'
 import type { RequestErrorType } from '../../utils/buildRequest.js'
 import { type ObserveErrorType, observe } from '../../utils/observe.js'
@@ -38,8 +44,13 @@ import type {
   GetAccountParameter,
   ReadParameters,
   WriteParameters,
+  WriteSyncParameters,
 } from '../internal/types.js'
-import { defineCall, pickWriteParameters } from '../internal/utils.js'
+import {
+  defineCall,
+  pickWriteParameters,
+  pickWriteSyncParameters,
+} from '../internal/utils.js'
 import * as Storage from '../Storage.js'
 import type { TransactionReceipt } from '../Transaction.js'
 import * as ZoneAbis from '../zones/Abis.js'
@@ -72,6 +83,19 @@ export type PreparedEncryptedDeposit = {
   zoneId: number
 }
 
+export type PreparedEncryptedDepositRecipient = {
+  /** Parent chain ID (e.g. `42431` for moderato). */
+  chainId: number
+  /** Encrypted recipient and memo payload. */
+  encrypted: EncryptedPayload
+  /** Encryption key index from the portal contract. */
+  keyIndex: bigint
+  /** Zone portal address on the parent chain. */
+  portalAddress: Address
+  /** 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.
@@ -626,6 +650,93 @@ export namespace encryptedDeposit {
     export type ErrorType = getEncryptionKey.ErrorType | BaseErrorType
   }
 
+  /**
+   * Prepares encrypted Zone recipient instructions without constructing a token
+   * deposit.
+   *
+   * Use this when another contract or service controls the token movement and
+   * only needs the ZonePortal `keyIndex` and encrypted recipient payload.
+   *
+   * @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 recipient = await Actions.zone.encryptedDeposit.prepareRecipient(client, {
+   *   recipient: '0x...',
+   *   zoneId: 7,
+   * })
+   * ```
+   *
+   * @param client - Public client connected to the parent Tempo chain.
+   * @param parameters - Encrypted recipient preparation parameters.
+   * @returns Prepared encrypted recipient instructions.
+   */
+  export async function prepareRecipient<
+    chain extends Chain | undefined,
+    account extends Account | undefined,
+  >(
+    client: Client<Transport, chain, account>,
+    parameters: prepareRecipient.Parameters,
+  ): Promise<prepareRecipient.ReturnValue> {
+    const chainId = client.chain?.id
+    if (!chainId) throw new Error('`chain` is required.')
+
+    const {
+      memo,
+      portalAddress: portalAddress_,
+      recipient,
+      zoneId,
+      ...rest
+    } = parameters
+    const portalAddress = portalAddress_ ?? getPortalAddress(chainId, zoneId)
+    const { keyIndex, publicKey } = await getEncryptionKey(client, {
+      ...rest,
+      portalAddress,
+      zoneId,
+    })
+    const encrypted = await encryptDepositPayload(
+      publicKey,
+      recipient,
+      portalAddress,
+      keyIndex,
+      memo,
+    )
+
+    return {
+      chainId,
+      encrypted,
+      keyIndex,
+      portalAddress,
+      zoneId,
+    }
+  }
+
+  export namespace prepareRecipient {
+    export type Parameters = ReadParameters & Args
+
+    export type Args = {
+      /** Optional deposit memo. @default `0x00...00` */
+      memo?: Hex.Hex | undefined
+      /** Zone portal address. @default resolved via the portal registry. */
+      portalAddress?: Address | undefined
+      /** Recipient address in the zone. */
+      recipient: Address
+      /** Zone ID (e.g. `7`). */
+      zoneId: number
+    }
+
+    export type ReturnValue = PreparedEncryptedDepositRecipient
+
+    export type ErrorType = getEncryptionKey.ErrorType | BaseErrorType
+  }
+
   /**
    * Defines the calls to approve and deposit tokens into a zone (encrypted).
    *
@@ -731,6 +842,7 @@ export async function encryptedDepositSync<
     }
     const receipt = await sendTransactionSync(client, {
       ...pickWriteParameters(parameters as never),
+      ...pickWriteSyncParameters(parameters as never),
       throwOnReceiptRevert,
       calls: encryptedDeposit.calls({
         ...parameters,
@@ -764,7 +876,8 @@ export namespace encryptedDepositSync {
   export type Parameters<
     chain extends Chain | undefined = Chain | undefined,
     account extends Account | undefined = Account | undefined,
-  > = encryptedDeposit.Parameters<chain, account>
+  > = encryptedDeposit.Parameters<chain, account> &
+    WriteSyncParameters<chain, account>
 
   export type Args = encryptedDeposit.Args
 
@@ -1047,7 +1160,8 @@ export namespace waitForDepositStatus {
 }
 
 /**
- * Returns the fee required for a withdrawal from a zone, given a gas limit.
+ * Returns the fee required for a withdrawal from a zone, given a callback gas
+ * limit.
  *
  * The client must be connected to the **zone chain**.
  *
@@ -1066,7 +1180,7 @@ export namespace waitForDepositStatus {
  * ```
  *
  * @param client - Zone client.
- * @param parameters - Optional gas limit parameter.
+ * @param parameters - Optional callback gas limit parameter.
  * @returns The withdrawal fee as a bigint.
  */
 export async function getWithdrawalFee<
@@ -1076,20 +1190,20 @@ export async function getWithdrawalFee<
   client: Client<Transport, chain, account>,
   parameters: getWithdrawalFee.Parameters = {},
 ): Promise<getWithdrawalFee.ReturnType> {
-  const { gas = 0n, ...rest } = parameters
+  const { callbackGas = 0n, ...rest } = parameters
   return readContract(client, {
     ...rest,
     address: Addresses.zoneOutbox,
     abi: ZoneAbis.zoneOutbox,
     functionName: 'calculateWithdrawalFee',
-    args: [gas],
+    args: [callbackGas],
   })
 }
 
 export namespace getWithdrawalFee {
   export type Parameters = ReadParameters & {
-    /** Gas limit for the withdrawal callback. @default `0n` */
-    gas?: bigint | undefined
+    /** Gas limit reserved for the withdrawal callback on the parent chain. @default `0n` */
+    callbackGas?: bigint | undefined
   }
 
   export type ReturnType = bigint
@@ -1192,7 +1306,7 @@ export async function requestWithdrawal<
   client: Client<Transport, chain, account>,
   parameters: requestWithdrawal.Parameters<chain, account>,
 ): Promise<requestWithdrawal.ReturnValue> {
-  const { account = client.account, ...rest } = parameters
+  const { account = client.account } = parameters
 
   const account_ = account ? parseAccount(account) : undefined
   if (!account) throw new Error('`account` is required.')
@@ -1202,7 +1316,7 @@ export async function requestWithdrawal<
 
   const args = { ...parameters, to }
   return sendTransaction(client, {
-    ...rest,
+    ...pickWriteParameters(parameters as never),
     calls: requestWithdrawal.calls(args),
   } as never) as never
 }
@@ -1220,12 +1334,12 @@ export namespace requestWithdrawal {
   export type Args = {
     /** Amount of tokens to withdraw. */
     amount: bigint
+    /** Gas limit reserved for the withdrawal callback on the parent chain. @default `0n` */
+    callbackGas?: bigint | undefined
     /** Optional callback data for the recipient. @default `'0x'` */
     data?: Hex.Hex | undefined
     /** Fallback address if callback fails. @default `to` */
     fallbackRecipient?: Address | undefined
-    /** Gas limit reserved for the withdrawal callback on the parent chain. @default `0n` */
-    gas?: bigint | undefined
     /** Optional withdrawal memo. @default `0x00...00` */
     memo?: Hex.Hex | undefined
     /** Recipient address on the parent Tempo chain. */
@@ -1248,9 +1362,9 @@ export namespace requestWithdrawal {
   export function calls(args: Args) {
     const {
       amount,
+      callbackGas = 0n,
       data = '0x',
       fallbackRecipient = args.to,
-      gas = 0n,
       memo = zeroHash,
       to,
       token,
@@ -1271,7 +1385,7 @@ export namespace requestWithdrawal {
           to,
           amount,
           memo,
-          gas,
+          callbackGas,
           fallbackRecipient,
           data,
           '0x',
@@ -1279,8 +1393,166 @@ export namespace requestWithdrawal {
       }),
     ]
   }
+
+  /**
+   * Prepares a zone withdrawal transaction request without broadcasting it.
+   *
+   * Use this to inspect or modify the populated ZoneOutbox transaction request
+   * and its maximum transaction fee before submitting a withdrawal.
+   *
+   * @example
+   * ```ts
+   * import { createClient } from 'viem'
+   * import { http, zoneModerato } from 'viem/tempo/zones'
+   * import { Actions } from 'viem/tempo'
+   *
+   * const client = createClient({
+   *   chain: zoneModerato(7),
+   *   transport: http(),
+   * })
+   *
+   * const prepared = await Actions.zone.requestWithdrawal.prepare(client, {
+   *   token: '0x20c0...0001',
+   *   amount: 1_000_000n,
+   *   to: '0x...',
+   * })
+   *
+   * console.log(prepared.maxFee)
+   * console.log(prepared.request.gas)
+   * ```
+   *
+   * @param client - Zone client.
+   * @param parameters - Withdrawal preparation parameters.
+   * @returns The prepared transaction request, maximum fee, and withdrawal details.
+   */
+  export async function prepare<
+    chain extends Chain | undefined,
+    account extends Account | undefined,
+    chainOverride extends Chain | undefined = undefined,
+    accountOverride extends Account | Address | undefined = undefined,
+  >(
+    client: Client<Transport, chain, account>,
+    parameters: prepare.Parameters<
+      chain,
+      account,
+      chainOverride,
+      accountOverride
+    >,
+  ): Promise<
+    prepare.ReturnType<chain, account, chainOverride, accountOverride>
+  > {
+    const {
+      account = client.account,
+      amount,
+      callbackGas = 0n,
+      data = '0x',
+      fallbackRecipient,
+      memo = zeroHash,
+      to: to_,
+      token,
+      ...transactionRequest
+    } = parameters
+
+    const account_ = account ? parseAccount(account) : undefined
+    const to = to_ ?? account_?.address
+    if (!to) throw new Error('`to` is required.')
+
+    const request = await prepareTransactionRequest(client, {
+      ...transactionRequest,
+      account,
+      calls: requestWithdrawal.calls({
+        amount,
+        callbackGas,
+        data,
+        fallbackRecipient,
+        memo,
+        to,
+        token,
+      }),
+    } as never)
+    const feePerGas = request.maxFeePerGas ?? request.gasPrice
+    if (typeof request.gas !== 'bigint' || typeof feePerGas !== 'bigint')
+      throw new Error('Prepared transaction fee parameters are unavailable.')
+    const maxFee = ceilDiv(request.gas * feePerGas, 1_000_000_000_000n)
+
+    return {
+      amount,
+      callbackGas,
+      data,
+      fallbackRecipient: fallbackRecipient ?? to,
+      maxFee,
+      memo,
+      request,
+      to,
+      token,
+    } as never
+  }
+
+  export namespace prepare {
+    export type Parameters<
+      chain extends Chain | undefined = Chain | undefined,
+      account extends Account | undefined = Account | undefined,
+      chainOverride extends Chain | undefined = Chain | undefined,
+      accountOverride extends Account | Address | undefined =
+        | Account
+        | Address
+        | undefined,
+    > = UnionOmit<
+      WriteParameters<chain, account>,
+      'account' | 'chain' | 'throwOnReceiptRevert'
+    > &
+      GetAccountParameter<account, accountOverride, false> &
+      GetChainParameter<chain, chainOverride> &
+      PrepareArgs
+
+    export type PrepareArgs = Omit<Args, 'to'> & {
+      /** Recipient address on the parent Tempo chain. @default `account.address` */
+      to?: Address | undefined
+    }
+
+    export type ReturnType<
+      chain extends Chain | undefined = Chain | undefined,
+      account extends Account | undefined = Account | undefined,
+      chainOverride extends Chain | undefined = Chain | undefined,
+      accountOverride extends Account | Address | undefined =
+        | Account
+        | Address
+        | undefined,
+    > = Compute<{
+      /** Amount of tokens to withdraw. */
+      amount: bigint
+      /** Gas limit reserved for the callback on the parent chain. */
+      callbackGas: bigint
+      /** Callback data for the recipient. */
+      data: Hex.Hex
+      /** Fallback address if the callback fails. */
+      fallbackRecipient: Address
+      /** Maximum Zone transaction fee in fee-token base units. */
+      maxFee: bigint
+      /** Withdrawal memo. */
+      memo: Hex.Hex
+      /** Prepared Zone transaction request. */
+      request: PrepareTransactionRequestReturnType<
+        chain,
+        account,
+        chainOverride,
+        accountOverride,
+        PrepareTransactionRequestRequest<chain, chainOverride> & {
+          calls: WithdrawalCalls
+        }
+      >
+      /** Recipient address on the parent Tempo chain. */
+      to: Address
+      /** Token address or ID to withdraw. */
+      token: TokenId.TokenIdOrAddress
+    }>
+
+    export type ErrorType = PrepareTransactionRequestErrorType | BaseErrorType
+  }
 }
 
+type WithdrawalCalls = ReturnType<typeof requestWithdrawal.calls>
+
 /**
  * Requests a withdrawal from a zone to the parent Tempo chain and waits for
  * the transaction receipt.
@@ -1315,11 +1587,7 @@ export async function requestWithdrawalSync<
   client: Client<Transport, chain, account>,
   parameters: requestWithdrawalSync.Parameters<chain, account>,
 ): Promise<requestWithdrawalSync.ReturnValue> {
-  const {
-    account = client.account,
-    throwOnReceiptRevert = true,
-    ...rest
-  } = parameters
+  const { account = client.account, throwOnReceiptRevert = true } = parameters
 
   const account_ = account ? parseAccount(account) : undefined
   if (!account) throw new Error('`account` is required.')
@@ -1329,7 +1597,8 @@ export async function requestWithdrawalSync<
 
   const args = { ...parameters, to }
   const receipt = await sendTransactionSync(client, {
-    ...rest,
+    ...pickWriteParameters(parameters as never),
+    ...pickWriteSyncParameters(parameters as never),
     calls: requestWithdrawal.calls(args),
     throwOnReceiptRevert,
   } as never)
@@ -1340,7 +1609,8 @@ export namespace requestWithdrawalSync {
   export type Parameters<
     chain extends Chain | undefined = Chain | undefined,
     account extends Account | undefined = Account | undefined,
-  > = requestWithdrawal.Parameters<chain, account>
+  > = requestWithdrawal.Parameters<chain, account> &
+    WriteSyncParameters<chain, account>
 
   export type Args = requestWithdrawal.Args
 
@@ -1391,7 +1661,7 @@ export async function requestVerifiableWithdrawal<
   client: Client<Transport, chain, account>,
   parameters: requestVerifiableWithdrawal.Parameters<chain, account>,
 ): Promise<requestVerifiableWithdrawal.ReturnValue> {
-  const { account = client.account, ...rest } = parameters
+  const { account = client.account } = parameters
 
   const account_ = account ? parseAccount(account) : undefined
   if (!account) throw new Error('`account` is required.')
@@ -1401,7 +1671,7 @@ export async function requestVerifiableWithdrawal<
 
   const args = { ...parameters, to }
   return sendTransaction(client, {
-    ...rest,
+    ...pickWriteParameters(parameters as never),
     calls: requestVerifiableWithdrawal.calls(args),
   } as never) as never
 }
@@ -1435,9 +1705,9 @@ export namespace requestVerifiableWithdrawal {
   export function calls(args: Args) {
     const {
       amount,
+      callbackGas = 0n,
       data = '0x',
       fallbackRecipient = args.to,
-      gas = 0n,
       memo = zeroHash,
       revealTo,
       to,
@@ -1459,7 +1729,7 @@ export namespace requestVerifiableWithdrawal {
           to,
           amount,
           memo,
-          gas,
+          callbackGas,
           fallbackRecipient,
           data,
           revealTo,
@@ -1504,11 +1774,7 @@ export async function requestVerifiableWithdrawalSync<
   client: Client<Transport, chain, account>,
   parameters: requestVerifiableWithdrawalSync.Parameters<chain, account>,
 ): Promise<requestVerifiableWithdrawalSync.ReturnValue> {
-  const {
-    account = client.account,
-    throwOnReceiptRevert = true,
-    ...rest
-  } = parameters
+  const { account = client.account, throwOnReceiptRevert = true } = parameters
 
   const account_ = account ? parseAccount(account) : undefined
   if (!account) throw new Error('`account` is required.')
@@ -1518,7 +1784,8 @@ export async function requestVerifiableWithdrawalSync<
 
   const args = { ...parameters, to }
   const receipt = await sendTransactionSync(client, {
-    ...rest,
+    ...pickWriteParameters(parameters as never),
+    ...pickWriteSyncParameters(parameters as never),
     calls: requestVerifiableWithdrawal.calls(args),
     throwOnReceiptRevert,
   } as never)
@@ -1529,7 +1796,8 @@ export namespace requestVerifiableWithdrawalSync {
   export type Parameters<
     chain extends Chain | undefined = Chain | undefined,
     account extends Account | undefined = Account | undefined,
-  > = requestVerifiableWithdrawal.Parameters<chain, account>
+  > = requestVerifiableWithdrawal.Parameters<chain, account> &
+    WriteSyncParameters<chain, account>
 
   export type Args = requestVerifiableWithdrawal.Args
 
@@ -1738,3 +2006,7 @@ function buildDepositHkdfInfo(
     Bytes.from(ephemeralPubkeyX),
   )
 }
+
+function ceilDiv(numerator: bigint, denominator: bigint) {
+  return (numerator + denominator - 1n) / denominator
+}

package/tempo/chainConfig.ts

@@ -22,6 +22,14 @@ import * as Transaction from './Transaction.js'
 
 const maxExpirySecs = 25
 
+/** Returns random past seconds to distinguish otherwise-identical expiring transactions. */
+function randomValidAfter(): number {
+  const now = BigInt(Math.floor(Date.now() / 1_000))
+  const latest = now - 60n
+  if (latest <= 0n) return 0
+  return Number(BigInt(Hex.random(8)) % latest)
+}
+
 export const chainConfig = {
   blockTime: 1_000,
   extendSchema: extendSchema<{
@@ -160,6 +168,8 @@ export const chainConfig = {
       if (useExpiringNonce) {
         request.nonceKey = maxUint256
         request.nonce = 0
+        if (typeof request.validAfter === 'undefined')
+          request.validAfter = randomValidAfter()
         if (typeof request.validBefore === 'undefined')
           request.validBefore = Math.floor(Date.now() / 1000) + maxExpirySecs
       } else if (typeof request.nonceKey !== 'undefined') {

package/tempo/internal/types.ts

@@ -77,3 +77,11 @@ export type WriteParameters<
     | 'validAfter'
     | 'validBefore'
   >
+
+export type WriteSyncParameters<
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+> = UnionPick<
+  viem_WriteContractSyncParameters<never, never, never, chain, account>,
+  'pollingInterval' | 'timeout'
+>

package/tempo/internal/utils.ts

@@ -216,6 +216,12 @@ export function pickWriteParameters(parameters: Record<string, unknown>) {
   }
 }
 
+/** @internal */
+export function pickWriteSyncParameters(parameters: Record<string, unknown>) {
+  const { pollingInterval, timeout } = parameters
+  return { pollingInterval, timeout }
+}
+
 /**
  * Parameters of an action's `.call` builder: the call arguments, optionally
  * preceded by a Client. The Client is used to resolve token symbols declared

package/utils/abi/decodeAbiParameters.ts

@@ -22,7 +22,6 @@ import {
 } from '../cursor.js'
 import { type SizeErrorType, size } from '../data/size.js'
 import { type SliceBytesErrorType, sliceBytes } from '../data/slice.js'
-import { type TrimErrorType, trim } from '../data/trim.js'
 import {
   type BytesToBigIntErrorType,
   type BytesToBoolErrorType,
@@ -355,7 +354,6 @@ function decodeTuple(
 type DecodeStringErrorType =
   | BytesToNumberErrorType
   | BytesToStringErrorType
-  | TrimErrorType
   | ErrorType
 
 function decodeString(
@@ -378,7 +376,7 @@ function decodeString(
   }
 
   const data = cursor.readBytes(length, 32)
-  const value = bytesToString(trim(data))
+  const value = bytesToString(data)
 
   // As we have gone wondering, restore to the original position + next slot.
   cursor.setPosition(staticPosition + 32)