viem 2.9.1 → 2.9.3

package/zksync/decorators/eip712.ts

@@ -0,0 +1,233 @@
+import type { Abi } from 'abitype'
+import { writeContract } from '../../actions/wallet/writeContract.js'
+import type { Client } from '../../clients/createClient.js'
+import type { WalletActions } from '../../clients/decorators/wallet.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { Account } from '../../types/account.js'
+import {
+  type DeployContractParameters,
+  type DeployContractReturnType,
+  deployContract,
+} from '../actions/deployContract.js'
+import {
+  type SendTransactionParameters,
+  type SendTransactionReturnType,
+  sendTransaction,
+} from '../actions/sendTransaction.js'
+import {
+  type SignTransactionParameters,
+  type SignTransactionReturnType,
+  signTransaction,
+} from '../actions/signTransaction.js'
+import type { ChainEIP712 } from '../types/chain.js'
+
+export type Eip712WalletActions<
+  chain extends ChainEIP712 | undefined = ChainEIP712 | undefined,
+  account extends Account | undefined = Account | undefined,
+> = {
+  /**
+   * Creates, signs, and sends a new transaction to the network.
+   *
+   * - Docs: https://viem.sh/docs/zksync/actions/sendTransaction
+   * - JSON-RPC Methods:
+   *   - JSON-RPC Accounts: [`eth_sendTransaction`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sendtransaction)
+   *   - Local Accounts: [`eth_sendRawTransaction`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sendrawtransaction)
+   *
+   * @param client - Client to use
+   * @param parameters - {@link SendTransactionParameters}
+   * @returns The [Transaction](https://viem.sh/docs/glossary/terms#transaction) hash. {@link SendTransactionReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom } from 'viem'
+   * import { zkSync } from 'viem/chains'
+   * import { eip712WalletActions } from 'viem/zksync'
+   *
+   * const client = createWalletClient({
+   *   chain: zkSync,
+   *   transport: custom(window.ethereum),
+   * }).extend(eip712WalletActions())
+   * const hash = await client.sendTransaction({
+   *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+   *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   *   value: 1000000000000000000n,
+   * })
+   *
+   * @example
+   * // Account Hoisting
+   * import { createWalletClient, http } from 'viem'
+   * import { privateKeyToAccount } from 'viem/accounts'
+   * import { zkSync } from 'viem/chains'
+   * import { eip712WalletActions } from 'viem/zksync'
+   *
+   * const client = createWalletClient({
+   *   account: privateKeyToAccount('0x…'),
+   *   chain: zkSync,
+   *   transport: http(),
+   * }).extend(eip712WalletActions())
+   * const hash = await client.sendTransaction({
+   *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   *   value: 1000000000000000000n,
+   * })
+   */
+  sendTransaction: <chainOverride extends ChainEIP712 | undefined = undefined>(
+    args: SendTransactionParameters<chain, account, chainOverride>,
+  ) => Promise<SendTransactionReturnType>
+  /**
+   * Signs a transaction.
+   *
+   * - Docs: https://viem.sh/docs/actions/wallet/signTransaction
+   * - JSON-RPC Methods:
+   *   - JSON-RPC Accounts: [`eth_signTransaction`](https://ethereum.github.io/execution-apis/api-documentation/)
+   *   - Local Accounts: Signs locally. No JSON-RPC request.
+   *
+   * @param args - {@link SignTransactionParameters}
+   * @returns The signed serialized tranasction. {@link SignTransactionReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom } from 'viem'
+   * import { zkSync } from 'viem/chains'
+   * import { eip712WalletActions } from 'viem/zksync'
+   *
+   * const client = createWalletClient({
+   *   chain: zkSync,
+   *   transport: custom(window.ethereum),
+   * }).extend(eip712WalletActions())
+   * const signature = await client.signTransaction({
+   *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+   *   to: '0x0000000000000000000000000000000000000000',
+   *   value: 1n,
+   * })
+   *
+   * @example
+   * // Account Hoisting
+   * import { createWalletClient, http } from 'viem'
+   * import { privateKeyToAccount } from 'viem/accounts'
+   * import { zkSync } from 'viem/chains'
+   * import { eip712WalletActions } from 'viem/zksync'
+   *
+   * const client = createWalletClient({
+   *   account: privateKeyToAccount('0x…'),
+   *   chain: zkSync,
+   *   transport: custom(window.ethereum),
+   * }).extend(eip712WalletActions())
+   * const signature = await client.signTransaction({
+   *   to: '0x0000000000000000000000000000000000000000',
+   *   value: 1n,
+   * })
+   */
+  signTransaction: <chainOverride extends ChainEIP712 | undefined = undefined>(
+    args: SignTransactionParameters<chain, account, chainOverride>,
+  ) => Promise<SignTransactionReturnType>
+  /**
+   * Deploys a contract to the network, given bytecode and constructor arguments using EIP712 transaction.
+   *
+   * - Docs: https://viem.sh/docs/contract/deployContract
+   * - Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/contracts/deploying-contracts
+   *
+   * @param args - {@link DeployContractParameters}
+   * @returns The [Transaction](https://viem.sh/docs/glossary/terms#transaction) hash. {@link DeployContractReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom } from 'viem'
+   * import { privateKeyToAccount } from 'viem/accounts'
+   * import { zkSync } from 'viem/chains'
+   * import { deployContract } from 'viem/contract'
+   *
+   * const client = createWalletClient({
+   *   account: privateKeyToAccount('0x…'),
+   *   chain: zksync,
+   *   transport: custom(provider),
+   * })
+   * const hash = await client.deployContract(client, {
+   *   abi: [],
+   *   account: '0x…,
+   *   deploymentType: 'create',
+   *   bytecode: '0x608060405260405161083e38038061083e833981016040819052610...',
+   *   factoryDeps: ['0x608060405260405161083e38038061083e833981016040819052610...'],
+   *   gasPerPubdata: 50000n
+   * })
+   */
+  deployContract: <
+    const abi extends Abi | readonly unknown[],
+    chainOverride extends ChainEIP712 | undefined,
+  >(
+    args: DeployContractParameters<
+      abi,
+      ChainEIP712 | undefined,
+      Account | undefined,
+      chainOverride
+    >,
+  ) => Promise<DeployContractReturnType>
+  /**
+   * Executes a write function on a contract.
+   *
+   * - Docs: https://viem.sh/docs/contract/writeContract
+   * - Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/contracts/writing-to-contracts
+   *
+   * A "write" function on a Solidity contract modifies the state of the blockchain. These types of functions require gas to be executed, and hence a [Transaction](https://viem.sh/docs/glossary/terms) is needed to be broadcast in order to change the state.
+   *
+   * Internally, uses a [Wallet Client](https://viem.sh/docs/clients/wallet) to call the [`sendTransaction` action](https://viem.sh/docs/actions/wallet/sendTransaction) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData).
+   *
+   * __Warning: The `write` internally sends a transaction – it does not validate if the contract write will succeed (the contract may throw an error). It is highly recommended to [simulate the contract write with `contract.simulate`](https://viem.sh/docs/contract/writeContract#usage) before you execute it.__
+   *
+   * @param client - Client to use
+   * @param parameters - {@link WriteContractParameters}
+   * @returns A [Transaction Hash](https://viem.sh/docs/glossary/terms#hash). {@link WriteContractReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom, parseAbi } from 'viem'
+   * import { zkSync } from 'viem/chains'
+   * import { eip712WalletActions } from 'viem/zksync'
+   *
+   * const client = createWalletClient({
+   *   chain: zkSync,
+   *   transport: custom(window.ethereum),
+   * }).extend(eip712WalletActions())
+   * const hash = await client.writeContract({
+   *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+   *   abi: parseAbi(['function mint(uint32 tokenId) nonpayable']),
+   *   functionName: 'mint',
+   *   args: [69420],
+   * })
+   *
+   * @example
+   * // With Validation
+   * import { createWalletClient, http, parseAbi } from 'viem'
+   * import { zkSync } from 'viem/chains'
+   * import { eip712WalletActions } from 'viem/zksync'
+   *
+   * const client = createWalletClient({
+   *   chain: zkSync,
+   *   transport: http(),
+   * }).extend(eip712WalletActions())
+   * const { request } = await client.simulateContract({
+   *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+   *   abi: parseAbi(['function mint(uint32 tokenId) nonpayable']),
+   *   functionName: 'mint',
+   *   args: [69420],
+   * }
+   * const hash = await client.writeContract(request)
+   */
+  writeContract: WalletActions<chain, account>['writeContract']
+}
+
+export function eip712WalletActions() {
+  return <
+    transport extends Transport,
+    chain extends ChainEIP712 | undefined = ChainEIP712 | undefined,
+    account extends Account | undefined = Account | undefined,
+  >(
+    client: Client<transport, chain, account>,
+  ): Eip712WalletActions<chain, account> => ({
+    sendTransaction: (args) => sendTransaction(client, args),
+    signTransaction: (args) => signTransaction(client, args),
+    deployContract: (args) => deployContract(client, args),
+    writeContract: (args) =>
+      writeContract(
+        Object.assign(client, {
+          sendTransaction: (args: any) => sendTransaction(client, args),
+        }),
+        args,
+      ),
+  })
+}

package/zksync/errors/bytecode.ts

@@ -0,0 +1,46 @@
+import { BaseError } from '../../errors/base.js'
+
+export type BytecodeLengthExceedsMaxSizeErrorType =
+  BytecodeLengthExceedsMaxSizeError & {
+    name: 'BytecodeLengthExceedsMaxSizeError'
+  }
+
+export class BytecodeLengthExceedsMaxSizeError extends BaseError {
+  override name = 'BytecodeLengthExceedsMaxSizeError'
+  constructor({
+    givenLength,
+    maxBytecodeSize,
+  }: { givenLength: number; maxBytecodeSize: bigint }) {
+    super(
+      `Bytecode cannot be longer than ${maxBytecodeSize} bytes. Given length: ${givenLength}`,
+    )
+  }
+}
+
+export type BytecodeLengthInWordsMustBeOddErrorType =
+  BytecodeLengthInWordsMustBeOddError & {
+    name: 'BytecodeLengthInWordsMustBeOddError'
+  }
+
+export class BytecodeLengthInWordsMustBeOddError extends BaseError {
+  override name = 'BytecodeLengthInWordsMustBeOddError'
+  constructor({ givenLengthInWords }: { givenLengthInWords: number }) {
+    super(
+      `Bytecode length in 32-byte words must be odd. Given length in words: ${givenLengthInWords}`,
+    )
+  }
+}
+
+export type BytecodeLengthMustBeDivisibleBy32ErrorType =
+  BytecodeLengthMustBeDivisibleBy32Error & {
+    name: 'BytecodeLengthMustBeDivisibleBy32Error'
+  }
+
+export class BytecodeLengthMustBeDivisibleBy32Error extends BaseError {
+  override name = 'BytecodeLengthMustBeDivisibleBy32Error'
+  constructor({ givenLength }: { givenLength: number }) {
+    super(
+      `The bytecode length in bytes must be divisible by 32. Given length: ${givenLength}`,
+    )
+  }
+}

package/zksync/errors/transaction.ts

@@ -0,0 +1,21 @@
+import { BaseError } from '../../errors/base.js'
+
+export type InvalidEip712TransactionErrorType =
+  InvalidEip712TransactionError & {
+    name: 'InvalidEip712TransactionError'
+  }
+export class InvalidEip712TransactionError extends BaseError {
+  override name = 'InvalidEip712TransactionError'
+
+  constructor() {
+    super(
+      [
+        'Transaction is not an EIP712 transaction.',
+        '',
+        'Transaction must:',
+        '  - include `type: "eip712"`',
+        '  - include one of the following: `customSignature`, `paymaster`, `paymasterInput`, `gasPerPubdata`, `factoryDeps`',
+      ].join('\n'),
+    )
+  }
+}

package/zksync/formatters.ts

@@ -0,0 +1,155 @@
+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,
+  ZkSyncRpcBlockOverrides,
+} from './types/block.js'
+import type { ZkSyncL2ToL1Log, ZkSyncLog } from './types/log.js'
+import type {
+  ZkSyncRpcTransaction,
+  ZkSyncRpcTransactionReceiptOverrides,
+  ZkSyncRpcTransactionRequest,
+  ZkSyncTransaction,
+  ZkSyncTransactionReceipt,
+  ZkSyncTransactionRequest,
+} from './types/transaction.js'
+
+export const formatters = {
+  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 = formatters.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: args.l1BatchNumber
+          ? hexToBigInt(args.l1BatchNumber)
+          : null,
+        l1BatchTimestamp: args.l1BatchTimestamp
+          ? hexToBigInt(args.l1BatchTimestamp)
+          : null,
+        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.map((dep) =>
+                    Array.from(hexToBytes(dep)),
+                  ),
+                }
+              : {}),
+            ...(args.customSignature
+              ? {
+                  customSignature: Array.from(hexToBytes(args.customSignature)),
+                }
+              : {}),
+          },
+          type: '0x71',
+        } as unknown as ZkSyncRpcTransactionRequest
+      return {} as ZkSyncRpcTransactionRequest
+    },
+  }),
+} as const satisfies ChainFormatters

package/zksync/package.json

@@ -1,6 +1,6 @@
 {
   "type": "module",
-  "types": "../_types/chains/zksync/index.d.ts",
-  "module": "../_esm/chains/zksync/index.js",
-  "main": "../_cjs/chains/zksync/index.js"
+  "types": "../_types/zksync/index.d.ts",
+  "module": "../_esm/zksync/index.js",
+  "main": "../_cjs/zksync/index.js"
 }

package/zksync/serializers.ts

@@ -0,0 +1,82 @@
+import type { Signature } from '../index.js'
+import type { ChainSerializers } from '../types/chain.js'
+import type { TransactionSerializable } from '../types/transaction.js'
+import { concatHex } from '../utils/data/concat.js'
+import { toHex } from '../utils/encoding/toHex.js'
+import { toRlp } from '../utils/encoding/toRlp.js'
+import { serializeTransaction as serializeTransaction_ } from '../utils/transaction/serializeTransaction.js'
+import type {
+  ZkSyncTransactionSerializable,
+  ZkSyncTransactionSerializableEIP712,
+  ZkSyncTransactionSerializedEIP712,
+} from './types/transaction.js'
+import { assertEip712Transaction } from './utils/assertEip712Transaction.js'
+import { isEIP712Transaction } from './utils/isEip712Transaction.js'
+
+export function serializeTransaction(
+  transaction: ZkSyncTransactionSerializable,
+  signature?: Signature | undefined,
+) {
+  if (isEIP712Transaction(transaction))
+    return serializeTransactionEIP712(
+      transaction as ZkSyncTransactionSerializableEIP712,
+    )
+  return serializeTransaction_(
+    transaction as TransactionSerializable,
+    signature,
+  )
+}
+
+export const serializers = {
+  transaction: serializeTransaction,
+} as const satisfies ChainSerializers
+
+export type SerializeTransactionEIP712ReturnType =
+  ZkSyncTransactionSerializedEIP712
+
+function serializeTransactionEIP712(
+  transaction: ZkSyncTransactionSerializableEIP712,
+): SerializeTransactionEIP712ReturnType {
+  const {
+    chainId,
+    gas,
+    nonce,
+    to,
+    from,
+    value,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    customSignature,
+    factoryDeps,
+    paymaster,
+    paymasterInput,
+    gasPerPubdata,
+    data,
+  } = transaction
+
+  assertEip712Transaction(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 ?? '0x0',
+    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
+}

package/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/zksync/types/chain.ts

@@ -0,0 +1,25 @@
+import type { ChainFormatters } from '../../types/chain.js'
+import type { Chain, ChainFormatter } from '../../types/chain.js'
+import type { EIP712DomainFn } from './eip712.js'
+import type { ZkSyncTransactionSerializable } from './transaction.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
+              ? ZkSyncTransactionSerializable &
+                  Parameters<formatters['transactionRequest']['format']>[0]
+              : ZkSyncTransactionSerializable
+            : ZkSyncTransactionSerializable,
+          TransactionSignable
+        >
+      | undefined
+  }
+>

package/zksync/types/eip712.ts

@@ -0,0 +1,31 @@
+import type { Address, TypedDataDomain } from 'abitype'
+import type { Hex } from '../../types/misc.js'
+import type { ZkSyncTransactionSerializable } from './transaction.js'
+
+type PaymasterParams = {
+  paymaster: Address
+  paymasterInput: number[]
+}
+
+export type ZkSyncEip712Meta = {
+  gasPerPubdata?: Hex | undefined
+  factoryDeps?: Hex[] | undefined
+  customSignature?: Hex | undefined
+  paymasterParams?: PaymasterParams | undefined
+}
+
+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
+    ZkSyncTransactionSerializable = ZkSyncTransactionSerializable,
+  TransactionSignable = {},
+> = (transaction: TTransactionSerializable) => EIP712Domain<TransactionSignable>