viem 0.0.0-main.20231026T203612 → 0.0.0-main.20231026T213343

package/chains/definitions/zkSync.ts

@@ -1,33 +1,41 @@
 import { defineChain } from '../../utils/chain.js'
+import { formattersZkSync } from '../zksync/formatters.js'
+import { serializersZkSync } from '../zksync/serializers.js'
 
-export const zkSync = /*#__PURE__*/ defineChain({
-  id: 324,
-  name: 'zkSync Era',
-  network: 'zksync-era',
-  nativeCurrency: {
-    decimals: 18,
-    name: 'Ether',
-    symbol: 'ETH',
-  },
-  rpcUrls: {
-    default: {
-      http: ['https://mainnet.era.zksync.io'],
-      webSocket: ['wss://mainnet.era.zksync.io/ws'],
+export const zkSync = /*#__PURE__*/ defineChain(
+  {
+    id: 324,
+    name: 'zkSync Era',
+    network: 'zksync-era',
+    nativeCurrency: {
+      decimals: 18,
+      name: 'Ether',
+      symbol: 'ETH',
     },
-    public: {
-      http: ['https://mainnet.era.zksync.io'],
-      webSocket: ['wss://mainnet.era.zksync.io/ws'],
+    rpcUrls: {
+      default: {
+        http: ['https://mainnet.era.zksync.io'],
+        webSocket: ['wss://mainnet.era.zksync.io/ws'],
+      },
+      public: {
+        http: ['https://mainnet.era.zksync.io'],
+        webSocket: ['wss://mainnet.era.zksync.io/ws'],
+      },
     },
-  },
-  blockExplorers: {
-    default: {
-      name: 'zkExplorer',
-      url: 'https://explorer.zksync.io',
+    blockExplorers: {
+      default: {
+        name: 'zkExplorer',
+        url: 'https://explorer.zksync.io',
+      },
     },
-  },
-  contracts: {
-    multicall3: {
-      address: '0xF9cda624FBC7e059355ce98a31693d299FACd963',
+    contracts: {
+      multicall3: {
+        address: '0xF9cda624FBC7e059355ce98a31693d299FACd963',
+      },
     },
   },
-})
+  {
+    serializers: serializersZkSync,
+    formatters: formattersZkSync,
+  },
+)

package/chains/definitions/zkSyncTestnet.ts

@@ -1,30 +1,38 @@
 import { defineChain } from '../../utils/chain.js'
+import { formattersZkSync } from '../zksync/formatters.js'
+import { serializersZkSync } from '../zksync/serializers.js'
 
-export const zkSyncTestnet = /*#__PURE__*/ defineChain({
-  id: 280,
-  name: 'zkSync Era Testnet',
-  network: 'zksync-era-testnet',
-  nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
-  rpcUrls: {
-    default: {
-      http: ['https://testnet.era.zksync.dev'],
-      webSocket: ['wss://testnet.era.zksync.dev/ws'],
+export const zkSyncTestnet = /*#__PURE__*/ defineChain(
+  {
+    id: 280,
+    name: 'zkSync Era Testnet',
+    network: 'zksync-era-testnet',
+    nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+    rpcUrls: {
+      default: {
+        http: ['https://testnet.era.zksync.dev'],
+        webSocket: ['wss://testnet.era.zksync.dev/ws'],
+      },
+      public: {
+        http: ['https://testnet.era.zksync.dev'],
+        webSocket: ['wss://testnet.era.zksync.dev/ws'],
+      },
     },
-    public: {
-      http: ['https://testnet.era.zksync.dev'],
-      webSocket: ['wss://testnet.era.zksync.dev/ws'],
+    blockExplorers: {
+      default: {
+        name: 'zkExplorer',
+        url: 'https://goerli.explorer.zksync.io',
+      },
     },
-  },
-  blockExplorers: {
-    default: {
-      name: 'zkExplorer',
-      url: 'https://goerli.explorer.zksync.io',
+    contracts: {
+      multicall3: {
+        address: '0xF9cda624FBC7e059355ce98a31693d299FACd963',
+      },
     },
+    testnet: true,
   },
-  contracts: {
-    multicall3: {
-      address: '0xF9cda624FBC7e059355ce98a31693d299FACd963',
-    },
+  {
+    serializers: serializersZkSync,
+    formatters: formattersZkSync,
   },
-  testnet: true,
-})
+)

package/chains/utils/index.ts

@@ -43,3 +43,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,143 @@
+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,
+  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 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',
+    )
+  }
+}