viem 3.0.0-next.10 → 3.0.0-next.13

package/src/core/actions/transaction/fill.ts

@@ -1,10 +1,11 @@
-import { Transaction, TransactionRequest } from 'ox'
+import { TransactionRequest } from 'ox'
 import type { Address, Errors, Hex } from 'ox'
 
 import type * as Account from '../../Account.js'
 import type * as Capabilities from '../../Capabilities.js'
 import type * as Chain from '../../Chain.js'
 import type * as Client from '../../Client.js'
+import { BaseError } from '../../Errors.js'
 import * as RpcError from '../../RpcError.js'
 import type * as NonceManager from '../../NonceManager.js'
 import { isAbortError } from '../../internal/errors.js'
@@ -86,7 +87,7 @@ export async function fill<chain extends Chain.Chain | undefined>(
 
     const fromRpc = chain?.codecs?.transaction?.fromRpc
     const transaction = (
-      fromRpc ? fromRpc(response.tx) : Transaction.fromRpc(response.tx)
+      fromRpc ? fromRpc(response.tx) : TransactionRequest.fromRpc(response.tx)
     ) as Record<string, any>
 
     // Remove unnecessary fields.
@@ -99,50 +100,70 @@ export async function fill<chain extends Chain.Chain | undefined>(
     delete transaction.yParity
 
     // Rewrite fields.
-    transaction.data = transaction.input
+    transaction.data = transaction.data ?? transaction.input
 
-    // Preference supplied fees (some nodes do not take these preferences).
     // Coerce to `bigint` so the return type stays consistent with the
     // node-derived (decoded) values regardless of the supplied input format.
     const quantity = (value: bigint | number | Hex.Hex | undefined) =>
       typeof value === 'undefined' ? undefined : BigInt(value)
-    if (transaction.gas)
-      transaction.gas = quantity(options.gas) ?? transaction.gas
-    if (transaction.gasPrice)
-      transaction.gasPrice = quantity(options.gasPrice) ?? transaction.gasPrice
-    if (transaction.maxFeePerBlobGas)
-      transaction.maxFeePerBlobGas =
-        quantity(options.maxFeePerBlobGas) ?? transaction.maxFeePerBlobGas
-    if (transaction.maxFeePerGas)
-      transaction.maxFeePerGas =
-        quantity(options.maxFeePerGas) ?? transaction.maxFeePerGas
-    if (transaction.maxPriorityFeePerGas)
-      transaction.maxPriorityFeePerGas =
-        quantity(options.maxPriorityFeePerGas) ??
-        transaction.maxPriorityFeePerGas
-    if (typeof transaction.nonce !== 'undefined')
-      transaction.nonce = quantity(options.nonce) ?? transaction.nonce
-
-    // Build the fee multiplier from the chain's `baseFeeMultiplier`.
-    const feeMultiplier = await (async () => {
-      if (typeof chain?.fees?.baseFeeMultiplier === 'function')
-        return chain.fees.baseFeeMultiplier({
-          block: await getBlock(client),
-          client,
-          request,
-        })
-      return chain?.fees?.baseFeeMultiplier ?? 1.2
-    })()
-    if (feeMultiplier < 1) throw new BaseFeeScalarError()
-
-    const decimals = feeMultiplier.toString().split('.')[1]?.length ?? 0
-    const denominator = 10 ** decimals
-    const multiplyFee = (base: bigint) =>
-      (base * BigInt(Math.round(feeMultiplier * denominator))) /
-      BigInt(denominator)
-
-    // Apply the fee multiplier to node-derived fees the caller did not supply.
-    if (!transaction.feePayerSignature) {
+    const filledNonce = quantity(transaction.nonce)
+    const requestedNonce = quantity(nonce)
+    const hasFeePayerSignature =
+      typeof transaction.feePayerSignature !== 'undefined' &&
+      transaction.feePayerSignature !== null
+
+    if (
+      hasFeePayerSignature &&
+      typeof requestedNonce !== 'undefined' &&
+      filledNonce !== requestedNonce
+    )
+      throw new FeePayerNonceMismatchError({
+        filledNonce,
+        requestedNonce,
+      })
+
+    // A fee payer signature commits to the filled transaction, so preserve
+    // its signed fields regardless of who produced the signature.
+    // https://tips.sh/0001#fee-payer-signature
+    if (!hasFeePayerSignature) {
+      // Preference supplied fees (some nodes do not take these preferences).
+      if (transaction.gas)
+        transaction.gas = quantity(options.gas) ?? transaction.gas
+      if (transaction.gasPrice)
+        transaction.gasPrice =
+          quantity(options.gasPrice) ?? transaction.gasPrice
+      if (transaction.maxFeePerBlobGas)
+        transaction.maxFeePerBlobGas =
+          quantity(options.maxFeePerBlobGas) ?? transaction.maxFeePerBlobGas
+      if (transaction.maxFeePerGas)
+        transaction.maxFeePerGas =
+          quantity(options.maxFeePerGas) ?? transaction.maxFeePerGas
+      if (transaction.maxPriorityFeePerGas)
+        transaction.maxPriorityFeePerGas =
+          quantity(options.maxPriorityFeePerGas) ??
+          transaction.maxPriorityFeePerGas
+      if (typeof transaction.nonce !== 'undefined')
+        transaction.nonce = quantity(options.nonce) ?? transaction.nonce
+
+      // Build the fee multiplier from the chain's `baseFeeMultiplier`.
+      const feeMultiplier = await (async () => {
+        if (typeof chain?.fees?.baseFeeMultiplier === 'function')
+          return chain.fees.baseFeeMultiplier({
+            block: await getBlock(client),
+            client,
+            request,
+          })
+        return chain?.fees?.baseFeeMultiplier ?? 1.2
+      })()
+      if (feeMultiplier < 1) throw new BaseFeeScalarError()
+
+      const decimals = feeMultiplier.toString().split('.')[1]?.length ?? 0
+      const denominator = 10 ** decimals
+      const multiplyFee = (base: bigint) =>
+        (base * BigInt(Math.round(feeMultiplier * denominator))) /
+        BigInt(denominator)
+
+      // Apply the fee multiplier to node-derived fees the caller did not supply.
       if (transaction.maxFeePerGas && !options.maxFeePerGas)
         transaction.maxFeePerGas = multiplyFee(transaction.maxFeePerGas)
       if (transaction.gasPrice && !options.gasPrice)
@@ -166,6 +187,26 @@ export async function fill<chain extends Chain.Chain | undefined>(
   }
 }
 
+/** Thrown when a fee-payer-signed fill changes the requested nonce. */
+export class FeePayerNonceMismatchError extends BaseError {
+  override readonly name = 'TransactionFill.FeePayerNonceMismatchError'
+
+  constructor({
+    filledNonce,
+    requestedNonce,
+  }: {
+    filledNonce: bigint | undefined
+    requestedNonce: bigint
+  }) {
+    super('The filled transaction nonce does not match the requested nonce.', {
+      metaMessages: [
+        `Requested Nonce: ${requestedNonce}`,
+        `Filled Nonce: ${filledNonce}`,
+      ],
+    })
+  }
+}
+
 export declare namespace fill {
   type Options<
     chain extends Chain.Chain | undefined = Chain.Chain | undefined,
@@ -196,6 +237,7 @@ export declare namespace fill {
   }
 
   type ErrorType =
+    | FeePayerNonceMismatchError
     | RpcError.ExecutionError
     | transactionRequest.assert.ErrorType
     | BaseFeeScalarError

package/src/core/actions/transaction/prepare.ts

@@ -22,7 +22,7 @@ import {
 import { Eip1559FeesNotSupportedError } from '../fee/estimateMaxPriorityFeePerGas.js'
 import { getAction } from '../getAction.js'
 import { estimateGas } from './estimateGas.js'
-import { fill } from './fill.js'
+import { FeePayerNonceMismatchError, fill } from './fill.js'
 
 /** Default `parameters` filled when none are supplied. */
 export const defaultParameters = [
@@ -244,6 +244,11 @@ export async function prepare<
     } catch (err) {
       if (isAbortError(err)) throw err
       if (err instanceof RpcError.ExecutionRevertedError) throw err
+      if (
+        err instanceof BaseError &&
+        err.walk((error) => error instanceof FeePayerNonceMismatchError)
+      )
+        throw err
       if (isUnsupportedFill(err)) supportsFill.set(client.uid, false)
       // Otherwise, fall back to manual preparation below.
     }

package/src/core/actions/transaction/sign.ts

@@ -84,7 +84,10 @@ export async function sign<chain extends Chain.Chain | undefined>(
   const request = {
     ...rest,
     chainId,
-    from: account.address,
+    from:
+      account.type === 'local'
+        ? (rest.from ?? account.address)
+        : account.address,
   } satisfies TransactionRequest.toRpc.Input
 
   if (account.type === 'local') {

package/src/core/actions/wallet/sendCalls.ts

@@ -133,6 +133,7 @@ export async function sendCalls<
       (error.name === 'RpcResponse.MethodNotFoundError' ||
         error.name === 'RpcResponse.MethodNotSupportedError' ||
         error.name === 'RpcError.UnknownRpcError' ||
+        details === 'this request method is not supported' ||
         details.includes('does not exist / is not available') ||
         details.includes('missing or invalid. request()') ||
         details.includes('did not match any variant of untagged enum') ||

package/src/core/internal/transport.ts

@@ -134,7 +134,7 @@ export function shouldRetry(error: Error): boolean {
   const code = (error as { code?: unknown }).code
   if (typeof code === 'number') {
     if (code === -1) return true // unknown
-    if (code === -32005) return true // limit exceeded
+    if (code === -32005 || code === -32007) return true // limit exceeded
     if (code === -32603) return true // internal
     if (code === 429) return true // too many requests (JSON-RPC body form)
     return false

package/src/erc4337/actions/userOperation/get.ts

@@ -42,8 +42,10 @@ export async function get<
 
   return {
     ...result,
+    blockHash: result.blockHash ?? null,
+    transactionHash: result.transactionHash ?? null,
     blockNumber:
-      result.blockNumber === null ? null : Hex.toBigInt(result.blockNumber),
+      result.blockNumber == null ? null : Hex.toBigInt(result.blockNumber),
     userOperation: UserOperation.fromRpc(result.userOperation),
   } as get.ReturnType<entryPointVersion>
 }

package/src/erc4337/actions/userOperation/waitForReceipt.ts

@@ -98,7 +98,7 @@ export async function waitForReceipt<
     return unpoll
   })
 
-  return promise
+  return promise.finally(() => unobserve())
 }
 
 export declare namespace waitForReceipt {

package/src/internal/inference.ts

@@ -73,3 +73,27 @@ export type { TransactionReceipt as z_TransactionReceipt } from 'ox/TransactionR
 export type { Type as z_TransactionReceiptType } from 'ox/TransactionReceipt'
 /** @deprecated Compiler support for declaration emit, not Viem API. */
 export type { Withdrawal as z_Withdrawal } from 'ox/Withdrawal'
+/** @deprecated Compiler support for declaration emit, not Viem API. */
+export type { Scope as z_KeyAuthorizationScope } from 'ox/tempo/KeyAuthorization'
+/** @deprecated Compiler support for declaration emit, not Viem API. */
+export type { Owner as z_MultisigConfigOwner } from 'ox/tempo/MultisigConfig'
+/** @deprecated Compiler support for declaration emit, not Viem API. */
+export type { Rpc as z_FrameReceiptRpc } from 'ox/FrameReceipt'
+/** @deprecated Compiler support for declaration emit, not Viem API. */
+export type { FrameRequest as z_FrameRequest } from 'ox/FrameRequest'
+/** @deprecated Compiler support for declaration emit, not Viem API. */
+export type { FrameSignature as z_FrameSignature } from 'ox/FrameSignature'
+/** @deprecated Compiler support for declaration emit, not Viem API. */
+export type { Rpc as z_FrameSignatureRpc } from 'ox/FrameSignature'
+/** @deprecated Compiler support for declaration emit, not Viem API. */
+export type { Rpc as z_TxEnvelopeRpc } from 'ox/TxEnvelope'
+/** @deprecated Compiler support for declaration emit, not Viem API. */
+export type { FrameReceipt as z_FrameReceipt } from 'ox/FrameReceipt'
+/** @deprecated Compiler support for declaration emit, not Viem API. */
+export type { TokenLimit as z_KeyAuthorizationTokenLimit } from 'ox/tempo/KeyAuthorization'
+/** @deprecated Compiler support for declaration emit, not Viem API. */
+export type { KeyAuthorizationOperation as z_MultisigKeyAuthorizationOperation } from 'ox/tempo/MultisigOperation'
+/** @deprecated Compiler support for declaration emit, not Viem API. */
+export type { Multisig as z_SignatureEnvelopeMultisig } from 'ox/tempo/SignatureEnvelope'
+/** @deprecated Compiler support for declaration emit, not Viem API. */
+export type { Primitive as z_SignatureEnvelopePrimitive } from 'ox/tempo/SignatureEnvelope'

package/src/node/transports/ipc.ts

@@ -107,6 +107,8 @@ export declare namespace ipc {
 
 const openingBrace = '{'.charCodeAt(0)
 const closingBrace = '}'.charCodeAt(0)
+const quote = '"'.charCodeAt(0)
+const backslash = '\\'.charCodeAt(0)
 
 /**
  * Extracts complete JSON messages from a (possibly partial) IPC buffer.
@@ -120,9 +122,22 @@ export function extractMessages(
 
   let cursor = 0
   let level = 0
+  let inString = false
+  let escaped = false
   for (let i = 0; i < buffer.length; i++) {
-    if (buffer[i] === openingBrace) level++
-    if (buffer[i] === closingBrace) level--
+    const byte = buffer[i]
+    if (inString) {
+      if (escaped) escaped = false
+      else if (byte === backslash) escaped = true
+      else if (byte === quote) inString = false
+      continue
+    }
+    if (byte === quote) {
+      inString = true
+      continue
+    }
+    if (byte === openingBrace) level++
+    if (byte === closingBrace) level--
     if (level === 0) {
       const message = buffer.subarray(cursor, i + 1)
       if (

package/src/op-stack/actions/l1/getGame.ts

@@ -12,7 +12,7 @@ export async function getGame<chain extends Chain.Chain | undefined>(
 ): Promise<getGame.ReturnType> {
   const { l2BlockNumber, strategy = 'latest' } = options
   const games = (await getGames(client, options)).filter(
-    (game) => game.l2BlockNumber > l2BlockNumber,
+    (game) => game.l2BlockNumber >= l2BlockNumber,
   )
   const game =
     strategy === 'random'

package/src/op-stack/actions/l1/getGames.ts

@@ -66,7 +66,7 @@ export async function getGames<chain extends Chain.Chain | undefined>(
   for (const [index, game] of rawGames.entries()) {
     const blockNumber = results[index]
     if (typeof blockNumber !== 'bigint') throw new GameSequenceNotFoundError()
-    if (!l2BlockNumber || blockNumber > l2BlockNumber)
+    if (l2BlockNumber === undefined || blockNumber >= l2BlockNumber)
       games.push({
         ...game,
         l2BlockNumber: blockNumber,

package/src/op-stack/actions/l1/getTimeToNextGame.ts

@@ -32,7 +32,7 @@ export async function getTimeToNextGame<chain extends Chain.Chain | undefined>(
 
   const seconds = (() => {
     if (now < latestGameTimestamp) return 0
-    if (latestGame.l2BlockNumber > l2BlockNumber) return 0
+    if (latestGame.l2BlockNumber >= l2BlockNumber) return 0
     if (intervalWithBuffer === 0) return 0
 
     const elapsedBlocks = Number(l2BlockNumber - latestGame.l2BlockNumber)

package/src/op-stack/actions/l1/getTimeToNextL2Output.ts

@@ -52,7 +52,7 @@ export async function getTimeToNextL2Output<
   const now = Date.now()
   const seconds = (() => {
     if (now < latestOutputTimestamp) return 0
-    if (latestOutput.l2BlockNumber > l2BlockNumber) return 0
+    if (latestOutput.l2BlockNumber >= l2BlockNumber) return 0
 
     const elapsedBlocks = Number(l2BlockNumber - latestOutput.l2BlockNumber)
     const elapsed = Math.ceil((now - latestOutputTimestamp) / 1000)