viem 2.57.7 → 2.57.8

package/tempo/internal/relay/request.ts

@@ -1,5 +1,5 @@
 import type { Address } from 'abitype'
-import { RpcResponse } from 'ox'
+import { Hex, RpcResponse } from 'ox'
 import type { Transaction as core_Transaction } from 'ox/tempo'
 import { tempo } from '../../../chains/index.js'
 import { type Client, createClient } from '../../../clients/createClient.js'
@@ -151,20 +151,33 @@ export function compose(
             | Record<string, unknown>
             | undefined
           // The node must estimate unsigned sponsorship independently of the sender's fee-token balance.
-          const request =
+          const sponsored =
             state.request.method === 'eth_fillTransaction' &&
             parameters?.feePayer === true &&
             !parameters.feePayerSignature
-              ? {
-                  ...state.request,
-                  params: [{ ...parameters, feeToken: undefined }],
-                }
-              : state.request
+              ? parameters
+              : undefined
+          const fees = sponsored ? parseFees(sponsored) : undefined
+          const request = (() => {
+            if (!sponsored) return state.request
+            const {
+              maxFeePerGas: _,
+              maxPriorityFeePerGas: __,
+              ...unpriced
+            } = sponsored
+            return {
+              ...state.request,
+              params: [
+                { ...(fees ? unpriced : sponsored), feeToken: undefined },
+              ],
+            }
+          })()
           requestOptions.signal?.throwIfAborted()
-          state.result = await downstream(request, {
+          const result = await downstream(request, {
             ...state.options,
             ...(isFill ? { signal: requestOptions.signal } : {}),
           })
+          state.result = fees ? restoreFees(result, fees) : result
           return
         }
         const plugin = plugins[index]!
@@ -389,3 +402,89 @@ export async function fill(
 
   return { ...result, tx: Utils.mergeCallsFromRequest(result.tx, transaction) }
 }
+
+/** Caller fee caps restored after an unpriced sponsored fill. */
+type Fees = {
+  maxFeePerGas: bigint | undefined
+  maxPriorityFeePerGas: bigint | undefined
+}
+
+/**
+ * Parses caller fee caps for a sponsored fill without gas. Tempo estimates gas before it knows the
+ * sponsor, so a priced request caps gas by the sender's fee balance.
+ */
+function parseFees(parameters: Record<string, unknown>): Fees | undefined {
+  if (parameters.gas != null) return undefined
+  const maxFeePerGas = parseFee(parameters.maxFeePerGas)
+  const maxPriorityFeePerGas = parseFee(parameters.maxPriorityFeePerGas)
+  // Invalid values reach the node unchanged so it rejects them itself.
+  if (maxFeePerGas === null || maxPriorityFeePerGas === null) return undefined
+  if (maxFeePerGas === undefined && maxPriorityFeePerGas === undefined)
+    return undefined
+  // Incompatible caps reach the node unchanged so it rejects the combination itself.
+  if (
+    maxFeePerGas !== undefined &&
+    maxPriorityFeePerGas !== undefined &&
+    maxPriorityFeePerGas > maxFeePerGas
+  )
+    return undefined
+  return { maxFeePerGas, maxPriorityFeePerGas }
+}
+
+/** Restores caller fee caps on a filled transaction. */
+function restoreFees(result: unknown, fees: Fees): unknown {
+  const { tx } = (result ?? {}) as Partial<Result>
+  // A downstream sponsor signature binds its own fees; changing them would invalidate it.
+  if (!tx || typeof tx !== 'object' || tx.feePayerSignature) return result
+  const filled = parseFee(tx.maxFeePerGas)
+  const tip = parseFee(tx.maxPriorityFeePerGas)
+  // A caller tip above the node-chosen fee cap raises the cap so the transaction stays valid.
+  const maxFeePerGas =
+    fees.maxFeePerGas ??
+    (filled != null &&
+    fees.maxPriorityFeePerGas !== undefined &&
+    fees.maxPriorityFeePerGas > filled
+      ? fees.maxPriorityFeePerGas
+      : filled)
+  if (maxFeePerGas == null)
+    return fees.maxPriorityFeePerGas === undefined
+      ? result
+      : {
+          ...(result as Result),
+          tx: {
+            ...tx,
+            maxPriorityFeePerGas: Hex.fromNumber(fees.maxPriorityFeePerGas),
+          },
+        }
+  // A node-chosen tip above the caller's fee cap would make the transaction invalid.
+  const maxPriorityFeePerGas =
+    fees.maxPriorityFeePerGas ??
+    (tip != null && tip < maxFeePerGas ? tip : maxFeePerGas)
+  return {
+    ...(result as Result),
+    tx: {
+      ...tx,
+      maxFeePerGas: Hex.fromNumber(maxFeePerGas),
+      maxPriorityFeePerGas: Hex.fromNumber(maxPriorityFeePerGas),
+    },
+  }
+}
+
+/** Parses a fee quantity, returning `null` for values the node should reject itself. */
+function parseFee(value: unknown) {
+  if (value == null) return undefined
+  if (typeof value === 'bigint')
+    return value >= 0n && value <= maxQuantity ? value : null
+  if (typeof value === 'number')
+    return Number.isSafeInteger(value) && value >= 0 ? BigInt(value) : null
+  // Only canonical RPC quantities are rewritten; leading zeros and over-width values reach the node.
+  if (typeof value === 'string' && quantityPattern.test(value))
+    return Hex.toBigInt(value as Hex.Hex)
+  return null
+}
+
+/** Largest 256-bit RPC quantity. */
+const maxQuantity = 2n ** 256n - 1n
+
+/** Canonical RPC quantity: `0x0` or a hex value without leading zeros, at most 256 bits. */
+const quantityPattern = /^0x(?:0|[1-9a-fA-F][0-9a-fA-F]{0,63})$/

package/tempo/internal/relay.ts

@@ -3,6 +3,9 @@ import { BaseError } from '../../errors/base.js'
 import { RpcRequestError } from '../../errors/request.js'
 import type * as Relay from '../Relay.js'
 
+/** Largest request body, in bytes, read before JSON parsing; above reth's 15 MB default. */
+const maxBodySize = 16 * 1_024 * 1_024
+
 /** Adapts an RPC handler to the Fetch API without changing its method results. */
 export async function fetch(
   request: Request,
@@ -21,7 +24,20 @@ export async function fetch(
 
   const body = await (async () => {
     try {
-      return { value: (await request.json()) as unknown }
+      const chunks = await readBody(request)
+      if (!chunks)
+        return {
+          status: 413,
+          error: {
+            jsonrpc: '2.0',
+            id: null,
+            error: {
+              code: -32600,
+              message: `Request body exceeds ${maxBodySize / 1_024 / 1_024} MiB`,
+            },
+          },
+        }
+      return { value: (await new Response(new Blob(chunks)).json()) as unknown }
     } catch {
       return {
         error: {
@@ -32,7 +48,8 @@ export async function fetch(
       }
     }
   })()
-  if (body.error) return Response.json(body.error)
+  if (body.error)
+    return Response.json(body.error, body.status ? { status: body.status } : {})
 
   const requestOptions = {
     ...options,
@@ -156,3 +173,25 @@ export async function fetch(
     ? new Response(null, { status: 204 })
     : Response.json(response)
 }
+
+/** Reads a request body, returning `undefined` once its declared or streamed size exceeds {@link maxBodySize}. */
+async function readBody(request: Request) {
+  if (Number(request.headers.get('content-length')) > maxBodySize) {
+    await request.body?.cancel()
+    return undefined
+  }
+  const chunks: Uint8Array<ArrayBuffer>[] = []
+  if (!request.body) return chunks
+  const reader = request.body.getReader()
+  let size = 0
+  for (;;) {
+    const { done, value } = await reader.read()
+    if (done) return chunks
+    size += value.byteLength
+    if (size > maxBodySize) {
+      await reader.cancel()
+      return undefined
+    }
+    chunks.push(value)
+  }
+}

package/tempo/internal/replacement.ts

@@ -0,0 +1,109 @@
+import * as Hex from 'ox/Hex'
+import { TxEnvelopeTempo } from 'ox/tempo'
+import type { ReplacementReason } from '../../actions/public/waitForTransactionReceipt.js'
+import { maxUint256 } from '../../constants/number.js'
+import type { ChainTransactionReplacement } from '../../types/chain.js'
+import { isAddressEqual } from '../../utils/address/isAddressEqual.js'
+import { keccak256 } from '../../utils/hash/keccak256.js'
+import type { Transaction } from '../Transaction.js'
+
+/**
+ * Tempo transaction replacement semantics.
+ *
+ * - Protocol nonces (nonce key `0`, including Ethereum transaction types) and
+ *   2D nonces occupy the sender's `(nonceKey, nonce)` slot.
+ * - Expiring nonces are deduplicated by their expiring nonce hash, so a
+ *   transaction is replaced only by another carrying the same sender payload
+ *   (e.g. re-sponsored with a different fee payer signature or fee token).
+ */
+export const transactionReplacement = {
+  getKey(transaction) {
+    const tx = transaction as Transaction
+    if (tx.type !== 'tempo') return `0:${tx.nonce}`
+    const nonceKey = tx.nonceKey ?? 0n
+    if (nonceKey === maxUint256) return `expiring:${getExpiringNonceHash(tx)}`
+    return `${nonceKey}:${tx.nonce}`
+  },
+  getReason({ replaced, replacement }) {
+    return getReason(replaced as Transaction, replacement as Transaction)
+  },
+} as const satisfies ChainTransactionReplacement
+
+/**
+ * Returns the expiring nonce hash of a Tempo transaction:
+ * `keccak256(encodeForSigning(tx) || sender)`. It excludes the fee payer
+ * signature and fee token, so it is invariant to sponsorship.
+ *
+ * @internal
+ */
+export function getExpiringNonceHash(transaction: Transaction) {
+  const tx = transaction as Extract<Transaction, { type: 'tempo' }>
+  const envelope = TxEnvelopeTempo.from({
+    accessList: tx.accessList,
+    authorizationList: tx.authorizationList,
+    calls: tx.calls,
+    chainId: tx.chainId,
+    feePayerSignature: tx.feePayerSignature ? null : undefined,
+    feeToken: tx.feeToken,
+    gas: tx.gas,
+    keyAuthorization: tx.keyAuthorization ?? undefined,
+    maxFeePerGas: tx.maxFeePerGas,
+    maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+    nonce: BigInt(tx.nonce),
+    nonceKey: tx.nonceKey,
+    validAfter: tx.validAfter,
+    validBefore: tx.validBefore,
+  })
+  return keccak256(
+    Hex.concat(TxEnvelopeTempo.encodeForSigning(envelope), tx.from),
+  )
+}
+
+function getReason(
+  replaced: Transaction,
+  replacement: Transaction,
+): ReplacementReason {
+  const calls = getCalls(replacement)
+  const replacedCalls = getCalls(replaced)
+  if (
+    calls.length === replacedCalls.length &&
+    calls.every((call, i) => isSameCall(call, replacedCalls[i]!))
+  )
+    return 'repriced'
+  if (
+    calls.every(
+      (call) =>
+        call.to &&
+        isAddressEqual(call.to, replacement.from) &&
+        !call.value &&
+        isEmpty(call.data),
+    )
+  )
+    return 'cancelled'
+  return 'replaced'
+}
+
+type Call = {
+  data?: Hex.Hex | undefined
+  to?: Hex.Hex | null | undefined
+  value?: bigint | undefined
+}
+
+function getCalls(transaction: Transaction): readonly Call[] {
+  if (transaction.type === 'tempo') return transaction.calls
+  return [
+    { data: transaction.input, to: transaction.to, value: transaction.value },
+  ]
+}
+
+function isSameCall(a: Call, b: Call) {
+  return (
+    (a.to && b.to ? isAddressEqual(a.to, b.to) : !a.to && !b.to) &&
+    (a.value ?? 0n) === (b.value ?? 0n) &&
+    (isEmpty(a.data) ? isEmpty(b.data) : a.data === b.data)
+  )
+}
+
+function isEmpty(data: Hex.Hex | undefined) {
+  return !data || data === '0x'
+}

package/tempo/internal/utils.ts

@@ -307,3 +307,11 @@ export function normalizeValue<type>(value: type): type {
   for (const [k, v] of Object.entries(value)) normalized[k] = normalizeValue(v)
   return normalized as never
 }
+
+/** 12-byte prefix shared by TIP-20 token addresses; shorter prefixes are cheap to grind with CREATE2. */
+const tip20Prefix = '0x20c000000000000000000000'
+
+/** Whether `address` carries the TIP-20 token address prefix. */
+export function isTip20(address: string | undefined): address is Address {
+  return !!address?.toLowerCase().startsWith(tip20Prefix)
+}

package/types/chain.ts

@@ -5,6 +5,7 @@ import type {
   VerifyHashParameters,
   VerifyHashReturnType,
 } from '../actions/public/verifyHash.js'
+import type { ReplacementReason } from '../actions/public/waitForTransactionReceipt.js'
 import type { PrepareTransactionRequestParameters } from '../actions/wallet/prepareTransactionRequest.js'
 import type { Client } from '../clients/createClient.js'
 import type { Transport } from '../clients/transports/createTransport.js'
@@ -125,10 +126,52 @@ export type ChainConfig<
     | undefined
   /** Modifies how data is serialized (e.g. transactions). */
   serializers?: ChainSerializers<formatters> | undefined
+  /**
+   * Chain-specific transaction replacement semantics, used by
+   * `waitForTransactionReceipt`.
+   */
+  transactionReplacement?: ChainTransactionReplacement | undefined
   /** Chain-specific signature verification. */
   verifyHash?: ChainVerifyHashFn | undefined
 }
 
+/////////////////////////////////////////////////////////////////////
+// Transaction replacement
+/////////////////////////////////////////////////////////////////////
+
+/** A formatted transaction, as seen by transaction replacement hooks. */
+type ReplacementTransaction = {
+  from: Address
+  hash: `0x${string}`
+  nonce: number
+}
+
+/**
+ * Chain-specific transaction replacement semantics. `waitForTransactionReceipt`
+ * uses it to find which mined transaction replaced a pending one, and why.
+ */
+export type ChainTransactionReplacement = {
+  /**
+   * Returns the key of the sender's nonce slot that a transaction consumes. A
+   * mined transaction from the same sender with the same key replaces a
+   * pending one.
+   *
+   * @default `String(transaction.nonce)`
+   */
+  getKey?: ((transaction: ReplacementTransaction) => string) | undefined
+  /**
+   * Classifies a replacement.
+   *
+   * @default Compares `to`, `value`, and `input`.
+   */
+  getReason?:
+    | ((parameters: {
+        replaced: ReplacementTransaction
+        replacement: ReplacementTransaction
+      }) => ReplacementReason)
+    | undefined
+}
+
 /////////////////////////////////////////////////////////////////////
 // Fees
 /////////////////////////////////////////////////////////////////////

package/utils/abi/encodeEventTopics.ts

@@ -21,7 +21,11 @@ import type {
 } from '../../types/contract.js'
 import type { Hex } from '../../types/misc.js'
 import type { IsNarrowable, UnionEvaluate } from '../../types/utils.js'
-import { type ToBytesErrorType, toBytes } from '../encoding/toBytes.js'
+import {
+  stringToBytes,
+  type ToBytesErrorType,
+  toBytes,
+} from '../encoding/toBytes.js'
 import { type Keccak256ErrorType, keccak256 } from '../hash/keccak256.js'
 import {
   type ToEventSelectorErrorType,
@@ -157,8 +161,8 @@ function encodeArg({
   param: AbiParameter
   value: AbiParameterToPrimitiveType<AbiParameter>
 }) {
-  if (param.type === 'string' || param.type === 'bytes')
-    return keccak256(toBytes(value as string))
+  if (param.type === 'string') return keccak256(stringToBytes(value as string))
+  if (param.type === 'bytes') return keccak256(toBytes(value as string))
   if (param.type === 'tuple' || param.type.match(/^(.*)\[(\d+)?\]$/))
     throw new FilterTypeNotSupportedError(param.type)
   return encodeAbiParameters([param], [value])

package/utils/abi/parseEventLogs.ts

@@ -6,7 +6,7 @@ import type { ContractEventName, GetEventArgs } from '../../types/contract.js'
 import type { Log } from '../../types/log.js'
 import type { RpcLog } from '../../types/rpc.js'
 import { isAddressEqual } from '../address/isAddressEqual.js'
-import { toBytes } from '../encoding/toBytes.js'
+import { stringToBytes, toBytes } from '../encoding/toBytes.js'
 import { formatLog } from '../formatters/log.js'
 import { keccak256 } from '../hash/keccak256.js'
 import { toEventSelector } from '../hash/toEventSelector.js'
@@ -213,7 +213,9 @@ function includesArgs(parameters: {
     try {
       if (input.type === 'address')
         return isAddressEqual(value as Address, arg as Address)
-      if (input.type === 'string' || input.type === 'bytes')
+      if (input.type === 'string')
+        return keccak256(stringToBytes(value as string)) === arg
+      if (input.type === 'bytes')
         return keccak256(toBytes(value as string)) === arg
       return value === arg
     } catch {

package/utils/ens/avatar/parseAvatarRecord.ts

@@ -7,9 +7,11 @@ import type { AssetGatewayUrls } from '../../../types/ens.js'
 import {
   type GetJsonImageErrorType,
   type GetMetadataAvatarUriErrorType,
+  type GetNftMetadataUriErrorType,
   type GetNftTokenUriErrorType,
   getJsonImage,
   getMetadataAvatarUri,
+  getNftMetadataUri,
   getNftTokenUri,
   type ParseAvatarUriErrorType,
   type ParseNftUriErrorType,
@@ -56,6 +58,7 @@ type ParseNftAvatarUriErrorType =
   | ParseAvatarUriErrorType
   | GetJsonImageErrorType
   | GetMetadataAvatarUriErrorType
+  | GetNftMetadataUriErrorType
   | ErrorType
 
 async function parseNftAvatarUri<chain extends Chain | undefined>(
@@ -95,12 +98,8 @@ async function parseNftAvatarUri<chain extends Chain | undefined>(
     return parseAvatarUri({ uri: getJsonImage(decoded), gatewayUrls })
   }
 
-  let uriTokenId = nft.tokenID
-  if (nft.namespace === 'erc1155')
-    uriTokenId = uriTokenId.replace('0x', '').padStart(64, '0')
-
   return getMetadataAvatarUri({
     gatewayUrls,
-    uri: resolvedNftUri.replace(/(?:0x)?{id}/, uriTokenId),
+    uri: getNftMetadataUri({ nft, uri: resolvedNftUri }),
   })
 }

package/utils/ens/avatar/utils.ts

@@ -19,6 +19,7 @@ import {
 import type { ErrorType } from '../../../errors/utils.js'
 import type { Chain } from '../../../types/chain.js'
 import type { AssetGatewayUrls } from '../../../types/ens.js'
+import { type NumberToHexErrorType, numberToHex } from '../../encoding/toHex.js'
 
 type UriItem = {
   uri: string
@@ -295,3 +296,27 @@ export async function getNftTokenUri<chain extends Chain | undefined>(
   }
   throw new EnsAvatarUnsupportedNamespaceError({ namespace: nft.namespace })
 }
+
+export type GetNftMetadataUriErrorType = NumberToHexErrorType | ErrorType
+
+/**
+ * Substitutes the `{id}` placeholder of an NFT metadata URI with the token ID.
+ *
+ * ERC-1155 requires the ID to be substituted as lowercase hex, without a `0x`
+ * prefix and zero-padded to 64 characters.
+ *
+ * @see https://eips.ethereum.org/EIPS/eip-1155#metadata
+ */
+export function getNftMetadataUri({
+  nft,
+  uri,
+}: {
+  nft: ParsedNft
+  uri: string
+}) {
+  const tokenId =
+    nft.namespace === 'erc1155'
+      ? numberToHex(BigInt(nft.tokenID), { size: 32 }).slice(2)
+      : nft.tokenID
+  return uri.replace(/(?:0x)?{id}/, tokenId)
+}

package/utils/typedData.ts

@@ -148,7 +148,7 @@ export function getTypesForEIP712Domain({
 }): TypedDataParameter[] {
   return [
     typeof domain?.name === 'string' && { name: 'name', type: 'string' },
-    domain?.version && { name: 'version', type: 'string' },
+    typeof domain?.version === 'string' && { name: 'version', type: 'string' },
     (typeof domain?.chainId === 'number' ||
       typeof domain?.chainId === 'bigint') && {
       name: 'chainId',