viem 0.0.0-portable-types-20230523145621 → 0.0.0-refactor-generics-20230831161903

package/src/utils/formatters/block.ts

@@ -1,26 +1,45 @@
-import type { Block } from '../../types/block.js'
+import type { Block, BlockTag } from '../../types/block.js'
 import type { Chain } from '../../types/chain.js'
-import type { Formatter, Formatters } from '../../types/formatter.js'
+import type {
+  ExtractChainFormatterExclude,
+  ExtractChainFormatterReturnType,
+} from '../../types/chain.js'
+import type { Hash } from '../../types/misc.js'
 import type { RpcBlock } from '../../types/rpc.js'
+import type { Prettify } from '../../types/utils.js'
 
-import {
-  type ExtractFormatter,
-  type Formatted,
-  defineFormatter,
-} from './format.js'
-import { formatTransaction } from './transaction.js'
+import { defineFormatter } from './formatter.js'
+import { type FormattedTransaction, formatTransaction } from './transaction.js'
 
-export type BlockFormatter<TChain extends Chain | undefined = Chain> =
-  TChain extends Chain
-    ? ExtractFormatter<TChain, 'block', NonNullable<Formatters['block']>>
-    : Formatters['block']
+type BlockPendingDependencies = 'hash' | 'logsBloom' | 'nonce' | 'number'
 
 export type FormattedBlock<
-  TFormatter extends Formatter | undefined = Formatter,
-> = Formatted<TFormatter, Block>
+  TChain extends { formatters?: Chain['formatters'] } | undefined =
+    | { formatters?: Chain['formatters'] }
+    | undefined,
+  TIncludeTransactions extends boolean = boolean,
+  TBlockTag extends BlockTag = BlockTag,
+  _FormatterReturnType = ExtractChainFormatterReturnType<
+    TChain,
+    'block',
+    Block<bigint, TIncludeTransactions>
+  >,
+  _ExcludedPendingDependencies extends string = BlockPendingDependencies &
+    ExtractChainFormatterExclude<TChain, 'block'>,
+  _Formatted = Omit<_FormatterReturnType, BlockPendingDependencies> & {
+    [K in _ExcludedPendingDependencies]: never
+  } & Pick<
+      Block<bigint, TIncludeTransactions, TBlockTag>,
+      BlockPendingDependencies
+    >,
+  _Transactions = TIncludeTransactions extends true
+    ? Prettify<FormattedTransaction<TChain, TBlockTag>>[]
+    : Hash[],
+> = Omit<_Formatted, 'transactions'> & {
+  transactions: _Transactions
+}
 
 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)
@@ -44,4 +63,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/formatter.js'
+import type { ChainFormatter } from '../../types/chain.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?: ChainFormatter['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/formatter.ts

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

package/src/utils/formatters/log.ts

@@ -9,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,27 +1,38 @@
+import type { BlockTag } from '../../types/block.js'
 import type { Chain } from '../../types/chain.js'
-import type { Formatter, Formatters } from '../../types/formatter.js'
+import type {
+  ExtractChainFormatterExclude,
+  ExtractChainFormatterReturnType,
+} from '../../types/chain.js'
 import type { RpcTransaction } from '../../types/rpc.js'
 import type { Transaction } from '../../types/transaction.js'
+import type { UnionOmit } from '../../types/utils.js'
 import { hexToNumber } from '../encoding/fromHex.js'
+import { defineFormatter } from './formatter.js'
 
-import {
-  type ExtractFormatter,
-  type Formatted,
-  defineFormatter,
-} from './format.js'
-
-export type TransactionFormatter<TChain extends Chain | undefined = Chain> =
-  TChain extends Chain
-    ? ExtractFormatter<
-        TChain,
-        'transaction',
-        NonNullable<Formatters['transaction']>
-      >
-    : Formatters['transaction']
+type TransactionPendingDependencies =
+  | 'blockHash'
+  | 'blockNumber'
+  | 'transactionIndex'
 
 export type FormattedTransaction<
-  TFormatter extends Formatter | undefined = Formatter,
-> = Formatted<TFormatter, Transaction>
+  TChain extends { formatters?: Chain['formatters'] } | undefined =
+    | { formatters?: Chain['formatters'] }
+    | undefined,
+  TBlockTag extends BlockTag = BlockTag,
+  _FormatterReturnType = ExtractChainFormatterReturnType<
+    TChain,
+    'transaction',
+    Transaction
+  >,
+  _ExcludedPendingDependencies extends string = TransactionPendingDependencies &
+    ExtractChainFormatterExclude<TChain, 'transaction'>,
+> = UnionOmit<_FormatterReturnType, TransactionPendingDependencies> & {
+  [K in _ExcludedPendingDependencies]: never
+} & Pick<
+    Transaction<bigint, number, TBlockTag extends 'pending' ? true : false>,
+    TransactionPendingDependencies
+  >
 
 export const transactionType = {
   '0x0': 'legacy',
@@ -51,20 +62,24 @@ 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,
   }
 
   if (transaction_.type === 'legacy') {
-    delete transaction_['accessList']
-    delete transaction_['maxFeePerGas']
-    delete transaction_['maxPriorityFeePerGas']
+    delete transaction_.accessList
+    delete transaction_.maxFeePerGas
+    delete transaction_.maxPriorityFeePerGas
   }
   if (transaction_.type === 'eip2930') {
-    delete transaction_['maxFeePerGas']
-    delete transaction_['maxPriorityFeePerGas']
+    delete transaction_.maxFeePerGas
+    delete transaction_.maxPriorityFeePerGas
   }
   return transaction_ as Transaction
 }
 
-export const defineTransaction = defineFormatter({ format: formatTransaction })
+export const defineTransaction = /*#__PURE__*/ defineFormatter(
+  'transaction',
+  formatTransaction,
+)

package/src/utils/formatters/transactionReceipt.ts

@@ -1,30 +1,22 @@
-import type { Chain } from '../../types/chain.js'
-import type { Formatter, Formatters } from '../../types/formatter.js'
+import type {
+  Chain,
+  ExtractChainFormatterReturnType,
+} from '../../types/chain.js'
 import type { RpcTransactionReceipt } from '../../types/rpc.js'
 import type { TransactionReceipt } from '../../types/transaction.js'
 import { hexToNumber } from '../encoding/fromHex.js'
 
-import {
-  type ExtractFormatter,
-  type Formatted,
-  defineFormatter,
-} from './format.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,
+> = ExtractChainFormatterReturnType<
+  TChain,
+  'transactionReceipt',
+  TransactionReceipt
+>
 
 const statuses = {
   '0x0': 'reverted',
@@ -62,11 +54,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,28 +1,25 @@
-import type { Chain } from '../../types/chain.js'
-import type { Formatter, Formatters } from '../../types/formatter.js'
+import type {
+  Chain,
+  ExtractChainFormatterParameters,
+} from '../../types/chain.js'
 import type { RpcTransactionRequest } from '../../types/rpc.js'
 import type { TransactionRequest } from '../../types/transaction.js'
 import { numberToHex } from '../encoding/toHex.js'
-
-import {
-  type ExtractFormatter,
-  type Formatted,
-  defineFormatter,
-} from './format.js'
-
-export type TransactionRequestFormatter<
-  TChain extends Chain | undefined = Chain,
-> = TChain extends Chain
-  ? ExtractFormatter<
-      TChain,
-      'transactionRequest',
-      NonNullable<Formatters['transactionRequest']>
-    >
-  : Formatters['transactionRequest']
+import { defineFormatter } from './formatter.js'
 
 export type FormattedTransactionRequest<
-  TFormatter extends Formatter | undefined = Formatter,
-> = Formatted<TFormatter, RpcTransactionRequest>
+  TChain extends Chain | undefined = Chain | undefined,
+> = ExtractChainFormatterParameters<
+  TChain,
+  'transactionRequest',
+  TransactionRequest
+>
+
+export const rpcTransactionType = {
+  legacy: '0x0',
+  eip2930: '0x1',
+  eip1559: '0x2',
+} as const
 
 export function formatTransactionRequest(
   transactionRequest: Partial<TransactionRequest>,
@@ -49,6 +46,10 @@ export function formatTransactionRequest(
       typeof transactionRequest.nonce !== 'undefined'
         ? numberToHex(transactionRequest.nonce)
         : undefined,
+    type:
+      typeof transactionRequest.type !== 'undefined'
+        ? rpcTransactionType[transactionRequest.type]
+        : undefined,
     value:
       typeof transactionRequest.value !== 'undefined'
         ? numberToHex(transactionRequest.value)
@@ -56,6 +57,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,5 +1,9 @@
+import type { AbiEvent } from 'abitype'
 import type { EventDefinition } from '../../types/contract.js'
 
-import { hashFunction } from './hashFunction.js'
+import { hashAbiItem, hashFunction } from './hashFunction.js'
 
-export const getEventSelector = (event: EventDefinition) => hashFunction(event)
+export const getEventSelector = (event: EventDefinition | AbiEvent) => {
+  if (typeof event === 'string') return hashFunction(event)
+  return hashAbiItem(event)
+}

package/src/utils/hash/getFunctionSelector.ts

@@ -1,5 +1,9 @@
+import type { AbiFunction } from 'abitype'
 import { slice } from '../data/slice.js'
 
-import { hashFunction } from './hashFunction.js'
+import { hashAbiItem, hashFunction } from './hashFunction.js'
 
-export const getFunctionSelector = (fn: string) => slice(hashFunction(fn), 0, 4)
+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,3 +1,5 @@
+import type { AbiEvent, AbiFunction } from 'abitype'
+import { formatAbiItem } from '../abi/formatAbiItem.js'
 import {
   extractFunctionName,
   extractFunctionParams,
@@ -10,7 +12,10 @@ 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(abiItem: AbiFunction | AbiEvent) {
+  return hash(formatAbiItem(abiItem))
+}

package/src/utils/index.ts

@@ -17,8 +17,14 @@ export { arrayRegex, bytesRegex, integerRegex } from './regex.js'
 
 export {
   type HttpOptions,
+  type HttpReturnType,
+  type RpcRequest,
   type RpcResponse,
   type Socket,
+  type WebSocketAsyncOptions,
+  type WebSocketAsyncReturnType,
+  type WebSocketOptions,
+  type WebSocketReturnType,
   getSocket,
   rpc,
 } from './rpc.js'
@@ -112,32 +118,23 @@ export { size } from './data/size.js'
 export { slice, sliceBytes, sliceHex } from './data/slice.js'
 export { trim } from './data/trim.js'
 export {
-  type BlockFormatter,
   type FormattedBlock,
   defineBlock,
   formatBlock,
 } from './formatters/block.js'
-export {
-  type ExtractFormatter,
-  type Formatted,
-  defineFormatter,
-  format,
-} from './formatters/format.js'
 export {
   type FormattedTransaction,
-  type TransactionFormatter,
   defineTransaction,
   formatTransaction,
   transactionType,
 } from './formatters/transaction.js'
+export { formatLog } from './formatters/log.js'
 export {
   type FormattedTransactionReceipt,
-  type TransactionReceiptFormatter,
   defineTransactionReceipt,
 } from './formatters/transactionReceipt.js'
 export {
   type FormattedTransactionRequest,
-  type TransactionRequestFormatter,
   defineTransactionRequest,
   formatTransactionRequest,
 } from './formatters/transactionRequest.js'
@@ -177,6 +174,7 @@ export { getCallError } from './errors/getCallError.js'
 export { getContractError } from './errors/getContractError.js'
 export { getEstimateGasError } from './errors/getEstimateGasError.js'
 export { getTransactionError } from './errors/getTransactionError.js'
+export { defineFormatter } from './formatters/formatter.js'
 export { getEventSelector } from './hash/getEventSelector.js'
 export { getFunctionSelector } from './hash/getFunctionSelector.js'
 export { isHash } from './hash/isHash.js'
@@ -232,8 +230,15 @@ export {
   assertTransactionLegacy,
 } from './transaction/assertTransaction.js'
 export { parseTransaction } from './transaction/parseTransaction.js'
-export { prepareRequest } from './transaction/prepareRequest.js'
-export { serializeTransaction } from './transaction/serializeTransaction.js'
+export {
+  /** @deprecated import `prepareTransactionRequest` from `viem/actions` instead. */
+  prepareTransactionRequest,
+} from '../actions/wallet/prepareTransactionRequest.js'
+export {
+  serializeTransaction,
+  type SerializeTransactionFn,
+} from './transaction/serializeTransaction.js'
+export { serializeAccessList } from './transaction/serializeAccessList.js'
 export { formatEther } from './unit/formatEther.js'
 export { formatGwei } from './unit/formatGwei.js'
 export { formatUnits } from './unit/formatUnits.js'

package/src/utils/observe.ts

@@ -3,11 +3,11 @@ import type { MaybePromise } from '../types/utils.js'
 type Callback = ((...args: any[]) => any) | undefined
 type Callbacks = Record<string, Callback>
 
-export const listenersCache = new Map<
+export const listenersCache = /*#__PURE__*/ new Map<
   string,
   { id: number; fns: Callbacks }[]
 >()
-export const cleanupCache = new Map<string, () => void>()
+export const cleanupCache = /*#__PURE__*/ new Map<string, () => void>()
 
 type EmitFunction<TCallbacks extends Callbacks> = (
   emit: TCallbacks,

package/src/utils/poll.ts

@@ -21,7 +21,7 @@ export function poll<TData>(
   const unwatch = () => (active = false)
 
   const watch = async () => {
-    let data: TData | void
+    let data: TData | void = undefined
     if (emitOnBegin) data = await fn({ unpoll: unwatch })
 
     const initialWait = (await initialWaitTime?.(data)) ?? interval

package/src/utils/promise/createBatchScheduler.ts

@@ -29,7 +29,7 @@ export type CreateBatchSchedulerReturnType<
     : (args: TParameters) => Promise<Resolved<TReturnType>>
 }
 
-const schedulerCache = new Map<number | string, SchedulerItem[]>()
+const schedulerCache = /*#__PURE__*/ new Map<number | string, SchedulerItem[]>()
 
 export function createBatchScheduler<
   TParameters,

package/src/utils/promise/withCache.ts

@@ -1,5 +1,5 @@
-export const promiseCache = new Map()
-export const responseCache = new Map()
+export const promiseCache = /*#__PURE__*/ new Map()
+export const responseCache = /*#__PURE__*/ new Map()
 
 export function getCache<TData>(cacheKey: string) {
   const buildCache = <TData>(cacheKey: string, cache: Map<string, TData>) => ({
@@ -27,8 +27,8 @@ export function getCache<TData>(cacheKey: string) {
 export type WithCacheParameters = {
   /** The key to cache the data against. */
   cacheKey: string
-  /** The maximum age (in ms) of the cached value. Default: Infinity (no expiry) */
-  maxAge?: number
+  /** The time that cached data will remain in memory. Default: Infinity (no expiry) */
+  cacheTime?: number
 }
 
 /**
@@ -37,7 +37,7 @@ export type WithCacheParameters = {
  */
 export async function withCache<TData>(
   fn: () => Promise<TData>,
-  { cacheKey, maxAge = Infinity }: WithCacheParameters,
+  { cacheKey, cacheTime = Infinity }: WithCacheParameters,
 ) {
   const cache = getCache<TData>(cacheKey)
 
@@ -45,9 +45,9 @@ export async function withCache<TData>(
   // and do not invoke the promise.
   // If the max age is 0, the cache is disabled.
   const response = cache.response.get()
-  if (response && maxAge > 0) {
+  if (response && cacheTime > 0) {
     const age = new Date().getTime() - response.created.getTime()
-    if (age < maxAge) return response.data
+    if (age < cacheTime) return response.data
   }
 
   let promise = cache.promise.get()
@@ -59,15 +59,17 @@ export async function withCache<TData>(
     cache.promise.set(promise)
   }
 
-  const data = await promise
+  try {
+    const data = await promise
 
-  // Clear the promise cache so that subsequent invocations will
-  // invoke the promise again.
-  cache.promise.clear()
+    // Store the response in the cache so that subsequent invocations
+    // will return the same response.
+    cache.response.set({ created: new Date(), data })
 
-  // Store the response in the cache so that subsequent invocations
-  // will return the same response.
-  cache.response.set({ created: new Date(), data })
-
-  return data
+    return data
+  } finally {
+    // Clear the promise cache so that subsequent invocations will
+    // invoke the promise again.
+    cache.promise.clear()
+  }
 }