viem 1.17.2 → 1.18.1

package/chains/utils/index.ts

@@ -1,3 +1,20 @@
+export {
+  type AssertCurrentChainErrorType,
+  type AssertCurrentChainParameters,
+  assertCurrentChain,
+} from '../../utils/chain/assertCurrentChain.js'
+export { defineChain } from '../../utils/chain/defineChain.js'
+export {
+  type ExtractChainErrorType,
+  type ExtractChainParameters,
+  type ExtractChainReturnType,
+  extractChain,
+} from '../../utils/chain/extractChain.js'
+export {
+  type GetChainContractAddressErrorType,
+  getChainContractAddress,
+} from '../../utils/chain/getChainContractAddress.js'
+
 export { formattersCelo } from '../celo/formatters.js'
 export {
   serializeTransactionCelo,
@@ -21,11 +38,17 @@ export type {
   CeloTransactionSerialized,
   CeloTransactionType,
   RpcTransactionCIP42,
+  RpcTransactionCIP64,
   RpcTransactionRequestCIP42,
+  RpcTransactionRequestCIP64,
   TransactionCIP42,
+  TransactionCIP64,
   TransactionRequestCIP42,
+  TransactionRequestCIP64,
   TransactionSerializableCIP42,
+  TransactionSerializableCIP64,
   TransactionSerializedCIP42,
+  TransactionSerializedCIP64,
 } from '../celo/types.js'
 
 export { formattersOptimism } from '../optimism/formatters.js'
@@ -43,3 +66,34 @@ export type {
   OptimismTransactionReceipt,
   OptimismTransactionReceiptOverrides,
 } from '../optimism/types.js'
+
+export { formattersZkSync } from '../zksync/formatters.js'
+export type {
+  ZkSyncBlock,
+  ZkSyncBlockOverrides,
+  ZkSyncEip712Meta,
+  ZkSyncFeeValues,
+  ZkSyncL2ToL1Log,
+  ZkSyncLog,
+  ZkSyncRpcBlock,
+  ZkSyncRpcBlockOverrides,
+  ZkSyncRpcL2ToL1Log,
+  ZkSyncRpcLog,
+  ZkSyncRpcTransaction,
+  ZkSyncRpcTransactionEIP712,
+  ZkSyncRpcTransactionPriority,
+  ZkSyncRpcTransactionReceiptOverrides,
+  ZkSyncRpcTransactionRequest,
+  ZkSyncRpcTransactionRequestEIP712,
+  ZkSyncTransaction,
+  ZkSyncTransactionEIP712,
+  ZkSyncTransactionReceipt,
+  ZkSyncTransactionReceiptOverrides,
+  ZkSyncTransactionRequest,
+  ZkSyncTransactionRequestEIP712,
+  ZkSyncTransactionSerializable,
+  ZkSyncTransactionSerializableEIP712,
+  ZkSyncTransactionSerialized,
+  ZkSyncTransactionSerializedEIP712,
+  ZkSyncTransactionType,
+} from '../zksync/types.js'

package/chains/zksync/formatters.ts

@@ -0,0 +1,142 @@
+import { type ChainFormatters } from '../../types/chain.js'
+import type { Hash } from '../../types/misc.js'
+import { hexToBigInt, hexToNumber } from '../../utils/encoding/fromHex.js'
+import { hexToBytes } from '../../utils/encoding/toBytes.js'
+import { toHex } from '../../utils/encoding/toHex.js'
+import { defineBlock } from '../../utils/formatters/block.js'
+import { formatLog } from '../../utils/formatters/log.js'
+import { defineTransaction } from '../../utils/formatters/transaction.js'
+import { defineTransactionReceipt } from '../../utils/formatters/transactionReceipt.js'
+import { defineTransactionRequest } from '../../utils/formatters/transactionRequest.js'
+import type {
+  ZkSyncBlockOverrides,
+  ZkSyncL2ToL1Log,
+  ZkSyncLog,
+  ZkSyncRpcBlockOverrides,
+  ZkSyncRpcTransaction,
+  ZkSyncRpcTransactionReceiptOverrides,
+  ZkSyncRpcTransactionRequest,
+  ZkSyncTransaction,
+  ZkSyncTransactionReceipt,
+  ZkSyncTransactionRequest,
+} from './types.js'
+
+export const formattersZkSync = {
+  block: /*#__PURE__*/ defineBlock({
+    format(
+      args: ZkSyncRpcBlockOverrides & {
+        transactions: Hash[] | ZkSyncRpcTransaction[]
+      },
+    ): ZkSyncBlockOverrides & {
+      transactions: Hash[] | ZkSyncTransaction[]
+    } {
+      const transactions = args.transactions?.map((transaction) => {
+        if (typeof transaction === 'string') return transaction
+        const formatted = formattersZkSync.transaction.format(
+          transaction as ZkSyncRpcTransaction,
+        ) as ZkSyncTransaction
+        if (formatted.typeHex === '0x71') formatted.type = 'eip712'
+        else if (formatted.typeHex === '0xff') formatted.type = 'priority'
+        return formatted
+      }) as Hash[] | ZkSyncTransaction[]
+      return {
+        l1BatchNumber: hexToBigInt(args.l1BatchNumber),
+        l1BatchTimestamp: hexToBigInt(args.l1BatchTimestamp),
+        transactions,
+      }
+    },
+  }),
+  transaction: /*#__PURE__*/ defineTransaction({
+    format(args: ZkSyncRpcTransaction): ZkSyncTransaction {
+      const transaction = {} as ZkSyncTransaction
+      if (args.type === '0x71') transaction.type = 'eip712'
+      else if (args.type === '0xff') transaction.type = 'priority'
+      return {
+        ...transaction,
+        l1BatchNumber: args.l1BatchNumber
+          ? hexToBigInt(args.l1BatchNumber)
+          : null,
+        l1BatchTxIndex: args.l1BatchTxIndex
+          ? hexToBigInt(args.l1BatchTxIndex)
+          : null,
+      } as ZkSyncTransaction
+    },
+  }),
+  transactionReceipt: /*#__PURE__*/ defineTransactionReceipt({
+    format(
+      args: ZkSyncRpcTransactionReceiptOverrides,
+    ): ZkSyncTransactionReceipt {
+      return {
+        l1BatchNumber: args.l1BatchNumber
+          ? hexToBigInt(args.l1BatchNumber)
+          : null,
+        l1BatchTxIndex: args.l1BatchTxIndex
+          ? hexToBigInt(args.l1BatchTxIndex)
+          : null,
+        logs: args.logs.map((log) => {
+          return {
+            ...formatLog(log),
+            l1BatchNumber: log.l1BatchNumber
+              ? hexToBigInt(log.l1BatchNumber)
+              : null,
+            transactionLogIndex: hexToNumber(log.transactionLogIndex),
+            logType: log.logType,
+          }
+        }) as ZkSyncLog[],
+        l2ToL1Logs: args.l2ToL1Logs.map((l2ToL1Log) => {
+          return {
+            blockNumber: hexToBigInt(l2ToL1Log.blockHash),
+            blockHash: l2ToL1Log.blockHash,
+            l1BatchNumber: hexToBigInt(l2ToL1Log.l1BatchNumber),
+            transactionIndex: hexToBigInt(l2ToL1Log.transactionIndex),
+            shardId: hexToBigInt(l2ToL1Log.shardId),
+            isService: l2ToL1Log.isService,
+            sender: l2ToL1Log.sender,
+            key: l2ToL1Log.key,
+            value: l2ToL1Log.value,
+            transactionHash: l2ToL1Log.transactionHash,
+            logIndex: hexToBigInt(l2ToL1Log.logIndex),
+          }
+        }) as ZkSyncL2ToL1Log[],
+      } as ZkSyncTransactionReceipt
+    },
+  }),
+  transactionRequest: /*#__PURE__*/ defineTransactionRequest({
+    exclude: [
+      'customSignature',
+      'factoryDeps',
+      'gasPerPubdata',
+      'paymaster',
+      'paymasterInput',
+    ],
+    format(args: ZkSyncTransactionRequest): ZkSyncRpcTransactionRequest {
+      if (
+        args.gasPerPubdata ||
+        (args.paymaster && args.paymasterInput) ||
+        args.factoryDeps ||
+        args.customSignature
+      )
+        return {
+          eip712Meta: {
+            ...(args.gasPerPubdata
+              ? { gasPerPubdata: toHex(args.gasPerPubdata) }
+              : {}),
+            ...(args.paymaster && args.paymasterInput
+              ? {
+                  paymasterParams: {
+                    paymaster: args.paymaster,
+                    paymasterInput: Array.from(hexToBytes(args.paymasterInput)),
+                  },
+                }
+              : {}),
+            ...(args.factoryDeps ? { factoryDeps: args.factoryDeps } : {}),
+            ...(args.customSignature
+              ? { customSignature: args.customSignature }
+              : {}),
+          },
+          type: args.type === 'eip712' ? '0x71' : '0xff',
+        } as ZkSyncRpcTransactionRequest
+      return {} as ZkSyncRpcTransactionRequest
+    },
+  }),
+} as const satisfies ChainFormatters

package/chains/zksync/serializers.ts

@@ -0,0 +1,124 @@
+import { InvalidAddressError } from '../../errors/address.js'
+import { BaseError } from '../../errors/base.js'
+import { InvalidChainIdError } from '../../errors/chain.js'
+import type { ChainSerializers } from '../../types/chain.js'
+import type { TransactionSerializable } from '../../types/transaction.js'
+import { isAddress } from '../../utils/address/isAddress.js'
+import { concatHex } from '../../utils/data/concat.js'
+import { toHex } from '../../utils/encoding/toHex.js'
+import { toRlp } from '../../utils/encoding/toRlp.js'
+import {
+  type SerializeTransactionFn,
+  serializeTransaction,
+} from '../../utils/transaction/serializeTransaction.js'
+import type {
+  ZkSyncTransactionSerializable,
+  ZkSyncTransactionSerializableEIP712,
+  ZkSyncTransactionSerializedEIP712,
+} from './types.js'
+
+export const serializeTransactionZkSync: SerializeTransactionFn<
+  ZkSyncTransactionSerializable
+> = (tx, signature) => {
+  if (isEIP712(tx))
+    return serializeTransactionZkSyncEIP712(
+      tx as ZkSyncTransactionSerializableEIP712,
+    )
+  return serializeTransaction(tx as TransactionSerializable, signature)
+}
+
+export const serializersZkSync = {
+  transaction: serializeTransactionZkSync,
+} as const satisfies ChainSerializers
+
+//////////////////////////////////////////////////////////////////////////////
+// Serializers
+
+export type SerializeTransactionEIP712ReturnType =
+  ZkSyncTransactionSerializedEIP712
+
+function serializeTransactionZkSyncEIP712(
+  transaction: ZkSyncTransactionSerializableEIP712,
+): SerializeTransactionEIP712ReturnType {
+  const {
+    chainId,
+    gas,
+    nonce,
+    to,
+    from,
+    value,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    customSignature,
+    factoryDeps,
+    paymaster,
+    paymasterInput,
+    gasPerPubdata,
+    data,
+  } = transaction
+
+  assertTransactionEIP712(transaction)
+
+  const serializedTransaction = [
+    nonce ? toHex(nonce) : '0x',
+    maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : '0x',
+    maxFeePerGas ? toHex(maxFeePerGas) : '0x',
+    gas ? toHex(gas) : '0x',
+    to ?? '0x',
+    value ? toHex(value) : '0x',
+    data ?? '0x',
+    toHex(chainId),
+    toHex(''),
+    toHex(''),
+    toHex(chainId),
+    from ?? '0x',
+    gasPerPubdata ? toHex(gasPerPubdata) : '0x',
+    factoryDeps ?? [],
+    customSignature ?? '0x', // EIP712 signature
+    paymaster && paymasterInput ? [paymaster, paymasterInput] : [],
+  ]
+
+  return concatHex([
+    '0x71',
+    toRlp(serializedTransaction),
+  ]) as SerializeTransactionEIP712ReturnType
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Utilities
+
+function isEIP712(transaction: ZkSyncTransactionSerializable) {
+  if (
+    'customSignature' in transaction ||
+    'paymaster' in transaction ||
+    'paymasterInput' in transaction ||
+    'gasPerPubdata' in transaction ||
+    'factoryDeps' in transaction
+  )
+    return true
+  return false
+}
+
+export function assertTransactionEIP712(
+  transaction: ZkSyncTransactionSerializableEIP712,
+) {
+  const { chainId, to, from, paymaster, paymasterInput } = transaction
+  if (chainId <= 0) throw new InvalidChainIdError({ chainId })
+
+  if (to && !isAddress(to)) throw new InvalidAddressError({ address: to })
+  if (from && !isAddress(from)) throw new InvalidAddressError({ address: from })
+  if (paymaster && !isAddress(paymaster))
+    throw new InvalidAddressError({ address: paymaster })
+
+  if (paymaster && !paymasterInput) {
+    throw new BaseError(
+      '`paymasterInput` must be provided when `paymaster` is defined',
+    )
+  }
+
+  if (!paymaster && paymasterInput) {
+    throw new BaseError(
+      '`paymaster` must be provided when `paymasterInput` is defined',
+    )
+  }
+}

package/chains/zksync/types.ts

@@ -0,0 +1,317 @@
+import type { Abi, AbiEvent, Address } from 'abitype'
+import type { Block, BlockTag } from '../../types/block.js'
+import type { FeeValuesEIP1559 } from '../../types/fee.js'
+import type { Log as Log_ } from '../../types/log.js'
+import type { Hex } from '../../types/misc.js'
+import type {
+  Index,
+  Quantity,
+  RpcBlock,
+  RpcLog as RpcLog_,
+  RpcTransactionRequest as RpcTransactionRequest_,
+} from '../../types/rpc.js'
+import type {
+  Transaction as Transaction_,
+  TransactionBase,
+  TransactionEIP1559 as TransactionEIP1559_,
+  TransactionEIP2930 as TransactionEIP2930_,
+  TransactionLegacy as TransactionLegacy_,
+  TransactionReceipt,
+  TransactionRequest as TransactionRequest_,
+  TransactionRequestBase,
+  TransactionSerializable,
+  TransactionSerializableEIP1559,
+  TransactionSerialized,
+  TransactionType,
+} from '../../types/transaction.js'
+import type { UnionOmit } from '../../types/utils.js'
+
+type EIP712Type = '0x71'
+type PriorityType = '0xff'
+
+// Types
+// https://era.zksync.io/docs/api/js/types.html
+
+export type ZkSyncLog<
+  TQuantity = bigint,
+  TIndex = number,
+  TPending extends boolean = boolean,
+  TAbiEvent extends AbiEvent | undefined = undefined,
+  TStrict extends boolean | undefined = undefined,
+  TAbi extends Abi | readonly unknown[] | undefined = TAbiEvent extends AbiEvent
+    ? [TAbiEvent]
+    : undefined,
+  TEventName extends string | undefined = TAbiEvent extends AbiEvent
+    ? TAbiEvent['name']
+    : undefined,
+> = Log_<TQuantity, TIndex, TPending, TAbiEvent, TStrict, TAbi, TEventName> & {
+  l1BatchNumber: TQuantity
+  transactionLogIndex: TIndex
+  logType: Hex | null
+}
+
+export type ZkSyncRpcLog = RpcLog_ & {
+  l1BatchNumber: Hex | null
+  // These are returned but doesn't apear in Log structure neither is mentioned in https://era.zksync.io/docs/api/js/types.html
+  transactionLogIndex: Hex
+  logType: Hex | null
+}
+
+type PaymasterParams = {
+  paymaster: Address
+  paymasterInput: number[]
+}
+
+export type ZkSyncEip712Meta = {
+  gasPerPubdata?: Hex
+  factoryDeps?: Hex[]
+  customSignature?: Hex
+  paymasterParams?: PaymasterParams
+}
+
+export type ZkSyncL2ToL1Log = {
+  blockNumber: bigint
+  blockHash: string
+  l1BatchNumber: bigint
+  transactionIndex: bigint
+  shardId: bigint
+  isService: boolean
+  sender: string
+  key: string
+  value: string
+  transactionHash: string
+  logIndex: bigint
+}
+
+export type ZkSyncRpcL2ToL1Log = {
+  blockNumber: Hex
+  blockHash: Hex
+  l1BatchNumber: Hex
+  transactionIndex: Hex
+  shardId: Hex
+  isService: boolean
+  sender: Hex
+  key: Hex
+  value: Hex
+  transactionHash: Hex
+  logIndex: Hex
+}
+
+export type ZkSyncFeeValues<TQuantity = bigint> = {
+  gasPrice: TQuantity
+  maxFeePerGas: TQuantity
+  maxPriorityFeePerGas: TQuantity
+}
+
+// Block
+// https://era.zksync.io/docs/api/js/types.html#block
+
+export type ZkSyncBlockOverrides = {
+  l1BatchNumber: bigint | null
+  l1BatchTimestamp: bigint | null
+}
+
+export type ZkSyncBlock<
+  TIncludeTransactions extends boolean = boolean,
+  TBlockTag extends BlockTag = BlockTag,
+> = Block<
+  bigint,
+  TIncludeTransactions,
+  TBlockTag,
+  ZkSyncTransaction<TBlockTag extends 'pending' ? true : false>
+> &
+  ZkSyncBlockOverrides
+
+// Block (RPC)
+
+export type ZkSyncRpcBlockOverrides = {
+  l1BatchNumber: Hex
+  l1BatchTimestamp: Hex
+}
+export type ZkSyncRpcBlock<
+  TBlockTag extends BlockTag = BlockTag,
+  TIncludeTransactions extends boolean = boolean,
+> = RpcBlock<
+  TBlockTag,
+  TIncludeTransactions,
+  ZkSyncRpcTransaction<TBlockTag extends 'pending' ? true : false>
+> &
+  ZkSyncRpcBlockOverrides
+
+// Transaction
+// https://era.zksync.io/docs/api/js/types.html#transactionresponse
+
+type TransactionOverrides = {
+  l1BatchNumber: bigint | null
+  l1BatchTxIndex: bigint | null
+}
+
+type TransactionPriority<TPending extends boolean = boolean> = TransactionBase<
+  bigint,
+  number,
+  TPending
+> &
+  TransactionOverrides &
+  FeeValuesEIP1559 & {
+    type: 'priority'
+  }
+
+export type ZkSyncTransactionEIP712<TPending extends boolean = boolean> =
+  TransactionBase<bigint, number, TPending> &
+    TransactionOverrides &
+    FeeValuesEIP1559 & {
+      type: 'eip712' | 'priority'
+    }
+
+type Transaction<TPending extends boolean = boolean> = Transaction_<
+  bigint,
+  number,
+  TPending
+> &
+  TransactionOverrides
+
+export type ZkSyncTransaction<TPending extends boolean = boolean> =
+  | Transaction<TPending>
+  | TransactionPriority<TPending>
+  | ZkSyncTransactionEIP712<TPending>
+
+// Transaction (RPC)
+
+type RpcTransactionOverrides = {
+  l1BatchNumber: Hex
+  l1BatchTxIndex: Hex
+}
+
+type RpcTransactionLegacy<TPending extends boolean = boolean> =
+  TransactionLegacy_<Hex, Hex, TPending, '0x0'> & RpcTransactionOverrides
+
+type RpcTransactionEIP2930<TPending extends boolean = boolean> =
+  TransactionEIP2930_<Hex, Hex, TPending, '0x1'> & RpcTransactionOverrides
+
+type RpcTransactionEIP1559<TPending extends boolean = boolean> =
+  TransactionEIP1559_<Hex, Hex, TPending, '0x2'> & RpcTransactionOverrides
+
+export type ZkSyncRpcTransactionPriority<TPending extends boolean = boolean> =
+  TransactionBase<Quantity, Index, TPending> &
+    ZkSyncFeeValues<Quantity> &
+    RpcTransactionOverrides & {
+      accessList?: undefined
+      chainId: Hex
+      type: PriorityType
+    }
+
+export type ZkSyncRpcTransactionEIP712<TPending extends boolean = boolean> =
+  TransactionBase<Quantity, Index, TPending> &
+    ZkSyncFeeValues<Quantity> &
+    RpcTransactionOverrides & {
+      accessList?: undefined
+      chainId: Hex
+      type: EIP712Type
+    }
+
+export type ZkSyncRpcTransaction<TPending extends boolean = boolean> =
+  UnionOmit<
+    | RpcTransactionLegacy<TPending>
+    | RpcTransactionEIP2930<TPending>
+    | RpcTransactionEIP1559<TPending>
+    | ZkSyncRpcTransactionPriority<TPending>
+    | ZkSyncRpcTransactionEIP712<TPending>,
+    'typeHex'
+  >
+
+// Transaction Request
+// https://era.zksync.io/docs/reference/concepts/transactions.html
+
+type TransactionRequest = TransactionRequest_ & {
+  gasPerPubdata?: undefined
+  customSignature?: undefined
+  paymaster?: undefined
+  paymasterInput?: undefined
+  factoryDeps?: undefined
+}
+
+export type ZkSyncTransactionRequestEIP712 = Omit<
+  TransactionRequestBase,
+  'type'
+> &
+  Partial<FeeValuesEIP1559> & {
+    gasPerPubdata?: bigint
+    customSignature?: Hex
+    factoryDeps?: Hex[]
+    type?: 'eip712' | 'priority'
+  } & (
+    | { paymaster: Address; paymasterInput: Hex }
+    | { paymaster?: undefined; paymasterInput?: undefined }
+  )
+
+export type ZkSyncTransactionRequest =
+  | TransactionRequest
+  | ZkSyncTransactionRequestEIP712
+
+type RpcTransactionRequest = RpcTransactionRequest_ & { eip712Meta?: undefined }
+
+export type ZkSyncRpcTransactionRequestEIP712 = TransactionRequestBase<
+  Quantity,
+  Index
+> &
+  Partial<FeeValuesEIP1559<Quantity>> & {
+    eip712Meta: ZkSyncEip712Meta
+    type: EIP712Type | PriorityType
+  }
+
+export type ZkSyncRpcTransactionRequest =
+  | RpcTransactionRequest
+  | ZkSyncRpcTransactionRequestEIP712
+
+export type ZkSyncTransactionType = TransactionType | 'eip712' | 'priority'
+
+// Transaction Receipt
+// https://era.zksync.io/docs/api/js/types.html#transactionreceipt
+
+export type ZkSyncRpcTransactionReceiptOverrides = {
+  l1BatchNumber: Hex
+  l1BatchTxIndex: Hex
+  logs: ZkSyncRpcLog[]
+  l2ToL1Logs: ZkSyncRpcL2ToL1Log[]
+  root: Hex
+}
+
+export type ZkSyncTransactionReceiptOverrides = {
+  l1BatchNumber: bigint | null
+  l1BatchTxIndex: bigint | null
+  logs: ZkSyncLog[]
+  l2ToL1Logs: ZkSyncL2ToL1Log[]
+}
+
+export type ZkSyncTransactionReceipt<
+  TStatus = 'success' | 'reverted',
+  TType = ZkSyncTransactionType,
+> = Omit<TransactionReceipt<bigint, number, TStatus, TType>, 'logs'> &
+  ZkSyncTransactionReceiptOverrides
+
+// Serializers
+
+export type ZkSyncTransactionSerializable =
+  | TransactionSerializable
+  | ZkSyncTransactionSerializableEIP712
+
+export type ZkSyncTransactionSerialized<
+  TType extends TransactionType = 'eip712',
+> = TType extends 'eip712'
+  ? ZkSyncTransactionSerializedEIP712
+  : TransactionSerialized<TType>
+
+export type ZkSyncTransactionSerializedEIP712 = `0x71${string}`
+
+export type ZkSyncTransactionSerializableEIP712<
+  TQuantity = bigint,
+  TIndex = number,
+> = Omit<TransactionSerializableEIP1559<TQuantity, TIndex>, 'type'> & {
+  from: Hex
+  gasPerPubdata?: bigint
+  paymaster?: Address
+  factoryDeps?: Hex[]
+  paymasterInput?: Hex
+  customSignature?: Hex
+  type?: 'eip712'
+}

package/clients/decorators/public.ts

@@ -859,7 +859,7 @@ export type PublicActions<
    * // { maxFeePerGas: ..., maxPriorityFeePerGas: ... }
    */
   estimateFeesPerGas: <
-    TChainOverride extends Chain | undefined,
+    TChainOverride extends Chain | undefined = undefined,
     TType extends FeeValuesType = 'eip1559',
   >(
     args?: EstimateFeesPerGasParameters<TChain, TChainOverride, TType>,
@@ -1115,7 +1115,9 @@ export type PublicActions<
    * const maxPriorityFeePerGas = await client.estimateMaxPriorityFeePerGas()
    * // 10000000n
    */
-  estimateMaxPriorityFeePerGas: <TChainOverride extends Chain | undefined,>(
+  estimateMaxPriorityFeePerGas: <
+    TChainOverride extends Chain | undefined = undefined,
+  >(
     args?: EstimateMaxPriorityFeePerGasParameters<TChain, TChainOverride>,
   ) => Promise<EstimateMaxPriorityFeePerGasReturnType>
   /**
@@ -1324,7 +1326,9 @@ export type PublicActions<
    *   value: 1n,
    * })
    */
-  prepareTransactionRequest: <TChainOverride extends Chain | undefined,>(
+  prepareTransactionRequest: <
+    TChainOverride extends Chain | undefined = undefined,
+  >(
     args: PrepareTransactionRequestParameters<TChain, TAccount, TChainOverride>,
   ) => Promise<PrepareTransactionRequestReturnType>
   /**
@@ -1424,7 +1428,7 @@ export type PublicActions<
   simulateContract: <
     const TAbi extends Abi | readonly unknown[],
     TFunctionName extends string,
-    TChainOverride extends Chain | undefined,
+    TChainOverride extends Chain | undefined = undefined,
   >(
     args: SimulateContractParameters<
       TAbi,