viem 1.6.3 → 1.6.5

package/dist/types/wallet.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../../src/wallet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,KAAK,kBAAkB,EAAE,MAAM,8BAA8B,CAAA;AAChF,OAAO,EACL,YAAY,EACZ,KAAK,sBAAsB,GAC5B,MAAM,kCAAkC,CAAA;AACzC,OAAO,EACL,cAAc,EACd,KAAK,wBAAwB,GAC9B,MAAM,oCAAoC,CAAA;AAC3C,OAAO,EACL,gBAAgB,EAChB,KAAK,0BAA0B,GAChC,MAAM,sCAAsC,CAAA;AAC7C,OAAO,EACL,kBAAkB,EAClB,KAAK,4BAA4B,GAClC,MAAM,wCAAwC,CAAA;AAC/C,OAAO,EACL,eAAe,EACf,KAAK,yBAAyB,EAC9B,KAAK,yBAAyB,GAC/B,MAAM,qCAAqC,CAAA;AAC5C,OAAO,EACL,WAAW,EACX,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,GAC3B,MAAM,iCAAiC,CAAA;AACxC,OAAO,EACL,aAAa,EACb,KAAK,uBAAuB,EAC5B,KAAK,uBAAuB,GAC7B,MAAM,mCAAmC,CAAA;AAC1C,OAAO,EACL,WAAW,EACX,KAAK,qBAAqB,GAC3B,MAAM,iCAAiC,CAAA;AACxC,OAAO,EACL,UAAU,EACV,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,GAC1B,MAAM,gCAAgC,CAAA"}

package/dist/types/window.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"window.d.ts","sourceRoot":"","sources":["../../src/window.ts"],"names":[],"mappings":"AAAA,OAAO,mBAAmB,CAAA"}

package/src/chains/celo/formatters.ts

@@ -1,85 +0,0 @@
-import { type ChainFormatters } from '../../types/chain.js'
-import type { Hash } from '../../types/misc.js'
-import { hexToBigInt } from '../../utils/encoding/fromHex.js'
-import { numberToHex } from '../../utils/encoding/toHex.js'
-import { defineBlock } from '../../utils/formatters/block.js'
-import {
-  defineTransaction,
-  formatTransaction,
-} from '../../utils/formatters/transaction.js'
-import { defineTransactionReceipt } from '../../utils/formatters/transactionReceipt.js'
-import { defineTransactionRequest } from '../../utils/formatters/transactionRequest.js'
-import type {
-  CeloBlockOverrides,
-  CeloRpcTransaction,
-  CeloRpcTransactionOverrides,
-  CeloRpcTransactionReceiptOverrides,
-  CeloRpcTransactionRequestOverrides,
-  CeloTransaction,
-  CeloTransactionOverrides,
-  CeloTransactionReceiptOverrides,
-  CeloTransactionRequestOverrides,
-} from './types.js'
-
-export const formattersCelo = {
-  block: /*#__PURE__*/ defineBlock({
-    exclude: ['difficulty', 'gasLimit', 'mixHash', 'nonce', 'uncles'],
-    format(
-      args: CeloBlockOverrides & {
-        transactions: Hash[] | CeloRpcTransaction[]
-      },
-    ): CeloBlockOverrides & {
-      transactions: Hash[] | CeloTransaction[]
-    } {
-      const transactions = args.transactions?.map((transaction) => {
-        if (typeof transaction === 'string') return transaction
-        return {
-          ...formatTransaction(transaction),
-          feeCurrency: transaction.feeCurrency,
-          gatewayFee: transaction.gatewayFee
-            ? hexToBigInt(transaction.gatewayFee)
-            : null,
-          gatewayFeeRecipient: transaction.gatewayFeeRecipient,
-        }
-      }) as Hash[] | CeloTransaction[]
-      return {
-        randomness: args.randomness,
-        transactions,
-      }
-    },
-  }),
-  transaction: /*#__PURE__*/ defineTransaction({
-    format(args: CeloRpcTransactionOverrides): CeloTransactionOverrides {
-      return {
-        feeCurrency: args.feeCurrency,
-        gatewayFee: args.gatewayFee ? hexToBigInt(args.gatewayFee) : null,
-        gatewayFeeRecipient: args.gatewayFeeRecipient,
-      }
-    },
-  }),
-  transactionReceipt: /*#__PURE__*/ defineTransactionReceipt({
-    format(
-      args: CeloRpcTransactionReceiptOverrides,
-    ): CeloTransactionReceiptOverrides {
-      return {
-        feeCurrency: args.feeCurrency,
-        gatewayFee: args.gatewayFee ? hexToBigInt(args.gatewayFee) : null,
-        gatewayFeeRecipient: args.gatewayFeeRecipient,
-      }
-    },
-  }),
-  transactionRequest: /*#__PURE__*/ defineTransactionRequest({
-    format(
-      args: CeloTransactionRequestOverrides,
-    ): CeloRpcTransactionRequestOverrides {
-      return {
-        feeCurrency: args.feeCurrency,
-        gatewayFee:
-          typeof args.gatewayFee !== 'undefined'
-            ? numberToHex(args.gatewayFee)
-            : undefined,
-        gatewayFeeRecipient: args.gatewayFeeRecipient,
-      }
-    },
-  }),
-} as const satisfies ChainFormatters

package/src/chains/celo/serializers.ts

@@ -1,190 +0,0 @@
-import type { Address } from 'abitype'
-
-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 { FeeValuesEIP1559 } from '../../types/fee.js'
-import type { Signature } from '../../types/misc.js'
-import type {
-  AccessList,
-  TransactionSerializable,
-  TransactionSerializableBase,
-} from '../../types/transaction.js'
-import { isAddress } from '../../utils/address/isAddress.js'
-import { concatHex } from '../../utils/data/concat.js'
-import { trim } from '../../utils/data/trim.js'
-import { toHex } from '../../utils/encoding/toHex.js'
-import { toRlp } from '../../utils/encoding/toRlp.js'
-import { serializeAccessList } from '../../utils/transaction/serializeAccessList.js'
-import {
-  type SerializeTransactionFn,
-  serializeTransaction,
-} from '../../utils/transaction/serializeTransaction.js'
-
-export const serializeTransactionCelo: SerializeTransactionFn<
-  CeloTransactionSerializable
-> = (tx, signature) => {
-  // Handle CIP-42 transactions
-  if (isCIP42(tx))
-    return serializeTransactionCIP42(
-      tx as TransactionSerializableCIP42,
-      signature,
-    )
-
-  // Handle other transaction types
-  return serializeTransaction(tx as TransactionSerializable, signature)
-}
-
-export const serializersCelo = {
-  transaction: serializeTransactionCelo,
-} as const satisfies ChainSerializers
-
-//////////////////////////////////////////////////////////////////////////////
-// Types
-
-export type TransactionSerializableCIP42<
-  TQuantity = bigint,
-  TIndex = number,
-> = TransactionSerializableBase<TQuantity, TIndex> &
-  FeeValuesEIP1559<TQuantity> & {
-    accessList?: AccessList
-    gasPrice?: never
-    feeCurrency?: Address
-    gatewayFeeRecipient?: Address
-    gatewayFee?: TQuantity
-    chainId: number
-    type?: 'cip42'
-  }
-
-export type CeloTransactionSerializable =
-  | TransactionSerializableCIP42
-  | TransactionSerializable
-
-export type SerializedCIP42TransactionReturnType = `0x7c${string}`
-
-//////////////////////////////////////////////////////////////////////////////
-// Serializers
-
-// 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,
-): SerializedCIP42TransactionReturnType {
-  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),
-  ]
-
-  if (signature) {
-    serializedTransaction.push(
-      signature.v === 27n ? '0x' : toHex(1), // yParity
-      trim(signature.r),
-      trim(signature.s),
-    )
-  }
-
-  return concatHex([
-    '0x7c',
-    toRlp(serializedTransaction),
-  ]) as SerializedCIP42TransactionReturnType
-}
-
-//////////////////////////////////////////////////////////////////////////////
-// Utilities
-
-// process as CIP42 if any of these fields are present. realistically gatewayfee is not used but is part of spec
-function isCIP42(transaction: CeloTransactionSerializable) {
-  if (
-    'maxFeePerGas' in transaction &&
-    'maxPriorityFeePerGas' in transaction &&
-    ('feeCurrency' in transaction ||
-      'gatewayFee' in transaction ||
-      'gatewayFeeRecipient' in transaction)
-  )
-    return true
-  return false
-}
-
-// maxFeePerGas must be less than 2^256 - 1: however writing like that caused exceptions to be raised
-const MAX_MAX_FEE_PER_GAS =
-  115792089237316195423570985008687907853269984665640564039457584007913129639935n
-
-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 (maxFeePerGas && maxFeePerGas > MAX_MAX_FEE_PER_GAS)
-    throw new FeeCapTooHighError({ maxFeePerGas })
-
-  if (
-    maxPriorityFeePerGas &&
-    maxFeePerGas &&
-    maxPriorityFeePerGas > maxFeePerGas
-  )
-    throw new TipAboveFeeCapError({ maxFeePerGas, maxPriorityFeePerGas })
-
-  if (
-    (gatewayFee && !gatewayFeeRecipient) ||
-    (gatewayFeeRecipient && !gatewayFee)
-  ) {
-    throw new BaseError(
-      '`gatewayFee` and `gatewayFeeRecipient` must be provided together.',
-    )
-  }
-
-  if (feeCurrency && !feeCurrency?.startsWith('0x')) {
-    throw new BaseError(
-      '`feeCurrency` MUST be a token address for CIP-42 transactions.',
-    )
-  }
-
-  if (!feeCurrency && !gatewayFeeRecipient) {
-    throw new BaseError(
-      'Either `feeCurrency` or `gatewayFeeRecipient` must be provided for CIP-42 transactions.',
-    )
-  }
-}

package/src/chains/celo/types.ts

@@ -1,111 +0,0 @@
-import type { Address } from 'abitype'
-
-import type { Block, BlockTag } from '../../types/block.js'
-import type { Hex } from '../../types/misc.js'
-import type {
-  RpcBlock,
-  RpcTransaction,
-  RpcTransactionReceipt,
-  RpcTransactionRequest,
-} from '../../types/rpc.js'
-import type {
-  Transaction,
-  TransactionReceipt,
-  TransactionRequest,
-} from '../../types/transaction.js'
-import type { NeverBy } from '../../types/utils.js'
-import type { OptimismRpcTransaction } from '../optimism/types.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,
-    OptimismRpcTransaction<TBlockTag extends 'pending' ? true : false>
-  >,
-  CeloBlockExclude
-> &
-  CeloRpcBlockOverrides
-
-export type CeloRpcTransactionOverrides = {
-  feeCurrency: Address | null
-  gatewayFee: Hex | null
-  gatewayFeeRecipient: Address | null
-}
-export type CeloRpcTransaction<TPending extends boolean = boolean> =
-  RpcTransaction<TPending> & CeloRpcTransactionOverrides
-
-export type CeloRpcTransactionReceiptOverrides = {
-  feeCurrency: Address | null
-  gatewayFee: Hex | null
-  gatewayFeeRecipient: Address | null
-}
-export type CeloRpcTransactionReceipt = RpcTransactionReceipt &
-  CeloRpcTransactionReceiptOverrides
-
-export type CeloRpcTransactionRequestOverrides = {
-  feeCurrency?: Address
-  gatewayFee?: Hex
-  gatewayFeeRecipient?: Address
-}
-export type CeloRpcTransactionRequest = RpcTransactionRequest &
-  CeloRpcTransactionRequestOverrides
-
-export type CeloTransactionOverrides = {
-  feeCurrency: Address | null
-  gatewayFee: bigint | null
-  gatewayFeeRecipient: Address | null
-}
-export type CeloTransaction<TPending extends boolean = boolean> =
-  Transaction<TPending> & CeloTransactionOverrides
-
-export type CeloTransactionReceiptOverrides = {
-  feeCurrency: Address | null
-  gatewayFee: bigint | null
-  gatewayFeeRecipient: Address | null
-}
-export type CeloTransactionReceipt = TransactionReceipt &
-  CeloTransactionReceiptOverrides
-
-export type CeloTransactionRequestOverrides = {
-  feeCurrency?: Address
-  gatewayFee?: bigint
-  gatewayFeeRecipient?: Address
-}
-export type CeloTransactionRequest = TransactionRequest &
-  CeloTransactionRequestOverrides

package/src/chains/optimism/fees.ts

@@ -1,5 +0,0 @@
-import type { ChainFees } from '../../types/chain.js'
-
-export const feesOptimism = {
-  defaultPriorityFee: 1_000_000n, // 0.001 gwei
-} as const satisfies ChainFees

package/src/chains/optimism/formatters.ts

@@ -1,74 +0,0 @@
-import { type ChainFormatters } from '../../types/chain.js'
-import type { Hash } from '../../types/misc.js'
-import { type RpcTransaction } from '../../types/rpc.js'
-import { hexToBigInt } from '../../utils/encoding/fromHex.js'
-import { defineBlock } from '../../utils/formatters/block.js'
-import {
-  defineTransaction,
-  formatTransaction,
-} from '../../utils/formatters/transaction.js'
-import { defineTransactionReceipt } from '../../utils/formatters/transactionReceipt.js'
-import type {
-  OptimismBlockOverrides,
-  OptimismRpcBlockOverrides,
-  OptimismRpcTransaction,
-  OptimismRpcTransactionReceiptOverrides,
-  OptimismTransaction,
-  OptimismTransactionReceiptOverrides,
-} from './types.js'
-
-export const formattersOptimism = {
-  block: /*#__PURE__*/ defineBlock({
-    format(
-      args: OptimismRpcBlockOverrides & {
-        transactions: Hash[] | OptimismRpcTransaction[]
-      },
-    ): OptimismBlockOverrides & {
-      transactions: Hash[] | OptimismTransaction[]
-    } {
-      const transactions = args.transactions?.map((transaction) => {
-        if (typeof transaction === 'string') return transaction
-        const formatted = formatTransaction(
-          transaction as RpcTransaction,
-        ) as OptimismTransaction
-        if (formatted.typeHex === '0x7e') {
-          formatted.isSystemTx = transaction.isSystemTx
-          formatted.mint = transaction.mint
-            ? hexToBigInt(transaction.mint)
-            : undefined
-          formatted.sourceHash = transaction.sourceHash
-          formatted.type = 'deposit'
-        }
-        return formatted
-      }) as Hash[] | OptimismTransaction[]
-      return {
-        transactions,
-        stateRoot: args.stateRoot,
-      }
-    },
-  }),
-  transaction: /*#__PURE__*/ defineTransaction({
-    format(args: OptimismRpcTransaction): OptimismTransaction {
-      const transaction = {} as OptimismTransaction
-      if (args.type === '0x7e') {
-        transaction.isSystemTx = args.isSystemTx
-        transaction.mint = args.mint ? hexToBigInt(args.mint) : undefined
-        transaction.sourceHash = args.sourceHash
-        transaction.type = 'deposit'
-      }
-      return transaction
-    },
-  }),
-  transactionReceipt: /*#__PURE__*/ defineTransactionReceipt({
-    format(
-      args: OptimismRpcTransactionReceiptOverrides,
-    ): OptimismTransactionReceiptOverrides {
-      return {
-        l1GasPrice: args.l1GasPrice ? hexToBigInt(args.l1GasPrice) : null,
-        l1GasUsed: args.l1GasUsed ? hexToBigInt(args.l1GasUsed) : null,
-        l1Fee: args.l1Fee ? hexToBigInt(args.l1Fee) : null,
-        l1FeeScalar: args.l1FeeScalar ? Number(args.l1FeeScalar) : null,
-      }
-    },
-  }),
-} as const satisfies ChainFormatters

package/src/chains/optimism/types.ts

@@ -1,102 +0,0 @@
-import type { Block, BlockTag } from '../../types/block.js'
-import type { FeeValuesEIP1559 } from '../../types/fee.js'
-import type { Hash, Hex } from '../../types/misc.js'
-import type {
-  Index,
-  Quantity,
-  RpcBlock,
-  RpcTransaction as RpcTransaction_,
-  RpcTransactionReceipt,
-} from '../../types/rpc.js'
-import type {
-  Transaction as Transaction_,
-  TransactionBase,
-  TransactionReceipt,
-} from '../../types/transaction.js'
-
-export type OptimismBlockOverrides = {
-  stateRoot: Hash
-}
-export type OptimismBlock<
-  TIncludeTransactions extends boolean = boolean,
-  TBlockTag extends BlockTag = BlockTag,
-> = Block<
-  bigint,
-  TIncludeTransactions,
-  TBlockTag,
-  OptimismTransaction<TBlockTag extends 'pending' ? true : false>
-> &
-  OptimismBlockOverrides
-
-export type OptimismRpcBlockOverrides = {
-  stateRoot: Hash
-}
-export type OptimismRpcBlock<
-  TBlockTag extends BlockTag = BlockTag,
-  TIncludeTransactions extends boolean = boolean,
-> = RpcBlock<
-  TBlockTag,
-  TIncludeTransactions,
-  OptimismRpcTransaction<TBlockTag extends 'pending' ? true : false>
-> &
-  OptimismRpcBlockOverrides
-
-type RpcTransaction<TPending extends boolean = boolean> =
-  RpcTransaction_<TPending> & {
-    isSystemTx?: undefined
-    mint?: undefined
-    sourceHash?: undefined
-  }
-
-export type OptimismRpcDepositTransaction<TPending extends boolean = boolean> =
-  Omit<TransactionBase<Quantity, Index, TPending>, 'typeHex'> &
-    FeeValuesEIP1559<Quantity> & {
-      isSystemTx?: boolean
-      mint?: Hex
-      sourceHash: Hex
-      type: '0x7e'
-    }
-export type OptimismRpcTransaction<TPending extends boolean = boolean> =
-  | RpcTransaction<TPending>
-  | OptimismRpcDepositTransaction<TPending>
-
-export type OptimismRpcTransactionReceiptOverrides = {
-  l1GasPrice: Hex | null
-  l1GasUsed: Hex | null
-  l1Fee: Hex | null
-  l1FeeScalar: `${number}` | null
-}
-export type OptimismRpcTransactionReceipt = RpcTransactionReceipt &
-  OptimismRpcTransactionReceiptOverrides
-
-type Transaction<TPending extends boolean = boolean> = Transaction_<
-  bigint,
-  number,
-  TPending
-> & {
-  isSystemTx?: undefined
-  mint?: undefined
-  sourceHash?: undefined
-}
-
-export type OptimismDepositTransaction<TPending extends boolean = boolean> =
-  TransactionBase<bigint, number, TPending> &
-    FeeValuesEIP1559 & {
-      isSystemTx?: boolean
-      mint?: bigint
-      sourceHash: Hex
-      type: 'deposit'
-    }
-
-export type OptimismTransaction<TPending extends boolean = boolean> =
-  | Transaction<TPending>
-  | OptimismDepositTransaction<TPending>
-
-export type OptimismTransactionReceiptOverrides = {
-  l1GasPrice: bigint | null
-  l1GasUsed: bigint | null
-  l1Fee: bigint | null
-  l1FeeScalar: number | null
-}
-export type OptimismTransactionReceipt = TransactionReceipt &
-  OptimismTransactionReceiptOverrides

package/src/utils/formatters/formatter.ts

@@ -1,37 +0,0 @@
-import type { Assign, Prettify } from '../../types/utils.js'
-
-export function defineFormatter<TType extends string, TParameters, TReturnType>(
-  type: TType,
-  format: (_: TParameters) => TReturnType,
-) {
-  return <
-    TOverrideParameters,
-    TOverrideReturnType,
-    TExclude extends (keyof TParameters)[] = [],
-  >({
-    exclude,
-    format: overrides,
-  }: {
-    exclude?: TExclude
-    format: (_: TOverrideParameters) => TOverrideReturnType
-  }) => {
-    return {
-      exclude,
-      format: (args: Assign<TParameters, TOverrideParameters>) => {
-        const formatted = format(args as any)
-        if (exclude) {
-          for (const key of exclude) {
-            delete (formatted as any)[key]
-          }
-        }
-        return {
-          ...formatted,
-          ...overrides(args),
-        } as Prettify<Assign<TReturnType, TOverrideReturnType>> & {
-          [K in TExclude[number]]: never
-        }
-      },
-      type,
-    }
-  }
-}