viem 2.0.0-beta.0 → 2.0.0-beta.10

package/utils/buildRequest.ts

@@ -51,35 +51,14 @@ import {
   type UserRejectedRequestErrorType,
 } from '../errors/rpc.js'
 import type { ErrorType } from '../errors/utils.js'
+import type {
+  EIP1193RequestFn,
+  EIP1193RequestOptions,
+} from '../types/eip1193.js'
 import type { CreateBatchSchedulerErrorType } from './promise/createBatchScheduler.js'
 import { type WithRetryErrorType, withRetry } from './promise/withRetry.js'
 import type { GetSocketErrorType } from './rpc.js'
 
-export type IsDeterministicErrorType = ErrorType
-
-export const isDeterministicError = (error: Error) => {
-  if ('code' in error)
-    return (
-      error.code !== -1 &&
-      error.code !== -32004 &&
-      error.code !== -32005 &&
-      error.code !== -32042 &&
-      error.code !== -32603
-    )
-  if (error instanceof HttpRequestError && error.status)
-    return (
-      error.status !== 403 &&
-      error.status !== 408 &&
-      error.status !== 413 &&
-      error.status !== 429 &&
-      error.status !== 500 &&
-      error.status !== 502 &&
-      error.status !== 503 &&
-      error.status !== 504
-    )
-  return false
-}
-
 export type RequestErrorType =
   | ChainDisconnectedErrorType
   | CreateBatchSchedulerErrorType
@@ -110,20 +89,16 @@ export type RequestErrorType =
   | WithRetryErrorType
   | ErrorType
 
-export function buildRequest<TRequest extends (args: any) => Promise<any>>(
-  request: TRequest,
-  {
-    retryDelay = 150,
-    retryCount = 3,
-  }: {
-    // The base delay (in ms) between retries.
-    retryDelay?: number
-    // The max number of times to retry.
-    retryCount?: number
-  } = {},
-) {
-  return (async (args: any) =>
-    withRetry(
+export function buildRequest<request extends (args: any) => Promise<any>>(
+  request: request,
+  options: EIP1193RequestOptions = {},
+): EIP1193RequestFn {
+  return async (args, overrideOptions = {}) => {
+    const { retryDelay = 150, retryCount = 3 } = {
+      ...options,
+      ...overrideOptions,
+    }
+    return withRetry(
       async () => {
         try {
           return await request(args)
@@ -208,7 +183,37 @@ export function buildRequest<TRequest extends (args: any) => Promise<any>>(
           return ~~(1 << count) * retryDelay
         },
         retryCount,
-        shouldRetry: ({ error }) => !isDeterministicError(error),
+        shouldRetry: ({ error }) => shouldRetry(error),
       },
-    )) as TRequest
+    )
+  }
+}
+
+export function shouldRetry(error: Error) {
+  if ('code' in error && typeof error.code === 'number') {
+    if (error.code === -1) return true // Unknown error
+    if (error.code === LimitExceededRpcError.code) return true
+    if (error.code === InternalRpcError.code) return true
+    return false
+  }
+  if (error instanceof HttpRequestError && error.status) {
+    // Forbidden
+    if (error.status === 403) return true
+    // Request Timeout
+    if (error.status === 408) return true
+    // Request Entity Too Large
+    if (error.status === 413) return true
+    // Too Many Requests
+    if (error.status === 429) return true
+    // Internal Server Error
+    if (error.status === 500) return true
+    // Bad Gateway
+    if (error.status === 502) return true
+    // Service Unavailable
+    if (error.status === 503) return true
+    // Gateway Timeout
+    if (error.status === 504) return true
+    return false
+  }
+  return true
 }

package/utils/ccip.ts

@@ -112,8 +112,7 @@ export async function ccipFetch({
 
   for (let i = 0; i < urls.length; i++) {
     const url = urls[i]
-    const method =
-      url.includes('{sender}') || url.includes('{data}') ? 'GET' : 'POST'
+    const method = url.includes('{data}') ? 'GET' : 'POST'
     const body = method === 'POST' ? { data, sender } : undefined
 
     try {
@@ -137,7 +136,9 @@ export async function ccipFetch({
       if (!response.ok) {
         error = new HttpRequestError({
           body,
-          details: stringify(result.error) || response.statusText,
+          details: result?.error
+            ? stringify(result.error)
+            : response.statusText,
           headers: response.headers,
           status: response.status,
           url,

package/utils/encoding/fromBytes.ts

@@ -27,14 +27,14 @@ export type FromBytesParameters<
 export type FromBytesReturnType<TTo> = TTo extends 'string'
   ? string
   : TTo extends 'hex'
-  ? Hex
-  : TTo extends 'bigint'
-  ? bigint
-  : TTo extends 'number'
-  ? number
-  : TTo extends 'boolean'
-  ? boolean
-  : never
+    ? Hex
+    : TTo extends 'bigint'
+      ? bigint
+      : TTo extends 'number'
+        ? number
+        : TTo extends 'boolean'
+          ? boolean
+          : never
 
 export type FromBytesErrorType =
   | BytesToHexErrorType

package/utils/encoding/fromHex.ts

@@ -41,14 +41,14 @@ export type FromHexParameters<
 export type FromHexReturnType<TTo> = TTo extends 'string'
   ? string
   : TTo extends 'bigint'
-  ? bigint
-  : TTo extends 'number'
-  ? number
-  : TTo extends 'bytes'
-  ? ByteArray
-  : TTo extends 'boolean'
-  ? boolean
-  : never
+    ? bigint
+    : TTo extends 'number'
+      ? number
+      : TTo extends 'bytes'
+        ? ByteArray
+        : TTo extends 'boolean'
+          ? boolean
+          : never
 
 export type FromHexErrorType =
   | HexToNumberErrorType

package/utils/encoding/toBytes.ts

@@ -114,9 +114,9 @@ const charCodeMap = {
 function charCodeToBase16(char: number) {
   if (char >= charCodeMap.zero && char <= charCodeMap.nine)
     return char - charCodeMap.zero
-  else if (char >= charCodeMap.A && char <= charCodeMap.F)
+  if (char >= charCodeMap.A && char <= charCodeMap.F)
     return char - (charCodeMap.A - 10)
-  else if (char >= charCodeMap.a && char <= charCodeMap.f)
+  if (char >= charCodeMap.a && char <= charCodeMap.f)
     return char - (charCodeMap.a - 10)
   return undefined
 }

package/utils/encoding/toRlp.ts

@@ -88,7 +88,9 @@ function getEncodableList(list: Encodable[]): Encodable {
         else if (sizeOfBodyLength === 3) cursor.pushUint24(bodyLength)
         else cursor.pushUint32(bodyLength)
       }
-      list.forEach((x) => x.encode(cursor))
+      for (const { encode } of list) {
+        encode(cursor)
+      }
     },
   }
 }

package/utils/ens/avatar/utils.ts

@@ -117,7 +117,9 @@ export function resolveAvatarUri({
       isOnChain: false,
       isEncoded: false,
     }
-  } else if (protocol === 'ar:/' && target) {
+  }
+
+  if (protocol === 'ar:/' && target) {
     return {
       uri: `${arweaveGateway}/${target}${subtarget || ''}`,
       isOnChain: false,

package/utils/ens/namehash.ts

@@ -28,7 +28,7 @@ export type NamehashErrorType =
  * - Since ENS names prohibit certain forbidden characters (e.g. underscore) and have other validation rules, you likely want to [normalize ENS names](https://docs.ens.domains/contract-api-reference/name-processing#normalising-names) with [UTS-46 normalization](https://unicode.org/reports/tr46) before passing them to `namehash`. You can use the built-in [`normalize`](https://viem.sh/docs/ens/utilities/normalize.html) function for this.
  *
  * @example
- * namehash('wagmi-dev.eth')
+ * namehash('wevm.eth')
  * '0xf246651c1b9a6b141d19c2604e9a58f567973833990f830d882534a747801359'
  *
  * @link https://eips.ethereum.org/EIPS/eip-137

package/utils/ens/normalize.ts

@@ -7,8 +7,8 @@ export type NormalizeErrorType = ErrorType
  * @description Normalizes ENS name according to ENSIP-15.
  *
  * @example
- * normalize('wagmi-dev.eth')
- * 'wagmi-dev.eth'
+ * normalize('wevm.eth')
+ * 'wevm.eth'
  *
  * @see https://docs.ens.domains/contract-api-reference/name-processing#normalising-names
  * @see https://github.com/ensdomains/docs/blob/9edf9443de4333a0ea7ec658a870672d5d180d53/ens-improvement-proposals/ensip-15-normalization-standard.md

package/utils/errors/getContractError.ts

@@ -48,8 +48,8 @@ export function getContractError<err extends ErrorType<string>>(
     err instanceof RawContractError
       ? err
       : err instanceof BaseError
-      ? err.walk((err) => 'data' in (err as Error)) || err.walk()
-      : {}
+        ? err.walk((err) => 'data' in (err as Error)) || err.walk()
+        : {}
   ) as RawContractError
 
   const cause = (() => {

package/utils/errors/getNodeError.ts

@@ -73,36 +73,37 @@ export function getNodeError(
       cause: err,
       message: executionRevertedError.details,
     }) as any
-  } else if (ExecutionRevertedError.nodeMessage.test(message))
+  }
+  if (ExecutionRevertedError.nodeMessage.test(message))
     return new ExecutionRevertedError({
       cause: err,
       message: err.details,
     }) as any
-  else if (FeeCapTooHighError.nodeMessage.test(message))
+  if (FeeCapTooHighError.nodeMessage.test(message))
     return new FeeCapTooHighError({
       cause: err,
       maxFeePerGas: args?.maxFeePerGas,
     }) as any
-  else if (FeeCapTooLowError.nodeMessage.test(message))
+  if (FeeCapTooLowError.nodeMessage.test(message))
     return new FeeCapTooLowError({
       cause: err,
       maxFeePerGas: args?.maxFeePerGas,
     }) as any
-  else if (NonceTooHighError.nodeMessage.test(message))
+  if (NonceTooHighError.nodeMessage.test(message))
     return new NonceTooHighError({ cause: err, nonce: args?.nonce }) as any
-  else if (NonceTooLowError.nodeMessage.test(message))
+  if (NonceTooLowError.nodeMessage.test(message))
     return new NonceTooLowError({ cause: err, nonce: args?.nonce }) as any
-  else if (NonceMaxValueError.nodeMessage.test(message))
+  if (NonceMaxValueError.nodeMessage.test(message))
     return new NonceMaxValueError({ cause: err, nonce: args?.nonce }) as any
-  else if (InsufficientFundsError.nodeMessage.test(message))
+  if (InsufficientFundsError.nodeMessage.test(message))
     return new InsufficientFundsError({ cause: err }) as any
-  else if (IntrinsicGasTooHighError.nodeMessage.test(message))
+  if (IntrinsicGasTooHighError.nodeMessage.test(message))
     return new IntrinsicGasTooHighError({ cause: err, gas: args?.gas }) as any
-  else if (IntrinsicGasTooLowError.nodeMessage.test(message))
+  if (IntrinsicGasTooLowError.nodeMessage.test(message))
     return new IntrinsicGasTooLowError({ cause: err, gas: args?.gas }) as any
-  else if (TransactionTypeNotSupportedError.nodeMessage.test(message))
+  if (TransactionTypeNotSupportedError.nodeMessage.test(message))
     return new TransactionTypeNotSupportedError({ cause: err }) as any
-  else if (TipAboveFeeCapError.nodeMessage.test(message))
+  if (TipAboveFeeCapError.nodeMessage.test(message))
     return new TipAboveFeeCapError({
       cause: err,
       maxFeePerGas: args?.maxFeePerGas,

package/utils/formatters/block.ts

@@ -15,9 +15,7 @@ import { type FormattedTransaction, formatTransaction } from './transaction.js'
 type BlockPendingDependencies = 'hash' | 'logsBloom' | 'nonce' | 'number'
 
 export type FormattedBlock<
-  TChain extends { formatters?: Chain['formatters'] } | undefined =
-    | { formatters?: Chain['formatters'] }
-    | undefined,
+  TChain extends Chain | undefined = undefined,
   TIncludeTransactions extends boolean = boolean,
   TBlockTag extends BlockTag = BlockTag,
   _FormatterReturnType = ExtractChainFormatterReturnType<
@@ -28,7 +26,7 @@ export type FormattedBlock<
   _ExcludedPendingDependencies extends string = BlockPendingDependencies &
     ExtractChainFormatterExclude<TChain, 'block'>,
   _Formatted = Omit<_FormatterReturnType, BlockPendingDependencies> & {
-    [K in _ExcludedPendingDependencies]: never
+    [_key in _ExcludedPendingDependencies]: never
   } & Pick<
       Block<bigint, TIncludeTransactions, TBlockTag>,
       BlockPendingDependencies

package/utils/formatters/formatter.ts

@@ -31,7 +31,7 @@ export function defineFormatter<TType extends string, TParameters, TReturnType>(
           ...formatted,
           ...overrides(args),
         } as Prettify<Assign<TReturnType, TOverrideReturnType>> & {
-          [K in TExclude[number]]: never
+          [_key in TExclude[number]]: never
         }
       },
       type,

package/utils/formatters/transaction.ts

@@ -17,9 +17,7 @@ type TransactionPendingDependencies =
   | 'transactionIndex'
 
 export type FormattedTransaction<
-  TChain extends { formatters?: Chain['formatters'] } | undefined =
-    | { formatters?: Chain['formatters'] }
-    | undefined,
+  TChain extends Chain | undefined = undefined,
   TBlockTag extends BlockTag = BlockTag,
   _FormatterReturnType = ExtractChainFormatterReturnType<
     TChain,
@@ -29,7 +27,7 @@ export type FormattedTransaction<
   _ExcludedPendingDependencies extends string = TransactionPendingDependencies &
     ExtractChainFormatterExclude<TChain, 'transaction'>,
 > = UnionLooseOmit<_FormatterReturnType, TransactionPendingDependencies> & {
-  [K in _ExcludedPendingDependencies]: never
+  [_K in _ExcludedPendingDependencies]: never
 } & Pick<
     Transaction<bigint, number, TBlockTag extends 'pending' ? true : false>,
     TransactionPendingDependencies
@@ -64,22 +62,39 @@ export function formatTransaction(transaction: Partial<RpcTransaction>) {
     transactionIndex: transaction.transactionIndex
       ? Number(transaction.transactionIndex)
       : null,
-    type: transaction.type ? transactionType[transaction.type] : undefined,
+    type: transaction.type
+      ? (transactionType as any)[transaction.type]
+      : undefined,
     typeHex: transaction.type ? transaction.type : undefined,
     value: transaction.value ? BigInt(transaction.value) : undefined,
     v: transaction.v ? BigInt(transaction.v) : undefined,
-  }
+  } as Transaction
+
+  transaction_.yParity = (() => {
+    // If `yParity` is provided, we will use it.
+    if (transaction.yParity) return Number(transaction.yParity)
+
+    // If no `yParity` provided, try derive from `v`.
+    if (typeof transaction_.v === 'bigint') {
+      if (transaction_.v === 0n || transaction_.v === 27n) return 0
+      if (transaction_.v === 1n || transaction_.v === 28n) return 1
+      if (transaction_.v >= 35n) return transaction_.v % 2n === 0n ? 1 : 0
+    }
+
+    return undefined
+  })()
 
   if (transaction_.type === 'legacy') {
     delete transaction_.accessList
     delete transaction_.maxFeePerGas
     delete transaction_.maxPriorityFeePerGas
+    delete transaction_.yParity
   }
   if (transaction_.type === 'eip2930') {
     delete transaction_.maxFeePerGas
     delete transaction_.maxPriorityFeePerGas
   }
-  return transaction_ as Transaction
+  return transaction_
 }
 
 export type DefineTransactionErrorType = DefineFormatterErrorType | ErrorType

package/utils/formatters/transactionReceipt.ts

@@ -12,7 +12,7 @@ import { formatLog } from './log.js'
 import { transactionType } from './transaction.js'
 
 export type FormattedTransactionReceipt<
-  TChain extends Chain | undefined = Chain | undefined,
+  TChain extends Chain | undefined = undefined,
 > = ExtractChainFormatterReturnType<
   TChain,
   'transactionReceipt',

package/utils/getAction.ts

@@ -1,13 +1,23 @@
 import type { Client } from '../clients/createClient.js'
 
+/**
+ * Retrieves and returns an action from the client (if exists), and falls
+ * back to the tree-shakable action.
+ *
+ * Useful for extracting overridden actions from a client (ie. if a consumer
+ * wants to override the `sendTransaction` implementation).
+ */
 export function getAction<params extends {}, returnType extends {}>(
   client: Client,
   action: (_: any, params: params) => returnType,
+  // Some minifiers drop `Function.prototype.name`, meaning that `action.name`
+  // will not work. For that case, the consumer needs to pass the name explicitly.
+  name: string,
 ) {
   return (params: params): returnType =>
     (
       client as Client & {
         [key: string]: (params: params) => returnType
       }
-    )[action.name]?.(params) ?? action(client, params)
+    )[action.name || name]?.(params) ?? action(client, params)
 }

package/utils/hash/getFunctionSignature.ts

@@ -1,29 +1,19 @@
-import type { AbiFunction } from 'abitype'
+import { type AbiFunction, formatAbiItem } from 'abitype'
 
 import type { ErrorType } from '../../errors/utils.js'
 import {
-  type FormatAbiItemErrorType,
-  formatAbiItem,
-} from '../abi/formatAbiItem.js'
-import {
-  type ExtractFunctionNameErrorType,
-  type ExtractFunctionParamsErrorType,
-  extractFunctionName,
-  extractFunctionParams,
-} from '../contract/extractFunctionParts.js'
+  type NormalizeSignatureErrorType,
+  normalizeSignature,
+} from './normalizeSignature.js'
 
 export type GetFunctionSignatureErrorType =
-  | ExtractFunctionNameErrorType
-  | ExtractFunctionParamsErrorType
-  | FormatAbiItemErrorType
+  | NormalizeSignatureErrorType
   | ErrorType
 
-export const getFunctionSignature = (fn: string | AbiFunction) => {
-  if (typeof fn === 'string') {
-    const name = extractFunctionName(fn)
-    const params = extractFunctionParams(fn) || []
-    return `${name}(${params.map(({ type }) => type).join(',')})`
-  }
-
-  return formatAbiItem(fn)
+export const getFunctionSignature = (fn_: string | AbiFunction) => {
+  const fn = (() => {
+    if (typeof fn_ === 'string') return fn_
+    return formatAbiItem(fn_)
+  })()
+  return normalizeSignature(fn)
 }

package/utils/hash/normalizeSignature.ts

@@ -0,0 +1,64 @@
+import { BaseError } from '../../errors/base.js'
+import type { ErrorType } from '../../errors/utils.js'
+
+export type NormalizeSignatureParameters = string
+export type NormalizeSignatureReturnType = string
+export type NormalizeSignatureErrorType = ErrorType
+
+export function normalizeSignature(
+  signature: NormalizeSignatureParameters,
+): NormalizeSignatureReturnType {
+  let active = true
+  let current = ''
+  let level = 0
+  let result = ''
+  let valid = false
+
+  for (let i = 0; i < signature.length; i++) {
+    const char = signature[i]
+
+    // If the character is a separator, we want to reactivate.
+    if (['(', ')', ','].includes(char)) active = true
+
+    // If the character is a "level" token, we want to increment/decrement.
+    if (char === '(') level++
+    if (char === ')') level--
+
+    // If we aren't active, we don't want to mutate the result.
+    if (!active) continue
+
+    // If level === 0, we are at the definition level.
+    if (level === 0) {
+      if (char === ' ' && ['event', 'function', ''].includes(result))
+        result = ''
+      else {
+        result += char
+
+        // If we are at the end of the definition, we must be finished.
+        if (char === ')') {
+          valid = true
+          break
+        }
+      }
+
+      continue
+    }
+
+    // Ignore spaces
+    if (char === ' ') {
+      // If the previous character is a separator, and the current section isn't empty, we want to deactivate.
+      if (signature[i - 1] !== ',' && current !== ',' && current !== ',(') {
+        current = ''
+        active = false
+      }
+      continue
+    }
+
+    result += char
+    current += char
+  }
+
+  if (!valid) throw new BaseError('Unable to normalize signature.')
+
+  return result
+}

package/utils/index.ts

@@ -1,7 +1,5 @@
 export {
-  type IsDeterministicErrorType,
   type RequestErrorType,
-  isDeterministicError,
   buildRequest,
 } from './buildRequest.js'
 
@@ -113,6 +111,12 @@ export {
   type EncodeFunctionResultParameters,
   encodeFunctionResult,
 } from './abi/encodeFunctionResult.js'
+export {
+  type ParseEventLogsErrorType,
+  type ParseEventLogsParameters,
+  type ParseEventLogsReturnType,
+  parseEventLogs,
+} from './abi/parseEventLogs.js'
 export {
   type GetAbiItemErrorType,
   type GetAbiItemParameters,
@@ -167,16 +171,6 @@ export {
   type IsAddressEqualErrorType,
   isAddressEqual,
 } from './address/isAddressEqual.js'
-export {
-  type ExtractFunctionNameErrorType,
-  type ExtractFunctionParamsErrorType,
-  type ExtractFunctionPartsErrorType,
-  type ExtractFunctionTypeErrorType,
-  extractFunctionName,
-  extractFunctionParams,
-  extractFunctionType,
-  extractFunctionParts,
-} from './contract/extractFunctionParts.js'
 export {
   type ConcatBytesErrorType,
   type ConcatErrorType,
@@ -291,7 +285,6 @@ export {
   type FromBytesParameters,
   type FromBytesReturnType,
   bytesToBigInt,
-  /** @deprecated – use `bytesToBigInt` */
   bytesToBigInt as bytesToBigint,
   bytesToBool,
   bytesToNumber,
@@ -431,10 +424,6 @@ export {
   type ParseTransactionErrorType,
   parseTransaction,
 } from './transaction/parseTransaction.js'
-export {
-  /** @deprecated import `prepareTransactionRequest` from `viem/actions` instead. */
-  prepareTransactionRequest,
-} from '../actions/wallet/prepareTransactionRequest.js'
 export {
   serializeTransaction,
   type SerializeTransactionErrorType,

package/utils/observe.ts

@@ -61,7 +61,7 @@ export function observe<TCallbacks extends Callbacks>(
     ) => {
       const listeners = getListeners()
       if (listeners.length === 0) return
-      listeners.forEach((listener) => listener.fns[key]?.(...args))
+      for (const listener of listeners) listener.fns[key]?.(...args)
     }) as TCallbacks[Extract<keyof TCallbacks, string>]
   }
 

package/utils/promise/createBatchScheduler.ts

@@ -66,12 +66,16 @@ export function createBatchScheduler<
     fn(args as TParameters[])
       .then((data) => {
         if (sort && Array.isArray(data)) data.sort(sort)
-        scheduler.forEach(({ pendingPromise }, i) =>
-          pendingPromise.resolve?.([data[i], data]),
-        )
+        for (let i = 0; i < scheduler.length; i++) {
+          const { pendingPromise } = scheduler[i]
+          pendingPromise.resolve?.([data[i], data])
+        }
       })
       .catch((err) => {
-        scheduler.forEach(({ pendingPromise }) => pendingPromise.reject?.(err))
+        for (let i = 0; i < scheduler.length; i++) {
+          const { pendingPromise } = scheduler[i]
+          pendingPromise.reject?.(err)
+        }
       })
   }
 

package/utils/signature/hashMessage.ts

@@ -1,3 +1,4 @@
+import { presignMessagePrefix } from '../../constants/strings.js'
 import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex, SignableMessage } from '../../types/misc.js'
 import { type ConcatErrorType, concat } from '../data/concat.js'
@@ -32,7 +33,7 @@ export function hashMessage<TTo extends To = 'hex'>(
     return toBytes(message.raw)
   })()
   const prefixBytes = stringToBytes(
-    `\x19Ethereum Signed Message:\n${messageBytes.length}`,
+    `${presignMessagePrefix}${messageBytes.length}`,
   )
   return keccak256(concat([prefixBytes, messageBytes]), to_)
 }

package/utils/transaction/getSerializedTransactionType.ts

@@ -16,8 +16,8 @@ export type GetSerializedTransactionType<
 > = TTransactionSerialized extends TransactionSerializedEIP1559
   ? 'eip1559'
   : TTransactionSerialized extends TransactionSerializedEIP2930
-  ? 'eip2930'
-  : 'legacy'
+    ? 'eip2930'
+    : 'legacy'
 
 export type GetSerializedTransactionTypeErrorType =
   | HexToNumberErrorType

package/utils/transaction/getTransactionType.ts

@@ -12,7 +12,8 @@ import type {
 } from '../../types/transaction.js'
 
 export type GetTransactionType<
-  TTransactionSerializable extends TransactionSerializable = TransactionSerializable,
+  TTransactionSerializable extends
+    TransactionSerializable = TransactionSerializable,
 > =
   | (TTransactionSerializable extends TransactionSerializableLegacy
       ? 'legacy'