viem 2.51.0 → 2.51.3

package/actions/wallet/sendCalls.ts

@@ -220,16 +220,20 @@ export async function sendCalls<
         )
       }
 
-      const promises: Promise<Hex>[] = []
+      const results: PromiseSettledResult<Hex>[] = []
       for (const call of calls) {
-        const promise = sendTransaction(client, {
-          account,
-          chain,
-          data: call.data,
-          to: call.to,
-          value: call.value ? hexToBigInt(call.value) : undefined,
-        })
-        promises.push(promise)
+        try {
+          const value = await sendTransaction(client, {
+            account,
+            chain,
+            data: call.data,
+            to: call.to,
+            value: call.value ? hexToBigInt(call.value) : undefined,
+          })
+          results.push({ status: 'fulfilled', value })
+        } catch (reason) {
+          results.push({ reason, status: 'rejected' })
+        }
 
         // Note: some browser wallets require a small delay between transactions
         // to prevent duplicate JSON-RPC requests.
@@ -239,7 +243,6 @@ export async function sendCalls<
           )
       }
 
-      const results = await Promise.allSettled(promises)
       if (results.every((r) => r.status === 'rejected')) throw results[0].reason
 
       const hashes = results.map((result) => {

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.51.0'
+export const version = '2.51.3'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "2.51.0",
+  "version": "2.51.3",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",
@@ -230,7 +230,7 @@
     "@scure/bip39": "1.6.0",
     "abitype": "1.2.3",
     "isows": "1.0.7",
-    "ox": "https://pkg.pr.new/ox@386a3439fe1ce76d237930f8c6e6bb493746069a",
+    "ox": "0.14.25",
     "ws": "8.20.1"
   },
   "license": "MIT",

package/tempo/Account.ts

@@ -19,6 +19,7 @@ import { keccak256 } from '../utils/hash/keccak256.js'
 import { hashMessage } from '../utils/signature/hashMessage.js'
 import { hashTypedData } from '../utils/signature/hashTypedData.js'
 import type { SerializeTransactionFn } from '../utils/transaction/serializeTransaction.js'
+import type { KeyAuthorizationManager } from './KeyAuthorizationManager.js'
 import * as Transaction from './Transaction.js'
 
 export type Account_base<source extends string = string> = RequiredBy<
@@ -62,6 +63,8 @@ export type RootAccount = Account_base<'root'> & {
 export type AccessKeyAccount = Account_base<'accessKey'> & {
   /** Access key ID. */
   accessKeyAddress: Address.Address
+  /** Pending key authorization manager. */
+  keyAuthorizationManager?: KeyAuthorizationManager | undefined
   /**
    * Signs a hash.
    *
@@ -125,12 +128,13 @@ export function fromHeadlessWebAuthn<
   privateKey: Hex.Hex,
   options: options | fromHeadlessWebAuthn.Options,
 ): fromHeadlessWebAuthn.ReturnValue<options> {
-  const { access, rpId, origin, internal_version } = options
+  const { access, keyAuthorizationManager, rpId, origin, internal_version } =
+    options
 
   const publicKey = P256.getPublicKey({ privateKey })
 
   return from({
-    access,
+    ...(access ? { access, keyAuthorizationManager } : {}),
     internal_version,
     keyType: 'webAuthn',
     publicKey,
@@ -161,7 +165,10 @@ export declare namespace fromHeadlessWebAuthn {
     WebAuthnP256.getSignPayload.Options,
     'challenge' | 'rpId' | 'origin'
   > &
-    Pick<from.Parameters, 'access' | 'internal_version'> & {
+    Pick<
+      from.Parameters,
+      'access' | 'internal_version' | 'keyAuthorizationManager'
+    > & {
       rpId: string
       origin: string
     }
@@ -187,11 +194,11 @@ export function fromP256<const options extends fromP256.Options>(
   privateKey: Hex.Hex,
   options: options | fromP256.Options = {},
 ): fromP256.ReturnValue<options> {
-  const { access, internal_version } = options
+  const { access, keyAuthorizationManager, internal_version } = options
   const publicKey = P256.getPublicKey({ privateKey })
 
   return from({
-    access,
+    ...(access ? { access, keyAuthorizationManager } : {}),
     internal_version,
     keyType: 'p256',
     publicKey,
@@ -207,7 +214,10 @@ export function fromP256<const options extends fromP256.Options>(
 }
 
 export declare namespace fromP256 {
-  export type Options = Pick<from.Parameters, 'access' | 'internal_version'>
+  export type Options = Pick<
+    from.Parameters,
+    'access' | 'internal_version' | 'keyAuthorizationManager'
+  >
 
   export type ReturnValue<options extends Options = Options> =
     from.ReturnValue<options>
@@ -230,11 +240,11 @@ export function fromSecp256k1<const options extends fromSecp256k1.Options>(
   privateKey: Hex.Hex,
   options: options | fromSecp256k1.Options = {},
 ): fromSecp256k1.ReturnValue<options> {
-  const { access, internal_version } = options
+  const { access, keyAuthorizationManager, internal_version } = options
   const publicKey = Secp256k1.getPublicKey({ privateKey })
 
   return from({
-    access,
+    ...(access ? { access, keyAuthorizationManager } : {}),
     internal_version,
     keyType: 'secp256k1',
     publicKey,
@@ -247,7 +257,10 @@ export function fromSecp256k1<const options extends fromSecp256k1.Options>(
 }
 
 export declare namespace fromSecp256k1 {
-  export type Options = Pick<from.Parameters, 'access' | 'internal_version'>
+  export type Options = Pick<
+    from.Parameters,
+    'access' | 'internal_version' | 'keyAuthorizationManager'
+  >
 
   export type ReturnValue<options extends Options = Options> =
     from.ReturnValue<options>
@@ -371,11 +384,11 @@ export function fromWebCryptoP256<
   keyPair: Awaited<ReturnType<typeof WebCryptoP256.createKeyPair>>,
   options: options | fromWebCryptoP256.Options = {},
 ): fromWebCryptoP256.ReturnValue<options> {
-  const { access, internal_version } = options
+  const { access, keyAuthorizationManager, internal_version } = options
   const { publicKey, privateKey } = keyPair
 
   return from({
-    access,
+    ...(access ? { access, keyAuthorizationManager } : {}),
     internal_version,
     keyType: 'p256',
     publicKey,
@@ -392,7 +405,10 @@ export function fromWebCryptoP256<
 }
 
 export declare namespace fromWebCryptoP256 {
-  export type Options = Pick<from.Parameters, 'access' | 'internal_version'>
+  export type Options = Pick<
+    from.Parameters,
+    'access' | 'internal_version' | 'keyAuthorizationManager'
+  >
 
   export type ReturnValue<options extends Options = Options> =
     from.ReturnValue<options>
@@ -402,9 +418,9 @@ export async function signVoucher(
   account: LocalAccount,
   parameters: signVoucher.Parameters,
 ): Promise<signVoucher.ReturnValue> {
-  return account.sign!({
-    hash: getVoucherSignPayload(parameters),
-  })
+  const hash = getVoucherSignPayload(parameters)
+  if (isAccessKeyAccount(account)) return account.sign({ hash, raw: true })
+  return account.sign!({ hash })
 }
 
 function getVoucherSignPayload(parameters: signVoucher.Parameters) {
@@ -436,6 +452,12 @@ export declare namespace signVoucher {
   type ReturnValue = Hex.Hex
 }
 
+function isAccessKeyAccount(
+  account: LocalAccount,
+): account is AccessKeyAccount {
+  return account.source === 'accessKey' && 'accessKeyAddress' in account
+}
+
 export async function signKeyAuthorization(
   account: LocalAccount,
   parameters: signKeyAuthorization.Parameters,
@@ -557,9 +579,9 @@ function fromBase(parameters: fromBase.Parameters): Account_base {
       return await sign({ hash: hashTypedData(typedData) })
     },
     async signVoucher(parameters) {
-      return await sign({
-        hash: getVoucherSignPayload(parameters),
-      })
+      const hash = getVoucherSignPayload(parameters)
+      if (parentAddress) return await sign({ hash, raw: true })
+      return await sign({ hash })
     },
     publicKey,
     source,
@@ -575,6 +597,8 @@ declare namespace fromBase {
     publicKey: PublicKey.PublicKey
     /** Key type. */
     keyType?: SignatureEnvelope.Type | undefined
+    /** Pending key authorization manager. */
+    keyAuthorizationManager?: KeyAuthorizationManager | undefined
     /** Sign function. */
     sign: NonNullable<LocalAccount['sign']>
     /** Source. */
@@ -629,12 +653,13 @@ declare namespace fromRoot {
 
 // biome-ignore lint/correctness/noUnusedVariables: _
 function fromAccessKey(parameters: fromAccessKey.Parameters): AccessKeyAccount {
-  const { access } = parameters
+  const { access, keyAuthorizationManager } = parameters
   const { address: parentAddress } = parseAccount(access)
   const account = fromBase({ ...parameters, parentAddress })
   return {
     ...account,
     accessKeyAddress: Address.fromPublicKey(parameters.publicKey),
+    keyAuthorizationManager,
     source: 'accessKey',
   }
 }
@@ -647,6 +672,8 @@ declare namespace fromAccessKey {
      * the parent account's address as the keychain address.
      */
     access: viem_Account | Address.Address
+    /** Pending key authorization manager. */
+    keyAuthorizationManager?: KeyAuthorizationManager | undefined
   }
 
   export type ReturnValue = AccessKeyAccount

package/tempo/KeyAuthorizationManager.ts

@@ -0,0 +1,51 @@
+import type { Address } from 'abitype'
+import type { KeyAuthorization } from 'ox/tempo'
+import type { MaybePromise } from '../types/utils.js'
+
+export type Key = {
+  address: Address
+  accessKey: Address
+  chainId: number
+}
+
+export type KeyAuthorizationManager = {
+  get(key: Key): MaybePromise<KeyAuthorization.Signed | undefined>
+  remove(key: Key): MaybePromise<void>
+  set(key: Key, keyAuthorization: KeyAuthorization.Signed): MaybePromise<void>
+}
+
+export function from(options: from.Options): KeyAuthorizationManager {
+  return options.source
+}
+
+export declare namespace from {
+  type Options = {
+    source: KeyAuthorizationManager
+  }
+}
+
+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)
+      },
+    },
+  })
+}
+
+function serializeKey(key: Key) {
+  return [
+    key.chainId,
+    key.address.toLowerCase(),
+    key.accessKey.toLowerCase(),
+  ].join(':')
+}

package/tempo/actions/accessKey.ts

@@ -654,6 +654,7 @@ export async function getMetadata<
   const account = parseAccount(account_)
   const result = await readContract(client, {
     ...rest,
+    account: null as never,
     ...getMetadata.call({ account: account.address, accessKey }),
   })
   return {

package/tempo/chainConfig.ts

@@ -4,6 +4,7 @@ import { getCode } from '../actions/public/getCode.js'
 import { verifyHash } from '../actions/public/verifyHash.js'
 import { maxUint256 } from '../constants/number.js'
 import type { Chain, ChainConfig as viem_ChainConfig } from '../types/chain.js'
+import { isAddressEqual } from '../utils/address/isAddressEqual.js'
 import { extendSchema } from '../utils/chain/defineChain.js'
 import { defineTransaction } from '../utils/formatters/transaction.js'
 import { defineTransactionReceipt } from '../utils/formatters/transactionReceipt.js'
@@ -39,11 +40,14 @@ export const chainConfig = {
     }),
   },
   prepareTransactionRequest: [
-    async (r, { phase }) => {
+    async (r, { client, phase }) => {
       const request = r as Transaction.TransactionRequest & {
         account?: Account | undefined
+        chainId?: number | undefined
         chain?:
-          | (Chain & { feeToken?: TokenId.TokenIdOrAddress | undefined })
+          | (Chain & {
+              feeToken?: TokenId.TokenIdOrAddress | undefined
+            })
           | undefined
       }
 
@@ -59,6 +63,46 @@ export const chainConfig = {
         return request as unknown as typeof r
       }
 
+      if (
+        !request.keyAuthorization &&
+        request.account?.source === 'accessKey'
+      ) {
+        const keyAuthorizationManager = request.account.keyAuthorizationManager
+        if (keyAuthorizationManager) {
+          const chainId = request.chainId ?? request.chain?.id
+          if (typeof chainId !== 'undefined') {
+            const address = request.account.address
+            const accessKey = request.account.accessKeyAddress
+            const key = { address, accessKey, chainId }
+            const keyAuthorization = await keyAuthorizationManager.get(key)
+
+            if (keyAuthorization) {
+              const now = BigInt(Math.floor(Date.now() / 1000))
+              if (
+                keyAuthorization.expiry != null &&
+                BigInt(keyAuthorization.expiry) <= now
+              ) {
+                await keyAuthorizationManager.remove(key)
+              } else {
+                const metadata = await getAction(
+                  client,
+                  getMetadata,
+                  'getMetadata',
+                )({ account: address, accessKey })
+
+                if (
+                  isAddressEqual(metadata.address, accessKey) &&
+                  !metadata.isRevoked &&
+                  metadata.expiry > now
+                )
+                  await keyAuthorizationManager.remove(key)
+                else request.keyAuthorization = keyAuthorization
+              }
+            }
+          }
+        }
+      }
+
       // 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

package/tempo/index.ts

@@ -34,6 +34,7 @@ export * as Expiry from './Expiry.js'
 export * from './errors.js'
 export * as Formatters from './Formatters.js'
 export * as Hardfork from './Hardfork.js'
+export * as KeyAuthorizationManager from './KeyAuthorizationManager.js'
 export * as P256 from './P256.js'
 export * as Storage from './Storage.js'
 export * as TokenIds from './TokenIds.js'

package/types/chain.ts

@@ -79,9 +79,10 @@ type PrepareTransactionRequestPhase =
   | 'beforeFillTransaction'
   | 'beforeFillParameters'
   | 'afterFillParameters'
+
 type PrepareTransactionRequestFn = (
   args: PrepareTransactionRequestParameters,
-  options: { phase: PrepareTransactionRequestPhase },
+  options: { client: Client; phase: PrepareTransactionRequestPhase },
 ) => Promise<PrepareTransactionRequestParameters>
 
 type ChainVerifyHashFn = (