viem 2.9.1 → 2.9.3

package/chains/zksync/types/transaction.ts

@@ -1,245 +0,0 @@
-import type { Address } from 'abitype'
-import type { FeeValuesEIP1559 } from '../../../types/fee.js'
-import type { Hex } from '../../../types/misc.js'
-import type {
-  Index,
-  Quantity,
-  RpcTransactionRequest as RpcTransactionRequest_,
-} from '../../../types/rpc.js'
-import type {
-  Transaction as Transaction_,
-  TransactionBase,
-  TransactionEIP1559 as TransactionEIP1559_,
-  TransactionEIP2930 as TransactionEIP2930_,
-  TransactionLegacy as TransactionLegacy_,
-  TransactionReceipt,
-  TransactionRequest as TransactionRequest_,
-  TransactionRequestBase,
-  TransactionSerializable,
-  TransactionSerializableEIP1559,
-  TransactionSerialized,
-  TransactionType,
-} from '../../../types/transaction.js'
-import type { ExactPartial, 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'
-
-// Transaction
-// https://era.zksync.io/docs/api/js/types#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 ZkSyncTransactionEIP712<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>
-  | ZkSyncTransactionEIP712<TPending>
-
-// Transaction (RPC)
-
-type RpcTransactionOverrides = {
-  l1BatchNumber: Hex | null
-  l1BatchTxIndex: Hex | null
-}
-
-type RpcTransactionLegacy<TPending extends boolean = boolean> =
-  TransactionLegacy_<Hex, Hex, TPending, '0x0'> & RpcTransactionOverrides
-
-type RpcTransactionEIP2930<TPending extends boolean = boolean> =
-  TransactionEIP2930_<Hex, Hex, TPending, '0x1'> & RpcTransactionOverrides
-
-type RpcTransactionEIP1559<TPending extends boolean = boolean> =
-  TransactionEIP1559_<Hex, Hex, TPending, '0x2'> & RpcTransactionOverrides
-
-export type ZkSyncRpcTransactionPriority<TPending extends boolean = boolean> =
-  TransactionBase<Quantity, Index, TPending> &
-    ZkSyncFeeValues<Quantity> &
-    RpcTransactionOverrides & {
-      accessList?: undefined
-      chainId: Hex
-      type: PriorityType
-    }
-
-export type ZkSyncRpcTransactionEIP712<TPending extends boolean = boolean> =
-  TransactionBase<Quantity, Index, TPending> &
-    ZkSyncFeeValues<Quantity> &
-    RpcTransactionOverrides & {
-      accessList?: undefined
-      chainId: Hex
-      type: EIP712Type
-    }
-
-export type ZkSyncRpcTransaction<TPending extends boolean = boolean> =
-  UnionOmit<
-    | RpcTransactionLegacy<TPending>
-    | RpcTransactionEIP2930<TPending>
-    | RpcTransactionEIP1559<TPending>
-    | ZkSyncRpcTransactionPriority<TPending>
-    | ZkSyncRpcTransactionEIP712<TPending>,
-    'typeHex'
-  >
-
-// Transaction Request
-// https://era.zksync.io/docs/reference/concepts/transactions
-
-type TransactionRequest = TransactionRequest_ & {
-  gasPerPubdata?: undefined
-  customSignature?: undefined
-  paymaster?: undefined
-  paymasterInput?: undefined
-  factoryDeps?: undefined
-}
-
-export type ZkSyncTransactionRequestEIP712 = Omit<
-  TransactionRequestBase,
-  'type'
-> &
-  ExactPartial<FeeValuesEIP1559> & {
-    gasPerPubdata?: bigint | undefined
-    customSignature?: Hex | undefined
-    factoryDeps?: Hex[] | undefined
-    type?: 'eip712' | 'priority' | undefined
-  } & (
-    | { paymaster: Address; paymasterInput: Hex }
-    | { paymaster?: undefined; paymasterInput?: undefined }
-  )
-
-export type ZkSyncTransactionRequest =
-  | TransactionRequest
-  | ZkSyncTransactionRequestEIP712
-
-type RpcTransactionRequest = RpcTransactionRequest_ & { eip712Meta?: undefined }
-
-export type ZkSyncRpcTransactionRequestEIP712 = TransactionRequestBase<
-  Quantity,
-  Index
-> &
-  ExactPartial<FeeValuesEIP1559<Quantity>> & {
-    eip712Meta: ZkSyncEip712Meta
-    type: EIP712Type | PriorityType
-  }
-
-export type ZkSyncRpcTransactionRequest =
-  | RpcTransactionRequest
-  | ZkSyncRpcTransactionRequestEIP712
-
-export type ZkSyncTransactionType = TransactionType | 'eip712' | 'priority'
-
-// Transaction Receipt
-// https://era.zksync.io/docs/api/js/types#transactionreceipt
-
-export type ZkSyncRpcTransactionReceiptOverrides = {
-  l1BatchNumber: Hex | null
-  l1BatchTxIndex: Hex | null
-  logs: ZkSyncRpcLog[]
-  l2ToL1Logs: ZkSyncRpcL2ToL1Log[]
-  root: Hex
-}
-
-export type ZkSyncTransactionReceiptOverrides = {
-  l1BatchNumber: bigint | null
-  l1BatchTxIndex: bigint | null
-  logs: ZkSyncLog[]
-  l2ToL1Logs: ZkSyncL2ToL1Log[]
-}
-
-export type ZkSyncTransactionReceipt<
-  TStatus = 'success' | 'reverted',
-  TType = ZkSyncTransactionType,
-> = Omit<TransactionReceipt<bigint, number, TStatus, TType>, 'logs'> &
-  ZkSyncTransactionReceiptOverrides
-
-// Serializers
-
-export type ZkSyncTransactionSerializable = OneOf<
-  TransactionSerializable | ZkSyncTransactionSerializableEIP712
->
-
-export type ZkSyncTransactionSerialized<
-  TType extends TransactionType = 'eip712',
-> = TType extends 'eip712'
-  ? ZkSyncTransactionSerializedEIP712
-  : TransactionSerialized<TType>
-
-export type ZkSyncTransactionSerializedEIP712 = `0x71${string}`
-
-export type ZkSyncTransactionSerializableEIP712<
-  TQuantity = bigint,
-  TIndex = number,
-> = Omit<TransactionSerializableEIP1559<TQuantity, TIndex>, 'type'> & {
-  from: Hex
-  gasPerPubdata?: bigint | undefined
-  paymaster?: Address | undefined
-  factoryDeps?: Hex[] | undefined
-  paymasterInput?: Hex | undefined
-  customSignature?: Hex | undefined
-  type?: 'eip712' | undefined
-}
-
-// 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> &
-  ExactPartial<FeeValuesEIP1559<TQuantity>> & {
-    accessList?: never | undefined
-    gasPerPubdata?: bigint | undefined
-    factoryDeps?: Hex[] | undefined
-    paymaster?: Address | undefined
-    paymasterInput?: Hex | undefined
-    customSignature?: Hex | undefined
-    type?: TTransactionType | undefined
-  }

package/chains/zksync/utils/abi/encodeDeployData.ts

@@ -1,120 +0,0 @@
-import type { Abi } from 'abitype'
-
-import { zeroHash } from '../../../../constants/bytes.js'
-import {
-  AbiConstructorNotFoundError,
-  AbiConstructorParamsNotFoundError,
-} from '../../../../errors/abi.js'
-import type { ContractConstructorArgs } from '../../../../types/contract.js'
-import type { Hash } from '../../../../types/misc.js'
-import type { Hex } from '../../../../types/misc.js'
-import { encodeAbiParameters } from '../../../../utils/abi/encodeAbiParameters.js'
-import {
-  type EncodeDeployDataParameters as EncodeDeployDataParameters_,
-  type EncodeDeployDataReturnType,
-} from '../../../../utils/abi/encodeDeployData.js'
-import { encodeFunctionData } from '../../../../utils/abi/encodeFunctionData.js'
-import { toHex } from '../../../../utils/encoding/toHex.js'
-import { contractDeployerAbi } from '../../constants/abis.js'
-import { accountAbstractionVersion1 } from '../../constants/contract.js'
-import type { ContractDeploymentType } from '../../types/contract.js'
-import { hashBytecode } from '../hashBytecode.js'
-
-const docsPath = '/docs/contract/encodeDeployData'
-
-export type EncodeDeployDataParameters<
-  abi extends Abi | readonly unknown[] = Abi,
-  hasConstructor = abi extends Abi
-    ? Abi extends abi
-      ? true
-      : [Extract<abi[number], { type: 'constructor' }>] extends [never]
-        ? false
-        : true
-    : true,
-  allArgs = ContractConstructorArgs<abi>,
-> = EncodeDeployDataParameters_<abi, hasConstructor, allArgs> & {
-  deploymentType?: ContractDeploymentType | undefined
-  salt?: Hash | undefined
-}
-
-export function encodeDeployData<const abi extends Abi | readonly unknown[]>(
-  parameters: EncodeDeployDataParameters<abi>,
-): EncodeDeployDataReturnType {
-  const { abi, args, bytecode, deploymentType, salt } =
-    parameters as EncodeDeployDataParameters
-
-  if (!args || args.length === 0) {
-    const { functionName, argsContractDeployer } = getDeploymentDetails(
-      deploymentType,
-      salt ?? zeroHash,
-      toHex(hashBytecode(bytecode)),
-      '0x',
-    )
-    return encodeFunctionData({
-      abi: contractDeployerAbi,
-      functionName,
-      args: argsContractDeployer,
-    })
-  }
-
-  const description = abi.find((x) => 'type' in x && x.type === 'constructor')
-  if (!description) throw new AbiConstructorNotFoundError({ docsPath })
-  if (!('inputs' in description))
-    throw new AbiConstructorParamsNotFoundError({ docsPath })
-  if (!description.inputs || description.inputs.length === 0)
-    throw new AbiConstructorParamsNotFoundError({ docsPath })
-
-  const data = encodeAbiParameters(description.inputs, args)
-  const { functionName, argsContractDeployer } = getDeploymentDetails(
-    deploymentType,
-    salt ?? zeroHash,
-    toHex(hashBytecode(bytecode)),
-    data,
-  )
-
-  return encodeFunctionData({
-    abi: contractDeployerAbi,
-    functionName,
-    args: argsContractDeployer,
-  })
-}
-
-function getDeploymentDetails(
-  deploymentType: ContractDeploymentType,
-  salt: Hash,
-  bytecodeHash: Hex,
-  data: Hex,
-): {
-  functionName: string
-  argsContractDeployer: readonly unknown[]
-} {
-  const contractDeploymentArgs = [salt, bytecodeHash, data]
-
-  const deploymentOptions = {
-    create: {
-      functionName: 'create',
-      argsContractDeployer: contractDeploymentArgs,
-    },
-    create2: {
-      functionName: 'create2',
-      argsContractDeployer: contractDeploymentArgs,
-    },
-    createAccount: {
-      functionName: 'createAccount',
-      argsContractDeployer: [
-        ...contractDeploymentArgs,
-        accountAbstractionVersion1,
-      ],
-    },
-    create2Account: {
-      functionName: 'create2Account',
-      argsContractDeployer: [
-        ...contractDeploymentArgs,
-        accountAbstractionVersion1,
-      ],
-    },
-  }
-
-  const deploymentKey = deploymentType || 'create'
-  return deploymentOptions[deploymentKey]
-}

package/chains/zksync/utils/assertEip712Request.ts

@@ -1,19 +0,0 @@
-import type { ErrorType } from '../../../errors/utils.js'
-import { type AssertRequestErrorType, assertRequest } from '../../../index.js'
-import type { ExactPartial } from '../../../types/utils.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 = ExactPartial<
-  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

@@ -1,36 +0,0 @@
-import { InvalidAddressError } from '../../../errors/address.js'
-import { BaseError } from '../../../errors/base.js'
-import { InvalidChainIdError } from '../../../errors/chain.js'
-import type { ExactPartial } from '../../../types/utils.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: ExactPartial<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

@@ -1,85 +0,0 @@
-import { toHex } from '../../../utils/encoding/toHex.js'
-import type { EIP712DomainFn } from '../types/eip712.js'
-import type {
-  ZkSyncEIP712TransactionSignable,
-  ZkSyncTransactionSerializable,
-  ZkSyncTransactionSerializableEIP712,
-} from '../types/transaction.js'
-import { assertEip712Transaction } from './assertEip712Transaction.js'
-import { hashBytecode } from './hashBytecode.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?.map((dep) => toHex(hashBytecode(dep))) ?? [],
-    paymasterInput: paymasterInput ? paymasterInput : '0x',
-  }
-}

package/chains/zksync/utils/hashBytecode.ts

@@ -1,48 +0,0 @@
-import type { Hex } from '../../../types/misc.js'
-import { pad } from '../../../utils/data/pad.js'
-import { toBytes } from '../../../utils/encoding/toBytes.js'
-import { sha256 } from '../../../utils/hash/sha256.js'
-import { maxBytecodeSize } from '../constants/number.js'
-import {
-  BytecodeLengthExceedsMaxSizeError,
-  BytecodeLengthInWordsMustBeOddError,
-  BytecodeLengthMustBeDivisibleBy32Error,
-} from '../errors/bytecode.js'
-
-export function hashBytecode(bytecode: Hex): Uint8Array {
-  const bytecodeBytes = toBytes(bytecode)
-  if (bytecodeBytes.length % 32 !== 0)
-    throw new BytecodeLengthMustBeDivisibleBy32Error({
-      givenLength: bytecodeBytes.length,
-    })
-
-  if (bytecodeBytes.length > maxBytecodeSize)
-    throw new BytecodeLengthExceedsMaxSizeError({
-      givenLength: bytecodeBytes.length,
-      maxBytecodeSize,
-    })
-
-  const hashStr = sha256(bytecodeBytes)
-  const hash = toBytes(hashStr)
-
-  // Note that the length of the bytecode
-  // should be provided in 32-byte words.
-  const bytecodeLengthInWords = bytecodeBytes.length / 32
-  if (bytecodeLengthInWords % 2 === 0) {
-    throw new BytecodeLengthInWordsMustBeOddError({
-      givenLengthInWords: bytecodeLengthInWords,
-    })
-  }
-
-  const bytecodeLength = toBytes(bytecodeLengthInWords)
-
-  // The bytecode should always take the first 2 bytes of the bytecode hash,
-  // so we pad it from the left in case the length is smaller than 2 bytes.
-  const bytecodeLengthPadded = pad(bytecodeLength, { size: 2 })
-
-  const codeHashVersion = new Uint8Array([1, 0])
-  hash.set(codeHashVersion, 0)
-  hash.set(bytecodeLengthPadded, 2)
-
-  return hash
-}

package/chains/zksync/utils/isEip712Transaction.ts

@@ -1,18 +0,0 @@
-import type { ExactPartial } from '../../../types/utils.js'
-import type { ZkSyncTransactionSerializable } from '../types/transaction.js'
-
-export function isEIP712Transaction(
-  transaction: ExactPartial<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
-}