viem 2.4.1 → 2.6.0

package/chains/zksync/types/block.ts

@@ -0,0 +1,34 @@
+import type { Block, BlockTag } from '../../../types/block.js'
+import type { Hex } from '../../../types/misc.js'
+import type { RpcBlock } from '../../../types/rpc.js'
+import type { ZkSyncRpcTransaction, ZkSyncTransaction } from './transaction.js'
+
+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
+
+export type ZkSyncRpcBlockOverrides = {
+  l1BatchNumber: Hex | null
+  l1BatchTimestamp: Hex | null
+}
+export type ZkSyncRpcBlock<
+  TBlockTag extends BlockTag = BlockTag,
+  TIncludeTransactions extends boolean = boolean,
+> = RpcBlock<
+  TBlockTag,
+  TIncludeTransactions,
+  ZkSyncRpcTransaction<TBlockTag extends 'pending' ? true : false>
+> &
+  ZkSyncRpcBlockOverrides

package/chains/zksync/types/chain.ts

@@ -0,0 +1,28 @@
+import type { ChainFormatters } from '../../../types/chain.js'
+import type { Chain, ChainFormatter } from '../../../types/chain.js'
+import type {
+  TransactionSerializable,
+  TransactionSerializableGeneric,
+} from '../../../types/transaction.js'
+import type { EIP712DomainFn } from './eip712.js'
+
+export type ChainEIP712<
+  formatters extends ChainFormatters | undefined = ChainFormatters | undefined,
+  TransactionSignable = {},
+> = Chain<
+  formatters,
+  {
+    /** Return EIP712 Domain for EIP712 transaction */
+    getEip712Domain?:
+      | EIP712DomainFn<
+          formatters extends ChainFormatters
+            ? formatters['transactionRequest'] extends ChainFormatter
+              ? TransactionSerializableGeneric &
+                  Parameters<formatters['transactionRequest']['format']>[0]
+              : TransactionSerializable
+            : TransactionSerializable,
+          TransactionSignable
+        >
+      | undefined
+  }
+>

package/chains/zksync/types/eip712.ts

@@ -0,0 +1,31 @@
+import type { Address, TypedDataDomain } from 'abitype'
+import type { Hex } from '../../../types/misc.js'
+import type { TransactionSerializable } from '../../../types/transaction.js'
+
+type PaymasterParams = {
+  paymaster: Address
+  paymasterInput: number[]
+}
+
+export type ZkSyncEip712Meta = {
+  gasPerPubdata?: Hex
+  factoryDeps?: Hex[]
+  customSignature?: Hex
+  paymasterParams?: PaymasterParams
+}
+
+type EIP712FieldType = 'uint256' | 'bytes' | 'bytes32[]'
+type EIP712Field = { name: string; type: EIP712FieldType }
+
+export type EIP712Domain<TransactionSignable> = {
+  domain: TypedDataDomain
+  types: Record<string, EIP712Field[]>
+  primaryType: string
+  message: TransactionSignable
+}
+
+export type EIP712DomainFn<
+  TTransactionSerializable extends
+    TransactionSerializable = TransactionSerializable,
+  TransactionSignable = {},
+> = (transaction: TTransactionSerializable) => EIP712Domain<TransactionSignable>

package/chains/zksync/types/fee.ts

@@ -0,0 +1,5 @@
+export type ZkSyncFeeValues<TQuantity = bigint> = {
+  gasPrice: TQuantity
+  maxFeePerGas: TQuantity
+  maxPriorityFeePerGas: TQuantity
+}

package/chains/zksync/types/log.ts

@@ -0,0 +1,57 @@
+import type { Abi, AbiEvent } from 'abitype'
+import type { Log as Log_ } from '../../../types/log.js'
+import type { Hex } from '../../../types/misc.js'
+import type { RpcLog as RpcLog_ } from '../../../types/rpc.js'
+
+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 | null
+  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
+  transactionLogIndex: Hex
+  logType: Hex | null
+}
+
+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
+}

package/chains/zksync/{types.ts → types/transaction.ts}

@@ -1,15 +1,11 @@
-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 { Address } from 'abitype'
+import type { FeeValuesEIP1559 } from '../../../types/fee.js'
+import type { Hex } from '../../../types/misc.js'
 import type {
   Index,
   Quantity,
-  RpcBlock,
-  RpcLog as RpcLog_,
   RpcTransactionRequest as RpcTransactionRequest_,
-} from '../../types/rpc.js'
+} from '../../../types/rpc.js'
 import type {
   Transaction as Transaction_,
   TransactionBase,
@@ -23,121 +19,20 @@ import type {
   TransactionSerializableEIP1559,
   TransactionSerialized,
   TransactionType,
-} from '../../types/transaction.js'
-import type { UnionOmit } from '../../types/utils.js'
+} from '../../../types/transaction.js'
+import type { OneOf, UnionOmit } from '../../../types/utils.js'
+import type { ZkSyncEip712Meta } from './eip712.js'
+import type { ZkSyncFeeValues } from './fee.js'
+import type {
+  ZkSyncL2ToL1Log,
+  ZkSyncLog,
+  ZkSyncRpcL2ToL1Log,
+  ZkSyncRpcLog,
+} from './log.js'
 
 type EIP712Type = '0x71'
 type PriorityType = '0xff'
 
-// Types
-// https://era.zksync.io/docs/api/js/types
-
-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 | null
-  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
-  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#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 | null
-  l1BatchTimestamp: Hex | null
-}
-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#transactionresponse
 
@@ -291,9 +186,9 @@ export type ZkSyncTransactionReceipt<
 
 // Serializers
 
-export type ZkSyncTransactionSerializable =
-  | TransactionSerializable
-  | ZkSyncTransactionSerializableEIP712
+export type ZkSyncTransactionSerializable = OneOf<
+  TransactionSerializable | ZkSyncTransactionSerializableEIP712
+>
 
 export type ZkSyncTransactionSerialized<
   TType extends TransactionType = 'eip712',
@@ -315,3 +210,36 @@ export type ZkSyncTransactionSerializableEIP712<
   customSignature?: Hex
   type?: 'eip712'
 }
+
+// EIP712 Signer
+
+export type ZkSyncEIP712TransactionSignable = {
+  txType: bigint
+  from: bigint
+  to: bigint
+  gasLimit: bigint
+  gasPerPubdataByteLimit: bigint
+  maxFeePerGas: bigint
+  maxPriorityFeePerGas: bigint
+  paymaster: bigint
+  nonce: bigint
+  value: bigint
+  data: Hex
+  factoryDeps: Hex[]
+  paymasterInput: Hex
+}
+
+export type TransactionRequestEIP712<
+  TQuantity = bigint,
+  TIndex = number,
+  TTransactionType = 'eip712',
+> = TransactionRequestBase<TQuantity, TIndex> &
+  Partial<FeeValuesEIP1559<TQuantity>> & {
+    accessList?: never
+    gasPerPubdata?: bigint
+    factoryDeps?: Hex[]
+    paymaster?: Address
+    paymasterInput?: Hex
+    customSignature?: Hex
+    type?: TTransactionType
+  }

package/chains/zksync/utils/assertEip712Request.ts

@@ -0,0 +1,18 @@
+import type { ErrorType } from '../../../errors/utils.js'
+import { type AssertRequestErrorType, assertRequest } from '../../../index.js'
+import type { SendTransactionParameters } from '../actions/sendTransaction.js'
+import type { zkSync } from '../chains.js'
+import { InvalidEip712TransactionError } from '../errors/transaction.js'
+import { isEIP712Transaction } from './isEip712Transaction.js'
+
+export type AssertEip712RequestParameters = Partial<
+  SendTransactionParameters<typeof zkSync>
+>
+
+export type AssertEip712RequestErrorType = AssertRequestErrorType | ErrorType
+
+export function assertEip712Request(args: AssertEip712RequestParameters) {
+  if (!isEIP712Transaction(args as any))
+    throw new InvalidEip712TransactionError()
+  assertRequest(args as any)
+}

package/chains/zksync/utils/assertEip712Transaction.ts

@@ -0,0 +1,35 @@
+import { InvalidAddressError } from '../../../errors/address.js'
+import { BaseError } from '../../../errors/base.js'
+import { InvalidChainIdError } from '../../../errors/chain.js'
+import { isAddress } from '../../../utils/address/isAddress.js'
+import { InvalidEip712TransactionError } from '../errors/transaction.js'
+import type {
+  ZkSyncTransactionSerializable,
+  ZkSyncTransactionSerializableEIP712,
+} from '../types/transaction.js'
+import { isEIP712Transaction } from './isEip712Transaction.js'
+
+export function assertEip712Transaction(
+  transaction: Partial<ZkSyncTransactionSerializable>,
+) {
+  const { chainId, to, from, paymaster, paymasterInput } =
+    transaction as ZkSyncTransactionSerializableEIP712
+
+  if (!isEIP712Transaction(transaction))
+    throw new InvalidEip712TransactionError()
+  if (!chainId || 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/utils/getEip712Domain.ts

@@ -0,0 +1,83 @@
+import type { EIP712DomainFn } from '../types/eip712.js'
+import type {
+  ZkSyncEIP712TransactionSignable,
+  ZkSyncTransactionSerializable,
+  ZkSyncTransactionSerializableEIP712,
+} from '../types/transaction.js'
+import { assertEip712Transaction } from './assertEip712Transaction.js'
+
+export const getEip712Domain: EIP712DomainFn<
+  ZkSyncTransactionSerializable,
+  ZkSyncEIP712TransactionSignable
+> = (transaction) => {
+  assertEip712Transaction(transaction)
+
+  const message = transactionToMessage(
+    transaction as ZkSyncTransactionSerializableEIP712,
+  )
+
+  return {
+    domain: {
+      name: 'zkSync',
+      version: '2',
+      chainId: transaction.chainId,
+    },
+    types: {
+      Transaction: [
+        { name: 'txType', type: 'uint256' },
+        { name: 'from', type: 'uint256' },
+        { name: 'to', type: 'uint256' },
+        { name: 'gasLimit', type: 'uint256' },
+        { name: 'gasPerPubdataByteLimit', type: 'uint256' },
+        { name: 'maxFeePerGas', type: 'uint256' },
+        { name: 'maxPriorityFeePerGas', type: 'uint256' },
+        { name: 'paymaster', type: 'uint256' },
+        { name: 'nonce', type: 'uint256' },
+        { name: 'value', type: 'uint256' },
+        { name: 'data', type: 'bytes' },
+        { name: 'factoryDeps', type: 'bytes32[]' },
+        { name: 'paymasterInput', type: 'bytes' },
+      ],
+    },
+    primaryType: 'Transaction',
+    message: message,
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Utilities
+
+function transactionToMessage(
+  transaction: ZkSyncTransactionSerializableEIP712,
+): ZkSyncEIP712TransactionSignable {
+  const {
+    gas,
+    nonce,
+    to,
+    from,
+    value,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    factoryDeps,
+    paymaster,
+    paymasterInput,
+    gasPerPubdata,
+    data,
+  } = transaction
+
+  return {
+    txType: 113n,
+    from: BigInt(from),
+    to: to ? BigInt(to) : 0n,
+    gasLimit: gas ?? 0n,
+    gasPerPubdataByteLimit: gasPerPubdata ?? 0n,
+    maxFeePerGas: maxFeePerGas ?? 0n,
+    maxPriorityFeePerGas: maxPriorityFeePerGas ?? 0n,
+    paymaster: paymaster ? BigInt(paymaster) : 0n,
+    nonce: nonce ? BigInt(nonce) : 0n,
+    value: value ?? 0n,
+    data: data ? data : '0x0',
+    factoryDeps: factoryDeps ?? [],
+    paymasterInput: paymasterInput ? paymasterInput : '0x0',
+  }
+}

package/chains/zksync/utils/isEip712Transaction.ts

@@ -0,0 +1,17 @@
+import type { ZkSyncTransactionSerializable } from '../types/transaction.js'
+
+export function isEIP712Transaction(
+  transaction: Partial<ZkSyncTransactionSerializable>,
+) {
+  if (transaction.type === 'eip712') return true
+  if (
+    ('customSignature' in transaction && transaction.customSignature) ||
+    ('paymaster' in transaction && transaction.paymaster) ||
+    ('paymasterInput' in transaction && transaction.paymasterInput) ||
+    ('gasPerPubdata' in transaction &&
+      typeof transaction.gasPerPubdata === 'bigint') ||
+    ('factoryDeps' in transaction && transaction.factoryDeps)
+  )
+    return true
+  return false
+}

package/clients/transports/http.ts

@@ -4,8 +4,12 @@ import {
   type UrlRequiredErrorType,
 } from '../../errors/transport.js'
 import type { ErrorType } from '../../errors/utils.js'
+import type { RpcRequest } from '../../types/rpc.js'
 import { createBatchScheduler } from '../../utils/promise/createBatchScheduler.js'
-import { type HttpOptions, type RpcRequest, rpc } from '../../utils/rpc.js'
+import {
+  type HttpRpcClientOptions,
+  getHttpRpcClient,
+} from '../../utils/rpc/http.js'
 
 import {
   type CreateTransportErrorType,
@@ -31,7 +35,7 @@ export type HttpTransportConfig = {
    * Request configuration to pass to `fetch`.
    * @link https://developer.mozilla.org/en-US/docs/Web/API/fetch
    */
-  fetchOptions?: HttpOptions['fetchOptions']
+  fetchOptions?: HttpRpcClientOptions['fetchOptions']
   /** The key of the HTTP transport. */
   key?: TransportConfig['key']
   /** The name of the HTTP transport. */
@@ -79,6 +83,9 @@ export function http(
     const timeout = timeout_ ?? config.timeout ?? 10_000
     const url_ = url || chain?.rpcUrls.default.http[0]
     if (!url_) throw new UrlRequiredError()
+
+    const rpcClient = getHttpRpcClient(url_, { fetchOptions, timeout })
+
     return createTransport(
       {
         key,
@@ -93,10 +100,8 @@ export function http(
               return requests.length > batchSize
             },
             fn: (body: RpcRequest[]) =>
-              rpc.http(url_, {
+              rpcClient.request({
                 body,
-                fetchOptions,
-                timeout,
               }),
             sort: (a, b) => a.id - b.id,
           })
@@ -104,7 +109,11 @@ export function http(
           const fn = async (body: RpcRequest) =>
             batch
               ? schedule(body)
-              : [await rpc.http(url_, { body, fetchOptions, timeout })]
+              : [
+                  await rpcClient.request({
+                    body,
+                  }),
+                ]
 
           const [{ error, result }] = await fn(body)
           if (error)