viem 0.0.1-alpha.0 → 0.0.1-alpha.10

package/dist/{parseGwei-a7d0bcb2.d.ts → parseGwei-7c87ff41.d.ts}

@@ -1,6 +1,78 @@
-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';
+import { AbiParameter, AbiParametersToPrimitiveTypes, Abi, ExtractAbiErrorNames, ExtractAbiEventNames } from 'abitype';
+import { H as Hex, A as Address, B as ByteArray } from './rpc-b77c5aee.js';
+import { E as ExtractFunctionNameFromAbi, h as ExtractResultFromAbi, m as ExtractConstructorArgsFromAbi, n as ExtractErrorArgsFromAbi, o as ExtractEventArgsFromAbi, g as ExtractArgsFromAbi } from './transactionRequest-08d30731.js';
+
+type DecodeAbiArgs<TParams extends readonly AbiParameter[]> = {
+    data: Hex;
+    params: TParams;
+};
+declare function decodeAbi<TParams extends readonly AbiParameter[]>({ data, params, }: DecodeAbiArgs<TParams>): AbiParametersToPrimitiveTypes<TParams> | undefined;
+
+type DecodeErrorResultArgs = {
+    abi: Abi;
+    data: Hex;
+};
+declare function decodeErrorResult({ abi, data }: DecodeErrorResultArgs): {
+    errorName: string;
+    args: readonly unknown[] | undefined;
+};
+
+type DecodeFunctionDataArgs = {
+    abi: Abi;
+    data: Hex;
+};
+declare function decodeFunctionData({ abi, data }: DecodeFunctionDataArgs): {
+    functionName: string;
+    args: readonly unknown[] | undefined;
+};
+
+type DecodeFunctionResultArgs<TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = any> = {
+    abi: TAbi;
+    functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>;
+    data: Hex;
+};
+type DecodeFunctionResultResponse<TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = any> = ExtractResultFromAbi<TAbi, TFunctionName>;
+declare function decodeFunctionResult<TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = any>({ abi, functionName, data, }: DecodeFunctionResultArgs<TAbi, TFunctionName>): DecodeFunctionResultResponse<TAbi, TFunctionName>;
+
+type EncodeAbiArgs<TParams extends readonly AbiParameter[]> = {
+    params: TParams;
+    values: AbiParametersToPrimitiveTypes<TParams>;
+};
+/**
+ * @description Encodes a list of primitive values into an ABI-encoded hex value.
+ */
+declare function encodeAbi<TParams extends readonly AbiParameter[]>({ params, values, }: EncodeAbiArgs<TParams>): `0x${string}`;
+
+type EncodeDeployDataArgs<TAbi extends Abi = Abi> = {
+    abi: TAbi;
+    bytecode: Hex;
+} & ExtractConstructorArgsFromAbi<TAbi>;
+declare function encodeDeployData<TAbi extends Abi = Abi>({ abi, args, bytecode, }: EncodeDeployDataArgs<TAbi>): `0x${string}`;
+
+type EncodeErrorResultArgs<TAbi extends Abi = Abi, TErrorName extends ExtractAbiErrorNames<TAbi> = any> = {
+    abi: TAbi;
+    errorName: TErrorName;
+} & ExtractErrorArgsFromAbi<TAbi, TErrorName>;
+declare function encodeErrorResult<TAbi extends Abi = Abi, TErrorName extends ExtractAbiErrorNames<TAbi> = any>({ abi, errorName, args }: EncodeErrorResultArgs<TAbi, TErrorName>): `0x${string}`;
+
+type EncodeEventTopicsArgs<TAbi extends Abi = Abi, TEventName extends ExtractAbiEventNames<TAbi> = any> = {
+    abi: TAbi;
+    eventName: TEventName;
+} & ExtractEventArgsFromAbi<TAbi, TEventName>;
+declare function encodeEventTopics<TAbi extends Abi = Abi, TEventName extends ExtractAbiEventNames<TAbi> = any>({ abi, eventName, args }: EncodeEventTopicsArgs<TAbi, TEventName>): `0x${string}`[];
+
+type EncodeFunctionDataArgs<TAbi extends Abi = Abi, TFunctionName extends string = any> = {
+    abi: TAbi;
+    functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>;
+} & ExtractArgsFromAbi<TAbi, TFunctionName>;
+declare function encodeFunctionData<TAbi extends Abi = Abi, TFunctionName extends string = any>({ abi, args, functionName }: EncodeFunctionDataArgs<TAbi, TFunctionName>): `0x${string}`;
+
+type EncodeFunctionResultArgs<TAbi extends Abi = Abi, TFunctionName extends string = any> = {
+    abi: TAbi;
+    functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>;
+    result?: ExtractResultFromAbi<TAbi, TFunctionName>;
+};
+declare function encodeFunctionResult<TAbi extends Abi = Abi, TFunctionName extends string = any>({ abi, functionName, result, }: EncodeFunctionResultArgs<TAbi, TFunctionName>): `0x${string}`;
 
 declare function getAddress(address: Address): `0x${string}`;
 
@@ -26,81 +98,6 @@ 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;
@@ -109,14 +106,16 @@ type PadOptions = {
     dir?: 'left' | 'right';
     size?: number;
 };
-declare function pad(hexOrBytes: Hex | ByteArray, { dir, size }?: PadOptions): `0x${string}` | Uint8Array;
+type PadResult<TValue extends ByteArray | Hex> = TValue extends Hex ? Hex : ByteArray;
+declare function pad<TValue extends ByteArray | Hex>(hexOrBytes: TValue, { dir, size }?: PadOptions): PadResult<TValue>;
 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;
+type TrimResult<TValue extends ByteArray | Hex> = TValue extends Hex ? Hex : ByteArray;
+declare function trim<TValue extends ByteArray | Hex>(hexOrBytes: TValue, { dir }?: TrimOptions): TrimResult<TValue>;
 
 /**
  * @description Retrieves the size of the value (in bytes).
@@ -164,7 +163,7 @@ 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 = {
+type NumberToHexOpts$1 = {
     signed?: boolean;
     size: number;
 } | {
@@ -174,7 +173,7 @@ type NumberToHexOpts = {
 /**
  * @description Encodes a number or bigint into a hex string
  */
-declare function numberToHex(value_: number | bigint, opts?: NumberToHexOpts): Hex;
+declare function numberToHex(value_: number | bigint, opts?: NumberToHexOpts$1): Hex;
 /**
  * @description Encodes a UTF-8 string into a hex string
  */
@@ -193,7 +192,7 @@ declare function hexToBytes(hex_: Hex): ByteArray;
 /**
  * @description Encodes a number into a byte array.
  */
-declare function numberToBytes(value: bigint | number, opts?: NumberToHexOpts): Uint8Array;
+declare function numberToBytes(value: bigint | number, opts?: NumberToHexOpts$1): Uint8Array;
 /**
  * @description Encodes a UTF-8 string into a byte array.
  */
@@ -232,18 +231,22 @@ type DecodeHexResponse<TTo> = TTo extends 'string' ? string : TTo extends 'bigin
  * @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>;
+type HexToBigIntOpts = {
+    signed?: boolean;
+};
 /**
  * @description Decodes a hex string into a bigint.
  */
-declare function hexToBigInt(hex: Hex): bigint;
+declare function hexToBigInt(hex: Hex, opts?: HexToBigIntOpts): bigint;
 /**
  * @description Decodes a hex string into a boolean.
  */
 declare function hexToBool(hex: Hex): boolean;
+type NumberToHexOpts = HexToBigIntOpts;
 /**
  * @description Decodes a hex string into a number.
  */
-declare function hexToNumber(hex: Hex): number;
+declare function hexToNumber(hex: Hex, opts?: NumberToHexOpts): number;
 /**
  * @description Decodes a hex string into a UTF-8 string.
  */
@@ -254,7 +257,7 @@ declare function decodeRlp<TTo extends 'bytes' | 'hex'>(value: ByteArray | Hex,
 
 declare const getEventSignature: (event: `${string}(${string})`) => `0x${string}`;
 
-declare const getFunctionSignature: (fn: string) => string;
+declare const getFunctionSignature: (fn: string) => `0x${string}`;
 
 type To = 'hex' | 'bytes';
 type Keccak256Hash<TTo extends To> = TTo extends 'bytes' ? ByteArray : TTo extends 'hex' ? Hex : never;
@@ -272,4 +275,4 @@ 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 };
+export { keccak256 as $, encodeAbi as A, encodeBytes as B, encodeDeployData as C, DecodeAbiArgs as D, EncodeAbiArgs as E, encodeErrorResult as F, GetContractAddressOptions as G, encodeEventTopics as H, encodeFunctionData as I, encodeFunctionResult as J, encodeHex as K, encodeRlp as L, getAddress as M, getContractAddress as N, getCreateAddress as O, getCreate2Address as P, getEventSignature as Q, getFunctionSignature as R, formatEther as S, isAddress as T, isAddressEqual as U, isBytes as V, isHex as W, hexToBigInt as X, hexToBool as Y, hexToBytes as Z, hexToString as _, DecodeErrorResultArgs as a, numberToBytes as a0, pad as a1, padBytes as a2, padHex as a3, parseEther as a4, parseGwei as a5, parseUnit as a6, formatGwei as a7, formatUnit as a8, hexToNumber as a9, numberToHex as aa, size as ab, slice as ac, sliceBytes as ad, sliceHex as ae, stringToBytes as af, stringToHex as ag, trim as ah, DecodeFunctionDataArgs as b, DecodeFunctionResultArgs as c, DecodeFunctionResultResponse as d, EncodeDeployDataArgs as e, EncodeErrorResultArgs as f, EncodeEventTopicsArgs as g, EncodeFunctionDataArgs as h, EncodeFunctionResultArgs as i, GetCreateAddressOptions as j, GetCreate2AddressOptions as k, EncodeRlpResponse as l, bytesToHex as m, bytesToString as n, boolToBytes as o, boolToHex as p, bytesToBigint as q, bytesToBool as r, bytesToNumber as s, decodeAbi as t, decodeBytes as u, decodeErrorResult as v, decodeFunctionData as w, decodeFunctionResult as x, decodeHex as y, decodeRlp as z };

package/dist/{rpc-3c0e3985.d.ts → rpc-26932bae.d.ts}

@@ -1,5 +1,3 @@
-import { B as BaseError } from './BaseError-7688f84e.js';
-
 type SuccessResult<T> = {
     method?: never;
     result: T;
@@ -59,40 +57,5 @@ declare const rpc: {
     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 };
+export { RpcResponse as R, rpc as r };

package/dist/{rpc-655c0ba4.d.ts → rpc-b77c5aee.d.ts}

@@ -289,4 +289,4 @@ type RpcTransactionReceipt = TransactionReceipt<Quantity, Index, Status, Transac
 type RpcTransactionRequest = TransactionRequest<Quantity, Index>;
 type RpcTransaction = TransactionLegacy<Quantity, Index, '0x0'> | TransactionEIP2930<Quantity, Index, '0x1'> | TransactionEIP1559<Quantity, Index, '0x2'>;
 
-export { Address as A, Block as B, TransactionRequestLegacy as C, Transaction as D, TransactionBase as E, FeeHistory as F, TransactionEIP1559 as G, Hex as H, TransactionEIP2930 as I, TransactionLegacy as J, EstimateGasParameters as K, Log as L, MergeIntersectionProperties as M, TransactionType$1 as N, OptionalNullable as O, RpcEstimateGasParameters as P, Quantity as Q, RpcBlock as R, TransactionReceipt as T, Uncle as U, AccessList as a, BlockIdentifier as b, BlockNumber as c, BlockTag as d, etherUnits as e, ByteArray as f, gweiUnits as g, FeeValues as h, FeeValuesEIP1559 as i, FeeValuesLegacy as j, Hash as k, RpcBlockIdentifier as l, RpcBlockNumber as m, RpcFeeHistory as n, RpcFeeValues as o, RpcLog as p, RpcTransaction as q, RpcTransactionReceipt as r, RpcTransactionRequest as s, transactionType as t, RpcUncle as u, TransactionRequest as v, weiUnits as w, TransactionRequestBase as x, TransactionRequestEIP1559 as y, TransactionRequestEIP2930 as z };
+export { Address as A, ByteArray as B, TransactionRequestLegacy as C, Transaction as D, TransactionBase as E, FeeHistory as F, TransactionEIP1559 as G, Hex as H, TransactionEIP2930 as I, TransactionLegacy as J, EstimateGasParameters as K, Log as L, MergeIntersectionProperties as M, TransactionType$1 as N, OptionalNullable as O, RpcEstimateGasParameters as P, Quantity as Q, RpcBlock as R, TransactionReceipt as T, Uncle as U, Hash as a, BlockTag as b, AccessList as c, Block as d, etherUnits as e, BlockIdentifier as f, gweiUnits as g, BlockNumber as h, FeeValues as i, FeeValuesEIP1559 as j, FeeValuesLegacy as k, RpcBlockIdentifier as l, RpcBlockNumber as m, RpcFeeHistory as n, RpcFeeValues as o, RpcLog as p, RpcTransaction as q, RpcTransactionReceipt as r, RpcTransactionRequest as s, transactionType as t, RpcUncle as u, TransactionRequest as v, weiUnits as w, TransactionRequestBase as x, TransactionRequestEIP1559 as y, TransactionRequestEIP2930 as z };

package/dist/transactionRequest-08d30731.d.ts

@@ -0,0 +1,132 @@
+import { Abi, AbiFunction, ExtractAbiFunction, AbiParametersToPrimitiveTypes, AbiError, ExtractAbiError, AbiEvent, ExtractAbiEvent, AbiStateMutability, ExtractAbiFunctionNames, AbiParameter, AbiParameterToPrimitiveType } from 'abitype';
+import { v as TransactionRequest, O as OptionalNullable, d as Block, R as RpcBlock, D as Transaction, q as RpcTransaction, T as TransactionReceipt, s as RpcTransactionRequest } from './rpc-b77c5aee.js';
+import { Chain, Formatter, Formatters } from './chains.js';
+
+type AbiItem = Abi[number];
+type AbiEventParametersToPrimitiveTypes<TAbiParameters extends readonly AbiParameter[], TBase = TAbiParameters[0] extends {
+    name: string;
+} ? {} : []> = TAbiParameters extends readonly [infer Head, ...infer Tail] ? Head extends {
+    indexed: true;
+} ? Head extends AbiParameter ? Head extends {
+    name: infer Name;
+} ? Name extends string ? {
+    [name in Name]?: AbiParameterToPrimitiveType<Head> | AbiParameterToPrimitiveType<Head>[] | null;
+} & (Tail extends readonly [] ? {} : Tail extends readonly AbiParameter[] ? AbiEventParametersToPrimitiveTypes<Tail> : {}) : never : [
+    (AbiParameterToPrimitiveType<Head> | AbiParameterToPrimitiveType<Head>[] | null),
+    ...(Tail extends readonly [] ? [] : Tail extends readonly AbiParameter[] ? AbiEventParametersToPrimitiveTypes<Tail> : [])
+] : TBase : TBase : TBase;
+type ExtractArgsFromAbi<TAbi extends Abi | readonly unknown[], TFunctionName extends string, TAbiFunction extends AbiFunction & {
+    type: 'function';
+} = TAbi extends Abi ? ExtractAbiFunction<TAbi, TFunctionName> : AbiFunction & {
+    type: 'function';
+}, TArgs = AbiParametersToPrimitiveTypes<TAbiFunction['inputs']>, FailedToParseArgs = ([TArgs] extends [never] ? true : false) | (readonly unknown[] extends TArgs ? true : false)> = true extends FailedToParseArgs ? {
+    /**
+     * Arguments to pass contract method
+     *
+     * Use a [const assertion](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-4.html#const-assertions) on {@link abi} for type inference.
+     */
+    args?: readonly unknown[];
+} : TArgs extends readonly [] ? {
+    args?: never;
+} : {
+    /** Arguments to pass contract method */ args: TArgs;
+};
+type ExtractConstructorArgsFromAbi<TAbi extends Abi | readonly unknown[], TAbiFunction extends AbiFunction & {
+    type: 'constructor';
+} = TAbi extends Abi ? Extract<TAbi[number], {
+    type: 'constructor';
+}> : AbiFunction & {
+    type: 'constructor';
+}, TArgs = AbiParametersToPrimitiveTypes<TAbiFunction['inputs']>, FailedToParseArgs = ([TArgs] extends [never] ? true : false) | (readonly unknown[] extends TArgs ? true : false)> = true extends FailedToParseArgs ? {
+    /**
+     * Arguments to pass contract method
+     *
+     * Use a [const assertion](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-4.html#const-assertions) on {@link abi} for type inference.
+     */
+    args?: readonly unknown[];
+} : TArgs extends readonly [] ? {
+    args?: never;
+} : {
+    /** Arguments to pass contract method */ args: TArgs;
+};
+type ExtractErrorArgsFromAbi<TAbi extends Abi | readonly unknown[], TErrorName extends string, TAbiError extends AbiError = TAbi extends Abi ? ExtractAbiError<TAbi, TErrorName> : AbiError, TArgs = AbiParametersToPrimitiveTypes<TAbiError['inputs']>, FailedToParseArgs = ([TArgs] extends [never] ? true : false) | (readonly unknown[] extends TArgs ? true : false)> = true extends FailedToParseArgs ? {
+    /**
+     * Arguments to pass contract method
+     *
+     * Use a [const assertion](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-4.html#const-assertions) on {@link abi} for type inference.
+     */
+    args?: readonly unknown[];
+} : TArgs extends readonly [] ? {
+    args?: never;
+} : {
+    /** Arguments to pass contract method */ args: TArgs;
+};
+type ExtractEventArgsFromAbi<TAbi extends Abi | readonly unknown[], TFunctionName extends string, TAbiEvent extends AbiEvent & {
+    type: 'event';
+} = TAbi extends Abi ? ExtractAbiEvent<TAbi, TFunctionName> : AbiEvent & {
+    type: 'event';
+}, TArgs = AbiEventParametersToPrimitiveTypes<TAbiEvent['inputs']>, FailedToParseArgs = ([TArgs] extends [never] ? true : false) | (readonly unknown[] extends TArgs ? true : false)> = true extends FailedToParseArgs ? {
+    /**
+     * Arguments to pass contract method
+     *
+     * Use a [const assertion](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-4.html#const-assertions) on {@link abi} for type inference.
+     */
+    args?: readonly unknown[];
+} : TArgs extends readonly [] ? {
+    args?: never;
+} : {
+    args?: TArgs;
+};
+type ExtractFunctionNameFromAbi<TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = string, TAbiStateMutability extends AbiStateMutability = AbiStateMutability> = TAbi extends Abi ? ExtractAbiFunctionNames<TAbi, TAbiStateMutability> extends infer AbiFunctionNames ? AbiFunctionNames | (TFunctionName extends AbiFunctionNames ? TFunctionName : never) | (Abi extends TAbi ? string : never) : never : TFunctionName;
+type ExtractResultFromAbi<TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = string, TAbiFunction extends AbiFunction & {
+    type: 'function';
+} = TAbi extends Abi ? ExtractAbiFunction<TAbi, TFunctionName> : AbiFunction & {
+    type: 'function';
+}, TArgs = AbiParametersToPrimitiveTypes<TAbiFunction['outputs']>, FailedToParseArgs = ([TArgs] extends [never] ? true : false) | (readonly unknown[] extends TArgs ? true : false)> = true extends FailedToParseArgs ? unknown : TArgs extends readonly [] ? void : TArgs extends readonly [infer Arg] ? Arg : TArgs;
+type GetValue<TAbi extends Abi | readonly unknown[], TFunctionName extends string, TValueType = TransactionRequest['value'], TAbiFunction extends AbiFunction & {
+    type: 'function';
+} = TAbi extends Abi ? ExtractAbiFunction<TAbi, TFunctionName> : AbiFunction & {
+    type: 'function';
+}> = TAbiFunction['stateMutability'] extends 'payable' ? TValueType : TAbiFunction['payable'] extends true ? TValueType : never;
+
+type ExtractFormatter<TChain extends Chain, TKey extends keyof NonNullable<TChain['formatters']>, TFallbackFormatter extends Formatter = Formatter> = NonNullable<TChain['formatters']>[TKey] extends NonNullable<unknown> ? NonNullable<TChain['formatters']>[TKey] : TFallbackFormatter;
+type FormatOptions<TSource, TTarget> = {
+    formatter: Formatter<TSource, TTarget>;
+};
+/**
+ * Creates a type that is the result of applying `TFormatter` to `TSource`.
+ *
+ * @example
+ * Formatted<() => { a: undefined, b: bigint }, { a: bigint }>
+ * => { a: undefined, b: bigint }
+ *
+ * @example
+ * Formatted<() => {}, { a: bigint }>
+ * => { a: bigint }
+ *
+ * @example
+ * Formatted<() => { a: bigint | undefined, b: bigint }, { a: bigint, b: bigint }, true>
+ * => { a?: bigint | undefined, b: bigint }
+ */
+type Formatted<TFormatter, TFallback, TAllowOptional = false> = TFormatter extends Formatter ? ReturnType<TFormatter> extends Record<string, never> ? TFallback : TAllowOptional extends true ? OptionalNullable<ReturnType<TFormatter>> : ReturnType<TFormatter> : never;
+/**
+ * @description Formats a data object using the given replacer and an optional formatter.
+ */
+declare function format<TFormatter, TSource extends Record<string, any>, TTarget>(data: TSource, { formatter }: FormatOptions<TSource, TTarget>): Formatted<TFormatter, TTarget, false>;
+
+type BlockFormatter<TChain extends Chain = Chain> = ExtractFormatter<TChain, 'block', NonNullable<Formatters['block']>>;
+type FormattedBlock<TFormatter extends Formatter | undefined = Formatter> = Formatted<TFormatter, Block>;
+declare function formatBlock(block: Partial<RpcBlock>): Block<bigint, Transaction<bigint, number>>;
+
+type TransactionFormatter<TChain extends Chain = Chain> = ExtractFormatter<TChain, 'transaction', NonNullable<Formatters['transaction']>>;
+type FormattedTransaction<TFormatter extends Formatter | undefined = Formatter> = Formatted<TFormatter, Transaction>;
+declare function formatTransaction(transaction: Partial<RpcTransaction>): Transaction<bigint, number>;
+
+type TransactionReceiptFormatter<TChain extends Chain = Chain> = ExtractFormatter<TChain, 'transactionReceipt', NonNullable<Formatters['transactionReceipt']>>;
+type FormattedTransactionReceipt<TFormatter extends Formatter | undefined = Formatter> = Formatted<TFormatter, TransactionReceipt>;
+
+type TransactionRequestFormatter<TChain extends Chain = Chain> = ExtractFormatter<TChain, 'transactionRequest', NonNullable<Formatters['transactionRequest']>>;
+type FormattedTransactionRequest<TFormatter extends Formatter | undefined = Formatter> = Formatted<TFormatter, RpcTransactionRequest>;
+declare function formatTransactionRequest(transactionRequest: Partial<TransactionRequest>): RpcTransactionRequest;
+
+export { AbiItem as A, BlockFormatter as B, ExtractFunctionNameFromAbi as E, FormattedBlock as F, GetValue as G, TransactionRequestFormatter as T, FormattedTransaction as a, FormattedTransactionRequest as b, formatTransaction as c, formatTransactionRequest as d, Formatted as e, formatBlock as f, ExtractArgsFromAbi as g, ExtractResultFromAbi as h, TransactionFormatter as i, FormattedTransactionReceipt as j, TransactionReceiptFormatter as k, ExtractFormatter as l, ExtractConstructorArgsFromAbi as m, ExtractErrorArgsFromAbi as n, ExtractEventArgsFromAbi as o, format as p };

package/dist/utils/index.d.ts

@@ -1,11 +1,36 @@
-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, aa as buildRequest, 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 { B as BlockFormatter, E as ExtractFormatter, e as Formatted, F as FormattedBlock, a as FormattedTransaction, h as FormattedTransactionReceipt, b as FormattedTransactionRequest, g as TransactionFormatter, i as TransactionReceiptFormatter, T as TransactionRequestFormatter, j as format, f as formatBlock, c as formatTransaction, d as formatTransactionRequest } from '../transactionRequest-ade896ac.js';
-export { H as HttpRequestError, R as RpcError, T as TimeoutError, r as rpc } from '../rpc-3c0e3985.js';
-import '../rpc-655c0ba4.js';
+export { D as DecodeAbiArgs, a as DecodeErrorResultArgs, b as DecodeFunctionDataArgs, c as DecodeFunctionResultArgs, d as DecodeFunctionResultResponse, E as EncodeAbiArgs, e as EncodeDeployDataArgs, f as EncodeErrorResultArgs, g as EncodeEventTopicsArgs, h as EncodeFunctionDataArgs, i as EncodeFunctionResultArgs, l as EncodeRlpResponse, G as GetContractAddressOptions, k as GetCreate2AddressOptions, j as GetCreateAddressOptions, o as boolToBytes, p as boolToHex, q as bytesToBigint, r as bytesToBool, m as bytesToHex, s as bytesToNumber, n as bytesToString, t as decodeAbi, u as decodeBytes, v as decodeErrorResult, w as decodeFunctionData, x as decodeFunctionResult, y as decodeHex, z as decodeRlp, A as encodeAbi, B as encodeBytes, C as encodeDeployData, F as encodeErrorResult, H as encodeEventTopics, I as encodeFunctionData, J as encodeFunctionResult, K as encodeHex, L as encodeRlp, S as formatEther, a7 as formatGwei, a8 as formatUnit, M as getAddress, N as getContractAddress, P as getCreate2Address, O as getCreateAddress, Q as getEventSignature, R as getFunctionSignature, X as hexToBigInt, Y as hexToBool, Z as hexToBytes, a9 as hexToNumber, _ as hexToString, T as isAddress, U as isAddressEqual, V as isBytes, W as isHex, $ as keccak256, a0 as numberToBytes, aa as numberToHex, a1 as pad, a2 as padBytes, a3 as padHex, a4 as parseEther, a5 as parseGwei, a6 as parseUnit, ab as size, ac as slice, ad as sliceBytes, ae as sliceHex, af as stringToBytes, ag as stringToHex, ah as trim } from '../parseGwei-7c87ff41.js';
+import { A as AbiItem } from '../transactionRequest-08d30731.js';
+export { B as BlockFormatter, l as ExtractFormatter, e as Formatted, F as FormattedBlock, a as FormattedTransaction, j as FormattedTransactionReceipt, b as FormattedTransactionRequest, i as TransactionFormatter, k as TransactionReceiptFormatter, T as TransactionRequestFormatter, p as format, f as formatBlock, c as formatTransaction, d as formatTransactionRequest } from '../transactionRequest-08d30731.js';
+import * as abitype_dist_abi_b1bae27f from 'abitype/dist/abi-b1bae27f';
+import { Abi } from 'abitype';
+import { A as Address } from '../rpc-b77c5aee.js';
+export { r as rpc } from '../rpc-26932bae.js';
 import '../chains.js';
 import '@wagmi/chains';
 
+declare function formatAbiItemWithArgs({ abiItem, args, includeFunctionName, includeName, }: {
+    abiItem: AbiItem;
+    args: readonly unknown[];
+    includeFunctionName?: boolean;
+    includeName?: boolean;
+}): string | undefined;
+
+declare function formatAbiItemWithParams(abiItem: AbiItem, { includeName }?: {
+    includeName?: boolean;
+}): string;
+
+declare function getAbiItem({ abi, name }: {
+    abi: Abi;
+    name: string;
+}): abitype_dist_abi_b1bae27f.q | abitype_dist_abi_b1bae27f.p | abitype_dist_abi_b1bae27f.o | undefined;
+
+declare function buildRequest<TRequest extends (args: any) => Promise<any>>(request: TRequest): TRequest;
+
+declare function extractFunctionParts(def: string): {
+    type: string | undefined;
+    name: string | undefined;
+    params: string | undefined;
+};
 declare function extractFunctionName(def: string): string | undefined;
 declare function extractFunctionParams(def: string): {
     indexed?: boolean | undefined;
@@ -14,4 +39,14 @@ declare function extractFunctionParams(def: string): {
 }[] | undefined;
 declare function extractFunctionType(def: string): string | undefined;
 
-export { extractFunctionName, extractFunctionParams, extractFunctionType };
+declare function getContractError(err: unknown, { abi, address, args, functionName, sender, }: {
+    abi: Abi;
+    args: any;
+    address?: Address;
+    functionName: string;
+    sender?: Address;
+}): unknown;
+
+declare function stringify(value: unknown): string;
+
+export { buildRequest, extractFunctionName, extractFunctionParams, extractFunctionParts, extractFunctionType, formatAbiItemWithArgs, formatAbiItemWithParams, getAbiItem, getContractError, stringify };

package/dist/utils/index.js

@@ -1,21 +1,4 @@
 import {
-  BaseError,
-  HttpRequestError,
-  InternalRpcError,
-  InvalidInputRpcError,
-  InvalidParamsRpcError,
-  InvalidRequestRpcError,
-  JsonRpcVersionUnsupportedError,
-  LimitExceededRpcError,
-  MethodNotFoundRpcError,
-  MethodNotSupportedRpcError,
-  ParseRpcError,
-  ResourceNotFoundRpcError,
-  ResourceUnavailableRpcError,
-  RpcError,
-  RpcRequestError,
-  TimeoutError,
-  TransactionRejectedRpcError,
   boolToBytes,
   boolToHex,
   buildRequest,
@@ -24,24 +7,39 @@ import {
   bytesToHex,
   bytesToNumber,
   bytesToString,
+  decodeAbi,
   decodeBytes,
+  decodeErrorResult,
+  decodeFunctionData,
+  decodeFunctionResult,
   decodeHex,
   decodeRlp,
+  encodeAbi,
   encodeBytes,
+  encodeDeployData,
+  encodeErrorResult,
+  encodeEventTopics,
+  encodeFunctionData,
+  encodeFunctionResult,
   encodeHex,
   encodeRlp,
   extractFunctionName,
   extractFunctionParams,
+  extractFunctionParts,
   extractFunctionType,
   format,
+  formatAbiItemWithArgs,
+  formatAbiItemWithParams,
   formatBlock,
   formatEther,
   formatGwei,
   formatTransaction,
   formatTransactionRequest,
   formatUnit,
+  getAbiItem,
   getAddress,
   getContractAddress,
+  getContractError,
   getCreate2Address,
   getCreateAddress,
   getEventSignature,
@@ -71,26 +69,10 @@ import {
   sliceHex,
   stringToBytes,
   stringToHex,
+  stringify,
   trim
-} from "../chunk-GI67STNV.js";
+} from "../chunk-6GAKRM5P.js";
 export {
-  BaseError,
-  HttpRequestError,
-  InternalRpcError,
-  InvalidInputRpcError,
-  InvalidParamsRpcError,
-  InvalidRequestRpcError,
-  JsonRpcVersionUnsupportedError,
-  LimitExceededRpcError,
-  MethodNotFoundRpcError,
-  MethodNotSupportedRpcError,
-  ParseRpcError,
-  ResourceNotFoundRpcError,
-  ResourceUnavailableRpcError,
-  RpcError,
-  RpcRequestError,
-  TimeoutError,
-  TransactionRejectedRpcError,
   boolToBytes,
   boolToHex,
   buildRequest,
@@ -99,24 +81,39 @@ export {
   bytesToHex,
   bytesToNumber,
   bytesToString,
+  decodeAbi,
   decodeBytes,
+  decodeErrorResult,
+  decodeFunctionData,
+  decodeFunctionResult,
   decodeHex,
   decodeRlp,
+  encodeAbi,
   encodeBytes,
+  encodeDeployData,
+  encodeErrorResult,
+  encodeEventTopics,
+  encodeFunctionData,
+  encodeFunctionResult,
   encodeHex,
   encodeRlp,
   extractFunctionName,
   extractFunctionParams,
+  extractFunctionParts,
   extractFunctionType,
   format,
+  formatAbiItemWithArgs,
+  formatAbiItemWithParams,
   formatBlock,
   formatEther,
   formatGwei,
   formatTransaction,
   formatTransactionRequest,
   formatUnit,
+  getAbiItem,
   getAddress,
   getContractAddress,
+  getContractError,
   getCreate2Address,
   getCreateAddress,
   getEventSignature,
@@ -146,5 +143,6 @@ export {
   sliceHex,
   stringToBytes,
   stringToHex,
+  stringify,
   trim
 };