viem 2.9.2 → 2.9.3

package/zksync/types/log.ts

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

package/zksync/types/transaction.ts

@@ -0,0 +1,245 @@
+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/zksync/utils/abi/encodeDeployData.ts

@@ -0,0 +1,120 @@
+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/zksync/utils/assertEip712Request.ts

@@ -0,0 +1,19 @@
+import type { ErrorType } from '../../errors/utils.js'
+import { type AssertRequestErrorType, assertRequest } from '../../index.js'
+import type { ExactPartial } from '../../types/utils.js'
+import type { zkSync } from '../../zksync/chains.js'
+import type { SendTransactionParameters } from '../actions/sendTransaction.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/zksync/utils/assertEip712Transaction.ts

@@ -0,0 +1,36 @@
+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/zksync/utils/getEip712Domain.ts

@@ -0,0 +1,85 @@
+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/zksync/utils/hashBytecode.ts

@@ -0,0 +1,48 @@
+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/zksync/utils/isEip712Transaction.ts

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

package/_cjs/chains/celo/chainConfig.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"chainConfig.js","sourceRoot":"","sources":["../../../chains/celo/chainConfig.ts"],"names":[],"mappings":";;;AAAA,mDAA4C;AAC5C,qDAA8C;AAEjC,QAAA,WAAW,GAAG;IACzB,UAAU,EAAV,0BAAU;IACV,WAAW,EAAX,4BAAW;CACH,CAAA"}