viem 0.0.0 → 0.0.1-alpha.0

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { C as CallArgs, a as CallResponse, b as CreateBlockFilterResponse, c as CreatePendingTransactionFilterResponse, D as DropTransactionArgs, E as EstimateGasArgs, d as EstimateGasResponse, G as GetBalanceArgs, e as GetBalanceResponse, f as GetBlockArgs, g as GetBlockNumberArgs, h as GetBlockNumberResponse, i as GetBlockResponse, j as GetBlockTransactionCountArgs, k as GetBlockTransactionCountResponse, l as GetFeeHistoryArgs, m as GetFeeHistoryResponse, n as GetFilterChangesArgs, o as GetFilterChangesResponse, p as GetGasPriceResponse, q as GetPermissionsResponse, r as GetTransactionArgs, s as GetTransactionConfirmationsArgs, t as GetTransactionConfirmationsResponse, u as GetTransactionCountArgs, v as GetTransactionCountResponse, x as GetTransactionReceiptArgs, y as GetTransactionReceiptResponse, w as GetTransactionResponse, I as ImpersonateAccountArgs, z as IncreaseTimeArgs, M as MineArgs, O as OnBlock, A as OnBlockNumber, B as OnBlockNumberResponse, F as OnBlockResponse, H as OnTransactions, J as OnTransactionsResponse, K as RequestPermissionsResponse, R as ResetArgs, L as RevertArgs, S as SendTransactionArgs, N as SendTransactionResponse, P as SendUnsignedTransactionArgs, Q as SendUnsignedTransactionResponse, T as SetBalanceArgs, U as SetBlockGasLimitArgs, Z as SetBlockTimestampIntervalArgs, V as SetCodeArgs, W as SetCoinbaseArgs, X as SetIntervalMiningArgs, Y as SetMinGasPriceArgs, $ as SetNextBlockBaseFeePerGasArgs, _ as SetNextBlockTimestampArgs, a0 as SetNonceArgs, a1 as SetStorageAtArgs, a2 as SignMessageArgs, a3 as SignMessageResponse, a4 as StopImpersonatingAccountArgs, a5 as SwitchChainArgs, a6 as UninstallFilterArgs, a7 as UninstallFilterResponse, a8 as WaitForTransactionReceiptArgs, a9 as WaitForTransactionReceiptResponse, aa as WatchAssetArgs, ab as WatchAssetResponse, ac as WatchBlockNumberArgs, ad as WatchBlocksArgs, ae as WatchPendingTransactionsArgs, af as addChain, ag as call, ah as createBlockFilter, ai as createPendingTransactionFilter, ak as dropTransaction, aj as estimateGas, al as getAutomine, am as getBalance, an as getBlock, ao as getBlockNumber, ap as getBlockTransactionCount, aq as getChainId, ar as getFeeHistory, as as getGasPrice, at as getPermissions, au as getTransaction, av as getTransactionConfirmations, aw as getTransactionCount, ax as getTransactionReceipt, ay as getTxpoolContent, az as getTxpoolStatus, aA as impersonateAccount, aB as increaseTime, aC as inspectTxpool, aD as mine, aE as removeBlockTimestampInterval, aG as requestAccounts, aH as requestPermissions, aF as reset, aI as revert, aJ as sendTransaction, aK as sendUnsignedTransaction, aL as setAutomine, aM as setBalance, aN as setBlockGasLimit, aO as setBlockTimestampInterval, aP as setCode, aQ as setCoinbase, aR as setIntervalMining, aS as setLoggingEnabled, aT as setMinGasPrice, aU as setNextBlockBaseFeePerGas, aV as setNextBlockTimestamp, aW as setNonce, aX as setStorageAt, aY as signMessage, aZ as snapshot, a_ as stopImpersonatingAccount, a$ as switchChain, b0 as uninstallFilter, b1 as waitForTransactionReceipt, b2 as watchAsset, b3 as watchBlockNumber, b4 as watchBlocks, b5 as watchPendingTransactions } from './watchAsset-bb30848d.js';
+export { C as Client, a as ClientConfig, P as PublicClient, b as PublicClientConfig, T as TestClient, c as TestClientConfig, d as Transport, e as TransportConfig, W as WalletClient, f as WalletClientConfig, g as createClient, h as createPublicClient, i as createTestClient, j as createTransport, k as createWalletClient } from './createWalletClient-c40fef16.js';
+export { E as EthereumProviderTransport, a as EthereumProviderTransportConfig, H as HttpTransport, b as HttpTransportConfig, U as UrlRequiredError, W as WebSocketTransport, c as WebSocketTransportConfig, e as ethereumProvider, h as http, w as webSocket } from './webSocket-14584a7e.js';
+export { a as AccessList, A as Address, B as Block, b as BlockIdentifier, c as BlockNumber, d as BlockTag, f as ByteArray, F as FeeHistory, h as FeeValues, i as FeeValuesEIP1559, j as FeeValuesLegacy, k as Hash, H as Hex, L as Log, R as RpcBlock, l as RpcBlockIdentifier, m as RpcBlockNumber, n as RpcFeeHistory, o as RpcFeeValues, p as RpcLog, q as RpcTransaction, r as RpcTransactionReceipt, s as RpcTransactionRequest, u as RpcUncle, D as Transaction, E as TransactionBase, G as TransactionEIP1559, I as TransactionEIP2930, J as TransactionLegacy, T as TransactionReceipt, v as TransactionRequest, x as TransactionRequestBase, y as TransactionRequestEIP1559, z as TransactionRequestEIP2930, C as TransactionRequestLegacy, U as Uncle, e as etherUnits, g as gweiUnits, t as transactionType, w as weiUnits } from './rpc-655c0ba4.js';
+export { E as EncodeRlpResponse, G as GetContractAddressOptions, b as GetCreate2AddressOptions, a as GetCreateAddressOptions, I as InternalRpcError, c as InvalidInputRpcError, d as InvalidParamsRpcError, e as InvalidRequestRpcError, J as JsonRpcVersionUnsupportedError, L as LimitExceededRpcError, M as MethodNotFoundRpcError, f as MethodNotSupportedRpcError, P as ParseRpcError, R as ResourceNotFoundRpcError, g as ResourceUnavailableRpcError, h as RpcRequestError, T as TransactionRejectedRpcError, k as boolToBytes, l as boolToHex, m as bytesToBigint, n as bytesToBool, i as bytesToHex, o as bytesToNumber, j as bytesToString, p as decodeBytes, q as decodeHex, r as decodeRlp, s as encodeBytes, t as encodeHex, u as encodeRlp, B as formatEther, $ as formatGwei, a0 as formatUnit, v as getAddress, w as getContractAddress, y as getCreate2Address, x as getCreateAddress, z as getEventSignature, A as getFunctionSignature, K as hexToBigInt, N as hexToBool, O as hexToBytes, a1 as hexToNumber, Q as hexToString, C as isAddress, D as isAddressEqual, F as isBytes, H as isHex, S as keccak256, U as numberToBytes, a2 as numberToHex, V as pad, W as padBytes, X as padHex, Y as parseEther, Z as parseGwei, _ as parseUnit, a3 as size, a4 as slice, a5 as sliceBytes, a6 as sliceHex, a7 as stringToBytes, a8 as stringToHex, a9 as trim } from './parseGwei-a7d0bcb2.js';
+export { B as BaseError } from './BaseError-7688f84e.js';
+export { F as FormattedBlock, a as FormattedTransaction, b as FormattedTransactionRequest, f as formatBlock, c as formatTransaction, d as formatTransactionRequest } from './transactionRequest-ade896ac.js';
+export { H as HttpRequestError, R as RpcError, T as TimeoutError } from './rpc-3c0e3985.js';
+import './chains.js';
+import '@wagmi/chains';
+import './eip1193-8f7c22ce.js';

package/dist/index.js

@@ -0,0 +1,278 @@
+import {
+  addChain,
+  call,
+  createBlockFilter,
+  createPendingTransactionFilter,
+  dropTransaction,
+  estimateGas,
+  getAutomine,
+  getBalance,
+  getBlock,
+  getBlockNumber,
+  getBlockTransactionCount,
+  getChainId,
+  getFeeHistory,
+  getGasPrice,
+  getPermissions,
+  getTransaction,
+  getTransactionConfirmations,
+  getTransactionCount,
+  getTransactionReceipt,
+  getTxpoolContent,
+  getTxpoolStatus,
+  impersonateAccount,
+  increaseTime,
+  inspectTxpool,
+  mine,
+  removeBlockTimestampInterval,
+  requestAccounts,
+  requestPermissions,
+  reset,
+  revert,
+  sendTransaction,
+  sendUnsignedTransaction,
+  setAutomine,
+  setBalance,
+  setBlockGasLimit,
+  setBlockTimestampInterval,
+  setCode,
+  setCoinbase,
+  setIntervalMining,
+  setLoggingEnabled,
+  setMinGasPrice,
+  setNextBlockBaseFeePerGas,
+  setNextBlockTimestamp,
+  setNonce,
+  setStorageAt,
+  signMessage,
+  snapshot,
+  stopImpersonatingAccount,
+  switchChain,
+  uninstallFilter,
+  waitForTransactionReceipt,
+  watchAsset,
+  watchBlockNumber,
+  watchBlocks,
+  watchPendingTransactions
+} from "./chunk-JSYJDK4W.js";
+import {
+  UrlRequiredError,
+  createClient,
+  createPublicClient,
+  createTestClient,
+  createTransport,
+  createWalletClient,
+  ethereumProvider,
+  http,
+  webSocket
+} from "./chunk-OPR6LKYX.js";
+import {
+  BaseError,
+  HttpRequestError,
+  InternalRpcError,
+  InvalidInputRpcError,
+  InvalidParamsRpcError,
+  InvalidRequestRpcError,
+  JsonRpcVersionUnsupportedError,
+  LimitExceededRpcError,
+  MethodNotFoundRpcError,
+  MethodNotSupportedRpcError,
+  ParseRpcError,
+  ResourceNotFoundRpcError,
+  ResourceUnavailableRpcError,
+  RpcError,
+  RpcRequestError,
+  TimeoutError,
+  TransactionRejectedRpcError,
+  boolToBytes,
+  boolToHex,
+  bytesToBigint,
+  bytesToBool,
+  bytesToHex,
+  bytesToNumber,
+  bytesToString,
+  decodeBytes,
+  decodeHex,
+  decodeRlp,
+  encodeBytes,
+  encodeHex,
+  encodeRlp,
+  etherUnits,
+  formatBlock,
+  formatEther,
+  formatGwei,
+  formatTransaction,
+  formatTransactionRequest,
+  formatUnit,
+  getAddress,
+  getContractAddress,
+  getCreate2Address,
+  getCreateAddress,
+  getEventSignature,
+  getFunctionSignature,
+  gweiUnits,
+  hexToBigInt,
+  hexToBool,
+  hexToBytes,
+  hexToNumber,
+  hexToString,
+  isAddress,
+  isAddressEqual,
+  isBytes,
+  isHex,
+  keccak256,
+  numberToBytes,
+  numberToHex,
+  pad,
+  padBytes,
+  padHex,
+  parseEther,
+  parseGwei,
+  parseUnit,
+  size,
+  slice,
+  sliceBytes,
+  sliceHex,
+  stringToBytes,
+  stringToHex,
+  transactionType,
+  trim,
+  weiUnits
+} from "./chunk-GI67STNV.js";
+export {
+  BaseError,
+  HttpRequestError,
+  InternalRpcError,
+  InvalidInputRpcError,
+  InvalidParamsRpcError,
+  InvalidRequestRpcError,
+  JsonRpcVersionUnsupportedError,
+  LimitExceededRpcError,
+  MethodNotFoundRpcError,
+  MethodNotSupportedRpcError,
+  ParseRpcError,
+  ResourceNotFoundRpcError,
+  ResourceUnavailableRpcError,
+  RpcError,
+  RpcRequestError,
+  TimeoutError,
+  TransactionRejectedRpcError,
+  UrlRequiredError,
+  addChain,
+  boolToBytes,
+  boolToHex,
+  bytesToBigint,
+  bytesToBool,
+  bytesToHex,
+  bytesToNumber,
+  bytesToString,
+  call,
+  createBlockFilter,
+  createClient,
+  createPendingTransactionFilter,
+  createPublicClient,
+  createTestClient,
+  createTransport,
+  createWalletClient,
+  decodeBytes,
+  decodeHex,
+  decodeRlp,
+  dropTransaction,
+  encodeBytes,
+  encodeHex,
+  encodeRlp,
+  estimateGas,
+  etherUnits,
+  ethereumProvider,
+  formatBlock,
+  formatEther,
+  formatGwei,
+  formatTransaction,
+  formatTransactionRequest,
+  formatUnit,
+  getAddress,
+  getAutomine,
+  getBalance,
+  getBlock,
+  getBlockNumber,
+  getBlockTransactionCount,
+  getChainId,
+  getContractAddress,
+  getCreate2Address,
+  getCreateAddress,
+  getEventSignature,
+  getFeeHistory,
+  getFunctionSignature,
+  getGasPrice,
+  getPermissions,
+  getTransaction,
+  getTransactionConfirmations,
+  getTransactionCount,
+  getTransactionReceipt,
+  getTxpoolContent,
+  getTxpoolStatus,
+  gweiUnits,
+  hexToBigInt,
+  hexToBool,
+  hexToBytes,
+  hexToNumber,
+  hexToString,
+  http,
+  impersonateAccount,
+  increaseTime,
+  inspectTxpool,
+  isAddress,
+  isAddressEqual,
+  isBytes,
+  isHex,
+  keccak256,
+  mine,
+  numberToBytes,
+  numberToHex,
+  pad,
+  padBytes,
+  padHex,
+  parseEther,
+  parseGwei,
+  parseUnit,
+  removeBlockTimestampInterval,
+  requestAccounts,
+  requestPermissions,
+  reset,
+  revert,
+  sendTransaction,
+  sendUnsignedTransaction,
+  setAutomine,
+  setBalance,
+  setBlockGasLimit,
+  setBlockTimestampInterval,
+  setCode,
+  setCoinbase,
+  setIntervalMining,
+  setLoggingEnabled,
+  setMinGasPrice,
+  setNextBlockBaseFeePerGas,
+  setNextBlockTimestamp,
+  setNonce,
+  setStorageAt,
+  signMessage,
+  size,
+  slice,
+  sliceBytes,
+  sliceHex,
+  snapshot,
+  stopImpersonatingAccount,
+  stringToBytes,
+  stringToHex,
+  switchChain,
+  transactionType,
+  trim,
+  uninstallFilter,
+  waitForTransactionReceipt,
+  watchAsset,
+  watchBlockNumber,
+  watchBlocks,
+  watchPendingTransactions,
+  webSocket,
+  weiUnits
+};

package/dist/parseGwei-a7d0bcb2.d.ts

@@ -0,0 +1,275 @@
+import { A as Address, f as ByteArray, H as Hex } from './rpc-655c0ba4.js';
+import { B as BaseError } from './BaseError-7688f84e.js';
+import { R as RpcError } from './rpc-3c0e3985.js';
+
+declare function getAddress(address: Address): `0x${string}`;
+
+type GetCreateAddressOptions = {
+    from: Address;
+    nonce: bigint;
+};
+type GetCreate2AddressOptions = {
+    bytecode: ByteArray | Hex;
+    from: Address;
+    salt: ByteArray | Hex;
+};
+type GetContractAddressOptions = ({
+    opcode?: 'CREATE';
+} & GetCreateAddressOptions) | ({
+    opcode: 'CREATE2';
+} & GetCreate2AddressOptions);
+declare function getContractAddress(opts: GetContractAddressOptions): `0x${string}`;
+declare function getCreateAddress(opts: GetCreateAddressOptions): `0x${string}`;
+declare function getCreate2Address(opts: GetCreate2AddressOptions): `0x${string}`;
+
+declare function isAddress(address: Address): boolean;
+
+declare function isAddressEqual(a: Address, b: Address): boolean;
+
+declare function buildRequest<TRequest extends (args: any) => Promise<any>>(request: TRequest): TRequest;
+declare class RequestError extends BaseError {
+    constructor(err: Error, { docsPath, humanMessage }: {
+        docsPath?: string;
+        humanMessage: string;
+    });
+}
+declare class RpcRequestError extends RequestError {
+    code: number;
+    constructor(err: RpcError, { docsPath, humanMessage }: {
+        docsPath?: string;
+        humanMessage: string;
+    });
+}
+declare class ParseRpcError extends RpcRequestError {
+    name: string;
+    code: number;
+    constructor(err: RpcError);
+}
+declare class InvalidRequestRpcError extends RpcRequestError {
+    name: string;
+    code: number;
+    constructor(err: RpcError);
+}
+declare class MethodNotFoundRpcError extends RpcRequestError {
+    name: string;
+    code: number;
+    constructor(err: RpcError);
+}
+declare class InvalidParamsRpcError extends RpcRequestError {
+    name: string;
+    code: number;
+    constructor(err: RpcError);
+}
+declare class InternalRpcError extends RpcRequestError {
+    name: string;
+    code: number;
+    constructor(err: RpcError);
+}
+declare class InvalidInputRpcError extends RpcRequestError {
+    name: string;
+    code: number;
+    constructor(err: RpcError);
+}
+declare class ResourceNotFoundRpcError extends RpcRequestError {
+    name: string;
+    code: number;
+    constructor(err: RpcError);
+}
+declare class ResourceUnavailableRpcError extends RpcRequestError {
+    name: string;
+    code: number;
+    constructor(err: RpcError);
+}
+declare class TransactionRejectedRpcError extends RpcRequestError {
+    name: string;
+    code: number;
+    constructor(err: RpcError);
+}
+declare class MethodNotSupportedRpcError extends RpcRequestError {
+    name: string;
+    code: number;
+    constructor(err: RpcError);
+}
+declare class LimitExceededRpcError extends RpcRequestError {
+    name: string;
+    code: number;
+    constructor(err: RpcError);
+}
+declare class JsonRpcVersionUnsupportedError extends RpcRequestError {
+    name: string;
+    code: number;
+    constructor(err: RpcError);
+}
+
+declare function isBytes(value: any): boolean;
+
+declare function isHex(value: any): boolean;
+
+type PadOptions = {
+    dir?: 'left' | 'right';
+    size?: number;
+};
+declare function pad(hexOrBytes: Hex | ByteArray, { dir, size }?: PadOptions): `0x${string}` | Uint8Array;
+declare function padHex(hex_: Hex, { dir, size }?: PadOptions): `0x${string}`;
+declare function padBytes(bytes: ByteArray, { dir, size }?: PadOptions): Uint8Array;
+
+type TrimOptions = {
+    dir?: 'left' | 'right';
+};
+declare function trim(hexOrBytes: Hex | ByteArray, { dir }?: TrimOptions): string | Uint8Array;
+
+/**
+ * @description Retrieves the size of the value (in bytes).
+ *
+ * @param value The value (hex or byte array) to retrieve the size of.
+ * @returns The size of the value (in bytes).
+ */
+declare function size(value: Hex | ByteArray): number;
+
+type SliceResult<TValue extends ByteArray | Hex> = TValue extends Hex ? Hex : ByteArray;
+/**
+ * @description Returns a section of the hex or byte array given a start/end bytes offset.
+ *
+ * @param value The hex or byte array to slice.
+ * @param start The start offset (in bytes).
+ * @param end The end offset (in bytes).
+ */
+declare function slice<TValue extends ByteArray | Hex>(value: TValue, start?: number, end?: number): SliceResult<TValue>;
+/**
+ * @description Returns a section of the byte array given a start/end bytes offset.
+ *
+ * @param value The byte array to slice.
+ * @param start The start offset (in bytes).
+ * @param end The end offset (in bytes).
+ */
+declare function sliceBytes(value: ByteArray, start?: number, end?: number): Uint8Array;
+/**
+ * @description Returns a section of the hex value given a start/end bytes offset.
+ *
+ * @param value The hex value to slice.
+ * @param start The start offset (in bytes).
+ * @param end The end offset (in bytes).
+ */
+declare function sliceHex(value_: Hex, start?: number, end?: number): string;
+
+/**
+ * @description Encodes a boolean into a hex string
+ */
+declare function boolToHex(value: boolean): Hex;
+/**
+ * @description Encodes a bytes array into a hex string
+ */
+declare function bytesToHex(value: ByteArray): Hex;
+/**
+ * @description Encodes a string, number, bigint, or ByteArray into a hex string
+ */
+declare function encodeHex(value: string | number | bigint | boolean | ByteArray): Hex;
+type NumberToHexOpts = {
+    signed?: boolean;
+    size: number;
+} | {
+    signed?: never;
+    size?: never;
+};
+/**
+ * @description Encodes a number or bigint into a hex string
+ */
+declare function numberToHex(value_: number | bigint, opts?: NumberToHexOpts): Hex;
+/**
+ * @description Encodes a UTF-8 string into a hex string
+ */
+declare function stringToHex(value: string): Hex;
+
+/**
+ * @description Encodes a boolean into a byte array.
+ */
+declare function boolToBytes(value: boolean): Uint8Array;
+/** @description Encodes a UTF-8 string, hex value, bigint, number or boolean to a byte array. */
+declare function encodeBytes(value: string | bigint | number | boolean | Hex): ByteArray;
+/**
+ * @description Encodes a hex string into a byte array.
+ */
+declare function hexToBytes(hex_: Hex): ByteArray;
+/**
+ * @description Encodes a number into a byte array.
+ */
+declare function numberToBytes(value: bigint | number, opts?: NumberToHexOpts): Uint8Array;
+/**
+ * @description Encodes a UTF-8 string into a byte array.
+ */
+declare function stringToBytes(value: string): ByteArray;
+
+type RecursiveArray<T> = T | Array<RecursiveArray<T>>;
+type To$1 = 'hex' | 'bytes';
+type EncodeRlpResponse<TTo extends To$1> = TTo extends 'bytes' ? ByteArray : TTo extends 'hex' ? Hex : never;
+declare function encodeRlp<TTo extends To$1 = 'hex'>(hexOrBytes: RecursiveArray<Hex> | RecursiveArray<ByteArray>, to_?: TTo): EncodeRlpResponse<TTo>;
+
+type DecodeBytesResponse<TTo> = TTo extends 'string' ? string : TTo extends 'hex' ? Hex : TTo extends 'bigint' ? bigint : TTo extends 'number' ? number : TTo extends 'boolean' ? boolean : never;
+/**
+ * @description Decodes a byte array into a UTF-8 string, hex value, number, bigint or boolean.
+ */
+declare function decodeBytes<TTo extends 'string' | 'hex' | 'bigint' | 'number' | 'boolean'>(bytes: ByteArray, to: TTo): DecodeBytesResponse<TTo>;
+/**
+ * @description Decodes a byte array into a bigint.
+ */
+declare function bytesToBigint(bytes: ByteArray): bigint;
+/**
+ * @description Decodes a byte array into a boolean.
+ */
+declare function bytesToBool(bytes: ByteArray): boolean;
+
+/**
+ * @description Decodes a byte array into a number.
+ */
+declare function bytesToNumber(bytes: ByteArray): number;
+/**
+ * @description Decodes a byte array into a UTF-8 string.
+ */
+declare function bytesToString(bytes: ByteArray): string;
+
+type DecodeHexResponse<TTo> = TTo extends 'string' ? string : TTo extends 'bigint' ? bigint : TTo extends 'number' ? number : TTo extends 'bytes' ? ByteArray : TTo extends 'boolean' ? boolean : never;
+/**
+ * @description Decodes a hex string into a string, number, bigint, boolean, or bytes32 array.
+ */
+declare function decodeHex<TTo extends 'string' | 'bigint' | 'number' | 'bytes' | 'boolean'>(hex: Hex, to: TTo): DecodeHexResponse<TTo>;
+/**
+ * @description Decodes a hex string into a bigint.
+ */
+declare function hexToBigInt(hex: Hex): bigint;
+/**
+ * @description Decodes a hex string into a boolean.
+ */
+declare function hexToBool(hex: Hex): boolean;
+/**
+ * @description Decodes a hex string into a number.
+ */
+declare function hexToNumber(hex: Hex): number;
+/**
+ * @description Decodes a hex string into a UTF-8 string.
+ */
+declare function hexToString(hex: Hex): string;
+
+type DecodeRlpResponse<TTo> = TTo extends 'bytes' ? ByteArray : TTo extends 'hex' ? Hex : never;
+declare function decodeRlp<TTo extends 'bytes' | 'hex'>(value: ByteArray | Hex, to: TTo): RecursiveArray<DecodeRlpResponse<TTo>>;
+
+declare const getEventSignature: (event: `${string}(${string})`) => `0x${string}`;
+
+declare const getFunctionSignature: (fn: string) => string;
+
+type To = 'hex' | 'bytes';
+type Keccak256Hash<TTo extends To> = TTo extends 'bytes' ? ByteArray : TTo extends 'hex' ? Hex : never;
+declare function keccak256<TTo extends To = 'hex'>(value: ByteArray, to_?: TTo): Keccak256Hash<TTo>;
+
+declare function formatEther(wei: bigint, unit?: 'wei' | 'gwei'): string;
+
+declare function formatGwei(wei: bigint, unit?: 'wei'): string;
+
+declare function formatUnit(value: bigint, decimals: number): string;
+
+declare function parseUnit(value: `${number}`, decimals: number): bigint;
+
+declare function parseEther(ether: `${number}`, unit?: 'wei' | 'gwei'): bigint;
+
+declare function parseGwei(ether: `${number}`, unit?: 'wei'): bigint;
+
+export { formatGwei as $, getFunctionSignature as A, formatEther as B, isAddress as C, isAddressEqual as D, EncodeRlpResponse as E, isBytes as F, GetContractAddressOptions as G, isHex as H, InternalRpcError as I, JsonRpcVersionUnsupportedError as J, hexToBigInt as K, LimitExceededRpcError as L, MethodNotFoundRpcError as M, hexToBool as N, hexToBytes as O, ParseRpcError as P, hexToString as Q, ResourceNotFoundRpcError as R, keccak256 as S, TransactionRejectedRpcError as T, numberToBytes as U, pad as V, padBytes as W, padHex as X, parseEther as Y, parseGwei as Z, parseUnit as _, GetCreateAddressOptions as a, formatUnit as a0, hexToNumber as a1, numberToHex as a2, size as a3, slice as a4, sliceBytes as a5, sliceHex as a6, stringToBytes as a7, stringToHex as a8, trim as a9, buildRequest as aa, GetCreate2AddressOptions as b, InvalidInputRpcError as c, InvalidParamsRpcError as d, InvalidRequestRpcError as e, MethodNotSupportedRpcError as f, ResourceUnavailableRpcError as g, RpcRequestError as h, bytesToHex as i, bytesToString as j, boolToBytes as k, boolToHex as l, bytesToBigint as m, bytesToBool as n, bytesToNumber as o, decodeBytes as p, decodeHex as q, decodeRlp as r, encodeBytes as s, encodeHex as t, encodeRlp as u, getAddress as v, getContractAddress as w, getCreateAddress as x, getCreate2Address as y, getEventSignature as z };

package/dist/rpc-3c0e3985.d.ts

@@ -0,0 +1,98 @@
+import { B as BaseError } from './BaseError-7688f84e.js';
+
+type SuccessResult<T> = {
+    method?: never;
+    result: T;
+    error?: never;
+};
+type ErrorResult<T> = {
+    method?: never;
+    result?: never;
+    error: T;
+};
+type Subscription<TResult, TError> = {
+    method: 'eth_subscription';
+    error?: never;
+    result?: never;
+    params: {
+        subscription: string;
+    } & ({
+        result: TResult;
+        error?: never;
+    } | {
+        result?: never;
+        error: TError;
+    });
+};
+type RpcRequest = {
+    method: string;
+    params?: any[];
+};
+type RpcResponse<TResult = any, TError = any> = {
+    jsonrpc: `${number}`;
+    id: number;
+} & (SuccessResult<TResult> | ErrorResult<TError> | Subscription<TResult, TError>);
+declare function http(url: string, { body, retryDelay, retryCount, timeout, }: {
+    body: RpcRequest;
+    retryDelay?: number;
+    retryCount?: number;
+    timeout?: number;
+}): Promise<RpcResponse<any, any>>;
+type Id = string | number;
+type CallbackFn = (message: any) => void;
+type CallbackMap = Map<Id, CallbackFn>;
+type Socket = WebSocket & {
+    requests: CallbackMap;
+    subscriptions: CallbackMap;
+};
+declare function webSocket(socket: Socket, { body, onData, onError, }: {
+    body: RpcRequest;
+    onData?: (message: RpcResponse) => void;
+    onError?: (message: RpcResponse['error']) => void;
+}): Socket;
+declare function webSocketAsync(socket: Socket, { body, timeout, }: {
+    body: RpcRequest;
+    timeout?: number;
+}): Promise<RpcResponse<any, any>>;
+declare const rpc: {
+    http: typeof http;
+    webSocket: typeof webSocket;
+    webSocketAsync: typeof webSocketAsync;
+};
+declare class HttpRequestError extends BaseError {
+    name: string;
+    status: number;
+    constructor({ body, details, status, url, }: {
+        body: {
+            [key: string]: unknown;
+        };
+        details: string;
+        status: number;
+        url: string;
+    });
+}
+declare class RpcError extends BaseError {
+    code: number;
+    name: string;
+    constructor({ body, error, url, }: {
+        body: {
+            [key: string]: unknown;
+        };
+        error: {
+            code: number;
+            message: string;
+        };
+        url: string;
+    });
+}
+declare class TimeoutError extends BaseError {
+    name: string;
+    constructor({ body, url, }: {
+        body: {
+            [key: string]: unknown;
+        };
+        url: string;
+    });
+}
+
+export { HttpRequestError as H, RpcError as R, TimeoutError as T, RpcResponse as a, rpc as r };