viem 0.0.0-tsc-and-nodenext-20230405154910 → 0.0.0-w-20230711200108

package/src/utils/filters/createFilterRequestScope.ts

@@ -0,0 +1,52 @@
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { OnResponseFn } from '../../clients/transports/fallback.js'
+import type { Chain } from '../../types/chain.js'
+import type { PublicRpcSchema } from '../../types/eip1193.js'
+import type { EIP1193RequestFn } from '../../types/eip1193.js'
+import type { Hex } from '../../types/misc.js'
+import type { Filter } from '../../types/utils.js'
+
+type CreateFilterRequestScopeParameters = {
+  method:
+    | 'eth_newFilter'
+    | 'eth_newPendingTransactionFilter'
+    | 'eth_newBlockFilter'
+}
+
+type FilterRpcSchema = Filter<
+  PublicRpcSchema,
+  { Method: 'eth_getFilterLogs' | 'eth_getFilterChanges' }
+>
+
+type CreateFilterRequestScopeReturnType = (
+  id: Hex,
+) => EIP1193RequestFn<FilterRpcSchema>
+
+/**
+ * Scopes `request` to the filter ID. If the client is a fallback, it will
+ * listen for responses and scope the child transport `request` function
+ * to the successful filter ID.
+ */
+export function createFilterRequestScope<TChain extends Chain | undefined>(
+  client: Client<Transport, TChain>,
+  { method }: CreateFilterRequestScopeParameters,
+): CreateFilterRequestScopeReturnType {
+  const requestMap: Record<Hex, EIP1193RequestFn> = {}
+
+  if (client.transport.type === 'fallback')
+    client.transport.onResponse?.(
+      ({
+        method: method_,
+        response: id,
+        status,
+        transport,
+      }: Parameters<OnResponseFn>[0]) => {
+        if (status === 'success' && method === method_)
+          requestMap[id as Hex] = transport.request
+      },
+    )
+
+  return ((id) =>
+    requestMap[id] || client.request) as CreateFilterRequestScopeReturnType
+}

package/src/utils/formatters/block.ts

@@ -1,25 +1,16 @@
-import type {
-  Chain,
-  Block,
-  Formatter,
-  Formatters,
-  RpcBlock,
-} from '../../types/index.js'
-import { defineFormatter } from './format.js'
-import type { ExtractFormatter, Formatted } from './format.js'
-import { formatTransaction } from './transaction.js'
+import type { Block } from '../../types/block.js'
+import type { Chain } from '../../types/chain.js'
+import type { ExtractFormatterReturnType } from '../../types/formatter.js'
+import type { RpcBlock } from '../../types/rpc.js'
 
-export type BlockFormatter<TChain extends Chain | undefined = Chain> =
-  TChain extends Chain
-    ? ExtractFormatter<TChain, 'block', NonNullable<Formatters['block']>>
-    : Formatters['block']
+import { defineFormatter } from './formatter.js'
+import { formatTransaction } from './transaction.js'
 
 export type FormattedBlock<
-  TFormatter extends Formatter | undefined = Formatter,
-> = Formatted<TFormatter, Block>
+  TChain extends Chain | undefined = Chain | undefined,
+> = ExtractFormatterReturnType<TChain, 'block', Block>
 
 export function formatBlock(block: Partial<RpcBlock>) {
-  // TODO: Properly format transactions with a custom formatter
   const transactions = block.transactions?.map((transaction) => {
     if (typeof transaction === 'string') return transaction
     return formatTransaction(transaction)
@@ -43,4 +34,4 @@ export function formatBlock(block: Partial<RpcBlock>) {
   } as Block
 }
 
-export const defineBlock = defineFormatter({ format: formatBlock })
+export const defineBlock = /*#__PURE__*/ defineFormatter('block', formatBlock)

package/src/utils/formatters/extract.ts

@@ -1,17 +1,18 @@
-import type { Formatter } from '../../types/index.js'
+import type { Formatter } from '../../types/formatter.js'
 
 /**
  * @description Picks out the keys from `value` that exist in the formatter.
  */
 export function extract(
   value: Record<string, unknown>,
-  { formatter }: { formatter?: Formatter },
+  { format }: { format?: Formatter['format'] },
 ) {
-  if (!formatter) return {}
-  const keys = Object.keys(formatter({}))
-  return keys.reduce((data, key) => {
+  if (!format) return {}
+  const keys = Object.keys(format({}))
+  return keys.reduce((data: Record<string, unknown>, key) => {
+    // rome-ignore lint/suspicious/noPrototypeBuiltins:
     if (value?.hasOwnProperty(key)) {
-      ;(data as any)[key] = value[key]
+      data[key] = value[key]
     }
     return data
   }, {})

package/src/utils/formatters/feeHistory.ts

@@ -1,4 +1,5 @@
-import type { FeeHistory, RpcFeeHistory } from '../../types/index.js'
+import type { FeeHistory } from '../../types/fee.js'
+import type { RpcFeeHistory } from '../../types/rpc.js'
 
 export function formatFeeHistory(feeHistory: RpcFeeHistory): FeeHistory {
   return {

package/src/utils/formatters/formatter.ts

@@ -0,0 +1,36 @@
+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 {
+      format: (args: TParameters & TOverrideParameters) => {
+        const formatted = format(args)
+        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,
+    }
+  }
+}

package/src/utils/formatters/log.ts

@@ -1,4 +1,5 @@
-import type { Log, RpcLog } from '../../types/index.js'
+import type { Log } from '../../types/log.js'
+import type { RpcLog } from '../../types/rpc.js'
 
 export function formatLog(
   log: Partial<RpcLog>,
@@ -8,10 +9,10 @@ export function formatLog(
     ...log,
     blockHash: log.blockHash ? log.blockHash : null,
     blockNumber: log.blockNumber ? BigInt(log.blockNumber) : null,
-    logIndex: log.logIndex ? BigInt(log.logIndex) : null,
+    logIndex: log.logIndex ? Number(log.logIndex) : null,
     transactionHash: log.transactionHash ? log.transactionHash : null,
     transactionIndex: log.transactionIndex
-      ? BigInt(log.transactionIndex)
+      ? Number(log.transactionIndex)
       : null,
     ...(eventName ? { args, eventName } : {}),
   } as Log

package/src/utils/formatters/transaction.ts

@@ -1,26 +1,13 @@
-import type {
-  Chain,
-  Formatter,
-  Formatters,
-  RpcTransaction,
-  Transaction,
-} from '../../types/index.js'
-import { hexToNumber } from '../encoding/index.js'
-import { defineFormatter } from './format.js'
-import type { ExtractFormatter, Formatted } from './format.js'
-
-export type TransactionFormatter<TChain extends Chain | undefined = Chain> =
-  TChain extends Chain
-    ? ExtractFormatter<
-        TChain,
-        'transaction',
-        NonNullable<Formatters['transaction']>
-      >
-    : Formatters['transaction']
+import type { Chain } from '../../types/chain.js'
+import type { ExtractFormatterReturnType } from '../../types/formatter.js'
+import type { RpcTransaction } from '../../types/rpc.js'
+import type { Transaction } from '../../types/transaction.js'
+import { hexToNumber } from '../encoding/fromHex.js'
+import { defineFormatter } from './formatter.js'
 
 export type FormattedTransaction<
-  TFormatter extends Formatter | undefined = Formatter,
-> = Formatted<TFormatter, Transaction>
+  TChain extends Chain | undefined = Chain | undefined,
+> = ExtractFormatterReturnType<TChain, 'transaction', Transaction>
 
 export const transactionType = {
   '0x0': 'legacy',
@@ -50,6 +37,7 @@ export function formatTransaction(transaction: Partial<RpcTransaction>) {
       ? Number(transaction.transactionIndex)
       : null,
     type: transaction.type ? transactionType[transaction.type] : undefined,
+    typeHex: transaction.type ? transaction.type : undefined,
     value: transaction.value ? BigInt(transaction.value) : undefined,
     v: transaction.v ? BigInt(transaction.v) : undefined,
   }
@@ -66,4 +54,7 @@ export function formatTransaction(transaction: Partial<RpcTransaction>) {
   return transaction_ as Transaction
 }
 
-export const defineTransaction = defineFormatter({ format: formatTransaction })
+export const defineTransaction = /*#__PURE__*/ defineFormatter(
+  'transaction',
+  formatTransaction,
+)

package/src/utils/formatters/transactionReceipt.ts

@@ -1,29 +1,16 @@
-import type {
-  Chain,
-  Formatter,
-  Formatters,
-  RpcTransactionReceipt,
-  TransactionReceipt,
-} from '../../types/index.js'
-import { hexToNumber } from '../encoding/index.js'
-import { defineFormatter } from './format.js'
-import type { ExtractFormatter, Formatted } from './format.js'
+import type { Chain } from '../../types/chain.js'
+import type { ExtractFormatterReturnType } from '../../types/formatter.js'
+import type { RpcTransactionReceipt } from '../../types/rpc.js'
+import type { TransactionReceipt } from '../../types/transaction.js'
+import { hexToNumber } from '../encoding/fromHex.js'
+
+import { defineFormatter } from './formatter.js'
 import { formatLog } from './log.js'
 import { transactionType } from './transaction.js'
 
-export type TransactionReceiptFormatter<
-  TChain extends Chain | undefined = Chain,
-> = TChain extends Chain
-  ? ExtractFormatter<
-      TChain,
-      'transactionReceipt',
-      NonNullable<Formatters['transactionReceipt']>
-    >
-  : Formatters['transactionReceipt']
-
 export type FormattedTransactionReceipt<
-  TFormatter extends Formatter | undefined = Formatter,
-> = Formatted<TFormatter, TransactionReceipt>
+  TChain extends Chain | undefined = Chain | undefined,
+> = ExtractFormatterReturnType<TChain, 'transactionReceipt', TransactionReceipt>
 
 const statuses = {
   '0x0': 'reverted',
@@ -61,11 +48,14 @@ export function formatTransactionReceipt(
       ? statuses[transactionReceipt.status]
       : null,
     type: transactionReceipt.type
-      ? transactionType[transactionReceipt.type]
+      ? transactionType[
+          transactionReceipt.type as keyof typeof transactionType
+        ] || transactionReceipt.type
       : null,
   } as TransactionReceipt
 }
 
-export const defineTransactionReceipt = defineFormatter({
-  format: formatTransactionReceipt,
-})
+export const defineTransactionReceipt = /*#__PURE__*/ defineFormatter(
+  'transactionReceipt',
+  formatTransactionReceipt,
+)

package/src/utils/formatters/transactionRequest.ts

@@ -1,27 +1,13 @@
-import type {
-  Chain,
-  Formatter,
-  Formatters,
-  RpcTransactionRequest,
-  TransactionRequest,
-} from '../../types/index.js'
-import { defineFormatter } from './format.js'
-import type { ExtractFormatter, Formatted } from './format.js'
-import { numberToHex } from '../encoding/index.js'
-
-export type TransactionRequestFormatter<
-  TChain extends Chain | undefined = Chain,
-> = TChain extends Chain
-  ? ExtractFormatter<
-      TChain,
-      'transactionRequest',
-      NonNullable<Formatters['transactionRequest']>
-    >
-  : Formatters['transactionRequest']
+import type { Chain } from '../../types/chain.js'
+import type { ExtractFormatterParameters } from '../../types/formatter.js'
+import type { RpcTransactionRequest } from '../../types/rpc.js'
+import type { TransactionRequest } from '../../types/transaction.js'
+import { numberToHex } from '../encoding/toHex.js'
+import { defineFormatter } from './formatter.js'
 
 export type FormattedTransactionRequest<
-  TFormatter extends Formatter | undefined = Formatter,
-> = Formatted<TFormatter, RpcTransactionRequest>
+  TChain extends Chain | undefined = Chain | undefined,
+> = ExtractFormatterParameters<TChain, 'transactionRequest', TransactionRequest>
 
 export function formatTransactionRequest(
   transactionRequest: Partial<TransactionRequest>,
@@ -55,6 +41,7 @@ export function formatTransactionRequest(
   } as RpcTransactionRequest
 }
 
-export const defineTransactionRequest = defineFormatter({
-  format: formatTransactionRequest,
-})
+export const defineTransactionRequest = /*#__PURE__*/ defineFormatter(
+  'transactionRequest',
+  formatTransactionRequest,
+)

package/src/utils/hash/getEventSelector.ts

@@ -1,4 +1,9 @@
-import type { EventDefinition } from '../../types/index.js'
-import { hashFunction } from './hashFunction.js'
+import type { EventDefinition } from '../../types/contract.js'
+import type { AbiEvent } from 'abitype'
 
-export const getEventSelector = (event: EventDefinition) => hashFunction(event)
+import { hashAbiItem, hashFunction } from './hashFunction.js'
+
+export const getEventSelector = (event: EventDefinition | AbiEvent) => {
+  if (typeof event === 'string') return hashFunction(event)
+  return hashAbiItem(event)
+}

package/src/utils/hash/getFunctionSelector.ts

@@ -1,4 +1,9 @@
-import { slice } from '../data/index.js'
-import { hashFunction } from './hashFunction.js'
+import { slice } from '../data/slice.js'
+import type { AbiFunction } from 'abitype'
 
-export const getFunctionSelector = (fn: string) => slice(hashFunction(fn), 0, 4)
+import { hashAbiItem, hashFunction } from './hashFunction.js'
+
+export const getFunctionSelector = (fn: string | AbiFunction) => {
+  if (typeof fn === 'string') return slice(hashFunction(fn), 0, 4)
+  return slice(hashAbiItem(fn), 0, 4)
+}

package/src/utils/hash/hashFunction.ts

@@ -1,15 +1,20 @@
-import { toBytes } from '../encoding/index.js'
 import {
   extractFunctionName,
   extractFunctionParams,
-} from '../contract/index.js'
+} from '../contract/extractFunctionParts.js'
+import { toBytes } from '../encoding/toBytes.js'
+import type { AbiEvent, AbiFunction } from 'abitype'
+
 import { keccak256 } from './keccak256.js'
 
 const hash = (value: string) => keccak256(toBytes(value))
 
 export function hashFunction(def: string) {
   const name = extractFunctionName(def)
-  const params = extractFunctionParams(def)
-  if (!params || params.length === 0) return hash(def.replace(/ /g, ''))
+  const params = extractFunctionParams(def) || []
   return hash(`${name}(${params.map(({ type }) => type).join(',')})`)
 }
+
+export function hashAbiItem(def: AbiFunction | AbiEvent) {
+  return hash(`${def.name}(${def.inputs.map(({ type }) => type).join(',')})`)
+}

package/src/utils/hash/isHash.ts

@@ -1,5 +1,6 @@
-import type { Hex } from '../../types/index.js'
-import { isHex, size } from '../data/index.js'
+import type { Hex } from '../../types/misc.js'
+import { isHex } from '../data/isHex.js'
+import { size } from '../data/size.js'
 
 export function isHash(hash: string): hash is Hex {
   return isHex(hash) && size(hash) === 32

package/src/utils/hash/keccak256.ts

@@ -1,8 +1,9 @@
 import { keccak_256 } from '@noble/hashes/sha3'
 
-import type { ByteArray, Hex } from '../../types/index.js'
-import { isHex } from '../data/index.js'
-import { toBytes, toHex } from '../encoding/index.js'
+import type { ByteArray, Hex } from '../../types/misc.js'
+import { isHex } from '../data/isHex.js'
+import { toBytes } from '../encoding/toBytes.js'
+import { toHex } from '../encoding/toHex.js'
 
 type To = 'hex' | 'bytes'
 
@@ -15,7 +16,9 @@ export function keccak256<TTo extends To = 'hex'>(
   to_?: TTo,
 ): Keccak256Hash<TTo> {
   const to = to_ || 'hex'
-  const bytes = keccak_256(isHex(value) ? toBytes(value) : value)
+  const bytes = keccak_256(
+    isHex(value, { strict: false }) ? toBytes(value) : value,
+  )
   if (to === 'bytes') return bytes as Keccak256Hash<TTo>
   return toHex(bytes) as Keccak256Hash<TTo>
 }