viem 0.0.1-alpha.3 → 0.0.1-alpha.31

package/dist/{eip1193-8b4d90ce.d.ts → eip1193-fcdeee04.d.ts}

@@ -1,4 +1,4 @@
-import { A as Address, H as Hash, Q as Quantity, s as RpcTransactionRequest, m as RpcBlockNumber, b as BlockTag, l as RpcBlockIdentifier, a as Hex, P as RpcEstimateGasParameters, n as RpcFeeHistory, R as RpcBlock, p as RpcLog, q as RpcTransaction, r as RpcTransactionReceipt, u as RpcUncle } from './rpc-15b85963.js';
+import { A as Address, a as Hash, a3 as Quantity, s as RpcTransactionRequest, m as RpcBlockNumber, g as BlockTag, l as RpcBlockIdentifier, H as Hex, n as RpcFeeHistory, R as RpcBlock, p as RpcLog, a6 as LogTopic, q as RpcTransaction, r as RpcTransactionReceipt, t as RpcUncle } from './chain-00b37e4e.js';
 
 declare class RpcError extends Error {
     code: number;
@@ -35,7 +35,7 @@ type Chain = {
         symbol: string;
         decimals: number;
     };
-    rpcUrls: string[];
+    rpcUrls: readonly string[];
     blockExplorerUrls?: string[];
     iconUrls?: string[];
 };
@@ -179,7 +179,7 @@ type PublicRequests = {
          * // => '0x5208'
          * */
         method: 'eth_estimateGas';
-        params: [parameters: RpcEstimateGasParameters, block: RpcBlockNumber | BlockTag];
+        params: [parameters: RpcTransactionRequest, block: RpcBlockNumber | BlockTag];
     }): Promise<Quantity>;
     request(args: {
         /**
@@ -331,22 +331,25 @@ type PublicRequests = {
          * @description Returns a list of all logs based on a filter object
          * @link https://eips.ethereum.org/EIPS/eip-1474
          * @example
-         * provider.request({ method: 'eth_getLogs', params: [{ ... }] })
+         * provider.request({ method: 'eth_getLogs', params: [{ fromBlock: '0x...', toBlock: '0x...', address: '0x...', topics: ['0x...'] }] })
          * // => [{ ... }, { ... }]
          * */
         method: 'eth_getLogs';
         params: [
-            filter: {
+            parameters: {
                 address?: Address | Address[];
-                topics?: Hex[];
+                topics?: LogTopic[];
             } & ({
                 fromBlock?: RpcBlockNumber | BlockTag;
                 toBlock?: RpcBlockNumber | BlockTag;
+                blockHash?: never;
             } | {
+                fromBlock?: never;
+                toBlock?: never;
                 blockHash?: Hash;
             })
         ];
-    }): Promise<RpcLog>;
+    }): Promise<RpcLog[]>;
     request(args: {
         /**
          * @description Returns the value from a storage position at an address
@@ -361,7 +364,7 @@ type PublicRequests = {
             index: Quantity,
             block: RpcBlockNumber | BlockTag | RpcBlockIdentifier
         ];
-    }): Promise<RpcLog>;
+    }): Promise<Hex>;
     request(args: {
         /**
          * @description Returns information about a transaction specified by block hash and transaction index
@@ -405,7 +408,7 @@ type PublicRequests = {
          * */
         method: 'eth_getTransactionCount';
         params: [address: Address, block: RpcBlockNumber | BlockTag | RpcBlockIdentifier];
-    }): Promise<Quantity | null>;
+    }): Promise<Quantity>;
     request(args: {
         /**
          * @description Returns the receipt of a transaction specified by hash
@@ -486,7 +489,7 @@ type PublicRequests = {
                 fromBlock?: RpcBlockNumber | BlockTag;
                 toBlock?: RpcBlockNumber | BlockTag;
                 address?: Address | Address[];
-                topics?: (Hex | Hex[] | null)[];
+                topics?: LogTopic[];
             }
         ];
     }): Promise<Quantity>;

package/dist/ens.d.ts

@@ -0,0 +1,22 @@
+export { z as GetEnsAddressArgs, A as GetEnsNameArgs, D as getEnsAddress, H as getEnsName } from './createPublicClient-99be385b.js';
+export { l as labelhash, n as namehash } from './namehash-88f4639d.js';
+import './eip1193-fcdeee04.js';
+import './chain-00b37e4e.js';
+import '@wagmi/chains';
+import 'abitype';
+import 'ethers@6/types/providers';
+import './createClient-5258d590.js';
+import './wallet-cf5c8351.js';
+
+/**
+ * @description Normalizes ENS name
+ *
+ * @example
+ * normalize('wagmi-dev.eth')
+ * 'wagmi-dev.eth'
+ *
+ * @see https://docs.ens.domains/contract-api-reference/name-processing#normalising-names
+ */
+declare function normalize(name: string): string;
+
+export { normalize };

package/dist/ens.js

@@ -0,0 +1,22 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+var _chunkMYFKW55Ljs = require('./chunk-MYFKW55L.js');
+require('./chunk-NCPBWOQA.js');
+require('./chunk-J7QHQ26Y.js');
+
+// src/utils/ens/normalize.ts
+var _idnauts46hx = require('idna-uts46-hx');
+function normalize(name) {
+  return _idnauts46hx.toUnicode.call(void 0, name, { useStd3ASCII: true });
+}
+
+
+
+
+
+
+exports.getEnsAddress = _chunkMYFKW55Ljs.getEnsAddress; exports.getEnsName = _chunkMYFKW55Ljs.getEnsName; exports.labelhash = _chunkMYFKW55Ljs.labelhash; exports.namehash = _chunkMYFKW55Ljs.namehash; exports.normalize = normalize;
+//# sourceMappingURL=ens.js.map

package/dist/ens.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/ens/normalize.ts"],"names":[],"mappings":";;;;;;;;;;AAAA,SAAS,iBAAiB;AAWnB,SAAS,UAAU,MAAc;AACtC,SAAO,UAAU,MAAM,EAAE,cAAc,KAAK,CAAC;AAC/C","sourcesContent":["import { toUnicode } from 'idna-uts46-hx'\n\n/**\n * @description Normalizes ENS name\n *\n * @example\n * normalize('wagmi-dev.eth')\n * 'wagmi-dev.eth'\n *\n * @see https://docs.ens.domains/contract-api-reference/name-processing#normalising-names\n */\nexport function normalize(name: string) {\n  return toUnicode(name, { useStd3ASCII: true })\n}\n"]}

package/dist/ens.mjs

@@ -0,0 +1,22 @@
+import {
+  getEnsAddress,
+  getEnsName,
+  labelhash,
+  namehash
+} from "./chunk-C54QK7K3.mjs";
+import "./chunk-IBWRBL2I.mjs";
+import "./chunk-6ZFIUYGC.mjs";
+
+// src/utils/ens/normalize.ts
+import { toUnicode } from "idna-uts46-hx";
+function normalize(name) {
+  return toUnicode(name, { useStd3ASCII: true });
+}
+export {
+  getEnsAddress,
+  getEnsName,
+  labelhash,
+  namehash,
+  normalize
+};
+//# sourceMappingURL=ens.mjs.map

package/dist/ens.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/ens/normalize.ts"],"sourcesContent":["import { toUnicode } from 'idna-uts46-hx'\n\n/**\n * @description Normalizes ENS name\n *\n * @example\n * normalize('wagmi-dev.eth')\n * 'wagmi-dev.eth'\n *\n * @see https://docs.ens.domains/contract-api-reference/name-processing#normalising-names\n */\nexport function normalize(name: string) {\n  return toUnicode(name, { useStd3ASCII: true })\n}\n"],"mappings":";;;;;;;;;;AAAA,SAAS,iBAAiB;AAWnB,SAAS,UAAU,MAAc;AACtC,SAAO,UAAU,MAAM,EAAE,cAAc,KAAK,CAAC;AAC/C;","names":[]}

package/dist/formatAbiItem-50cb39d8.d.ts

@@ -0,0 +1,14 @@
+import { b as AbiItem } from './chain-00b37e4e.js';
+
+declare function formatAbiItemWithArgs({ abiItem, args, includeFunctionName, includeName, }: {
+    abiItem: AbiItem;
+    args: readonly unknown[];
+    includeFunctionName?: boolean;
+    includeName?: boolean;
+}): string | undefined;
+
+declare function formatAbiItem(abiItem: AbiItem, { includeName }?: {
+    includeName?: boolean;
+}): string;
+
+export { formatAbiItem as a, formatAbiItemWithArgs as f };

package/dist/getAbiItem-6d4f64d2.d.ts

@@ -0,0 +1,97 @@
+import { AbiParameter, Narrow, Abi, AbiParametersToPrimitiveTypes } from 'abitype';
+import { H as Hex, b as AbiItem, a6 as LogTopic, a0 as ExtractEventNameFromAbi, a7 as ExtractEventArgsFromTopics, a8 as ExtractFunctionNameFromAbi, a9 as ExtractArgsFromAbi, Z as ExtractResultFromAbi, a4 as ExtractConstructorArgsFromAbi, aa as ExtractErrorNameFromAbi, ab as ExtractErrorArgsFromAbi, a1 as ExtractEventArgsFromAbi, ac as ExtractNameFromAbi } from './chain-00b37e4e.js';
+import * as abitype_dist_abi_78346466 from 'abitype/dist/abi-78346466';
+
+type DecodeAbiArgs<TParams extends readonly AbiParameter[] | readonly unknown[] = readonly AbiParameter[]> = {
+    data: Hex;
+    params: Narrow<TParams>;
+};
+declare function decodeAbi<TParams extends readonly AbiParameter[] | readonly unknown[]>({ data, params }: DecodeAbiArgs<TParams>): readonly unknown[] | undefined;
+
+type DecodeErrorResultArgs = {
+    abi?: Abi;
+    data: Hex;
+};
+type DecodeErrorResultResponse = {
+    abiItem: AbiItem;
+    errorName: string;
+    args?: readonly unknown[];
+};
+declare function decodeErrorResult({ abi, data, }: DecodeErrorResultArgs): DecodeErrorResultResponse;
+
+type DecodeEventLogArgs<TAbi extends Abi | readonly unknown[] = Abi, TEventName extends string = string, TTopics extends LogTopic[] = LogTopic[], TData extends Hex | undefined = undefined> = {
+    abi: Narrow<TAbi>;
+    data?: TData;
+    eventName?: ExtractEventNameFromAbi<TAbi, TEventName>;
+    topics: [signature: Hex, ...args: TTopics];
+};
+type DecodeEventLogResponse<TAbi extends Abi | readonly unknown[] = Abi, TEventName extends string = string, TTopics extends LogTopic[] = LogTopic[], TData extends Hex | undefined = undefined> = {
+    eventName: TEventName;
+} & ExtractEventArgsFromTopics<TAbi, TEventName, TTopics, TData>;
+declare function decodeEventLog<TAbi extends Abi | readonly unknown[], TEventName extends string, TTopics extends LogTopic[], TData extends Hex | undefined = undefined>({ abi, data, topics, }: DecodeEventLogArgs<TAbi, TEventName, TTopics, TData>): DecodeEventLogResponse<TAbi, TEventName, TTopics, TData>;
+
+type DecodeFunctionDataArgs = {
+    abi: Abi | readonly unknown[];
+    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 = string> = {
+    abi: Narrow<TAbi>;
+    functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>;
+    data: Hex;
+} & Partial<ExtractArgsFromAbi<TAbi, TFunctionName>>;
+type DecodeFunctionResultResponse<TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = string> = ExtractResultFromAbi<TAbi, TFunctionName>;
+declare function decodeFunctionResult<TAbi extends Abi | readonly unknown[], TFunctionName extends string>({ abi, args, functionName, data, }: DecodeFunctionResultArgs<TAbi, TFunctionName>): DecodeFunctionResultResponse<TAbi, TFunctionName>;
+
+type EncodeAbiArgs<TParams extends readonly AbiParameter[] | readonly unknown[] = readonly AbiParameter[]> = {
+    params: Narrow<TParams>;
+    values: TParams extends readonly AbiParameter[] ? AbiParametersToPrimitiveTypes<TParams> : never;
+};
+/**
+ * @description Encodes a list of primitive values into an ABI-encoded hex value.
+ */
+declare function encodeAbi<TParams extends readonly AbiParameter[] | readonly unknown[]>({ params, values }: EncodeAbiArgs<TParams>): `0x${string}`;
+
+type EncodeDeployDataArgs<TAbi extends Abi | readonly unknown[] = Abi> = {
+    abi: Narrow<TAbi>;
+    bytecode: Hex;
+} & ExtractConstructorArgsFromAbi<TAbi>;
+declare function encodeDeployData<TAbi extends Abi | readonly unknown[]>({ abi, args, bytecode, }: EncodeDeployDataArgs<TAbi>): `0x${string}`;
+
+type EncodeErrorResultArgs<TAbi extends Abi | readonly unknown[] = Abi, TErrorName extends string = string> = {
+    abi: Narrow<TAbi>;
+    errorName: ExtractErrorNameFromAbi<TAbi, TErrorName>;
+} & ExtractErrorArgsFromAbi<TAbi, TErrorName>;
+declare function encodeErrorResult<TAbi extends Abi | readonly unknown[], TErrorName extends string>({ abi, errorName, args }: EncodeErrorResultArgs<TAbi, TErrorName>): `0x${string}`;
+
+type EncodeEventTopicsArgs<TAbi extends Abi | readonly unknown[] = Abi, TEventName extends string = string> = {
+    abi: Narrow<TAbi>;
+    args?: ExtractEventArgsFromAbi<TAbi, TEventName>;
+    eventName: ExtractEventNameFromAbi<TAbi, TEventName>;
+};
+declare function encodeEventTopics<TAbi extends Abi | readonly unknown[], TEventName extends string>({ abi, eventName, args }: EncodeEventTopicsArgs<TAbi, TEventName>): `0x${string}`[];
+
+type EncodeFunctionDataArgs<TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = string> = {
+    abi: Narrow<TAbi>;
+    functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>;
+} & ExtractArgsFromAbi<TAbi, TFunctionName>;
+declare function encodeFunctionData<TAbi extends Abi | readonly unknown[], TFunctionName extends string>({ abi, args, functionName }: EncodeFunctionDataArgs<TAbi, TFunctionName>): `0x${string}`;
+
+type EncodeFunctionResultArgs<TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = string> = {
+    abi: Narrow<TAbi>;
+    functionName: ExtractFunctionNameFromAbi<TAbi, TFunctionName>;
+    result?: ExtractResultFromAbi<TAbi, TFunctionName>;
+};
+declare function encodeFunctionResult<TAbi extends Abi | readonly unknown[], TFunctionName extends string>({ abi, functionName, result, }: EncodeFunctionResultArgs<TAbi, TFunctionName>): `0x${string}`;
+
+type GetAbiItemArgs<TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = any> = {
+    abi: Narrow<TAbi>;
+    name: ExtractNameFromAbi<TAbi, TFunctionName>;
+} & Partial<ExtractArgsFromAbi<TAbi, TFunctionName>>;
+declare function getAbiItem<TAbi extends Abi | readonly unknown[], TFunctionName extends string>({ abi, args, name }: GetAbiItemArgs<TAbi, TFunctionName>): abitype_dist_abi_78346466.q | abitype_dist_abi_78346466.p | abitype_dist_abi_78346466.o | undefined;
+
+export { DecodeAbiArgs as D, EncodeAbiArgs as E, GetAbiItemArgs as G, DecodeErrorResultArgs as a, DecodeErrorResultResponse as b, DecodeEventLogArgs as c, DecodeEventLogResponse as d, DecodeFunctionDataArgs as e, DecodeFunctionResultArgs as f, DecodeFunctionResultResponse as g, EncodeDeployDataArgs as h, EncodeErrorResultArgs as i, EncodeEventTopicsArgs as j, EncodeFunctionDataArgs as k, EncodeFunctionResultArgs as l, decodeAbi as m, decodeErrorResult as n, decodeEventLog as o, decodeFunctionData as p, decodeFunctionResult as q, encodeAbi as r, encodeDeployData as s, encodeErrorResult as t, encodeEventTopics as u, encodeFunctionData as v, encodeFunctionResult as w, getAbiItem as x };