viem 0.0.0-main.20231026T201258 → 0.0.0-main.20231026T205555

package/chains/zksync/formatters.ts

@@ -0,0 +1,144 @@
+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 {
+  L2ToL1Log,
+  Log,
+  ZkSyncBlockOverrides,
+  ZkSyncRpcBlockOverrides,
+  ZkSyncRpcTransaction,
+  ZkSyncRpcTransactionReceiptOverrides,
+  ZkSyncRpcTransactionRequest,
+  ZkSyncTransaction,
+  ZkSyncTransactionReceipt,
+  ZkSyncTransactionReceiptOverrides,
+  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,
+    ): ZkSyncTransactionReceiptOverrides {
+      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 Log[],
+        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 L2ToL1Log[],
+      } as ZkSyncTransactionReceipt
+    },
+  }),
+  transactionRequest: /*#__PURE__*/ defineTransactionRequest({
+    exclude: [
+      'customSignature',
+      'factoryDeps',
+      'gasPerPubdata',
+      'paymaster',
+      'paymasterInput',
+    ],
+    format(args: ZkSyncTransactionRequest): ZkSyncRpcTransactionRequest {
+      if (
+        (args.type === 'eip712' || args.type === 'priority') &&
+        (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/types.ts

@@ -0,0 +1,285 @@
+import type { 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_,
+  TransactionType,
+} from '../../types/rpc.js'
+import type {
+  Transaction as Transaction_,
+  TransactionBase,
+  TransactionEIP2930,
+  TransactionLegacy,
+  TransactionReceipt,
+  TransactionRequest as TransactionRequest_,
+  TransactionRequestBase,
+} from '../../types/transaction.js'
+import type { UnionOmit } from '../../types/utils.js'
+
+import type { Abi, AbiEvent } from 'abitype'
+
+// Types
+// https://era.zksync.io/docs/api/js/types.html
+
+export type Log<
+  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 RpcLog = 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 Eip712Meta = {
+  gasPerPubdata?: Hex
+  factoryDeps?: Hex[]
+  customSignature?: Hex
+  paymasterParams?: PaymasterParams
+}
+
+export type L2ToL1Log = {
+  blockNumber: bigint
+  blockHash: string
+  l1BatchNumber: bigint
+  transactionIndex: bigint
+  shardId: bigint
+  isService: boolean
+  sender: string
+  key: string
+  value: string
+  transactionHash: string
+  logIndex: bigint
+}
+
+export type RpcL2ToL1Log = {
+  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
+}
+
+type EIP712Type = '0x71'
+type PriorityType = '0xff'
+
+// 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 TransactionEIP712<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>
+  | TransactionEIP712<TPending>
+
+// Transaction (RPC)
+
+type RpcTransactionOverrides = {
+  l1BatchNumber: Hex
+  l1BatchTxIndex: Hex
+}
+
+export type RpcTransactionLegacy<TPending extends boolean = boolean> =
+  TransactionLegacy<Quantity, Index, TPending, '0x0'> & RpcTransactionOverrides
+
+export type RpcTransactionEIP2930<TPending extends boolean = boolean> =
+  TransactionEIP2930<Quantity, Index, TPending, '0x1'> & RpcTransactionOverrides
+
+// Cannot use default EIP1559 transaction because the fee `gasPrice` parameter is set to `never`
+export type RpcTransactionEIP1559<TPending extends boolean = boolean> =
+  TransactionBase<Quantity, Index, TPending> &
+    ZkSyncFeeValues<Quantity> &
+    RpcTransactionOverrides & {
+      type: '0x2'
+    }
+
+export type RpcTransactionPriority<TPending extends boolean = boolean> =
+  TransactionBase<Quantity, Index, TPending> &
+    ZkSyncFeeValues<Quantity> &
+    RpcTransactionOverrides & {
+      type: PriorityType
+    }
+
+export type RpcTransactionEIP712<TPending extends boolean = boolean> =
+  TransactionBase<Quantity, Index, TPending> &
+    ZkSyncFeeValues<Quantity> &
+    RpcTransactionOverrides & {
+      type: EIP712Type
+    }
+
+export type ZkSyncRpcTransaction<TPending extends boolean = boolean> =
+  UnionOmit<
+    | RpcTransactionLegacy<TPending>
+    | RpcTransactionEIP2930<TPending>
+    | RpcTransactionEIP1559<TPending>
+    | RpcTransactionPriority<TPending>
+    | RpcTransactionEIP712<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 RpcTransactionRequestEIP712 = TransactionRequestBase<
+  Quantity,
+  Index
+> &
+  Partial<FeeValuesEIP1559<Quantity>> & {
+    eip712Meta: Eip712Meta
+    type: EIP712Type | PriorityType
+  }
+
+export type ZkSyncRpcTransactionRequest =
+  | RpcTransactionRequest
+  | RpcTransactionRequestEIP712
+
+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: RpcLog[]
+  l2ToL1Logs: RpcL2ToL1Log[]
+  root: Hex
+}
+
+export type ZkSyncTransactionReceiptOverrides = {
+  l1BatchNumber: bigint | null
+  l1BatchTxIndex: bigint | null
+  logs: Log[]
+  l2ToL1Logs: L2ToL1Log[]
+}
+export type ZkSyncTransactionReceipt = Omit<TransactionReceipt, 'logs'> &
+  ZkSyncTransactionReceiptOverrides

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,

package/clients/decorators/wallet.ts

@@ -128,7 +128,7 @@ export type WalletActions<
    */
   deployContract: <
     const TAbi extends Abi | readonly unknown[],
-    TChainOverride extends Chain | undefined,
+    TChainOverride extends Chain | undefined = undefined,
   >(
     args: DeployContractParameters<TAbi, TChain, TAccount, TChainOverride>,
   ) => Promise<DeployContractReturnType>
@@ -228,7 +228,9 @@ export type WalletActions<
    *   value: 1n,
    * })
    */
-  prepareTransactionRequest: <TChainOverride extends Chain | undefined,>(
+  prepareTransactionRequest: <
+    TChainOverride extends Chain | undefined = undefined,
+  >(
     args: PrepareTransactionRequestParameters<TChain, TAccount, TChainOverride>,
   ) => Promise<PrepareTransactionRequestReturnType>
   /**
@@ -347,7 +349,7 @@ export type WalletActions<
    *   value: 1000000000000000000n,
    * })
    */
-  sendTransaction: <TChainOverride extends Chain | undefined>(
+  sendTransaction: <TChainOverride extends Chain | undefined = undefined>(
     args: SendTransactionParameters<TChain, TAccount, TChainOverride>,
   ) => Promise<SendTransactionReturnType>
   /**
@@ -439,7 +441,7 @@ export type WalletActions<
    * })
    * const signature = await client.signTransaction(request)
    */
-  signTransaction: <TChainOverride extends Chain | undefined,>(
+  signTransaction: <TChainOverride extends Chain | undefined = undefined>(
     args: SignTransactionParameters<TChain, TAccount, TChainOverride>,
   ) => Promise<SignTransactionReturnType>
   /**
@@ -640,7 +642,7 @@ export type WalletActions<
   writeContract: <
     const TAbi extends Abi | readonly unknown[],
     TFunctionName extends string,
-    TChainOverride extends Chain | undefined,
+    TChainOverride extends Chain | undefined = undefined,
   >(
     args: WriteContractParameters<
       TAbi,

package/errors/version.ts

@@ -1 +1 @@
-export const version = '0.0.0-main.20231026T201258'
+export const version = '0.0.0-main.20231026T205555'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "0.0.0-main.20231026T201258",
+  "version": "0.0.0-main.20231026T205555",
   "type": "module",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",

package/utils/chain.ts

@@ -36,7 +36,7 @@ export function assertCurrentChain({
 
 export function defineChain<
   const chain extends Chain,
-  formatters extends ChainFormatters,
+  formatters extends ChainFormatters | undefined = undefined,
 >(
   chain: chain,
   config: ChainConfig<formatters> = {},

package/utils/formatters/extract.ts

@@ -4,19 +4,30 @@ import type { ChainFormatter } from '../../types/chain.js'
 export type ExtractErrorType = ErrorType
 
 /**
- * @description Picks out the keys from `value` that exist in the formatter.
+ * @description Picks out the keys from `value` that exist in the formatter..
  */
 export function extract(
-  value: Record<string, unknown>,
+  value_: Record<string, unknown>,
   { format }: { format?: ChainFormatter['format'] },
 ) {
   if (!format) return {}
-  const keys = Object.keys(format({}))
-  return keys.reduce((data: Record<string, unknown>, key) => {
-    // biome-ignore lint/suspicious/noPrototypeBuiltins:
-    if (value?.hasOwnProperty(key)) {
-      data[key] = value[key]
+
+  const value: Record<string, unknown> = {}
+  function extract_(formatted: Record<string, any>) {
+    const keys = Object.keys(formatted)
+    for (const key of keys) {
+      if (key in value_) value[key] = value_[key]
+      if (
+        formatted[key] &&
+        typeof formatted[key] === 'object' &&
+        !Array.isArray(formatted[key])
+      )
+        extract_(formatted[key])
     }
-    return data
-  }, {})
+  }
+
+  const formatted = format(value_ || {})
+  extract_(formatted)
+
+  return value
 }

package/utils/formatters/formatter.ts

@@ -10,7 +10,7 @@ export function defineFormatter<TType extends string, TParameters, TReturnType>(
   return <
     TOverrideParameters,
     TOverrideReturnType,
-    TExclude extends (keyof TParameters)[] = [],
+    TExclude extends (keyof TParameters | keyof TOverrideParameters)[] = [],
   >({
     exclude,
     format: overrides,