viem 0.0.1-alpha.19 → 0.0.1-alpha.20

package/src/chains.ts

@@ -1,167 +1,99 @@
-// TODO: Remove chain formatter implementation once @wagmi/chains supports it.
+import * as chains from '@wagmi/chains'
 
-import type { Chain as Chain_ } from '@wagmi/chains'
+import type { Address, Hex, Quantity } from './types'
 import {
-  arbitrumGoerli as arbitrumGoerli_,
-  arbitrum as arbitrum_,
-  avalancheFuji as avalancheFuji_,
-  avalanche as avalanche_,
-  bscTestnet as bscTestnet_,
-  bsc as bsc_,
-  fantomTestnet as fantomTestnet_,
-  fantom as fantom_,
-  foundry as foundry_,
-  goerli as goerli_,
-  hardhat as hardhat_,
-  localhost as localhost_,
-  mainnet as mainnet_,
-  optimismGoerli as optimismGoerli_,
-  optimism as optimism_,
-  polygonMumbai as polygonMumbai_,
-  polygon as polygon_,
-  sepolia as sepolia_,
-} from '@wagmi/chains'
-
-import type {
-  Address,
-  Block,
-  Hex,
-  Quantity,
-  RpcBlock,
-  RpcTransaction,
-  RpcTransactionReceipt,
-  RpcTransactionRequest,
-  Transaction,
-  TransactionReceipt,
-  TransactionRequest,
-} from './types'
-import {
-  formatBlock,
-  formatTransaction,
-  formatTransactionRequest,
+  defineBlock,
+  defineChain,
+  defineTransaction,
+  defineTransactionReceipt,
+  defineTransactionRequest,
 } from './utils'
-import { formatTransactionReceipt } from './utils/formatters/transactionReceipt'
-
-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>
-}
 
-export type Chain<TFormatters extends Formatters = Formatters> = Chain_ & {
-  formatters?: TFormatters
-}
-
-export function defineChain<
-  TFormatters extends Formatters = Formatters,
-  TChain extends Chain<TFormatters> = Chain<TFormatters>,
->(chain: TChain) {
-  return chain
-}
-
-function defineFormatter<TSource extends Record<string, unknown>, TFormatted>({
-  format,
-}: {
-  format: (data: TSource) => TFormatted
-}) {
-  return <
-      TFormat extends Formatter<
-        TSource,
-        Partial<TFormatted> & { [key: string]: unknown }
-      >,
-      TExclude extends (keyof TSource)[] = [],
-    >({
-      exclude,
-      format: formatOverride,
-    }: {
-      exclude?: TExclude
-      format?: TFormat
-    }) =>
-    (data: TSource & { [key: string]: unknown }) => {
-      const formatted = format(data)
-      if (exclude) {
-        for (const key of exclude) {
-          delete (formatted as any)[key]
-        }
-      }
-      return {
-        ...formatted,
-        ...formatOverride?.(data),
-      } as TFormatted &
-        ReturnType<TFormat> & {
-          [K in TExclude[number]]: never
-        }
-    }
-}
+export type { Chain } from './types'
+export { defineChain } from './utils'
 
-export const defineBlock = defineFormatter({ format: formatBlock })
-export const defineTransaction = defineFormatter({ format: formatTransaction })
-export const defineTransactionRequest = defineFormatter({
-  format: formatTransactionRequest,
-})
-export const defineTransactionReceipt = defineFormatter({
-  format: formatTransactionReceipt,
-})
-
-export const arbitrumGoerli = defineChain(arbitrumGoerli_)
-export const arbitrum = defineChain(arbitrum_)
-export const avalancheFuji = defineChain(avalancheFuji_)
-export const avalanche = defineChain(avalanche_)
-export const bscTestnet = defineChain(bscTestnet_)
-export const bsc = defineChain(bsc_)
-export const celo = defineChain({
-  id: 42220,
-  name: 'Celo',
-  network: 'celo',
-  nativeCurrency: { name: 'Celo', symbol: 'CELO', decimals: 18 },
-  rpcUrls: {
-    public: { http: ['https://rpc.ankr.com/celo'] },
-    default: { http: ['https://rpc.ankr.com/celo'] },
-  },
-  formatters: {
-    block: defineBlock({
-      exclude: ['difficulty', 'gasLimit', 'mixHash', 'nonce', 'uncles'],
-      format: (block) => ({
-        randomness: block.randomness as {
-          committed: Hex
-          revealed: Hex
-        },
-      }),
+const celoFormatters = {
+  block: defineBlock({
+    exclude: ['difficulty', 'gasLimit', 'mixHash', 'nonce', 'uncles'],
+    format: (block) => ({
+      randomness: block.randomness as {
+        committed: Hex
+        revealed: Hex
+      },
+    }),
+  }),
+  transaction: defineTransaction({
+    format: (transaction) => ({
+      feeCurrency: transaction.feeCurrency as Address | null,
+      gatewayFee: transaction.gatewayFee
+        ? BigInt(transaction.gatewayFee as Quantity)
+        : null,
+      gatewayFeeRecipient: transaction.gatewayFeeRecipient as Address | null,
     }),
-    transaction: defineTransaction({
-      format: (transaction) => ({
-        feeCurrency: transaction.feeCurrency as Address | null,
-        gatewayFee: transaction.gatewayFee
-          ? BigInt(transaction.gatewayFee as Quantity)
-          : null,
-        gatewayFeeRecipient: transaction.gatewayFeeRecipient as Address | null,
-      }),
+  }),
+  transactionReceipt: defineTransactionReceipt({
+    format: (transaction) => ({
+      feeCurrency: transaction.feeCurrency as Address | null,
+      gatewayFee: transaction.gatewayFee
+        ? BigInt(transaction.gatewayFee as Quantity)
+        : null,
+      gatewayFeeRecipient: transaction.gatewayFeeRecipient as Address | null,
     }),
-    transactionRequest: defineTransactionRequest({
-      format: (transactionRequest) => ({
-        feeCurrency: transactionRequest.feeCurrency as Address | undefined,
-        gatewayFee: transactionRequest.gatewayFee as Quantity | undefined,
-        gatewayFeeRecipient: transactionRequest.gatewayFeeRecipient as
-          | Address
-          | undefined,
-      }),
+  }),
+  transactionRequest: defineTransactionRequest({
+    format: (transactionRequest) => ({
+      feeCurrency: transactionRequest.feeCurrency as Address | undefined,
+      gatewayFee: transactionRequest.gatewayFee as Quantity | undefined,
+      gatewayFeeRecipient: transactionRequest.gatewayFeeRecipient as
+        | Address
+        | undefined,
     }),
-  },
+  }),
+}
+
+export const arbitrum = defineChain(chains.arbitrum)
+export const arbitrumGoerli = defineChain(chains.arbitrumGoerli)
+export const aurora = defineChain(chains.aurora)
+export const auroraGoerli = defineChain(chains.auroraTestnet)
+export const avalanche = defineChain(chains.avalanche)
+export const avalancheFuji = defineChain(chains.avalancheFuji)
+export const bronos = defineChain(chains.bronos)
+export const bronosTestnet = defineChain(chains.bronosTestnet)
+export const bsc = defineChain(chains.bsc)
+export const bscTestnet = defineChain(chains.bscTestnet)
+export const canto = defineChain(chains.canto)
+export const celo = defineChain({
+  ...chains.celo,
+  formatters: celoFormatters,
+})
+export const celoAlfajores = defineChain({
+  ...chains.celoAlfajores,
+  formatters: celoFormatters,
 })
-export const fantomTestnet = defineChain(fantomTestnet_)
-export const fantom = defineChain(fantom_)
-export const foundry = defineChain(foundry_)
-export const goerli = defineChain(goerli_)
-export const hardhat = defineChain(hardhat_)
-export const localhost = defineChain(localhost_)
-export const mainnet = defineChain(mainnet_)
-export const optimismGoerli = defineChain(optimismGoerli_)
-export const optimism = defineChain(optimism_)
-export const polygonMumbai = defineChain(polygonMumbai_)
-export const polygon = defineChain(polygon_)
-export const sepolia = defineChain(sepolia_)
+export const crossbell = defineChain(chains.crossbell)
+export const evmos = defineChain(chains.evmos)
+export const evmosTestnet = defineChain(chains.evmosTestnet)
+export const fantom = defineChain(chains.fantom)
+export const fantomTestnet = defineChain(chains.fantomTestnet)
+export const filecoin = defineChain(chains.filecoin)
+export const filecoinTestnet = defineChain(chains.filecoinHyperspace)
+export const foundry = defineChain(chains.foundry)
+export const goerli = defineChain(chains.goerli)
+export const gnosis = defineChain(chains.gnosis)
+export const gnosisChiado = defineChain(chains.gnosisChiado)
+export const hardhat = defineChain(chains.hardhat)
+export const iotex = defineChain(chains.iotex)
+export const iotexTestnet = defineChain(chains.iotexTestnet)
+export const localhost = defineChain(chains.localhost)
+export const mainnet = defineChain(chains.mainnet)
+export const metis = defineChain(chains.metis)
+export const metisGoerli = defineChain(chains.metisGoerli)
+export const optimism = defineChain(chains.optimism)
+export const optimismGoerli = defineChain(chains.optimismGoerli)
+export const polygon = defineChain(chains.polygon)
+export const polygonMumbai = defineChain(chains.polygonMumbai)
+export const sepolia = defineChain(chains.sepolia)
+export const taraxa = defineChain(chains.taraxa)
+export const taraxaTestnet = defineChain(chains.taraxaTestnet)
+export const zkSync = defineChain(chains.zkSync)
+export const zkSyncTestnet = defineChain(chains.zkSyncTestnet)

package/src/clients/createClient.ts

@@ -1,4 +1,4 @@
-import type { Chain } from '../chains'
+import { Chain } from '../types'
 import type { Requests } from '../types/eip1193'
 import { buildRequest } from '../utils/buildRequest'
 import { uid } from '../utils/uid'

package/src/clients/createPublicClient.ts

@@ -1,8 +1,8 @@
-import type { Chain } from '../chains'
 import type { PublicRequests } from '../types/eip1193'
 import type { Transport } from './transports/createTransport'
 import type { Client, ClientConfig } from './createClient'
 import { createClient } from './createClient'
+import { Chain } from '../types'
 
 export type PublicClientConfig<
   TTransport extends Transport = Transport,

package/src/clients/createTestClient.ts

@@ -2,7 +2,7 @@ import type { TestRequests } from '../types/eip1193'
 import type { Transport } from './transports/createTransport'
 import type { Client, ClientConfig } from './createClient'
 import { createClient } from './createClient'
-import type { Chain } from '../chains'
+import { Chain } from '../types'
 
 type TestClientModes = 'anvil' | 'hardhat'
 

package/src/clients/createWalletClient.ts

@@ -2,7 +2,7 @@ import type { SignableRequests, WalletRequests } from '../types/eip1193'
 import type { Transport } from './transports/createTransport'
 import type { Client, ClientConfig } from './createClient'
 import { createClient } from './createClient'
-import type { Chain } from '../chains'
+import { Chain } from '../types'
 
 export type WalletClientConfig<
   TTransport extends Transport = Transport,

package/src/clients/transports/createTransport.ts

@@ -1,4 +1,4 @@
-import type { Chain } from '../../chains'
+import type { Chain } from '../../types'
 import type { Requests } from '../../types/eip1193'
 
 export type BaseRpcRequests = {

package/src/index.test.ts

@@ -67,6 +67,8 @@ test('exports actions', () => {
       "call": [Function],
       "createBlockFilter": [Function],
       "createClient": [Function],
+      "createContractEventFilter": [Function],
+      "createEventFilter": [Function],
       "createPendingTransactionFilter": [Function],
       "createPublicClient": [Function],
       "createTestClient": [Function],

package/src/index.ts

@@ -2,6 +2,10 @@ export type {
   CallArgs,
   CallResponse,
   CreateBlockFilterResponse,
+  CreateContractEventFilterArgs,
+  CreateContractEventFilterResponse,
+  CreateEventFilterArgs,
+  CreateEventFilterResponse,
   CreatePendingTransactionFilterResponse,
   EstimateGasArgs,
   EstimateGasResponse,
@@ -89,6 +93,8 @@ export {
   addChain,
   call,
   createBlockFilter,
+  createContractEventFilter,
+  createEventFilter,
   createPendingTransactionFilter,
   deployContract,
   dropTransaction,
@@ -185,8 +191,6 @@ export {
   webSocket,
 } from './clients'
 
-export { etherUnits, gweiUnits, transactionType, weiUnits } from './constants'
-
 export {
   AbiConstructorNotFoundError,
   AbiConstructorParamsNotFoundError,
@@ -325,12 +329,14 @@ export {
   encodeFunctionResult,
   encodeHex,
   encodeRlp,
+  etherUnits,
   getAddress,
   getContractAddress,
   getCreateAddress,
   getCreate2Address,
   getEventSignature,
   getFunctionSignature,
+  gweiUnits,
   formatEther,
   isAddress,
   isAddressEqual,
@@ -361,5 +367,7 @@ export {
   sliceHex,
   stringToBytes,
   stringToHex,
+  transactionType,
   trim,
+  weiUnits,
 } from './utils'

package/src/types/chain.ts

@@ -0,0 +1,6 @@
+import { Chain as Chain_ } from '@wagmi/chains'
+import { Formatters } from './formatter'
+
+export type Chain<TFormatters extends Formatters = Formatters> = Chain_ & {
+  formatters?: TFormatters
+}

package/src/types/contract.ts

@@ -10,6 +10,7 @@ import type {
   AbiParametersToPrimitiveTypes,
   ExtractAbiFunction,
   ExtractAbiEvent,
+  ExtractAbiEventNames,
   ExtractAbiError,
   AbiStateMutability,
   ExtractAbiFunctionNames,
@@ -139,9 +140,9 @@ export type ExtractErrorArgsFromAbi<
 
 export type ExtractEventArgsFromAbi<
   TAbi extends Abi | readonly unknown[],
-  TFunctionName extends string,
+  TEventName extends string,
   TAbiEvent extends AbiEvent & { type: 'event' } = TAbi extends Abi
-    ? ExtractAbiEvent<TAbi, TFunctionName>
+    ? ExtractAbiEvent<TAbi, TEventName>
     : AbiEvent & { type: 'event' },
   TArgs = AbiEventParametersToPrimitiveTypes<TAbiEvent['inputs']>,
   FailedToParseArgs =
@@ -162,6 +163,18 @@ export type ExtractEventArgsFromAbi<
       args?: TArgs
     }
 
+export type ExtractEventNameFromAbi<
+  TAbi extends Abi | readonly unknown[] = Abi,
+  TEventName extends string = string,
+> = TAbi extends Abi
+  ? ExtractAbiEventNames<TAbi> extends infer AbiEventNames
+    ?
+        | AbiEventNames
+        | (TEventName extends AbiEventNames ? TEventName : never)
+        | (Abi extends TAbi ? string : never)
+    : never
+  : TEventName
+
 export type ExtractFunctionNameFromAbi<
   TAbi extends Abi | readonly unknown[] = Abi,
   TFunctionName extends string = string,
@@ -201,6 +214,8 @@ export type ExtractResultFromAbi<
 //////////////////////////////////////////////////////////////////////
 // Event/Function Definitions
 
+export type EventDefinition = `${string}(${string})`
+
 type ExtractArgsFromDefinitionConfig = {
   indexedOnly: unknown
 }

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

@@ -6,15 +6,19 @@ export type {
   Uncle,
 } from './block'
 
+export type { Chain } from './chain'
+
 export type {
   AbiItem,
   AbiEventParametersToPrimitiveTypes,
+  EventDefinition,
   ExtractArgsFromAbi,
   ExtractArgsFromEventDefinition,
   ExtractArgsFromFunctionDefinition,
   ExtractConstructorArgsFromAbi,
   ExtractErrorArgsFromAbi,
   ExtractEventArgsFromAbi,
+  ExtractEventNameFromAbi,
   ExtractFunctionNameFromAbi,
   ExtractResultFromAbi,
   GetValue,
@@ -30,6 +34,8 @@ export type {
 
 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'

package/src/types/transaction.ts

@@ -1,4 +1,4 @@
-import type { transactionType } from '../constants'
+import { transactionType } from '../utils'
 import type { FeeValuesEIP1559, FeeValuesLegacy } from './fee'
 import type { Log } from './log'
 import type { Address, Hash, Hex } from './misc'

package/src/utils/abi/decodeErrorResult.ts

@@ -4,14 +4,14 @@ import { Hex } from '../../types'
 import { slice } from '../data'
 import { getFunctionSignature } from '../hash'
 import { decodeAbi } from './decodeAbi'
-import { formatAbiItemWithParams } from './formatAbiItemWithParams'
+import { formatAbiItem } from './formatAbiItem'
 
 export type DecodeErrorResultArgs = { abi: Abi; data: Hex }
 
 export function decodeErrorResult({ abi, data }: DecodeErrorResultArgs) {
   const signature = slice(data, 0, 4)
   const description = abi.find(
-    (x) => signature === getFunctionSignature(formatAbiItemWithParams(x)),
+    (x) => signature === getFunctionSignature(formatAbiItem(x)),
   )
   if (!description)
     throw new AbiErrorSignatureNotFoundError(signature, {

package/src/utils/abi/decodeFunctionData.ts

@@ -5,14 +5,14 @@ import { Hex } from '../../types'
 import { slice } from '../data'
 import { getFunctionSignature } from '../hash'
 import { decodeAbi } from './decodeAbi'
-import { formatAbiItemWithParams } from './formatAbiItemWithParams'
+import { formatAbiItem } from './formatAbiItem'
 
 export type DecodeFunctionDataArgs = { abi: Abi; data: Hex }
 
 export function decodeFunctionData({ abi, data }: DecodeFunctionDataArgs) {
   const signature = slice(data, 0, 4)
   const description = abi.find(
-    (x) => signature === getFunctionSignature(formatAbiItemWithParams(x)),
+    (x) => signature === getFunctionSignature(formatAbiItem(x)),
   )
   if (!description)
     throw new AbiFunctionSignatureNotFoundError(signature, {

package/src/utils/abi/encodeErrorResult.ts

@@ -8,7 +8,7 @@ import { ExtractErrorArgsFromAbi, Hex } from '../../types'
 import { concatHex } from '../data'
 import { getFunctionSignature } from '../hash'
 import { encodeAbi } from './encodeAbi'
-import { formatAbiItemWithParams } from './formatAbiItemWithParams'
+import { formatAbiItem } from './formatAbiItem'
 import { getAbiItem } from './getAbiItem'
 
 const docsPath = '/docs/contract/encodeErrorResult'
@@ -27,7 +27,7 @@ export function encodeErrorResult<
 >({ abi, errorName, args }: EncodeErrorResultArgs<TAbi, TErrorName>) {
   const description = getAbiItem({ abi, name: errorName })
   if (!description) throw new AbiErrorNotFoundError(errorName, { docsPath })
-  const definition = formatAbiItemWithParams(description)
+  const definition = formatAbiItem(description)
   const signature = getFunctionSignature(definition)
 
   let data: Hex = '0x'

package/src/utils/abi/encodeEventTopics.ts

@@ -9,11 +9,11 @@ import {
   AbiEventNotFoundError,
   FilterTypeNotSupportedError,
 } from '../../errors'
-import { ExtractEventArgsFromAbi, Hex } from '../../types'
+import { EventDefinition, ExtractEventArgsFromAbi, Hex } from '../../types'
 import { encodeBytes } from '../encoding'
 import { keccak256, getEventSignature } from '../hash'
 import { encodeAbi } from './encodeAbi'
-import { formatAbiItemWithParams } from './formatAbiItemWithParams'
+import { formatAbiItem } from './formatAbiItem'
 import { getAbiItem } from './getAbiItem'
 
 export type EncodeEventTopicsArgs<
@@ -33,8 +33,8 @@ export function encodeEventTopics<
     throw new AbiEventNotFoundError(eventName, {
       docsPath: '/docs/contract/encodeEventTopics',
     })
-  const definition = formatAbiItemWithParams(abiItem)
-  const signature = getEventSignature(definition as `${string}(${string})`)
+  const definition = formatAbiItem(abiItem)
+  const signature = getEventSignature(definition as EventDefinition)
 
   let topics: Hex[] = []
   if (args && 'inputs' in abiItem) {

package/src/utils/abi/encodeFunctionData.ts

@@ -5,7 +5,7 @@ import { ExtractArgsFromAbi, ExtractFunctionNameFromAbi } from '../../types'
 import { concatHex } from '../data'
 import { getFunctionSignature } from '../hash'
 import { encodeAbi } from './encodeAbi'
-import { formatAbiItemWithParams } from './formatAbiItemWithParams'
+import { formatAbiItem } from './formatAbiItem'
 import { getAbiItem } from './getAbiItem'
 
 export type EncodeFunctionDataArgs<
@@ -25,7 +25,7 @@ export function encodeFunctionData<
     throw new AbiFunctionNotFoundError(functionName, {
       docsPath: '/docs/contract/encodeFunctionData',
     })
-  const definition = formatAbiItemWithParams(description)
+  const definition = formatAbiItem(description)
   const signature = getFunctionSignature(definition)
   const data =
     'inputs' in description && description.inputs