viem 0.0.1-sushi.26 → 0.1.0

package/src/types/fee.ts

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,135 +0,0 @@
-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',
-    )
-  })
-})