viem 2.0.0-alpha.16 → 2.0.0-alpha.18

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/createClient.ts

@@ -1,8 +1,9 @@
 import type { Address } from 'abitype'
 
-import type { Account, JsonRpcAccount } from '../accounts/types.js'
+import type { JsonRpcAccount } from '../accounts/types.js'
 import type { ParseAccountErrorType } from '../accounts/utils/parseAccount.js'
 import type { ErrorType } from '../errors/utils.js'
+import type { Account } from '../types/account.js'
 import type { Chain } from '../types/chain.js'
 import type {
   EIP1193RequestFn,
@@ -12,6 +13,8 @@ import type {
 import type { Prettify } from '../types/utils.js'
 import { parseAccount } from '../utils/accounts.js'
 import { uid } from '../utils/uid.js'
+import type { PublicActions } from './decorators/public.js'
+import type { WalletActions } from './decorators/wallet.js'
 import type { Transport } from './transports/createTransport.js'
 
 export type ClientConfig<
@@ -53,6 +56,38 @@ export type ClientConfig<
   type?: string | undefined
 }
 
+// Actions that are used internally by other Actions (ie. `call` is used by `readContract`).
+// They are allowed to be extended, but must conform to their parameter & return type interfaces.
+// Example: an extended `call` action must accept `CallParameters` as parameters,
+// and conform to the `CallReturnType` return type.
+type ExtendableProtectedActions = Pick<
+  PublicActions,
+  | 'call'
+  | 'createContractEventFilter'
+  | 'createEventFilter'
+  | 'estimateContractGas'
+  | 'estimateGas'
+  | 'getBlock'
+  | 'getBlockNumber'
+  | 'getChainId'
+  | 'getContractEvents'
+  | 'getEnsText'
+  | 'getFilterChanges'
+  | 'getGasPrice'
+  | 'getLogs'
+  | 'getTransaction'
+  | 'getTransactionCount'
+  | 'getTransactionReceipt'
+  | 'prepareTransactionRequest'
+  | 'readContract'
+  | 'sendRawTransaction'
+  | 'simulateContract'
+  | 'uninstallFilter'
+  | 'watchBlockNumber'
+  | 'watchContractEvent'
+> &
+  Pick<WalletActions, 'sendTransaction' | 'writeContract'>
+
 // TODO: Move `transport` to slot index 2 since `chain` and `account` used more frequently.
 // Otherwise, we end up with a lot of `Client<Transport, chain, account>` in actions.
 export type Client<
@@ -63,7 +98,9 @@ export type Client<
   extended extends Extended | undefined = Extended | undefined,
 > = Client_Base<transport, chain, account, rpcSchema> &
   (extended extends Extended ? extended : unknown) & {
-    extend: <const client extends Extended>(
+    extend: <
+      const client extends Extended & Partial<ExtendableProtectedActions>,
+    >(
       fn: (
         client: Client<transport, chain, account, rpcSchema, extended>,
       ) => client,

package/clients/decorators/public.ts

@@ -872,7 +872,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>,
@@ -1128,7 +1128,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>
   /**
@@ -1337,7 +1339,9 @@ export type PublicActions<
    *   value: 1n,
    * })
    */
-  prepareTransactionRequest: <TChainOverride extends Chain | undefined,>(
+  prepareTransactionRequest: <
+    TChainOverride extends Chain | undefined = undefined,
+  >(
     args: PrepareTransactionRequestParameters<TChain, TAccount, TChainOverride>,
   ) => Promise<PrepareTransactionRequestReturnType>
   /**