viem 1.10.9 → 1.10.11

package/src/actions/public/waitForTransactionReceipt.ts

@@ -1,258 +0,0 @@
-import type { Client } from '../../clients/createClient.js'
-import type { Transport } from '../../clients/transports/createTransport.js'
-import {
-  TransactionNotFoundError,
-  TransactionReceiptNotFoundError,
-  WaitForTransactionReceiptTimeoutError,
-} from '../../errors/transaction.js'
-import type { Chain } from '../../types/chain.js'
-import type { Hash } from '../../types/misc.js'
-import type { Transaction } from '../../types/transaction.js'
-import { observe } from '../../utils/observe.js'
-import { withRetry } from '../../utils/promise/withRetry.js'
-import { stringify } from '../../utils/stringify.js'
-
-import { getBlock } from './getBlock.js'
-import {
-  type GetTransactionReturnType,
-  getTransaction,
-} from './getTransaction.js'
-import {
-  type GetTransactionReceiptReturnType,
-  getTransactionReceipt,
-} from './getTransactionReceipt.js'
-import { watchBlockNumber } from './watchBlockNumber.js'
-
-export type ReplacementReason = 'cancelled' | 'replaced' | 'repriced'
-export type ReplacementReturnType<
-  TChain extends Chain | undefined = Chain | undefined,
-> = {
-  reason: ReplacementReason
-  replacedTransaction: Transaction
-  transaction: Transaction
-  transactionReceipt: GetTransactionReceiptReturnType<TChain>
-}
-
-export type WaitForTransactionReceiptReturnType<
-  TChain extends Chain | undefined = Chain | undefined,
-> = GetTransactionReceiptReturnType<TChain>
-
-export type WaitForTransactionReceiptParameters<
-  TChain extends Chain | undefined = Chain | undefined,
-> = {
-  /**
-   * The number of confirmations (blocks that have passed) to wait before resolving.
-   * @default 1
-   */
-  confirmations?: number
-  /** The hash of the transaction. */
-  hash: Hash
-  /** Optional callback to emit if the transaction has been replaced. */
-  onReplaced?: (response: ReplacementReturnType<TChain>) => void
-  /**
-   * Polling frequency (in ms). Defaults to the client's pollingInterval config.
-   * @default client.pollingInterval
-   */
-  pollingInterval?: number
-  /** Optional timeout (in milliseconds) to wait before stopping polling. */
-  timeout?: number
-}
-
-/**
- * Waits for the [Transaction](https://viem.sh/docs/glossary/terms.html#transaction) to be included on a [Block](https://viem.sh/docs/glossary/terms.html#block) (one confirmation), and then returns the [Transaction Receipt](https://viem.sh/docs/glossary/terms.html#transaction-receipt). If the Transaction reverts, then the action will throw an error.
- *
- * - Docs: https://viem.sh/docs/actions/public/waitForTransactionReceipt.html
- * - Example: https://stackblitz.com/github/wagmi-dev/viem/tree/main/examples/transactions/sending-transactions
- * - JSON-RPC Methods:
- *   - Polls [`eth_getTransactionReceipt`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getTransactionReceipt) on each block until it has been processed.
- *   - If a Transaction has been replaced:
- *     - Calls [`eth_getBlockByNumber`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getblockbynumber) and extracts the transactions
- *     - Checks if one of the Transactions is a replacement
- *     - If so, calls [`eth_getTransactionReceipt`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getTransactionReceipt).
- *
- * The `waitForTransactionReceipt` action additionally supports Replacement detection (e.g. sped up Transactions).
- *
- * Transactions can be replaced when a user modifies their transaction in their wallet (to speed up or cancel). Transactions are replaced when they are sent from the same nonce.
- *
- * There are 3 types of Transaction Replacement reasons:
- *
- * - `repriced`: The gas price has been modified (e.g. different `maxFeePerGas`)
- * - `cancelled`: The Transaction has been cancelled (e.g. `value === 0n`)
- * - `replaced`: The Transaction has been replaced (e.g. different `value` or `data`)
- *
- * @param client - Client to use
- * @param parameters - {@link WaitForTransactionReceiptParameters}
- * @returns The transaction receipt. {@link WaitForTransactionReceiptReturnType}
- *
- * @example
- * import { createPublicClient, waitForTransactionReceipt, http } from 'viem'
- * import { mainnet } from 'viem/chains'
- *
- * const client = createPublicClient({
- *   chain: mainnet,
- *   transport: http(),
- * })
- * const transactionReceipt = await waitForTransactionReceipt(client, {
- *   hash: '0x4ca7ee652d57678f26e887c149ab0735f41de37bcad58c9f6d3ed5824f15b74d',
- * })
- */
-export async function waitForTransactionReceipt<
-  TChain extends Chain | undefined,
->(
-  client: Client<Transport, TChain>,
-  {
-    confirmations = 1,
-    hash,
-    onReplaced,
-    pollingInterval = client.pollingInterval,
-    timeout,
-  }: WaitForTransactionReceiptParameters<TChain>,
-): Promise<WaitForTransactionReceiptReturnType<TChain>> {
-  const observerId = stringify(['waitForTransactionReceipt', client.uid, hash])
-
-  let transaction: GetTransactionReturnType<TChain> | undefined
-  let replacedTransaction: GetTransactionReturnType<TChain> | undefined
-  let receipt: GetTransactionReceiptReturnType<TChain>
-  let retrying = false
-
-  return new Promise((resolve, reject) => {
-    if (timeout)
-      setTimeout(
-        () => reject(new WaitForTransactionReceiptTimeoutError({ hash })),
-        timeout,
-      )
-
-    const _unobserve = observe(
-      observerId,
-      { onReplaced, resolve, reject },
-      (emit) => {
-        const _unwatch = watchBlockNumber(client, {
-          emitMissed: true,
-          emitOnBegin: true,
-          poll: true,
-          pollingInterval,
-          async onBlockNumber(blockNumber_) {
-            if (retrying) return
-
-            let blockNumber = blockNumber_
-
-            const done = (fn: () => void) => {
-              _unwatch()
-              fn()
-              _unobserve()
-            }
-
-            try {
-              // If we already have a valid receipt, let's check if we have enough
-              // confirmations. If we do, then we can resolve.
-              if (receipt) {
-                if (blockNumber - receipt.blockNumber + 1n < confirmations)
-                  return
-
-                done(() => emit.resolve(receipt))
-                return
-              }
-
-              // Get the transaction to check if it's been replaced.
-              // We need to retry as some RPC Providers may be slow to sync
-              // up mined transactions.
-              if (!transaction) {
-                retrying = true
-                await withRetry(
-                  async () => {
-                    transaction = await getTransaction(client, { hash })
-                    if (transaction.blockNumber)
-                      blockNumber = transaction.blockNumber
-                  },
-                  {
-                    // exponential backoff
-                    delay: ({ count }) => ~~(1 << count) * 200,
-                    retryCount: 6,
-                  },
-                )
-                retrying = false
-              }
-
-              // Get the receipt to check if it's been processed.
-              receipt = await getTransactionReceipt(client, { hash })
-
-              // Check if we have enough confirmations. If not, continue polling.
-              if (
-                confirmations > 0 &&
-                blockNumber - receipt.blockNumber + 1n < confirmations
-              )
-                return
-
-              done(() => emit.resolve(receipt))
-            } catch (err) {
-              // If the receipt is not found, the transaction will be pending.
-              // We need to check if it has potentially been replaced.
-              if (
-                transaction &&
-                (err instanceof TransactionNotFoundError ||
-                  err instanceof TransactionReceiptNotFoundError)
-              ) {
-                try {
-                  replacedTransaction = transaction
-
-                  // Let's retrieve the transactions from the current block.
-                  const block = await getBlock(client, {
-                    blockNumber,
-                    includeTransactions: true,
-                  })
-
-                  const replacementTransaction = (
-                    block.transactions as Transaction[]
-                  ).find(
-                    ({ from, nonce }) =>
-                      from === replacedTransaction!.from &&
-                      nonce === replacedTransaction!.nonce,
-                  )
-
-                  // If we couldn't find a replacement transaction, continue polling.
-                  if (!replacementTransaction) return
-
-                  // If we found a replacement transaction, return it's receipt.
-                  receipt = await getTransactionReceipt(client, {
-                    hash: replacementTransaction.hash,
-                  })
-
-                  // Check if we have enough confirmations. If not, continue polling.
-                  if (blockNumber - receipt.blockNumber + 1n < confirmations)
-                    return
-
-                  let reason: ReplacementReason = 'replaced'
-                  if (
-                    replacementTransaction.to === replacedTransaction.to &&
-                    replacementTransaction.value === replacedTransaction.value
-                  ) {
-                    reason = 'repriced'
-                  } else if (
-                    replacementTransaction.from === replacementTransaction.to &&
-                    replacementTransaction.value === 0n
-                  ) {
-                    reason = 'cancelled'
-                  }
-
-                  done(() => {
-                    emit.onReplaced?.({
-                      reason,
-                      replacedTransaction: replacedTransaction!,
-                      transaction: replacementTransaction,
-                      transactionReceipt: receipt,
-                    })
-                    emit.resolve(receipt)
-                  })
-                } catch (err_) {
-                  done(() => emit.reject(err_))
-                }
-              } else {
-                done(() => emit.reject(err))
-              }
-            }
-          },
-        })
-      },
-    )
-  })
-}

package/src/chains/utils.ts

@@ -1,45 +0,0 @@
-export { formattersCelo } from './celo/formatters.js'
-export {
-  serializeTransactionCelo,
-  serializersCelo,
-} from './celo/serializers.js'
-export { parseTransactionCelo } from './celo/parsers.js'
-export type {
-  CeloBlock,
-  CeloBlockOverrides,
-  CeloRpcBlock,
-  CeloRpcBlockOverrides,
-  CeloRpcTransaction,
-  CeloRpcTransactionReceipt,
-  CeloRpcTransactionReceiptOverrides,
-  CeloRpcTransactionRequest,
-  CeloTransaction,
-  CeloTransactionReceipt,
-  CeloTransactionReceiptOverrides,
-  CeloTransactionRequest,
-  CeloTransactionSerializable,
-  CeloTransactionSerialized,
-  CeloTransactionType,
-  RpcTransactionCIP42,
-  RpcTransactionRequestCIP42,
-  TransactionCIP42,
-  TransactionRequestCIP42,
-  TransactionSerializableCIP42,
-  TransactionSerializedCIP42,
-} from './celo/types.js'
-
-export { formattersOptimism } from './optimism/formatters.js'
-export type {
-  OptimismBlock,
-  OptimismBlockOverrides,
-  OptimismDepositTransaction,
-  OptimismRpcBlock,
-  OptimismRpcBlockOverrides,
-  OptimismRpcDepositTransaction,
-  OptimismRpcTransaction,
-  OptimismRpcTransactionReceipt,
-  OptimismRpcTransactionReceiptOverrides,
-  OptimismTransaction,
-  OptimismTransactionReceipt,
-  OptimismTransactionReceiptOverrides,
-} from './optimism/types.js'

package/src/clients/transports/webSocket.ts

@@ -1,141 +0,0 @@
-import type { WebSocket } from 'isomorphic-ws'
-
-import { RpcRequestError } from '../../errors/request.js'
-import { UrlRequiredError } from '../../errors/transport.js'
-import type { Hash } from '../../types/misc.js'
-import { type RpcResponse, getSocket, rpc } from '../../utils/rpc.js'
-import {
-  type Transport,
-  type TransportConfig,
-  createTransport,
-} from './createTransport.js'
-
-type WebSocketTransportSubscribeParameters = {
-  onData: (data: RpcResponse) => void
-  onError?: (error: any) => void
-}
-
-type WebSocketTransportSubscribeReturnType = {
-  subscriptionId: Hash
-  unsubscribe: () => Promise<RpcResponse<boolean>>
-}
-
-type WebSocketTransportSubscribe = {
-  subscribe(
-    args: WebSocketTransportSubscribeParameters & {
-      /**
-       * @description Add information about compiled contracts
-       * @link https://hardhat.org/hardhat-network/docs/reference#hardhat_addcompilationresult
-       */
-      params: ['newHeads']
-    },
-  ): Promise<WebSocketTransportSubscribeReturnType>
-}
-
-export type WebSocketTransportConfig = {
-  /** The key of the WebSocket transport. */
-  key?: TransportConfig['key']
-  /** The name of the WebSocket transport. */
-  name?: TransportConfig['name']
-  /** The max number of times to retry. */
-  retryCount?: TransportConfig['retryCount']
-  /** The base delay (in ms) between retries. */
-  retryDelay?: TransportConfig['retryDelay']
-  /** The timeout (in ms) for async WebSocket requests. Default: 10_000 */
-  timeout?: TransportConfig['timeout']
-}
-
-export type WebSocketTransport = Transport<
-  'webSocket',
-  {
-    getSocket(): Promise<WebSocket>
-    subscribe: WebSocketTransportSubscribe['subscribe']
-  }
->
-
-/**
- * @description Creates a WebSocket transport that connects to a JSON-RPC API.
- */
-export function webSocket(
-  /** URL of the JSON-RPC API. Defaults to the chain's public RPC URL. */
-  url?: string,
-  config: WebSocketTransportConfig = {},
-): WebSocketTransport {
-  const { key = 'webSocket', name = 'WebSocket JSON-RPC', retryDelay } = config
-  return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
-    const retryCount = config.retryCount ?? retryCount_
-    const timeout = timeout_ ?? config.timeout ?? 10_000
-    const url_ = url || chain?.rpcUrls.default.webSocket?.[0]
-    if (!url_) throw new UrlRequiredError()
-    return createTransport(
-      {
-        key,
-        name,
-        async request({ method, params }) {
-          const body = { method, params }
-          const socket = await getSocket(url_)
-          const { error, result } = await rpc.webSocketAsync(socket, {
-            body,
-            timeout,
-          })
-          if (error)
-            throw new RpcRequestError({
-              body,
-              error,
-              url: url_,
-            })
-          return result
-        },
-        retryCount,
-        retryDelay,
-        timeout,
-        type: 'webSocket',
-      },
-      {
-        getSocket() {
-          return getSocket(url_)
-        },
-        async subscribe({ params, onData, onError }: any) {
-          const socket = await getSocket(url_)
-          const { result: subscriptionId } = await new Promise<any>(
-            (resolve, reject) =>
-              rpc.webSocket(socket, {
-                body: {
-                  method: 'eth_subscribe',
-                  params,
-                },
-                onResponse(response) {
-                  if (response.error) {
-                    reject(response.error)
-                    onError?.(response.error)
-                    return
-                  }
-
-                  if (typeof response.id === 'number') {
-                    resolve(response)
-                    return
-                  }
-                  if (response.method !== 'eth_subscription') return
-                  onData(response.params)
-                },
-              }),
-          )
-          return {
-            subscriptionId,
-            async unsubscribe() {
-              return new Promise<any>((resolve) =>
-                rpc.webSocket(socket, {
-                  body: {
-                    method: 'eth_unsubscribe',
-                    params: [subscriptionId],
-                  },
-                  onResponse: resolve,
-                }),
-              )
-            },
-          }
-        },
-      },
-    )
-  }
-}

package/src/contract.ts

@@ -1,110 +0,0 @@
-export {
-  type CreateContractEventFilterParameters,
-  type CreateContractEventFilterReturnType,
-  createContractEventFilter,
-} from './actions/public/createContractEventFilter.js'
-export {
-  type EstimateContractGasParameters,
-  type EstimateContractGasReturnType,
-  estimateContractGas,
-} from './actions/public/estimateContractGas.js'
-export {
-  type GetBytecodeParameters,
-  type GetBytecodeReturnType,
-  getBytecode,
-} from './actions/public/getBytecode.js'
-export {
-  type GetStorageAtParameters,
-  type GetStorageAtReturnType,
-  getStorageAt,
-} from './actions/public/getStorageAt.js'
-export {
-  type MulticallParameters,
-  type MulticallReturnType,
-  multicall,
-} from './actions/public/multicall.js'
-export type {
-  WatchEventOnLogsFn,
-  /** @deprecated - use `WatchEventOnLogsFn` instead. */
-  WatchEventOnLogsFn as OnLogsFn,
-  WatchEventOnLogsParameter,
-  /** @deprecated - use `WatchEventOnLogsParameter` instead. */
-  WatchEventOnLogsParameter as OnLogsParameter,
-} from './actions/public/watchEvent.js'
-export {
-  type ReadContractParameters,
-  type ReadContractReturnType,
-  readContract,
-} from './actions/public/readContract.js'
-export {
-  type SimulateContractParameters,
-  type SimulateContractReturnType,
-  simulateContract,
-} from './actions/public/simulateContract.js'
-export {
-  type WatchContractEventParameters,
-  watchContractEvent,
-} from './actions/public/watchContractEvent.js'
-export {
-  type DeployContractParameters,
-  type DeployContractReturnType,
-  deployContract,
-} from './actions/wallet/deployContract.js'
-export {
-  type WriteContractParameters,
-  type WriteContractReturnType,
-  writeContract,
-} from './actions/wallet/writeContract.js'
-export {
-  type DecodeAbiParametersReturnType,
-  decodeAbiParameters,
-} from './utils/abi/decodeAbiParameters.js'
-export {
-  type DecodeErrorResultParameters,
-  type DecodeErrorResultReturnType,
-  decodeErrorResult,
-} from './utils/abi/decodeErrorResult.js'
-export {
-  type DecodeEventLogParameters,
-  type DecodeEventLogReturnType,
-  decodeEventLog,
-} from './utils/abi/decodeEventLog.js'
-export {
-  type DecodeFunctionDataParameters,
-  decodeFunctionData,
-} from './utils/abi/decodeFunctionData.js'
-export {
-  type DecodeFunctionResultParameters,
-  type DecodeFunctionResultReturnType,
-  decodeFunctionResult,
-} from './utils/abi/decodeFunctionResult.js'
-export {
-  type EncodeAbiParametersReturnType,
-  encodeAbiParameters,
-} from './utils/abi/encodeAbiParameters.js'
-export {
-  type EncodeDeployDataParameters,
-  encodeDeployData,
-} from './utils/abi/encodeDeployData.js'
-export {
-  type EncodeErrorResultParameters,
-  encodeErrorResult,
-} from './utils/abi/encodeErrorResult.js'
-export {
-  type EncodeEventTopicsParameters,
-  encodeEventTopics,
-} from './utils/abi/encodeEventTopics.js'
-export {
-  type EncodeFunctionDataParameters,
-  encodeFunctionData,
-} from './utils/abi/encodeFunctionData.js'
-export {
-  type EncodeFunctionResultParameters,
-  encodeFunctionResult,
-} from './utils/abi/encodeFunctionResult.js'
-export {
-  type GetAbiItemParameters,
-  getAbiItem,
-} from './utils/abi/getAbiItem.js'
-export { formatAbiItemWithArgs } from './utils/abi/formatAbiItemWithArgs.js'
-export { formatAbiItem } from './utils/abi/formatAbiItem.js'

package/src/ens.ts

@@ -1,28 +0,0 @@
-export { normalize } from './utils/ens/normalize.js'
-export {
-  type GetEnsAddressParameters,
-  type GetEnsAddressReturnType,
-  getEnsAddress,
-} from './actions/ens/getEnsAddress.js'
-export {
-  type GetEnsAvatarParameters,
-  type GetEnsAvatarReturnType,
-  getEnsAvatar,
-} from './actions/ens/getEnsAvatar.js'
-export {
-  type GetEnsNameParameters,
-  type GetEnsNameReturnType,
-  getEnsName,
-} from './actions/ens/getEnsName.js'
-export {
-  type GetEnsResolverParameters,
-  type GetEnsResolverReturnType,
-  getEnsResolver,
-} from './actions/ens/getEnsResolver.js'
-export {
-  type GetEnsTextParameters,
-  type GetEnsTextReturnType,
-  getEnsText,
-} from './actions/ens/getEnsText.js'
-export { labelhash } from './utils/ens/labelhash.js'
-export { namehash } from './utils/ens/namehash.js'

package/src/errors/version.ts

@@ -1 +0,0 @@
-export const version = '1.10.8'