viem 2.55.10 → 2.55.13

package/tempo/actions/earn.ts

@@ -67,6 +67,9 @@ import * as policyActions from './policy.js'
 import * as tokenActions from './token.js'
 import * as zoneActions from './zone.js'
 
+// biome-ignore lint/performance/noBarrelFile: namespace module
+export * from './earn/deployment.js'
+
 /** TIP-403 policy ID that allows every sender, recipient, and mint recipient. */
 export const alwaysAllowPolicyId = 1n
 
@@ -923,7 +926,7 @@ export async function depositSharesSync<
     caller: args.caller,
     earnShareAmount: args.earnShares,
     receipt,
-    receivedVenueShareAmount: args.receivedVenueShares,
+    receivedVenueShareAmount: args.receivedEngineShares,
     recipient: args.receiver,
     venueShareAmount: args.requestedVenueShares,
   }
@@ -1039,7 +1042,9 @@ export namespace privateDeposit {
         zonePortal: portalAddress,
       }),
     ])
-    const assetToken = parameters.assetToken ?? config.vaultAsset
+    const assetToken = parameters.assetToken ?? config.privateAsset
+    if (!isAddressEqual(assetToken, config.privateAsset))
+      throw new Error('`assetToken` must match the Zone gateway private asset.')
     const { encrypted, keyIndex } =
       await zoneActions.encryptedDeposit.prepareRecipient(client, {
         ...readParameters,
@@ -1049,18 +1054,13 @@ export namespace privateDeposit {
         zoneId: config.zoneId,
       })
     const shareAmountMin = resolveMinimumShareAmount(parameters)
-    const direct = isAddressEqual(assetToken, config.vaultAsset)
     const data = encodeAbiParameters(Abis.earnRouterCallbackData, [
       {
         actionId,
-        earnVault: config.vault,
         flow: 0,
         minEarnShares: shareAmountMin,
         minOutputAmount: 0n,
-        minVaultAssets: direct
-          ? assetAmount
-          : (parameters.vaultAssetAmountMin ?? 0n),
-        outputToken: config.shareToken,
+        minVaultAssets: parameters.vaultAssetAmountMin ?? assetAmount,
         zoneReturn: { encrypted, keyIndex, refundRecipient: recoveryRecipient },
       },
     ])
@@ -1084,9 +1084,9 @@ export namespace privateDeposit {
     export type Args = PrivatePreparationParameters & {
       /** Assets withdrawn from the Zone, base units. */
       assetAmount: bigint
-      /** Asset token withdrawn from the Zone. @default vault asset */
+      /** Private asset withdrawn from the Zone. @default gateway private asset */
       assetToken?: Address | undefined
-      /** Minimum vault assets accepted after swapping `assetToken`. @default `0n` */
+      /** Minimum vault assets accepted after conversion. @default `assetAmount` */
       vaultAssetAmountMin?: bigint | undefined
     } & MinimumShareAmountParameters
     export type ReturnValue = PreparedZoneRequest
@@ -1429,15 +1429,15 @@ export type FeeConfig = {
   excess: {
     /** Excess fee recipient. */
     account: Address
-    /** Annual target growth rate, scaled to 18 decimals. */
-    annualTargetRate: bigint
+    /** Annual target growth rate in basis points. */
+    annualTargetRateBps: number
     /** Whether the excess fee is active. */
     enabled: boolean
-    /** Rate applied above the target, scaled to 18 decimals. */
-    excessFeeRate: bigint
+    /** Rate applied above the target in basis points. */
+    excessFeeRateBps: number
   }
-  /** Fixed fee recipients and their 18-decimal rates. */
-  fixedFees: readonly { account: Address; rate: bigint }[]
+  /** Fixed fee recipients and their rates in basis points. */
+  fixedFees: readonly { account: Address; rateBps: number }[]
 }
 
 /** Pending vault fee amounts. */
@@ -2419,9 +2419,9 @@ export namespace privateRedeem {
         zonePortal: portalAddress,
       }),
     ])
-    const assetToken = parameters.assetToken ?? config.vaultAsset
-    if (isAddressEqual(assetToken, config.shareToken))
-      throw new Error('`assetToken` cannot be the Earn share token.')
+    const assetToken = parameters.assetToken ?? config.privateAsset
+    if (!isAddressEqual(assetToken, config.privateAsset))
+      throw new Error('`assetToken` must match the Zone gateway private asset.')
 
     const [{ encrypted, keyIndex }, assetAmountMin] = await Promise.all([
       zoneActions.encryptedDeposit.prepareRecipient(client, {
@@ -2447,16 +2447,13 @@ export namespace privateRedeem {
         return EarnShares.minimumOutput(assetAmount, parameters.slippageBps)
       })(),
     ])
-    const direct = isAddressEqual(assetToken, config.vaultAsset)
     const data = encodeAbiParameters(Abis.earnRouterCallbackData, [
       {
         actionId,
-        earnVault: config.vault,
         flow: 1,
         minEarnShares: 0n,
-        minOutputAmount: direct ? 0n : assetAmountMin,
-        minVaultAssets: direct ? assetAmountMin : 1n,
-        outputToken: assetToken,
+        minOutputAmount: assetAmountMin,
+        minVaultAssets: assetAmountMin,
         zoneReturn: { encrypted, keyIndex, refundRecipient: recoveryRecipient },
       },
     ])
@@ -2480,31 +2477,24 @@ export namespace privateRedeem {
       PrivatePreparationParameters & {
         /** Earn shares withdrawn from the Zone, base units. */
         shareAmount: bigint
-      } & (
-        | ({
-            /** Asset token returned to the Zone. @default vault asset */
-            assetToken?: undefined
-          } & OneOf<
-            | {
-                /** Minimum assets returned to the Zone. */
-                assetAmountMin: bigint
-              }
-            | {
-                /** Quoted assets returned to the Zone. */
-                assetAmount: bigint
-                /** Slippage tolerance under `assetAmount` (50 = 0.5%). */
-                slippageBps: number
-              }
-            | {
-                /** Slippage tolerance under a live vault quote (50 = 0.5%). */
-                slippageBps: number
-              }
-          >)
-        | ({
-            /** Asset token returned to the Zone after a swap. */
-            assetToken: Address
-          } & MinimumAssetAmountParameters)
-      )
+        /** Private asset returned to the Zone. Must match the gateway. @default gateway private asset */
+        assetToken?: Address | undefined
+      } & OneOf<
+        | {
+            /** Minimum assets returned to the Zone. */
+            assetAmountMin: bigint
+          }
+        | {
+            /** Quoted assets returned to the Zone. */
+            assetAmount: bigint
+            /** Slippage tolerance under `assetAmount` (50 = 0.5%). */
+            slippageBps: number
+          }
+        | {
+            /** Slippage tolerance under a live vault quote (50 = 0.5%). */
+            slippageBps: number
+          }
+      >
     export type ReturnValue = PreparedZoneRequest
     export type ErrorType = BaseErrorType
   }
@@ -3006,19 +2996,6 @@ export namespace withdrawExactSync {
   export type ErrorType = BaseErrorType
 }
 
-type MinimumAssetAmountParameters = OneOf<
-  | {
-      /** Minimum assets returned to the Zone. */
-      assetAmountMin: bigint
-    }
-  | {
-      /** Quoted assets returned to the Zone. */
-      assetAmount: bigint
-      /** Slippage tolerance under `assetAmount` (50 = 0.5%). */
-      slippageBps: number
-    }
->
-
 type MinimumShareAmountParameters = OneOf<
   | {
       /** Minimum Earn shares returned to the Zone. */
@@ -3132,7 +3109,16 @@ async function getZoneGatewayConfig<chain extends Chain | undefined>(
   },
 ) {
   const { flow, gateway, vault, zoneId, zonePortal, ...rest } = parameters
-  const [vaultAsset, shareToken, supportsFlow] = await multicall(client, {
+  const [
+    vaultAsset,
+    shareToken,
+    allowedZoneId,
+    routerVault,
+    privateAsset,
+    routerVaultAsset,
+    routerShareToken,
+    supportsFlow,
+  ] = await multicall(client, {
     ...rest,
     allowFailure: false,
     contracts: [
@@ -3146,6 +3132,31 @@ async function getZoneGatewayConfig<chain extends Chain | undefined>(
         address: vault,
         functionName: 'earnShare',
       },
+      {
+        abi: Abis.earnRouter,
+        address: gateway,
+        functionName: 'allowedZoneId',
+      },
+      {
+        abi: Abis.earnRouter,
+        address: gateway,
+        functionName: 'earnVault',
+      },
+      {
+        abi: Abis.earnRouter,
+        address: gateway,
+        functionName: 'privateAsset',
+      },
+      {
+        abi: Abis.earnRouter,
+        address: gateway,
+        functionName: 'vaultAsset',
+      },
+      {
+        abi: Abis.earnRouter,
+        address: gateway,
+        functionName: 'earnShare',
+      },
       {
         abi: Abis.earnRouter,
         address: gateway,
@@ -3156,7 +3167,16 @@ async function getZoneGatewayConfig<chain extends Chain | undefined>(
     deployless: true,
   })
   if (!supportsFlow) throw new Error('Zone gateway flow is not supported.')
+  if (allowedZoneId !== zoneId)
+    throw new Error('Zone gateway is configured for a different Zone.')
+  if (!isAddressEqual(routerVault, vault))
+    throw new Error('Zone gateway is configured for a different Earn vault.')
+  if (!isAddressEqual(routerVaultAsset, vaultAsset))
+    throw new Error('Zone gateway vault asset does not match the Earn vault.')
+  if (!isAddressEqual(routerShareToken, shareToken))
+    throw new Error('Zone gateway share token does not match the Earn vault.')
   return {
+    privateAsset,
     shareToken,
     vault,
     vaultAsset,

package/tempo/actions/token.ts

@@ -4,9 +4,15 @@ import { TokenId, TokenRole } from 'ox/tempo'
 import type { Account } from '../../accounts/types.js'
 import { parseAccount } from '../../accounts/utils/parseAccount.js'
 import { estimateContractGas } from '../../actions/public/estimateContractGas.js'
-import { multicall } from '../../actions/public/multicall.js'
-import type { ReadContractReturnType } from '../../actions/public/readContract.js'
-import { readContract } from '../../actions/public/readContract.js'
+import {
+  type MulticallParameters,
+  type MulticallReturnType,
+  multicall,
+} from '../../actions/public/multicall.js'
+import {
+  type ReadContractReturnType,
+  readContract,
+} from '../../actions/public/readContract.js'
 import {
   type SimulateContractReturnType,
   simulateContract,
@@ -1399,7 +1405,7 @@ export async function getMetadata<chain extends Chain | undefined>(
   }
 
   if (TokenId.fromAddress(address) === TokenId.fromAddress(Addresses.pathUsd))
-    return multicall(client, {
+    return readMetadataContracts(client, {
       ...rest,
       contracts: [
         {
@@ -1433,8 +1439,6 @@ export async function getMetadata<chain extends Chain | undefined>(
           functionName: 'totalSupply',
         },
       ] as const,
-      allowFailure: true,
-      deployless: true,
     }).then(([currency, decimals, logoURI, name, symbol, totalSupply]) => ({
       name: unwrapMulticallResult(name),
       symbol: unwrapMulticallResult(symbol),
@@ -1445,7 +1449,7 @@ export async function getMetadata<chain extends Chain | undefined>(
       ...overrides,
     }))
 
-  return multicall(client, {
+  return readMetadataContracts(client, {
     ...rest,
     contracts: [
       {
@@ -1499,8 +1503,6 @@ export async function getMetadata<chain extends Chain | undefined>(
         functionName: 'transferPolicyId',
       },
     ] as const,
-    allowFailure: true,
-    deployless: true,
   }).then(
     ([
       currency,
@@ -1529,6 +1531,55 @@ export async function getMetadata<chain extends Chain | undefined>(
   )
 }
 
+async function readMetadataContracts<
+  chain extends Chain | undefined,
+  const contracts extends readonly unknown[],
+>(
+  client: Client<Transport, chain>,
+  parameters: Pick<
+    MulticallParameters<contracts>,
+    | 'blockNumber'
+    | 'blockOverrides'
+    | 'blockTag'
+    | 'contracts'
+    | 'stateOverride'
+  >,
+): Promise<MulticallReturnType<contracts>>
+async function readMetadataContracts<chain extends Chain | undefined>(
+  client: Client<Transport, chain>,
+  parameters: Pick<
+    MulticallParameters,
+    | 'blockNumber'
+    | 'blockOverrides'
+    | 'blockTag'
+    | 'contracts'
+    | 'stateOverride'
+  >,
+): Promise<MulticallReturnType> {
+  // Preserve the action's deployless default unless the client overrides it.
+  if (client.batch?.multicall === undefined)
+    return multicall(client, {
+      ...parameters,
+      allowFailure: true,
+      deployless: true,
+    })
+
+  const { contracts, ...rest } = parameters
+  const results = await Promise.allSettled(
+    contracts.map((contract) =>
+      readContract(client, {
+        ...rest,
+        ...contract,
+      }),
+    ),
+  )
+  return results.map((result) =>
+    result.status === 'fulfilled'
+      ? { result: result.value, status: 'success' }
+      : { error: result.reason, status: 'failure' },
+  )
+}
+
 function unwrapMulticallResult<result>(
   response:
     | { result: result; status: 'success' }

package/tempo/actions/zone.ts

@@ -29,6 +29,7 @@ import { zeroHash } from '../../constants/bytes.js'
 import type { BaseErrorType } from '../../errors/base.js'
 import type { Chain, GetChainParameter } from '../../types/chain.js'
 import type { Compute, UnionOmit } from '../../types/utils.js'
+import { parseEventLogs } from '../../utils/abi/parseEventLogs.js'
 import type { RequestErrorType } from '../../utils/buildRequest.js'
 import { type ObserveErrorType, observe } from '../../utils/observe.js'
 import { type PollErrorType, poll } from '../../utils/poll.js'
@@ -1547,8 +1548,16 @@ export async function requestWithdrawalSync<
     gas: parameters.gas ?? defaultWithdrawalGas,
     throwOnReceiptRevert,
   } as never)
+  const [event] = parseEventLogs({
+    abi: ZoneAbis.zoneOutbox,
+    logs: receipt.logs,
+    eventName: 'WithdrawalRequested',
+    strict: true,
+  })
+  if (!event) throw new Error('`WithdrawalRequested` event not found.')
   const senderTag = WithdrawalSenderTag.from({
-    sender: account_.address,
+    fallbackNonce: event.args.fallbackNonce,
+    sender: event.args.sender,
     transactionHash: receipt.transactionHash,
   })
   return { receipt, senderTag }

package/tempo/chainConfig.ts

@@ -116,6 +116,36 @@ export const chainConfig = {
         if (request.account?.source !== 'multisig') delete request.account
       }
 
+      // Register concurrency before account preparation performs storage or
+      // network I/O so overlapping requests cannot miss each other.
+      const useExpiringNonce = await (async () => {
+        if (request.nonceKey === 'expiring' || request.nonceKey === maxUint256)
+          return true
+        if (multisig) return false
+        if (request.feePayer && typeof request.nonceKey === 'undefined')
+          return true
+        const account = request.account as
+          | Account
+          | MultisigAccount
+          | Address
+          | undefined
+        const address = typeof account === 'string' ? account : account?.address
+        if (address && typeof request.nonceKey === 'undefined')
+          return await Concurrent.detect(address.toLowerCase())
+        return false
+      })()
+
+      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') {
+        request.nonce = typeof request.nonce === 'number' ? request.nonce : 0
+      }
+
       if (
         !request.keyAuthorization &&
         request.account?.source === 'accessKey'
@@ -156,33 +186,6 @@ export const chainConfig = {
         }
       }
 
-      // Use expiring nonces for concurrent transactions (TIP-1009).
-      // When nonceKey is 'expiring', feePayer is specified, or concurrent requests
-      // are detected, we use expiring nonces (nonceKey = uint256.max) with a
-      // validBefore timestamp.
-      const useExpiringNonce = await (async () => {
-        if (request.nonceKey === 'expiring') return true
-        if (multisig) return false
-        if (request.feePayer && typeof request.nonceKey === 'undefined')
-          return true
-        const address = request.account?.address
-        if (address && typeof request.nonceKey === 'undefined')
-          return await Concurrent.detect(address)
-        return false
-      })()
-
-      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') {
-        // Explicit nonceKey provided (2D nonce mode)
-        request.nonce = typeof request.nonce === 'number' ? request.nonce : 0
-      }
-
       if (!request.feeToken && request.chain?.feeToken)
         request.feeToken = request.chain.feeToken
 

package/tempo/internal/WithdrawalSenderTag.ts

@@ -1,19 +1,20 @@
 import type { Address } from 'abitype'
 import { AbiParameters, Hash, type Hex } from 'ox'
 
-/** Derives a withdrawal sender tag from its sender and transaction hash. @internal */
+/** Derives a user withdrawal sender tag. @internal */
 export function from(options: from.Options): Hex.Hex {
-  const { sender, transactionHash } = options
+  const { fallbackNonce, sender, transactionHash } = options
   return Hash.keccak256(
     AbiParameters.encodePacked(
-      ['address', 'bytes32'],
-      [sender, transactionHash],
+      ['address', 'bytes32', 'uint64'],
+      [sender, transactionHash, fallbackNonce],
     ),
   )
 }
 
 export declare namespace from {
   type Options = {
+    fallbackNonce: bigint
     sender: Address
     transactionHash: Hex.Hex
   }

package/tempo/zones/Abis.ts

@@ -168,6 +168,23 @@ export const zonePortal = [
 ] as const
 
 export const zoneOutbox = [
+  {
+    name: 'WithdrawalRequested',
+    type: 'event',
+    inputs: [
+      { name: 'withdrawalIndex', type: 'uint64', indexed: true },
+      { name: 'sender', type: 'address', indexed: true },
+      { name: 'token', type: 'address', indexed: false },
+      { name: 'to', type: 'address', indexed: false },
+      { name: 'amount', type: 'uint128', indexed: false },
+      { name: 'fee', type: 'uint128', indexed: false },
+      { name: 'memo', type: 'bytes32', indexed: false },
+      { name: 'gasLimit', type: 'uint64', indexed: false },
+      { name: 'fallbackNonce', type: 'uint64', indexed: false },
+      { name: 'data', type: 'bytes', indexed: false },
+      { name: 'revealTo', type: 'bytes', indexed: false },
+    ],
+  },
   {
     name: 'requestWithdrawal',
     type: 'function',

package/tokens/definitions/usdc.ts

@@ -40,6 +40,7 @@ export const usdc = /*#__PURE__*/ defineToken({
     137: '0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359', // polygon
     143: '0x754704Bc059F8C67012fEd69BC8A327a5aafb603', // monad
     146: '0x29219dd400f2Bf60E5a23d13Be72B486D4038894', // sonic
+    196: '0xB6CEceAB302E2E4948951eE7843FC24E92933061', // xLayer
     300: '0xAe045DE5638162fa134807Cb558E15A3F5A7F853', // zksyncSepoliaTestnet
     324: '0x1d17CBcF0D6D143135aE902365D2E5e2A16538D4', // zksync
     338: '0xEb33dc5fac03833e132593659e1dE7256aB59794', // cronosTestnet
@@ -50,11 +51,16 @@ export const usdc = /*#__PURE__*/ defineToken({
     1328: '0x4fCF1784B31630811181f670Aea7A7bEF803eaED', // seiTestnet
     1329: '0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392', // sei
     1439: '0x0C382e685bbeeFE5d3d9C29e29E341fEE8E84C5d', // injectiveTestnet
+    1672: '0xC879C018dB60520F4355C26eD1a6D572cdAC1815', // pharos
     1776: '0xa00C59fF5a080D2b954d0c75e46E22a0c371235a', // injective
+    1952: '0xDec90b78111Ba2fc6FC6d84d8B9ec159A2d4b9B3', // xLayerTestnet
     2818: '0xCfb1186F4e93D60E60a8bDd997427D1F33bc372B', // morph
+    2910: '0x7433b41C6c5e1d58D4Da99483609520255ab661B', // morphHoodi
+    3343: '0x98d2919b9A214E6Fa5384AC81E6864bA686Ad74c', // edge
     4801: '0x66145f38cBAC35Ca6F1Dfb4914dF98F1614aeA88', // worldchainSepolia
     8453: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // base
     10143: '0x534b2f3A21130d7a60830c2Df862319e593943A3', // monadTestnet
+    33431: '0x2d9F7CAD728051AA35Ecdc472a14cf8cDF5CFD6B', // edgeTestnet
     42161: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831', // arbitrum
     42220: '0xcebA9300f2b948710d2653dD7B07f33A8B32118C', // celo
     43113: '0x5425890298aed601595a70AB815c96711a31Bc65', // avalancheFuji
@@ -70,6 +76,7 @@ export const usdc = /*#__PURE__*/ defineToken({
     98866: '0x222365EF19F7947e5484218551B56bb3965Aa7aF', // plumeMainnet
     98867: '0xcB5f30e335672893c7eb944B374c196392C19D18', // plumeSepolia
     421614: '0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d', // arbitrumSepolia
+    688689: '0xcfC8330f4BCAB529c625D12781b1C19466A9Fc8B', // pharosTestnet
     763373: '0xFabab97dCE620294D2B0b0e46C68964e326300Ac', // inkSepolia
     812242: '0x6d7f141b6819C2c9CC2f818e6ad549E7Ca090F8f', // codexTestnet
     5042002: '0x3600000000000000000000000000000000000000', // arcTestnet

package/utils/promise/withRetry.ts

@@ -39,13 +39,13 @@ export function withRetry<data>(
   }: WithRetryParameters = {},
 ) {
   return new Promise<data>((resolve, reject) => {
-    const attemptRetry = async ({ count = 0 } = {}) => {
+    const attemptRetry = async ({ count = 0 } = {}): Promise<void> => {
       if (signal?.aborted) {
         reject(getAbortError(signal))
         return
       }
 
-      const retry = async ({ error }: { error: Error }) => {
+      const retry = async ({ error }: { error: Error }): Promise<void> => {
         const delay =
           typeof delay_ === 'function' ? delay_({ count, error }) : delay_
         if (delay) {
@@ -56,7 +56,7 @@ export function withRetry<data>(
             return
           }
         }
-        attemptRetry({ count: count + 1 })
+        return attemptRetry({ count: count + 1 })
       }
 
       try {
@@ -79,6 +79,6 @@ export function withRetry<data>(
         reject(err)
       }
     }
-    attemptRetry()
+    void attemptRetry().catch(reject)
   })
 }

package/utils/typedData.ts

@@ -6,6 +6,7 @@ import {
   InvalidDomainError,
   InvalidPrimaryTypeError,
   InvalidStructTypeError,
+  InvalidTypedDataTypeError,
 } from '../errors/typedData.js'
 import type { ErrorType } from '../errors/utils.js'
 import type { Hex } from '../types/misc.js'
@@ -86,6 +87,10 @@ export function validateTypedData<
       const { name, type } = param
       const value = data[name]
 
+      const baseType = type.replace(/(\[[0-9]*\])+$/, '')
+      if (baseType === 'int' || baseType === 'uint')
+        throw new InvalidTypedDataTypeError({ type })
+
       const integerMatch = type.match(integerRegex)
       if (
         integerMatch &&