viem 0.0.1-cjs.10 → 0.0.1-sushi.26

package/src/types/fee.ts

@@ -0,0 +1,47 @@
+import type { Address, Hex } from './misc'
+
+export type EstimateGasParameters<TQuantity = bigint> = {
+  /** Contract code or a hashed method call with encoded args */
+  data?: Hex
+  /** Gas provided for transaction execution */
+  gas?: TQuantity
+  /** Transaction sender */
+  from?: Address
+  /** Transaction recipient */
+  to?: Address
+  /** Value in wei sent with this transaction */
+  value?: TQuantity
+} & Partial<FeeValues<TQuantity>>
+
+export type FeeHistory<TQuantity = bigint> = {
+  /**
+   * An array of block base fees per gas (in wei). This includes the next block after
+   * the newest of the returned range, because this value can be derived from the newest block.
+   * Zeroes are returned for pre-EIP-1559 blocks. */
+  baseFeePerGas: TQuantity[]
+  /** An array of block gas used ratios. These are calculated as the ratio of gasUsed and gasLimit. */
+  gasUsedRatio: number[]
+  /** Lowest number block of the returned range. */
+  oldestBlock: TQuantity
+  /** An array of effective priority fees (in wei) per gas data points from a single block. All zeroes are returned if the block is empty. */
+  reward?: TQuantity[][]
+}
+
+export type FeeValuesLegacy<TQuantity = bigint> = {
+  /** Base fee per gas. */
+  gasPrice: TQuantity
+  maxFeePerGas?: never
+  maxPriorityFeePerGas?: never
+}
+
+export type FeeValuesEIP1559<TQuantity = bigint> = {
+  gasPrice?: never
+  /** Total fee per gas in wei (gasPrice/baseFeePerGas + maxPriorityFeePerGas). */
+  maxFeePerGas: TQuantity
+  /** Max priority fee per gas (in wei). */
+  maxPriorityFeePerGas: TQuantity
+}
+
+export type FeeValues<TQuantity = bigint> =
+  | FeeValuesLegacy<TQuantity>
+  | FeeValuesEIP1559<TQuantity>

package/src/types/filter.ts

@@ -0,0 +1,8 @@
+import type { Hex } from './misc'
+
+export type FilterType = 'transaction' | 'block' | 'event'
+
+export type Filter<TFilterType extends FilterType = 'event'> = {
+  id: Hex
+  type: TFilterType
+}

package/src/types/formatter.ts

@@ -0,0 +1,23 @@
+import { Block } from './block'
+import {
+  RpcBlock,
+  RpcTransaction,
+  RpcTransactionReceipt,
+  RpcTransactionRequest,
+} from './rpc'
+import {
+  Transaction,
+  TransactionReceipt,
+  TransactionRequest,
+} from './transaction'
+
+export type Formatter<TSource = any, TTarget = any> = (
+  value: TSource & { [key: string]: unknown },
+) => TTarget
+
+export type Formatters = {
+  block?: Formatter<RpcBlock, Block>
+  transaction?: Formatter<RpcTransaction, Transaction>
+  transactionReceipt?: Formatter<RpcTransactionReceipt, TransactionReceipt>
+  transactionRequest?: Formatter<TransactionRequest, RpcTransactionRequest>
+}

package/src/types/index.ts

@@ -0,0 +1,84 @@
+export type {
+  Block,
+  BlockIdentifier,
+  BlockNumber,
+  BlockTag,
+  Uncle,
+} from './block'
+
+export type { Chain } from './chain'
+
+export type {
+  AbiItem,
+  AbiEventParametersToPrimitiveTypes,
+  ContractConfig,
+  EventDefinition,
+  ExtractArgsFromAbi,
+  ExtractArgsFromEventDefinition,
+  ExtractConstructorArgsFromAbi,
+  ExtractErrorArgsFromAbi,
+  ExtractErrorNameFromAbi,
+  ExtractEventArgsFromAbi,
+  ExtractEventArgsFromTopics,
+  ExtractEventNameFromAbi,
+  ExtractFunctionNameFromAbi,
+  ExtractNameFromAbi,
+  ExtractResultFromAbi,
+  GetValue,
+} from './contract'
+
+export type {
+  EstimateGasParameters,
+  FeeHistory,
+  FeeValues,
+  FeeValuesEIP1559,
+  FeeValuesLegacy,
+} from './fee'
+
+export type { Filter, FilterType } from './filter'
+
+export type { Formatter, Formatters } from './formatter'
+
+export type { Log } from './log'
+
+export type { Address, ByteArray, Hex, Hash, LogTopic } from './misc'
+
+export type { MulticallContracts } from './multicall'
+
+export type {
+  Index,
+  Quantity,
+  RpcBlock,
+  RpcBlockIdentifier,
+  RpcBlockNumber,
+  RpcEstimateGasParameters,
+  RpcFeeHistory,
+  RpcFeeValues,
+  RpcLog,
+  RpcTransactionReceipt,
+  RpcTransactionRequest,
+  RpcTransaction,
+  RpcUncle,
+} from './rpc'
+
+export type {
+  AccessList,
+  TransactionReceipt,
+  TransactionRequest,
+  TransactionRequestBase,
+  TransactionRequestEIP1559,
+  TransactionRequestEIP2930,
+  TransactionRequestLegacy,
+  Transaction,
+  TransactionBase,
+  TransactionEIP1559,
+  TransactionEIP2930,
+  TransactionLegacy,
+} from './transaction'
+
+export type {
+  PartialBy,
+  Prettify,
+  MergeIntersectionProperties,
+  OptionalNullable,
+} from './utils'

package/src/types/log.ts

@@ -0,0 +1,22 @@
+import type { Address, Hash, Hex } from './misc'
+
+export type Log<TQuantity = bigint, TIndex = number> = {
+  /** The address from which this log originated */
+  address: Address
+  /** Hash of block containing this log or `null` if pending */
+  blockHash: Hash | null
+  /** Number of block containing this log or `null` if pending */
+  blockNumber: TQuantity | null
+  /** Contains the non-indexed arguments of the log */
+  data: Hex
+  /** Index of this log within its block or `null` if pending */
+  logIndex: TIndex | null
+  /** Hash of the transaction that created this log or `null` if pending */
+  transactionHash: Hash | null
+  /** Index of the transaction that created this log or `null` if pending */
+  transactionIndex: TIndex | null
+  /** List of order-dependent topics */
+  topics: Hex[]
+  /** `true` if this filter has been destroyed and is invalid */
+  removed: boolean
+}

package/src/types/misc.ts

@@ -0,0 +1,5 @@
+export type Address = `0x${string}`
+export type ByteArray = Uint8Array
+export type Hex = `0x${string}`
+export type Hash = `0x${string}`
+export type LogTopic = Hex | Hex[] | null

package/src/types/multicall.ts

@@ -0,0 +1,82 @@
+import { Abi } from 'abitype';
+import { ContractConfig, ExtractResultFromAbi } from './contract';
+
+type MAXIMUM_DEPTH = 20
+
+export type Contract<
+  TAbi extends Abi | readonly unknown[] = Abi | readonly unknown[],
+  TFunctionName extends string = string,
+> = { abi: TAbi; functionName: TFunctionName }
+
+export type MulticallContracts<
+  TContracts extends Contract[],
+  TProperties extends Record<string, any> = object,
+  Result extends any[] = [],
+  Depth extends ReadonlyArray<number> = [],
+> = Depth['length'] extends MAXIMUM_DEPTH
+  ? (ContractConfig & TProperties)[]
+  : TContracts extends []
+  ? []
+  : TContracts extends [infer Head extends Contract]
+  ? [
+      ...Result,
+      ContractConfig<Head['abi'], Head['functionName']> &
+        TProperties,
+    ]
+  : TContracts extends [
+      infer Head extends Contract,
+      ...infer Tail extends Contract[],
+    ]
+  ? MulticallContracts<
+      [...Tail],
+      TProperties,
+      [
+        ...Result,
+        ContractConfig<Head['abi'], Head['functionName']> &
+          TProperties,
+      ],
+      [...Depth, 1]
+    >
+  : unknown[] extends TContracts
+  ? TContracts
+  : // If `TContracts` is *some* array but we couldn't assign `unknown[]` to it, then it must hold some known/homogenous type!
+  // use this to infer the param types in the case of Array.map() argument
+  TContracts extends ContractConfig<infer TAbi, infer TFunctionName>[]
+  ? (ContractConfig<TAbi, TFunctionName> & TProperties)[]
+  : (ContractConfig & TProperties)[]
+
+
+export type MulticallResult<Result, TAllowFailure extends boolean = true> = TAllowFailure extends true ? ({
+  error?: undefined
+  result: Result
+  status: 'success'
+} | {
+  error: Error
+  result?: undefined
+  status: 'error'
+}) : Result
+
+export type MulticallResults<
+  TContracts extends Contract[],
+  TAllowFailure extends boolean = true,
+  Result extends any[] = [],
+  Depth extends ReadonlyArray<number> = [],
+> = Depth['length'] extends MAXIMUM_DEPTH
+  ? MulticallResult<ExtractResultFromAbi, TAllowFailure>[]
+  : TContracts extends []
+  ? []
+  : TContracts extends [infer Head extends Contract]
+  ? [...Result, MulticallResult<ExtractResultFromAbi<Head['abi'], Head['functionName']>, TAllowFailure>]
+  : TContracts extends [
+      infer Head extends Contract,
+      ...infer Tail extends Contract[],
+    ]
+  ? MulticallResults<
+      [...Tail],
+      TAllowFailure,
+      [...Result, MulticallResult<ExtractResultFromAbi<Head['abi'], Head['functionName']>, TAllowFailure>],
+      [...Depth, 1]
+    >
+  : TContracts extends ContractConfig<infer TAbi, infer TFunctionName>[]
+  ? MulticallResult<ExtractResultFromAbi<TAbi, TFunctionName>, TAllowFailure>[]
+  : MulticallResult<ExtractResultFromAbi, TAllowFailure>[]

package/src/types/rpc.ts

@@ -0,0 +1,35 @@
+import type { Block, BlockIdentifier, BlockNumber, Uncle } from './block'
+import type { EstimateGasParameters, FeeHistory, FeeValues } from './fee'
+import type { Log } from './log'
+import type {
+  TransactionEIP1559,
+  TransactionEIP2930,
+  TransactionLegacy,
+  TransactionReceipt,
+  TransactionRequest,
+} from './transaction'
+
+export type Index = `0x${string}`
+export type Quantity = `0x${string}`
+export type Status = '0x0' | '0x1'
+export type TransactionType = '0x0' | '0x1' | '0x2'
+
+export type RpcBlock = Block<Quantity, RpcTransaction>
+export type RpcBlockNumber = BlockNumber<Quantity>
+export type RpcBlockIdentifier = BlockIdentifier<Quantity>
+export type RpcEstimateGasParameters = EstimateGasParameters<Quantity>
+export type RpcUncle = Uncle<Quantity>
+export type RpcFeeHistory = FeeHistory<Quantity>
+export type RpcFeeValues = FeeValues<Quantity>
+export type RpcLog = Log<Quantity, Index>
+export type RpcTransactionReceipt = TransactionReceipt<
+  Quantity,
+  Index,
+  Status,
+  TransactionType
+>
+export type RpcTransactionRequest = TransactionRequest<Quantity, Index>
+export type RpcTransaction =
+  | TransactionLegacy<Quantity, Index, '0x0'>
+  | TransactionEIP2930<Quantity, Index, '0x1'>
+  | TransactionEIP1559<Quantity, Index, '0x2'>

package/src/types/transaction.ts

@@ -0,0 +1,145 @@
+import { transactionType } from '../utils'
+import type { FeeValuesEIP1559, FeeValuesLegacy } from './fee'
+import type { Log } from './log'
+import type { Address, Hash, Hex } from './misc'
+import type { ValueOf } from './utils'
+
+export type AccessList = Array<{ address: Address; storageKeys: Array<Hex> }>
+
+export type TransactionType = ValueOf<typeof transactionType>
+
+export type TransactionReceipt<
+  TQuantity = bigint,
+  TIndex = number,
+  TStatus = 'success' | 'reverted',
+  TType = TransactionType,
+> = {
+  /** Hash of block containing this transaction */
+  blockHash: Hash
+  /** Number of block containing this transaction */
+  blockNumber: TQuantity
+  /** Address of new contract or `null` if no contract was created */
+  contractAddress: Address | null
+  /** Gas used by this and all preceding transactions in this block */
+  cumulativeGasUsed: TQuantity
+  /** Pre-London, it is equal to the transaction's gasPrice. Post-London, it is equal to the actual gas price paid for inclusion. */
+  effectiveGasPrice: TQuantity
+  /** Transaction sender */
+  from: Address
+  /** Gas used by this transaction */
+  gasUsed: TQuantity
+  /** List of log objects generated by this transaction */
+  logs: Log<TQuantity, TIndex>[]
+  /** Logs bloom filter */
+  logsBloom: Hex
+  /** `1` if this transaction was successful or `0` if it failed */
+  status: TStatus
+  /** Transaction recipient or `null` if deploying a contract */
+  to: Address | null
+  /** Hash of this transaction */
+  transactionHash: Hash
+  /** Index of this transaction in the block */
+  transactionIndex: TIndex
+  /** Transaction type */
+  type: TType
+}
+
+export type TransactionBase<TQuantity = bigint, TIndex = number> = {
+  /** Hash of block containing this transaction or `null` if pending */
+  blockHash: Hash | null
+  /** Number of block containing this transaction or `null` if pending */
+  blockNumber: TQuantity | null
+  /** Transaction sender */
+  from: Address
+  /** Gas provided for transaction execution */
+  gas: TQuantity
+  /** Hash of this transaction */
+  hash: Hash
+  /** Contract code or a hashed method call */
+  input: Hex
+  /** Unique number identifying this transaction */
+  nonce: TIndex
+  /** ECDSA signature r */
+  r: Hex
+  /** ECDSA signature s */
+  s: Hex
+  /** Transaction recipient or `null` if deploying a contract */
+  to: Address | null
+  /** Index of this transaction in the block or `null` if pending */
+  transactionIndex: TIndex | null
+  /** ECDSA recovery ID */
+  v: TQuantity
+  /** Value in wei sent with this transaction */
+  value: TQuantity
+}
+export type TransactionLegacy<
+  TQuantity = bigint,
+  TIndex = number,
+  TType = 'legacy',
+> = TransactionBase<TQuantity, TIndex> &
+  FeeValuesLegacy<TQuantity> & {
+    accessList?: never
+    type: TType
+  }
+export type TransactionEIP2930<
+  TQuantity = bigint,
+  TIndex = number,
+  TType = 'eip2930',
+> = TransactionBase<TQuantity, TIndex> &
+  FeeValuesLegacy<TQuantity> & {
+    accessList: AccessList
+    type: TType
+  }
+export type TransactionEIP1559<
+  TQuantity = bigint,
+  TIndex = number,
+  TType = 'eip1559',
+> = TransactionBase<TQuantity, TIndex> &
+  FeeValuesEIP1559<TQuantity> & {
+    accessList: AccessList
+    type: TType
+  }
+export type Transaction<TQuantity = bigint, TIndex = number> =
+  | TransactionLegacy<TQuantity, TIndex>
+  | TransactionEIP2930<TQuantity, TIndex>
+  | TransactionEIP1559<TQuantity, TIndex>
+
+export type TransactionRequestBase<TQuantity = bigint, TIndex = number> = {
+  /** Contract code or a hashed method call with encoded args */
+  data?: Hex
+  /** Transaction sender */
+  from: Address
+  /** Gas provided for transaction execution */
+  gas?: TQuantity
+  /** Unique number identifying this transaction */
+  nonce?: TIndex
+  /** Transaction recipient */
+  to?: Address
+  /** Value in wei sent with this transaction */
+  value?: TQuantity
+}
+export type TransactionRequestLegacy<
+  TQuantity = bigint,
+  TIndex = number,
+> = TransactionRequestBase<TQuantity, TIndex> &
+  Partial<FeeValuesLegacy<TQuantity>> & {
+    accessList?: never
+  }
+export type TransactionRequestEIP2930<
+  TQuantity = bigint,
+  TIndex = number,
+> = TransactionRequestBase<TQuantity, TIndex> &
+  Partial<FeeValuesLegacy<TQuantity>> & {
+    accessList?: AccessList
+  }
+export type TransactionRequestEIP1559<
+  TQuantity = bigint,
+  TIndex = number,
+> = TransactionRequestBase<TQuantity, TIndex> &
+  Partial<FeeValuesEIP1559<TQuantity>> & {
+    accessList?: AccessList
+  }
+export type TransactionRequest<TQuantity = bigint, TIndex = number> =
+  | TransactionRequestLegacy<TQuantity, TIndex>
+  | TransactionRequestEIP2930<TQuantity, TIndex>
+  | TransactionRequestEIP1559<TQuantity, TIndex>

package/src/types/utils.ts

@@ -0,0 +1,88 @@
+export type MaybePromise<T> = T | Promise<T>
+
+/**
+ * @description Merges the intersection properties of T and U.
+ *
+ * @example
+ * MergeIntersectionProperties<{ a: string, b: number }, { a: number, c: boolean }>
+ * => { a: number, b: number }
+ */
+export type MergeIntersectionProperties<T, U> = {
+  [K in
+    keyof T as K extends keyof U
+      ? U[K] extends void
+        ? never
+        : K
+      : K]: K extends keyof U ? U[K] : T[K]
+}
+
+/**
+ * @description Makes nullable properties from T optional.
+ *
+ * @example
+ * OptionalNullable<{ a: string | undefined, c: number }>
+ * => { a?: string | undefined, c: number }
+ */
+export type OptionalNullable<T> = {
+  [K in keyof T as T[K] extends NonNullable<unknown> ? K : never]: T[K]
+} & {
+  [K in keyof T as T[K] extends NonNullable<unknown> ? never : K]?: T[K]
+}
+
+/**
+ * @description Constructs a type by excluding `undefined` from `T`.
+ *
+ * @example
+ * NoUndefined<string | undefined>
+ * => string
+ */
+export type NoUndefined<T> = T extends undefined ? never : T
+
+/**
+ * @description Creates a type that is a partial of T, but with the required keys K.
+ *
+ * @example
+ * PartialBy<{ a: string, b: number }, 'a'>
+ * => { a?: string, b: number }
+ */
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>
+
+/**
+ * @description Combines members of an intersection into a readable type.
+ *
+ * @link https://twitter.com/mattpocockuk/status/1622730173446557697?s=20&t=NdpAcmEFXY01xkqU3KO0Mg
+ * @example
+ * Prettify<{ a: string } | { b: string } | { c: number, d: bigint }>
+ * => { a: string, b: string, c: number, d: bigint }
+ */
+export type Prettify<T> = {
+  [K in keyof T]: T[K]
+} & {}
+
+type TrimLeft<T, Chars extends string = ' '> = T extends `${Chars}${infer R}`
+  ? TrimLeft<R>
+  : T
+type TrimRight<T, Chars extends string = ' '> = T extends `${infer R}${Chars}`
+  ? TrimRight<R>
+  : T
+
+/**
+ * @description Trims empty space from type T.
+ *
+ * @example
+ * Trim<'      lol  '>
+ * => 'lol'
+ */
+export type Trim<T, Chars extends string = ' '> = TrimLeft<
+  TrimRight<T, Chars>,
+  Chars
+>
+
+/**
+ * @description Creates a type that extracts the values of T.
+ *
+ * @example
+ * ValueOf<{ a: string, b: number }>
+ * => string | number
+ */
+export type ValueOf<T> = T[keyof T]

package/src/types/window.ts

@@ -0,0 +1,9 @@
+import type { Events, Requests } from './eip1193'
+
+type WindowProvider = Requests & Events
+
+declare global {
+  interface Window {
+    ethereum?: WindowProvider
+  }
+}

package/src/utils/abi/decodeAbi.bench.ts

@@ -0,0 +1,135 @@
+import { AbiCoder } from 'ethers/lib/utils'
+import { bench, describe } from 'vitest'
+
+import { decodeAbi } from './decodeAbi'
+
+describe('ABI Decode (static struct)', () => {
+  bench('viem: `decodeAbi`', () => {
+    decodeAbi({
+      data: '0x00000000000000000000000000000000000000000000000000000000000001a40000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac00000000000000000000000000000000000000000000000000000000000000450000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c961145a54c96e3ae9baa048c4f4d6b04c13916b00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002',
+      params: [
+        {
+          components: [
+            {
+              components: [
+                {
+                  internalType: 'uint256',
+                  name: 'x',
+                  type: 'uint256',
+                },
+                {
+                  internalType: 'bool',
+                  name: 'y',
+                  type: 'bool',
+                },
+                {
+                  internalType: 'address',
+                  name: 'z',
+                  type: 'address',
+                },
+              ],
+              internalType: 'struct ABIExample.Foo',
+              name: 'foo',
+              type: 'tuple',
+            },
+            {
+              components: [
+                {
+                  internalType: 'uint256',
+                  name: 'x',
+                  type: 'uint256',
+                },
+                {
+                  internalType: 'bool',
+                  name: 'y',
+                  type: 'bool',
+                },
+                {
+                  internalType: 'address',
+                  name: 'z',
+                  type: 'address',
+                },
+              ],
+              internalType: 'struct ABIExample.Foo',
+              name: 'baz',
+              type: 'tuple',
+            },
+            {
+              internalType: 'uint8[2]',
+              name: 'x',
+              type: 'uint8[2]',
+            },
+          ],
+          internalType: 'struct ABIExample.Bar',
+          name: 'barOut',
+          type: 'tuple',
+        },
+      ],
+    })
+  })
+
+  bench('ethers: `AbiCoder.decode`', () => {
+    const coder = new AbiCoder()
+    coder.decode(
+      [
+        {
+          components: [
+            {
+              components: [
+                {
+                  internalType: 'uint256',
+                  name: 'x',
+                  type: 'uint256',
+                },
+                {
+                  internalType: 'bool',
+                  name: 'y',
+                  type: 'bool',
+                },
+                {
+                  internalType: 'address',
+                  name: 'z',
+                  type: 'address',
+                },
+              ],
+              internalType: 'struct ABIExample.Foo',
+              name: 'foo',
+              type: 'tuple',
+            },
+            {
+              components: [
+                {
+                  internalType: 'uint256',
+                  name: 'x',
+                  type: 'uint256',
+                },
+                {
+                  internalType: 'bool',
+                  name: 'y',
+                  type: 'bool',
+                },
+                {
+                  internalType: 'address',
+                  name: 'z',
+                  type: 'address',
+                },
+              ],
+              internalType: 'struct ABIExample.Foo',
+              name: 'baz',
+              type: 'tuple',
+            },
+            {
+              internalType: 'uint8[2]',
+              name: 'x',
+              type: 'uint8[2]',
+            },
+          ],
+          internalType: 'struct ABIExample.Bar',
+          name: 'barOut',
+          type: 'tuple',
+        },
+      ],
+      '0x00000000000000000000000000000000000000000000000000000000000001a40000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a5cc3c03994db5b0d9a5eedd10cabab0813678ac00000000000000000000000000000000000000000000000000000000000000450000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c961145a54c96e3ae9baa048c4f4d6b04c13916b00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002',
+    )
+  })
+})