viem 2.9.2 → 2.9.4

package/chains/zksync/decorators/eip712.ts

@@ -1,233 +0,0 @@
-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/chains/zksync/errors/bytecode.ts

@@ -1,46 +0,0 @@
-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/chains/zksync/errors/transaction.ts

@@ -1,21 +0,0 @@
-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/chains/zksync/formatters.ts

@@ -1,155 +0,0 @@
-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/chains/zksync/serializers.ts

@@ -1,82 +0,0 @@
-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/chains/zksync/types/block.ts

@@ -1,34 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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/chains/zksync/types/eip712.ts

@@ -1,31 +0,0 @@
-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>

package/chains/zksync/types/log.ts

@@ -1,57 +0,0 @@
-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
-}