viem 2.9.1 → 2.9.3

package/celo/parsers.ts

@@ -0,0 +1,203 @@
+import { InvalidSerializedTransactionError } from '../errors/transaction.js'
+import type { Hex } from '../types/misc.js'
+import type { ExactPartial } from '../types/utils.js'
+import { isHex } from '../utils/data/isHex.js'
+import { sliceHex } from '../utils/data/slice.js'
+import { hexToBigInt, hexToNumber } from '../utils/encoding/fromHex.js'
+import type { RecursiveArray } from '../utils/encoding/toRlp.js'
+import type { GetSerializedTransactionType } from '../utils/transaction/getSerializedTransactionType.js'
+import {
+  type ParseTransactionReturnType as ParseTransactionReturnType_,
+  parseAccessList,
+  parseTransaction as parseTransaction_,
+  toTransactionArray,
+} from '../utils/transaction/parseTransaction.js'
+import {
+  assertTransactionCIP42,
+  assertTransactionCIP64,
+} from './serializers.js'
+import type {
+  CeloTransactionSerialized,
+  CeloTransactionType,
+  TransactionSerializableCIP42,
+  TransactionSerializableCIP64,
+  TransactionSerializedCIP42,
+  TransactionSerializedCIP64,
+} from './types.js'
+
+export type ParseTransactionReturnType<
+  TSerialized extends CeloTransactionSerialized = CeloTransactionSerialized,
+  TType extends CeloTransactionType = GetSerializedTransactionType<TSerialized>,
+> = TSerialized extends TransactionSerializedCIP42
+  ? TransactionSerializableCIP42
+  : ParseTransactionReturnType_<TSerialized, TType>
+
+export function parseTransaction<TSerialized extends CeloTransactionSerialized>(
+  serializedTransaction: TSerialized,
+): ParseTransactionReturnType<TSerialized> {
+  const serializedType = sliceHex(serializedTransaction, 0, 1)
+
+  if (serializedType === '0x7c')
+    return parseTransactionCIP42(
+      serializedTransaction as TransactionSerializedCIP42,
+    ) as ParseTransactionReturnType<TSerialized>
+
+  if (serializedType === '0x7b')
+    return parseTransactionCIP64(
+      serializedTransaction as TransactionSerializedCIP64,
+    ) as ParseTransactionReturnType<TSerialized>
+
+  return parseTransaction_(
+    serializedTransaction,
+  ) as ParseTransactionReturnType<TSerialized>
+}
+
+function parseTransactionCIP42(
+  serializedTransaction: TransactionSerializedCIP42,
+): TransactionSerializableCIP42 {
+  const transactionArray = toTransactionArray(serializedTransaction)
+
+  const [
+    chainId,
+    nonce,
+    maxPriorityFeePerGas,
+    maxFeePerGas,
+    gas,
+    feeCurrency,
+    gatewayFeeRecipient,
+    gatewayFee,
+    to,
+    value,
+    data,
+    accessList,
+    v,
+    r,
+    s,
+  ] = transactionArray
+
+  if (transactionArray.length !== 15 && transactionArray.length !== 12) {
+    throw new InvalidSerializedTransactionError({
+      attributes: {
+        chainId,
+        nonce,
+        maxPriorityFeePerGas,
+        maxFeePerGas,
+        gas,
+        feeCurrency,
+        to,
+        gatewayFeeRecipient,
+        gatewayFee,
+        value,
+        data,
+        accessList,
+        ...(transactionArray.length > 12
+          ? {
+              v,
+              r,
+              s,
+            }
+          : {}),
+      },
+      serializedTransaction,
+      type: 'cip42',
+    })
+  }
+
+  const transaction: ExactPartial<TransactionSerializableCIP42> = {
+    chainId: hexToNumber(chainId as Hex),
+    type: 'cip42',
+  }
+
+  if (isHex(to) && to !== '0x') transaction.to = to
+  if (isHex(gas) && gas !== '0x') transaction.gas = hexToBigInt(gas)
+  if (isHex(data) && data !== '0x') transaction.data = data
+  if (isHex(nonce) && nonce !== '0x') transaction.nonce = hexToNumber(nonce)
+  if (isHex(value) && value !== '0x') transaction.value = hexToBigInt(value)
+  if (isHex(feeCurrency) && feeCurrency !== '0x')
+    transaction.feeCurrency = feeCurrency
+  if (isHex(gatewayFeeRecipient) && gatewayFeeRecipient !== '0x')
+    transaction.gatewayFeeRecipient = gatewayFeeRecipient
+  if (isHex(gatewayFee) && gatewayFee !== '0x')
+    transaction.gatewayFee = hexToBigInt(gatewayFee)
+  if (isHex(maxFeePerGas) && maxFeePerGas !== '0x')
+    transaction.maxFeePerGas = hexToBigInt(maxFeePerGas)
+  if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== '0x')
+    transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas)
+  if (accessList.length !== 0 && accessList !== '0x')
+    transaction.accessList = parseAccessList(accessList as RecursiveArray<Hex>)
+
+  assertTransactionCIP42(transaction as TransactionSerializableCIP42)
+
+  return transaction as TransactionSerializableCIP42
+}
+
+function parseTransactionCIP64(
+  serializedTransaction: TransactionSerializedCIP64,
+): TransactionSerializableCIP64 {
+  const transactionArray = toTransactionArray(serializedTransaction)
+
+  const [
+    chainId,
+    nonce,
+    maxPriorityFeePerGas,
+    maxFeePerGas,
+    gas,
+    to,
+    value,
+    data,
+    accessList,
+    feeCurrency,
+    v,
+    r,
+    s,
+  ] = transactionArray
+
+  if (transactionArray.length !== 13 && transactionArray.length !== 10) {
+    throw new InvalidSerializedTransactionError({
+      attributes: {
+        chainId,
+        nonce,
+        maxPriorityFeePerGas,
+        maxFeePerGas,
+        gas,
+        to,
+        value,
+        data,
+        accessList,
+        feeCurrency,
+        ...(transactionArray.length > 10
+          ? {
+              v,
+              r,
+              s,
+            }
+          : {}),
+      },
+      serializedTransaction,
+      type: 'cip64',
+    })
+  }
+
+  const transaction: ExactPartial<TransactionSerializableCIP64> = {
+    chainId: hexToNumber(chainId as Hex),
+    type: 'cip64',
+  }
+
+  if (isHex(to) && to !== '0x') transaction.to = to
+  if (isHex(gas) && gas !== '0x') transaction.gas = hexToBigInt(gas)
+  if (isHex(data) && data !== '0x') transaction.data = data
+  if (isHex(nonce) && nonce !== '0x') transaction.nonce = hexToNumber(nonce)
+  if (isHex(value) && value !== '0x') transaction.value = hexToBigInt(value)
+  if (isHex(feeCurrency) && feeCurrency !== '0x')
+    transaction.feeCurrency = feeCurrency
+  if (isHex(maxFeePerGas) && maxFeePerGas !== '0x')
+    transaction.maxFeePerGas = hexToBigInt(maxFeePerGas)
+  if (isHex(maxPriorityFeePerGas) && maxPriorityFeePerGas !== '0x')
+    transaction.maxPriorityFeePerGas = hexToBigInt(maxPriorityFeePerGas)
+  if (accessList.length !== 0 && accessList !== '0x')
+    transaction.accessList = parseAccessList(accessList as RecursiveArray<Hex>)
+
+  assertTransactionCIP64(transaction as TransactionSerializableCIP64)
+
+  return transaction as TransactionSerializableCIP64
+}

package/celo/serializers.ts

@@ -0,0 +1,228 @@
+import { InvalidAddressError } from '../errors/address.js'
+import { BaseError } from '../errors/base.js'
+import { InvalidChainIdError } from '../errors/chain.js'
+import { FeeCapTooHighError, TipAboveFeeCapError } from '../errors/node.js'
+import type { ChainSerializers } from '../types/chain.js'
+import type { Signature } from '../types/misc.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 { serializeAccessList } from '../utils/transaction/serializeAccessList.js'
+import {
+  serializeTransaction as serializeTransaction_,
+  toYParitySignatureArray,
+} from '../utils/transaction/serializeTransaction.js'
+import type {
+  CeloTransactionSerializable,
+  TransactionSerializableCIP42,
+  TransactionSerializableCIP64,
+  TransactionSerializedCIP42,
+  TransactionSerializedCIP64,
+} from './types.js'
+import { isCIP42, isCIP64, isEmpty, isPresent } from './utils.js'
+
+export function serializeTransaction(
+  transaction: CeloTransactionSerializable,
+  signature?: Signature | undefined,
+) {
+  if (isCIP64(transaction))
+    return serializeTransactionCIP64(transaction, signature)
+  if (isCIP42(transaction))
+    return serializeTransactionCIP42(transaction, signature)
+  return serializeTransaction_(transaction, signature)
+}
+
+export const serializers = {
+  transaction: serializeTransaction,
+} as const satisfies ChainSerializers
+
+//////////////////////////////////////////////////////////////////////////////
+// Serializers
+
+export type SerializeTransactionCIP42ReturnType = TransactionSerializedCIP42
+export type SerializeTransactionCIP64ReturnType = TransactionSerializedCIP64
+
+// There shall be a typed transaction with the code 0x7c that has the following format:
+// 0x7c || rlp([chain_id, nonce, max_priority_fee_per_gas, max_fee_per_gas, gas_limit, feecurrency, gatewayFeeRecipient, gatewayfee, destination, amount, data, access_list, signature_y_parity, signature_r, signature_s]).
+// This will be in addition to the type 0x02 transaction as specified in EIP-1559.
+function serializeTransactionCIP42(
+  transaction: TransactionSerializableCIP42,
+  signature?: Signature | undefined,
+): SerializeTransactionCIP42ReturnType {
+  assertTransactionCIP42(transaction)
+  const {
+    chainId,
+    gas,
+    nonce,
+    to,
+    value,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    accessList,
+    feeCurrency,
+    gatewayFeeRecipient,
+    gatewayFee,
+    data,
+  } = transaction
+
+  const serializedTransaction = [
+    toHex(chainId),
+    nonce ? toHex(nonce) : '0x',
+    maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : '0x',
+    maxFeePerGas ? toHex(maxFeePerGas) : '0x',
+    gas ? toHex(gas) : '0x',
+    feeCurrency ?? '0x',
+    gatewayFeeRecipient ?? '0x',
+    gatewayFee ? toHex(gatewayFee) : '0x',
+    to ?? '0x',
+    value ? toHex(value) : '0x',
+    data ?? '0x',
+    serializeAccessList(accessList),
+    ...toYParitySignatureArray(transaction, signature),
+  ]
+
+  return concatHex([
+    '0x7c',
+    toRlp(serializedTransaction),
+  ]) as SerializeTransactionCIP42ReturnType
+}
+
+function serializeTransactionCIP64(
+  transaction: TransactionSerializableCIP64,
+  signature?: Signature | undefined,
+): SerializeTransactionCIP64ReturnType {
+  assertTransactionCIP64(transaction)
+  const {
+    chainId,
+    gas,
+    nonce,
+    to,
+    value,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    accessList,
+    feeCurrency,
+    data,
+  } = transaction
+
+  const serializedTransaction = [
+    toHex(chainId),
+    nonce ? toHex(nonce) : '0x',
+    maxPriorityFeePerGas ? toHex(maxPriorityFeePerGas) : '0x',
+    maxFeePerGas ? toHex(maxFeePerGas) : '0x',
+    gas ? toHex(gas) : '0x',
+    to ?? '0x',
+    value ? toHex(value) : '0x',
+    data ?? '0x',
+    serializeAccessList(accessList),
+    feeCurrency!,
+    ...toYParitySignatureArray(transaction, signature),
+  ]
+
+  return concatHex([
+    '0x7b',
+    toRlp(serializedTransaction),
+  ]) as SerializeTransactionCIP64ReturnType
+}
+
+// maxFeePerGas must be less than 2^256 - 1
+const MAX_MAX_FEE_PER_GAS = 2n ** 256n - 1n
+
+export function assertTransactionCIP42(
+  transaction: TransactionSerializableCIP42,
+) {
+  const {
+    chainId,
+    maxPriorityFeePerGas,
+    gasPrice,
+    maxFeePerGas,
+    to,
+    feeCurrency,
+    gatewayFee,
+    gatewayFeeRecipient,
+  } = transaction
+  if (chainId <= 0) throw new InvalidChainIdError({ chainId })
+  if (to && !isAddress(to)) throw new InvalidAddressError({ address: to })
+  if (gasPrice)
+    throw new BaseError(
+      '`gasPrice` is not a valid CIP-42 Transaction attribute.',
+    )
+
+  if (isPresent(maxFeePerGas) && maxFeePerGas > MAX_MAX_FEE_PER_GAS)
+    throw new FeeCapTooHighError({ maxFeePerGas })
+
+  if (
+    isPresent(maxPriorityFeePerGas) &&
+    isPresent(maxFeePerGas) &&
+    maxPriorityFeePerGas > maxFeePerGas
+  )
+    throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas })
+
+  if (
+    (isPresent(gatewayFee) && isEmpty(gatewayFeeRecipient)) ||
+    (isPresent(gatewayFeeRecipient) && isEmpty(gatewayFee))
+  ) {
+    throw new BaseError(
+      '`gatewayFee` and `gatewayFeeRecipient` must be provided together.',
+    )
+  }
+
+  if (isPresent(feeCurrency) && !isAddress(feeCurrency)) {
+    throw new BaseError(
+      '`feeCurrency` MUST be a token address for CIP-42 transactions.',
+    )
+  }
+
+  if (isPresent(gatewayFeeRecipient) && !isAddress(gatewayFeeRecipient)) {
+    throw new InvalidAddressError(gatewayFeeRecipient)
+  }
+
+  if (isEmpty(feeCurrency) && isEmpty(gatewayFeeRecipient)) {
+    throw new BaseError(
+      'Either `feeCurrency` or `gatewayFeeRecipient` must be provided for CIP-42 transactions.',
+    )
+  }
+}
+
+export function assertTransactionCIP64(
+  transaction: TransactionSerializableCIP64,
+) {
+  const {
+    chainId,
+    maxPriorityFeePerGas,
+    gasPrice,
+    maxFeePerGas,
+    to,
+    feeCurrency,
+  } = transaction
+
+  if (chainId <= 0) throw new InvalidChainIdError({ chainId })
+  if (to && !isAddress(to)) throw new InvalidAddressError({ address: to })
+
+  if (gasPrice)
+    throw new BaseError(
+      '`gasPrice` is not a valid CIP-64 Transaction attribute.',
+    )
+
+  if (isPresent(maxFeePerGas) && maxFeePerGas > MAX_MAX_FEE_PER_GAS)
+    throw new FeeCapTooHighError({ maxFeePerGas })
+  if (
+    isPresent(maxPriorityFeePerGas) &&
+    isPresent(maxFeePerGas) &&
+    maxPriorityFeePerGas > maxFeePerGas
+  )
+    throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas })
+
+  if (isPresent(feeCurrency) && !isAddress(feeCurrency)) {
+    throw new BaseError(
+      '`feeCurrency` MUST be a token address for CIP-64 transactions.',
+    )
+  }
+
+  if (isEmpty(feeCurrency)) {
+    throw new BaseError(
+      '`feeCurrency` must be provided for CIP-64 transactions.',
+    )
+  }
+}

package/celo/types.ts

@@ -0,0 +1,245 @@
+import type { Address } from 'abitype'
+
+import type { Block, BlockTag } from '../types/block.js'
+import type { FeeValuesEIP1559 } from '../types/fee.js'
+import type { Hex } from '../types/misc.js'
+import type {
+  Index,
+  Quantity,
+  RpcBlock,
+  RpcTransaction as RpcTransaction_,
+  RpcTransactionRequest as RpcTransactionRequest_,
+  TransactionType,
+} from '../types/rpc.js'
+import type {
+  AccessList,
+  Transaction as Transaction_,
+  TransactionBase,
+  TransactionRequest as TransactionRequest_,
+  TransactionRequestBase,
+  TransactionSerializable,
+  TransactionSerializableBase,
+  TransactionSerialized,
+} from '../types/transaction.js'
+import type { ExactPartial, NeverBy, OneOf } from '../types/utils.js'
+
+type CeloBlockExclude =
+  | 'difficulty'
+  | 'gasLimit'
+  | 'mixHash'
+  | 'nonce'
+  | 'uncles'
+
+export type CeloBlockOverrides = {
+  randomness: {
+    committed: Hex
+    revealed: Hex
+  }
+}
+export type CeloBlock<
+  TIncludeTransactions extends boolean = boolean,
+  TBlockTag extends BlockTag = BlockTag,
+> = NeverBy<
+  Block<
+    bigint,
+    TIncludeTransactions,
+    TBlockTag,
+    CeloTransaction<TBlockTag extends 'pending' ? true : false>
+  >,
+  CeloBlockExclude
+> &
+  CeloBlockOverrides
+
+export type CeloRpcBlockOverrides = {
+  randomness: {
+    committed: Hex
+    revealed: Hex
+  }
+}
+export type CeloRpcBlock<
+  TBlockTag extends BlockTag = BlockTag,
+  TIncludeTransactions extends boolean = boolean,
+> = NeverBy<
+  RpcBlock<
+    TBlockTag,
+    TIncludeTransactions,
+    RpcTransaction<TBlockTag extends 'pending' ? true : false>
+  >,
+  CeloBlockExclude
+> &
+  CeloRpcBlockOverrides
+
+export type CeloRpcTransaction<TPending extends boolean = boolean> =
+  | RpcTransaction<TPending>
+  | RpcTransactionCIP42<TPending>
+  | RpcTransactionCIP64<TPending>
+
+export type CeloRpcTransactionRequest =
+  | RpcTransactionRequest
+  | RpcTransactionRequestCIP42
+  | RpcTransactionRequestCIP64
+
+export type CeloTransaction<TPending extends boolean = boolean> =
+  | Transaction<TPending>
+  | TransactionCIP42<TPending>
+  | TransactionCIP64<TPending>
+
+export type CeloTransactionRequest =
+  | TransactionRequest
+  | TransactionRequestCIP42
+  | TransactionRequestCIP64
+
+export type CeloTransactionSerializable = OneOf<
+  | TransactionSerializable
+  | TransactionSerializableCIP42
+  | TransactionSerializableCIP64
+>
+
+export type CeloTransactionSerialized<
+  TType extends CeloTransactionType = CeloTransactionType,
+> =
+  | TransactionSerialized<TType>
+  | TransactionSerializedCIP42
+  | TransactionSerializedCIP64
+
+export type CeloTransactionType = TransactionType | 'cip42' | 'cip64'
+
+type RpcTransaction<TPending extends boolean = boolean> =
+  RpcTransaction_<TPending> & {
+    feeCurrency: Address | null
+    gatewayFee: Hex | null
+    gatewayFeeRecipient: Address | null
+  }
+
+type RpcTransactionRequest = RpcTransactionRequest_ & {
+  feeCurrency?: Address | undefined
+  gatewayFee?: Hex | undefined
+  gatewayFeeRecipient?: Address | undefined
+}
+
+export type RpcTransactionCIP42<TPending extends boolean = boolean> = Omit<
+  TransactionBase<Quantity, Index, TPending>,
+  'typeHex'
+> &
+  FeeValuesEIP1559<Quantity> & {
+    feeCurrency: Address | null
+    gatewayFee: Hex | null
+    gatewayFeeRecipient: Address | null
+    type: '0x7c'
+  }
+
+export type RpcTransactionCIP64<TPending extends boolean = boolean> = Omit<
+  TransactionBase<Quantity, Index, TPending>,
+  'typeHex'
+> &
+  FeeValuesEIP1559<Quantity> & {
+    feeCurrency: Address | null
+    gatewayFee?: undefined
+    gatewayFeeRecipient?: undefined
+    type: '0x7b'
+  }
+
+export type RpcTransactionRequestCIP42 = TransactionRequestBase<
+  Quantity,
+  Index
+> &
+  ExactPartial<FeeValuesEIP1559<Quantity>> & {
+    accessList?: AccessList | undefined
+    feeCurrency?: Address | undefined
+    gatewayFee?: Hex | undefined
+    gatewayFeeRecipient?: Address | undefined
+    type?: '0x7c' | undefined
+  }
+
+export type RpcTransactionRequestCIP64 = TransactionRequestBase<
+  Quantity,
+  Index
+> &
+  ExactPartial<FeeValuesEIP1559<Quantity>> & {
+    accessList?: AccessList | undefined
+    feeCurrency?: Address | undefined
+    gatewayFee?: undefined
+    gatewayFeeRecipient?: undefined
+    type?: '0x7b' | undefined
+  }
+
+type Transaction<TPending extends boolean = boolean> = Transaction_<
+  bigint,
+  number,
+  TPending
+> & {
+  feeCurrency: Address | null
+  gatewayFee: bigint | null
+  gatewayFeeRecipient: Address | null
+}
+
+export type TransactionCIP42<TPending extends boolean = boolean> =
+  TransactionBase<bigint, number, TPending> &
+    FeeValuesEIP1559 & {
+      feeCurrency: Address | null
+      gatewayFee: bigint | null
+      gatewayFeeRecipient: Address | null
+      type: 'cip42'
+    }
+
+export type TransactionCIP64<TPending extends boolean = boolean> =
+  TransactionBase<bigint, number, TPending> &
+    FeeValuesEIP1559 & {
+      feeCurrency: Address | null
+      gatewayFee?: undefined
+      gatewayFeeRecipient?: undefined
+      type: 'cip64'
+    }
+
+type TransactionRequest = TransactionRequest_ & {
+  feeCurrency?: Address | undefined
+  gatewayFee?: bigint | undefined
+  gatewayFeeRecipient?: Address | undefined
+}
+
+export type TransactionRequestCIP42 = TransactionRequestBase &
+  ExactPartial<FeeValuesEIP1559> & {
+    accessList?: AccessList | undefined
+    feeCurrency?: Address | undefined
+    gatewayFee?: bigint | undefined
+    gatewayFeeRecipient?: Address | undefined
+    type?: 'cip42' | undefined
+  }
+
+export type TransactionRequestCIP64 = TransactionRequestBase &
+  ExactPartial<FeeValuesEIP1559> & {
+    accessList?: AccessList | undefined
+    feeCurrency?: Address | undefined
+    gatewayFee?: undefined
+    gatewayFeeRecipient?: undefined
+    type?: 'cip64' | undefined
+  }
+
+export type TransactionSerializableCIP42<
+  TQuantity = bigint,
+  TIndex = number,
+> = TransactionSerializableBase<TQuantity, TIndex> &
+  ExactPartial<FeeValuesEIP1559<TQuantity>> & {
+    accessList?: AccessList | undefined
+    feeCurrency?: Address | undefined
+    gatewayFeeRecipient?: Address | undefined
+    gatewayFee?: TQuantity | undefined
+    chainId: number
+    type?: 'cip42' | undefined
+  }
+
+export type TransactionSerializableCIP64<
+  TQuantity = bigint,
+  TIndex = number,
+> = TransactionSerializableBase<TQuantity, TIndex> &
+  ExactPartial<FeeValuesEIP1559<TQuantity>> & {
+    accessList?: AccessList | undefined
+    feeCurrency?: Address | undefined
+    gatewayFee?: undefined
+    gatewayFeeRecipient?: undefined
+    chainId: number
+    type?: 'cip64' | undefined
+  }
+
+export type TransactionSerializedCIP42 = `0x7c${string}`
+export type TransactionSerializedCIP64 = `0x7b${string}`