viem 0.0.1-alpha.24 → 0.0.1-alpha.26

package/dist/chunk-YTG4YXMB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/actions/wallet/addChain.ts","../src/actions/wallet/getAccounts.ts","../src/actions/wallet/getPermissions.ts","../src/actions/wallet/requestAccounts.ts","../src/actions/wallet/requestPermissions.ts","../src/actions/wallet/sendTransaction.ts","../src/actions/wallet/signMessage.ts","../src/actions/wallet/switchChain.ts","../src/actions/wallet/watchAsset.ts","../src/actions/wallet/writeContract.ts","../src/actions/wallet/deployContract.ts"],"names":[],"mappings":"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","sourcesContent":["import type { WalletClient } from '../../clients'\nimport type { Chain } from '../../types'\nimport { numberToHex } from '../../utils'\n\nexport async function addChain(client: WalletClient, chain: Chain) {\n  const { id, name, nativeCurrency, rpcUrls, blockExplorers } = chain\n  await client.request({\n    method: 'wallet_addEthereumChain',\n    params: [\n      {\n        chainId: numberToHex(id),\n        chainName: name,\n        nativeCurrency,\n        rpcUrls: rpcUrls.default.http,\n        blockExplorerUrls: blockExplorers\n          ? Object.values(blockExplorers).map(({ url }) => url)\n          : undefined,\n      },\n    ],\n  })\n}\n","import type { WalletClient } from '../../clients'\nimport { checksumAddress } from '../../utils/address'\n\nexport async function getAccounts(client: WalletClient) {\n  const addresses = await client.request({ method: 'eth_accounts' })\n  return addresses.map((address) => checksumAddress(address))\n}\n","import type { WalletClient } from '../../clients'\nimport type { WalletPermission } from '../../types/eip1193'\n\nexport type GetPermissionsResponse = WalletPermission[]\n\nexport async function getPermissions(client: WalletClient) {\n  const permissions = await client.request({ method: 'wallet_getPermissions' })\n  return permissions\n}\n","import type { WalletClient } from '../../clients'\nimport { getAddress } from '../../utils'\n\nexport async function requestAccounts(client: WalletClient) {\n  const addresses = await client.request({ method: 'eth_requestAccounts' })\n  return addresses.map((address) => getAddress(address))\n}\n","import type { WalletClient } from '../../clients'\nimport type { WalletPermission } from '../../types/eip1193'\n\nexport type RequestPermissionsArgs = {\n  eth_accounts: Record<string, any>\n} & {\n  [key: string]: Record<string, any>\n}\nexport type RequestPermissionsResponse = WalletPermission[]\n\nexport async function requestPermissions(\n  client: WalletClient,\n  permissions: RequestPermissionsArgs,\n) {\n  return client.request({\n    method: 'wallet_requestPermissions',\n    params: [permissions],\n  })\n}\n","import type { WalletClient } from '../../clients'\nimport { InvalidGasArgumentsError } from '../../errors'\nimport type {\n  Chain,\n  Formatter,\n  Hash,\n  MergeIntersectionProperties,\n  TransactionRequest,\n} from '../../types'\nimport type { Formatted, TransactionRequestFormatter } from '../../utils'\nimport { extract, format, formatTransactionRequest } from '../../utils'\n\nexport type FormattedTransactionRequest<\n  TFormatter extends Formatter | undefined = Formatter,\n> = MergeIntersectionProperties<\n  Formatted<TFormatter, TransactionRequest, true>,\n  TransactionRequest\n>\n\nexport type SendTransactionArgs<TChain extends Chain = Chain> =\n  FormattedTransactionRequest<TransactionRequestFormatter<TChain>> & {\n    chain?: TChain\n  }\n\nexport type SendTransactionResponse = Hash\n\nexport async function sendTransaction<TChain extends Chain>(\n  client: WalletClient,\n  {\n    chain,\n    from,\n    accessList,\n    data,\n    gas,\n    gasPrice,\n    maxFeePerGas,\n    maxPriorityFeePerGas,\n    nonce,\n    to,\n    value,\n    ...rest\n  }: SendTransactionArgs<TChain>,\n): Promise<SendTransactionResponse> {\n  if (\n    maxFeePerGas !== undefined &&\n    maxPriorityFeePerGas !== undefined &&\n    maxFeePerGas < maxPriorityFeePerGas\n  )\n    throw new InvalidGasArgumentsError()\n\n  const formatter = chain?.formatters?.transactionRequest\n  const request_ = format(\n    {\n      from,\n      accessList,\n      data,\n      gas,\n      gasPrice,\n      maxFeePerGas,\n      maxPriorityFeePerGas,\n      nonce,\n      to,\n      value,\n      // Pick out extra data that might exist on the chain's transaction request type.\n      ...extract(rest, { formatter }),\n    } as TransactionRequest,\n    {\n      formatter: formatter || formatTransactionRequest,\n    },\n  )\n\n  const hash = await client.request({\n    method: 'eth_sendTransaction',\n    params: [request_],\n  })\n  return hash\n}\n","import type { WalletClient } from '../../clients'\nimport { BaseError } from '../../errors'\nimport type { Address, ByteArray, Hex } from '../../types'\nimport { encodeHex } from '../../utils'\n\nexport type SignMessageArgs = {\n  from: Address\n  data: Hex | ByteArray\n}\n\nexport type SignMessageResponse = Hex\n\nexport async function signMessage(\n  client: WalletClient,\n  { from, data: data_ }: SignMessageArgs,\n): Promise<SignMessageResponse> {\n  let data\n  if (typeof data_ === 'string') {\n    if (!data_.startsWith('0x'))\n      throw new BaseError(\n        `data (\"${data_}\") must be a hex value. Encode it first to a hex with the \\`encodeHex\\` util.`,\n        {\n          docsPath: '/TODO',\n        },\n      )\n    data = data_\n  } else {\n    data = encodeHex(data_)\n  }\n  const signed = await client.request({\n    method: 'personal_sign',\n    params: [data, from],\n  })\n  return signed\n}\n","import type { WalletClient } from '../../clients'\nimport { Chain } from '../../types'\nimport { numberToHex } from '../../utils'\n\nexport type SwitchChainArgs = { id: Chain['id'] }\n\nexport async function switchChain(\n  client: WalletClient,\n  { id }: SwitchChainArgs,\n) {\n  await client.request({\n    method: 'wallet_switchEthereumChain',\n    params: [\n      {\n        chainId: numberToHex(id),\n      },\n    ],\n  })\n}\n","import type { WalletClient } from '../../clients'\nimport type { WatchAssetParams } from '../../types/eip1193'\n\nexport type WatchAssetArgs = WatchAssetParams\nexport type WatchAssetResponse = boolean\n\nexport async function watchAsset(\n  client: WalletClient,\n  params: WatchAssetParams,\n): Promise<WatchAssetResponse> {\n  const added = await client.request({\n    method: 'wallet_watchAsset',\n    params: [params],\n  })\n  return added\n}\n","import { Abi } from 'abitype'\n\nimport type { WalletClient } from '../../clients'\nimport type { Chain, ContractConfig, GetValue } from '../../types'\nimport { EncodeFunctionDataArgs, encodeFunctionData } from '../../utils'\nimport {\n  sendTransaction,\n  SendTransactionArgs,\n  SendTransactionResponse,\n} from './sendTransaction'\n\nexport type WriteContractArgs<\n  TChain extends Chain = Chain,\n  TAbi extends Abi | readonly unknown[] = Abi,\n  TFunctionName extends string = string,\n> = Omit<SendTransactionArgs<TChain>, 'to' | 'data' | 'value'> & {\n  value?: GetValue<TAbi, TFunctionName, SendTransactionArgs<TChain>['value']>\n} & ContractConfig<TAbi, TFunctionName, 'payable' | 'nonpayable'>\n\nexport type WriteContractResponse = SendTransactionResponse\n\nexport async function writeContract<\n  TChain extends Chain,\n  TAbi extends Abi | readonly unknown[],\n  TFunctionName extends string,\n>(\n  client: WalletClient,\n  {\n    abi,\n    address,\n    args,\n    functionName,\n    ...request\n  }: WriteContractArgs<TChain, TAbi, TFunctionName>,\n): Promise<WriteContractResponse> {\n  const data = encodeFunctionData({\n    abi,\n    args,\n    functionName,\n  } as unknown as EncodeFunctionDataArgs<TAbi, TFunctionName>)\n  const hash = await sendTransaction(client, {\n    data,\n    to: address,\n    ...request,\n  } as unknown as SendTransactionArgs<TChain>)\n  return hash\n}\n","import { Abi, Narrow } from 'abitype'\nimport { WalletClient } from '../../clients'\n\nimport { Chain, ExtractConstructorArgsFromAbi, Hex } from '../../types'\nimport { encodeDeployData } from '../../utils'\nimport {\n  sendTransaction,\n  SendTransactionArgs,\n  SendTransactionResponse,\n} from '../wallet'\n\nexport type DeployContractArgs<\n  TChain extends Chain = Chain,\n  TAbi extends Abi | readonly unknown[] = Abi,\n> = Omit<\n  SendTransactionArgs<TChain>,\n  'accessList' | 'to' | 'data' | 'value'\n> & {\n  abi: Narrow<TAbi>\n  bytecode: Hex\n} & ExtractConstructorArgsFromAbi<TAbi>\n\nexport type DeployContractResponse = SendTransactionResponse\n\nexport function deployContract<TChain extends Chain, TAbi extends Abi>(\n  walletClient: WalletClient,\n  { abi, args, bytecode, ...request }: DeployContractArgs<TChain, TAbi>,\n): Promise<DeployContractResponse> {\n  const calldata = encodeDeployData({\n    abi,\n    args,\n    bytecode,\n  } as unknown as DeployContractArgs<TChain, TAbi>)\n  return sendTransaction(walletClient, {\n    ...request,\n    data: calldata,\n  } as unknown as SendTransactionArgs<TChain>)\n}\n"]}

package/dist/{contract-70f4ddbe.d.ts → contract-9dd2f98b.d.ts}

@@ -1,42 +1,44 @@
-import { C as Chain, Q as ExtractFormatter, W as Formatters, K as Formatter, N as Formatted, e as Block, R as RpcBlock, x as Transaction, T as TransactionReceipt, p as RpcTransactionReceipt, S as TransactionType, A as Address, s as TransactionRequest, X as Trim } from './chain-afa13f5a.js';
 import { Abi, AbiFunction, ExtractAbiFunction, AbiParametersToPrimitiveTypes, AbiError, ExtractAbiError, AbiEvent, ExtractAbiEvent, ExtractAbiErrorNames, ExtractAbiEventNames, AbiStateMutability, ExtractAbiFunctionNames, Narrow, AbiParameter, AbiParameterToPrimitiveType, AbiType, AbiTypeToPrimitiveType } from 'abitype';
-
-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>>;
-declare const defineBlock: <TFormat extends Formatter<Partial<RpcBlock>, Partial<Block<bigint, Transaction<bigint, number>>> & {
-    [key: string]: unknown;
-}>, TExclude extends (keyof RpcBlock)[] = []>({ exclude, format: formatOverride, }: {
-    exclude?: TExclude | undefined;
-    format?: TFormat | undefined;
-}) => (data: Partial<RpcBlock> & {
-    [key: string]: unknown;
-}) => Block<bigint, Transaction<bigint, number>> & ReturnType<TFormat> & { [K in TExclude[number]]: never; };
-
-type TransactionReceiptFormatter<TChain extends Chain = Chain> = ExtractFormatter<TChain, 'transactionReceipt', NonNullable<Formatters['transactionReceipt']>>;
-type FormattedTransactionReceipt<TFormatter extends Formatter | undefined = Formatter> = Formatted<TFormatter, TransactionReceipt>;
-declare const defineTransactionReceipt: <TFormat extends Formatter<Partial<RpcTransactionReceipt>, Partial<TransactionReceipt<bigint, number, "success" | "reverted", TransactionType>> & {
-    [key: string]: unknown;
-}>, TExclude extends (keyof RpcTransactionReceipt)[] = []>({ exclude, format: formatOverride, }: {
-    exclude?: TExclude | undefined;
-    format?: TFormat | undefined;
-}) => (data: Partial<RpcTransactionReceipt> & {
-    [key: string]: unknown;
-}) => TransactionReceipt<bigint, number, "success" | "reverted", TransactionType> & ReturnType<TFormat> & { [K in TExclude[number]]: never; };
+import { G as LogTopic, H as Hex, A as Address, P as Prettify, s as TransactionRequest, N as NoUndefined, I as Trim } from './chain-42de87e5.js';
 
 type AbiItem = Abi[number];
+type HashedEventTypes = 'string' | 'bytes' | 'tuple' | `${string}[${string}]`;
+type EventTopicParam<TPrimitiveType = Hex, TTopic extends LogTopic = LogTopic> = NoUndefined<(TTopic extends Hex ? TPrimitiveType : undefined) | (TTopic extends Hex[] ? TPrimitiveType[] : undefined) | (TTopic extends null ? null : undefined)>;
+type AbiEventParameterToPrimitiveType<TParam extends AbiParameter> = EventTopicParam<AbiParameterToPrimitiveType<TParam>>;
 type AbiEventParametersToPrimitiveTypes<TAbiParameters extends readonly AbiParameter[], TBase = TAbiParameters[0] extends {
     name: string;
-} ? {} : []> = TAbiParameters extends readonly [infer Head, ...infer Tail] ? Head extends {
+} ? {} : []> = Prettify<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;
+    [name in Name]?: AbiEventParameterToPrimitiveType<Head>;
 } & (Tail extends readonly [] ? {} : Tail extends readonly AbiParameter[] ? AbiEventParametersToPrimitiveTypes<Tail> : {}) : never : [
-    (AbiParameterToPrimitiveType<Head> | AbiParameterToPrimitiveType<Head>[] | null),
+    AbiEventParameterToPrimitiveType<Head>,
     ...(Tail extends readonly [] ? [] : Tail extends readonly AbiParameter[] ? AbiEventParametersToPrimitiveTypes<Tail> : [])
-] : TBase : TBase : TBase;
+] : TBase : TBase : TBase>;
+type AbiEventTopicToPrimitiveType<TParam extends AbiParameter, TTopic extends LogTopic, TPrimitiveType = TParam['type'] extends HashedEventTypes ? TTopic : AbiParameterToPrimitiveType<TParam>> = EventTopicParam<TPrimitiveType, TTopic>;
+type AbiEventTopicsToPrimitiveTypes<TAbiParameters extends readonly AbiParameter[], TTopics extends LogTopic[] | undefined = undefined, TData extends Hex | undefined = undefined, TBase = TAbiParameters[0] extends {
+    name: string;
+} ? {} : []> = Prettify<TAbiParameters extends readonly [infer Head, ...infer Tail] ? TTopics extends readonly [infer TopicHead, ...infer TopicTail] ? Head extends {
+    indexed: true;
+} ? Head extends AbiParameter ? Head extends {
+    name: infer Name;
+} ? Name extends string ? {
+    [name in Name]: TopicHead extends LogTopic ? AbiEventTopicToPrimitiveType<Head, TopicHead> : never;
+} & (Tail extends readonly [] ? {} : Tail extends readonly AbiParameter[] ? TopicTail extends LogTopic[] ? AbiEventTopicsToPrimitiveTypes<Tail, TopicTail, TData> : {} : {}) : never : [
+    TopicHead extends LogTopic ? AbiEventTopicToPrimitiveType<Head, TopicHead> : never,
+    ...(Tail extends readonly [] ? [] : Tail extends readonly AbiParameter[] ? TopicTail extends LogTopic[] ? AbiEventTopicsToPrimitiveTypes<Tail, TopicTail, TData> : [] : [])
+] : TBase : TBase : TTopics extends readonly [] ? TData extends Hex ? Head extends AbiParameter ? Head extends {
+    indexed: true;
+} ? Tail extends readonly AbiParameter[] ? AbiEventTopicsToPrimitiveTypes<Tail, [], TData> : TBase : Head extends {
+    name: infer Name;
+} ? Name extends string ? {
+    [name in Name]: AbiParameterToPrimitiveType<Head>;
+} & (Tail extends readonly [] ? {} : Tail extends readonly AbiParameter[] ? AbiEventTopicsToPrimitiveTypes<Tail, [], TData> : {}) : never : [
+    AbiParameterToPrimitiveType<Head>,
+    ...(Tail extends readonly [] ? [] : Tail extends readonly AbiParameter[] ? AbiEventTopicsToPrimitiveTypes<Tail, [], TData> : [])
+] : TBase : TBase : TBase : undefined>;
 type ExtractArgsFromAbi<TAbi extends Abi | readonly unknown[], TFunctionName extends string, TAbiFunction extends AbiFunction & {
     type: 'function';
 } = TAbi extends Abi ? ExtractAbiFunction<TAbi, TFunctionName> : AbiFunction & {
@@ -99,6 +101,17 @@ type ExtractEventArgsFromAbi<TAbi extends Abi | readonly unknown[], TEventName e
 } : {
     args?: TArgs;
 };
+type ExtractEventArgsFromTopics<TAbi extends Abi | readonly unknown[], TEventName extends string, TTopics extends LogTopic[], TData extends Hex | undefined, TAbiEvent extends AbiEvent & {
+    type: 'event';
+} = TAbi extends Abi ? ExtractAbiEvent<TAbi, TEventName> : AbiEvent & {
+    type: 'event';
+}, TArgs = AbiEventTopicsToPrimitiveTypes<TAbiEvent['inputs'], TTopics, TData>> = TTopics extends readonly [] ? TData extends undefined ? {
+    args?: never;
+} : {
+    args?: TArgs;
+} : {
+    args?: TArgs;
+};
 type ExtractErrorNameFromAbi<TAbi extends Abi | readonly unknown[] = Abi, TErrorName extends string = string> = TAbi extends Abi ? ExtractAbiErrorNames<TAbi> extends infer AbiErrorNames ? AbiErrorNames | (TErrorName extends AbiErrorNames ? TErrorName : never) | (Abi extends TAbi ? string : never) : never : TErrorName;
 type ExtractEventNameFromAbi<TAbi extends Abi | readonly unknown[] = Abi, TEventName extends string = string> = TAbi extends Abi ? ExtractAbiEventNames<TAbi> extends infer AbiEventNames ? AbiEventNames | (TEventName extends AbiEventNames ? TEventName : never) | (Abi extends TAbi ? string : never) : never : TEventName;
 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;
@@ -133,9 +146,9 @@ type ExtractTypeFromArg<TArg, TRest = unknown, TConfig extends ExtractArgsFromDe
 ] : never : TRest : TRest;
 type ExtractTypesFromArgs<TArgs, TConfig extends ExtractArgsFromDefinitionConfig = ExtractArgsFromDefinitionDefaultConfig> = Trim<TArgs> extends `${infer Head},${infer Tail}` ? ExtractTypeFromArg<Head, ExtractTypesFromArgs<Tail, TConfig>, TConfig> : ExtractTypeFromArg<Trim<TArgs>, Trim<TArgs> extends NamedArg<string, string> ? Trim<TArgs> extends IndexedArg<string> ? [] : unknown : [], TConfig>;
 type ExtractArgsFromDefinition<TDef, TConfig extends ExtractArgsFromDefinitionConfig = ExtractArgsFromDefinitionDefaultConfig> = TDef extends `${string}(${infer Args})` ? ExtractTypesFromArgs<Args, TConfig> : 'Error: Invalid definition was provided.';
-type ExtractArgsFromEventDefinition<TDef, TConfig extends ExtractArgsFromDefinitionConfig = {
+type ExtractArgsFromEventDefinition<TDef extends EventDefinition | undefined, TConfig extends ExtractArgsFromDefinitionConfig = {
     indexedOnly: true;
-}> = ExtractArgsFromDefinition<TDef, TConfig> extends [...args: any] ? ExtractArgsFromDefinition<TDef, TConfig> | [] : ExtractArgsFromDefinition<TDef, TConfig>;
+}> = Prettify<TDef extends EventDefinition ? ExtractArgsFromDefinition<TDef, TConfig> extends [...args: any] ? ExtractArgsFromDefinition<TDef, TConfig> | [] : ExtractArgsFromDefinition<TDef, TConfig> : undefined>;
 type ContractConfig<TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = string, TAbiStateMutability extends AbiStateMutability = AbiStateMutability> = {
     /** Contract ABI */
     abi: Narrow<TAbi>;
@@ -150,4 +163,4 @@ type GetValue<TAbi extends Abi | readonly unknown[], TFunctionName extends strin
     type: 'function';
 }> = TAbiFunction['stateMutability'] extends 'payable' ? TValueType : TAbiFunction['payable'] extends true ? TValueType : never;
 
-export { AbiItem as A, BlockFormatter as B, ContractConfig as C, ExtractResultFromAbi as E, FormattedBlock as F, GetValue as G, TransactionReceiptFormatter as T, EventDefinition as a, ExtractArgsFromEventDefinition as b, ExtractEventNameFromAbi as c, ExtractEventArgsFromAbi as d, ExtractConstructorArgsFromAbi as e, formatBlock as f, FormattedTransactionReceipt as g, ExtractFunctionNameFromAbi as h, ExtractArgsFromAbi as i, ExtractErrorNameFromAbi as j, ExtractErrorArgsFromAbi as k, ExtractNameFromAbi as l, defineBlock as m, defineTransactionReceipt as n };
+export { AbiItem as A, ContractConfig as C, ExtractResultFromAbi as E, GetValue as G, ExtractConstructorArgsFromAbi as a, ExtractEventNameFromAbi as b, ExtractEventArgsFromAbi as c, ExtractEventArgsFromTopics as d, ExtractFunctionNameFromAbi as e, ExtractArgsFromAbi as f, ExtractErrorNameFromAbi as g, ExtractErrorArgsFromAbi as h, ExtractNameFromAbi as i, EventDefinition as j, ExtractArgsFromEventDefinition as k };

package/dist/contract.d.ts

@@ -0,0 +1,129 @@
+export { D as DecodeAbiArgs, a as DecodeEventLogArgs, b as DecodeEventLogResponse, c as DecodeFunctionDataArgs, d as DecodeFunctionResultArgs, e as DecodeFunctionResultResponse, E as EncodeAbiArgs, f as EncodeDeployDataArgs, g as EncodeErrorResultArgs, h as EncodeEventTopicsArgs, i as EncodeFunctionDataArgs, j as EncodeFunctionResultArgs, G as GetAbiItemArgs, k as decodeAbi, l as decodeEventLog, m as decodeFunctionData, n as decodeFunctionResult, o as encodeAbi, p as encodeDeployData, q as encodeErrorResult, r as encodeEventTopics, s as encodeFunctionData, t as encodeFunctionResult, v as formatAbiItem, u as formatAbiItemWithArgs, w as getAbiItem } from './getAbiItem-d2e8bd76.js';
+export { a as DecodeErrorResultArgs, D as DecodeErrorResultResponse, d as decodeErrorResult } from './decodeErrorResult-ac835649.js';
+import { Abi, Narrow } from 'abitype';
+import { C as Chain, H as Hex, A as Address, b as BlockTag, L as Log } from './chain-42de87e5.js';
+import { C as ContractConfig, E as ExtractResultFromAbi, a as ExtractConstructorArgsFromAbi, G as GetValue, b as ExtractEventNameFromAbi, c as ExtractEventArgsFromAbi } from './contract-9dd2f98b.js';
+import { P as PublicClient } from './createPublicClient-fd558574.js';
+import { W as WalletClient } from './createWalletClient-4df88244.js';
+import { S as SendTransactionArgs, a as SendTransactionResponse } from './sendTransaction-7ce442c0.js';
+import { C as CallArgs } from './call-3476b8ee.js';
+export { G as GetBytecodeArgs, a as GetBytecodeResponse, O as OnLogs, b as OnLogsResponse, g as getBytecode } from './watchEvent-569c9976.js';
+export { R as ReadContractArgs, a as ReadContractResponse, r as readContract } from './readContract-c460f23a.js';
+import 'abitype/dist/abi-78346466';
+import '@wagmi/chains';
+import './eip1193-617a05ae.js';
+import './createClient-6689596e.js';
+import './transactionRequest-f437b4ba.js';
+
+type MAXIMUM_DEPTH = 20;
+type Contract<TAbi extends Abi | readonly unknown[] = Abi | readonly unknown[], TFunctionName extends string = string> = {
+    abi: TAbi;
+    functionName: TFunctionName;
+};
+type MulticallContracts<TContracts extends Contract[], TProperties extends Record<string, any> = object, Result extends any[] = [], Depth extends ReadonlyArray<number> = []> = Depth['length'] extends MAXIMUM_DEPTH ? (ContractConfig & TProperties)[] : TContracts extends [] ? [] : TContracts extends [infer Head extends Contract] ? [
+    ...Result,
+    ContractConfig<Head['abi'], Head['functionName']> & TProperties
+] : TContracts extends [
+    infer Head extends Contract,
+    ...infer Tail extends Contract[]
+] ? MulticallContracts<[
+    ...Tail
+], TProperties, [
+    ...Result,
+    ContractConfig<Head['abi'], Head['functionName']> & TProperties
+], [
+    ...Depth,
+    1
+]> : unknown[] extends TContracts ? TContracts : TContracts extends ContractConfig<infer TAbi, infer TFunctionName>[] ? (ContractConfig<TAbi, TFunctionName> & TProperties)[] : (ContractConfig & TProperties)[];
+type MulticallResult<Result, TAllowFailure extends boolean = true> = TAllowFailure extends true ? ({
+    error?: undefined;
+    result: Result;
+    status: 'success';
+} | {
+    error: Error;
+    result?: undefined;
+    status: 'error';
+}) : Result;
+type MulticallResults<TContracts extends Contract[], TAllowFailure extends boolean = true, Result extends any[] = [], Depth extends ReadonlyArray<number> = []> = Depth['length'] extends MAXIMUM_DEPTH ? MulticallResult<ExtractResultFromAbi, TAllowFailure>[] : TContracts extends [] ? [] : TContracts extends [infer Head extends Contract] ? [...Result, MulticallResult<ExtractResultFromAbi<Head['abi'], Head['functionName']>, TAllowFailure>] : TContracts extends [
+    infer Head extends Contract,
+    ...infer Tail extends Contract[]
+] ? MulticallResults<[
+    ...Tail
+], TAllowFailure, [
+    ...Result,
+    MulticallResult<ExtractResultFromAbi<Head['abi'], Head['functionName']>, TAllowFailure>
+], [
+    ...Depth,
+    1
+]> : TContracts extends ContractConfig<infer TAbi, infer TFunctionName>[] ? MulticallResult<ExtractResultFromAbi<TAbi, TFunctionName>, TAllowFailure>[] : MulticallResult<ExtractResultFromAbi, TAllowFailure>[];
+
+type DeployContractArgs<TChain extends Chain = Chain, TAbi extends Abi | readonly unknown[] = Abi> = Omit<SendTransactionArgs<TChain>, 'accessList' | 'to' | 'data' | 'value'> & {
+    abi: Narrow<TAbi>;
+    bytecode: Hex;
+} & ExtractConstructorArgsFromAbi<TAbi>;
+type DeployContractResponse = SendTransactionResponse;
+declare function deployContract<TChain extends Chain, TAbi extends Abi>(walletClient: WalletClient, { abi, args, bytecode, ...request }: DeployContractArgs<TChain, TAbi>): Promise<DeployContractResponse>;
+
+type WriteContractArgs<TChain extends Chain = Chain, TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = string> = Omit<SendTransactionArgs<TChain>, 'to' | 'data' | 'value'> & {
+    value?: GetValue<TAbi, TFunctionName, SendTransactionArgs<TChain>['value']>;
+} & ContractConfig<TAbi, TFunctionName, 'payable' | 'nonpayable'>;
+type WriteContractResponse = SendTransactionResponse;
+declare function writeContract<TChain extends Chain, TAbi extends Abi | readonly unknown[], TFunctionName extends string>(client: WalletClient, { abi, address, args, functionName, ...request }: WriteContractArgs<TChain, TAbi, TFunctionName>): Promise<WriteContractResponse>;
+
+type SimulateContractArgs<TChain extends Chain = Chain, TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = any> = Omit<CallArgs<TChain>, 'to' | 'data' | 'value'> & ContractConfig<TAbi, TFunctionName, 'payable' | 'nonpayable'> & {
+    value?: GetValue<TAbi, TFunctionName, CallArgs<TChain>['value']>;
+};
+type SimulateContractResponse<TChain extends Chain = Chain, TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = string> = {
+    result: ExtractResultFromAbi<TAbi, TFunctionName>;
+    request: WriteContractArgs<TChain, TAbi, TFunctionName> & ContractConfig<TAbi, TFunctionName, 'payable' | 'nonpayable'>;
+};
+declare function simulateContract<TChain extends Chain, TAbi extends Abi | readonly unknown[], TFunctionName extends string>(client: PublicClient<any, TChain>, { abi, address, args, functionName, ...callRequest }: SimulateContractArgs<TChain, TAbi, TFunctionName>): Promise<SimulateContractResponse<TChain, TAbi, TFunctionName>>;
+
+type EstimateContractGasArgs<TChain extends Chain = Chain, TAbi extends Abi | readonly unknown[] = Abi, TFunctionName extends string = any> = Omit<CallArgs<TChain>, 'to' | 'data' | 'value'> & ContractConfig<TAbi, TFunctionName, 'payable' | 'nonpayable'> & {
+    value?: GetValue<TAbi, TFunctionName, CallArgs<TChain>['value']>;
+};
+type EstimateContractGasResponse = bigint;
+declare function estimateContractGas<TChain extends Chain, TAbi extends Abi | readonly unknown[], TFunctionName extends string>(client: PublicClient<any, TChain>, { abi, address, args, functionName, ...request }: EstimateContractGasArgs<TChain, TAbi, TFunctionName>): Promise<EstimateContractGasResponse>;
+
+type GetStorageAtArgs = {
+    address: Address;
+    slot: Hex;
+} & ({
+    blockNumber?: never;
+    blockTag?: BlockTag;
+} | {
+    blockNumber?: bigint;
+    blockTag?: never;
+});
+type GetStorageAtResponse = Hex | undefined;
+declare function getStorageAt(client: PublicClient, { address, blockNumber, blockTag, slot }: GetStorageAtArgs): Promise<GetStorageAtResponse>;
+
+type MulticallArgs<TContracts extends ContractConfig[] = ContractConfig[], TAllowFailure extends boolean = true> = Pick<CallArgs, 'blockNumber' | 'blockTag'> & {
+    allowFailure?: TAllowFailure;
+    contracts: readonly [...MulticallContracts<TContracts>];
+    multicallAddress: Address;
+};
+type MulticallResponse<TContracts extends ContractConfig[] = ContractConfig[], TAllowFailure extends boolean = true> = MulticallResults<TContracts, TAllowFailure>;
+declare function multicall<TContracts extends ContractConfig[], TAllowFailure extends boolean = true>(client: PublicClient, args: MulticallArgs<TContracts, TAllowFailure>): Promise<MulticallResponse<TContracts, TAllowFailure>>;
+
+type OnLogsResponse = Log[];
+type OnLogs = (logs: OnLogsResponse) => void;
+type WatchContractEventArgs<TAbi extends Abi | readonly unknown[] = Abi, TEventName extends string = any> = {
+    /** The address of the contract. */
+    address: Address | Address[];
+    /** Contract ABI. */
+    abi: TAbi;
+    /** Whether or not the event logs should be batched on each invocation. */
+    batch?: boolean;
+    /** Contract event. */
+    eventName?: ExtractEventNameFromAbi<TAbi, TEventName>;
+    /** The callback to call when an error occurred when trying to get for a new block. */
+    onError?: (error: Error) => void;
+    /** The callback to call when new event logs are received. */
+    onLogs: OnLogs;
+    /** Polling frequency (in ms). Defaults to Client's pollingInterval config. */
+    pollingInterval?: number;
+} & ExtractEventArgsFromAbi<TAbi, TEventName>;
+declare function watchContractEvent<TAbi extends Abi | readonly unknown[] = Abi, TEventName extends string = any>(client: PublicClient, { abi, address, args, batch, eventName, onError, onLogs, pollingInterval, }: WatchContractEventArgs<TAbi, TEventName>): () => void;
+
+export { DeployContractArgs, DeployContractResponse, EstimateContractGasArgs, EstimateContractGasResponse, GetStorageAtArgs, GetStorageAtResponse, MulticallArgs, MulticallResponse, SimulateContractArgs, SimulateContractResponse, WatchContractEventArgs, WriteContractArgs, WriteContractResponse, deployContract, estimateContractGas, getStorageAt, multicall, simulateContract, watchContractEvent, writeContract };

package/dist/contract.js

@@ -0,0 +1,55 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+var _chunkLINNE4N4js = require('./chunk-LINNE4N4.js');
+
+
+
+var _chunkYTG4YXMBjs = require('./chunk-YTG4YXMB.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkDSQO3E4Fjs = require('./chunk-DSQO3E4F.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.decodeAbi = _chunkDSQO3E4Fjs.decodeAbi; exports.decodeErrorResult = _chunkDSQO3E4Fjs.decodeErrorResult; exports.decodeEventLog = _chunkDSQO3E4Fjs.decodeEventLog; exports.decodeFunctionData = _chunkDSQO3E4Fjs.decodeFunctionData; exports.decodeFunctionResult = _chunkDSQO3E4Fjs.decodeFunctionResult; exports.deployContract = _chunkYTG4YXMBjs.deployContract; exports.encodeAbi = _chunkDSQO3E4Fjs.encodeAbi; exports.encodeDeployData = _chunkDSQO3E4Fjs.encodeDeployData; exports.encodeErrorResult = _chunkDSQO3E4Fjs.encodeErrorResult; exports.encodeEventTopics = _chunkDSQO3E4Fjs.encodeEventTopics; exports.encodeFunctionData = _chunkDSQO3E4Fjs.encodeFunctionData; exports.encodeFunctionResult = _chunkDSQO3E4Fjs.encodeFunctionResult; exports.estimateContractGas = _chunkLINNE4N4js.estimateContractGas; exports.formatAbiItem = _chunkDSQO3E4Fjs.formatAbiItem; exports.formatAbiItemWithArgs = _chunkDSQO3E4Fjs.formatAbiItemWithArgs; exports.getAbiItem = _chunkDSQO3E4Fjs.getAbiItem; exports.getBytecode = _chunkLINNE4N4js.getBytecode; exports.getStorageAt = _chunkLINNE4N4js.getStorageAt; exports.multicall = _chunkLINNE4N4js.multicall; exports.readContract = _chunkLINNE4N4js.readContract; exports.simulateContract = _chunkLINNE4N4js.simulateContract; exports.watchContractEvent = _chunkLINNE4N4js.watchContractEvent; exports.writeContract = _chunkYTG4YXMBjs.writeContract;
+//# sourceMappingURL=contract.js.map

package/dist/contract.mjs

@@ -0,0 +1,55 @@
+import {
+  estimateContractGas,
+  getBytecode,
+  getStorageAt,
+  multicall,
+  readContract,
+  simulateContract,
+  watchContractEvent
+} from "./chunk-QSIX64VZ.mjs";
+import {
+  deployContract,
+  writeContract
+} from "./chunk-BSAB6UH4.mjs";
+import {
+  decodeAbi,
+  decodeErrorResult,
+  decodeEventLog,
+  decodeFunctionData,
+  decodeFunctionResult,
+  encodeAbi,
+  encodeDeployData,
+  encodeErrorResult,
+  encodeEventTopics,
+  encodeFunctionData,
+  encodeFunctionResult,
+  formatAbiItem,
+  formatAbiItemWithArgs,
+  getAbiItem
+} from "./chunk-PRG3BBPZ.mjs";
+export {
+  decodeAbi,
+  decodeErrorResult,
+  decodeEventLog,
+  decodeFunctionData,
+  decodeFunctionResult,
+  deployContract,
+  encodeAbi,
+  encodeDeployData,
+  encodeErrorResult,
+  encodeEventTopics,
+  encodeFunctionData,
+  encodeFunctionResult,
+  estimateContractGas,
+  formatAbiItem,
+  formatAbiItemWithArgs,
+  getAbiItem,
+  getBytecode,
+  getStorageAt,
+  multicall,
+  readContract,
+  simulateContract,
+  watchContractEvent,
+  writeContract
+};
+//# sourceMappingURL=contract.mjs.map

package/dist/{createClient-60e3ab98.d.ts → createClient-6689596e.d.ts}

@@ -1,5 +1,5 @@
-import { C as Chain } from './chain-afa13f5a.js';
-import { R as Requests } from './eip1193-9317a312.js';
+import { C as Chain } from './chain-42de87e5.js';
+import { R as Requests } from './eip1193-617a05ae.js';
 
 type BaseRpcRequests = {
     request(...args: any): Promise<any>;
@@ -11,19 +11,25 @@ type TransportConfig<TType extends string = string, TRequests extends BaseRpcReq
     key: string;
     /** The JSON-RPC request function that matches the EIP-1193 request spec. */
     request: TRequests;
+    /** The base delay (in ms) between retries. */
+    retryDelay?: number;
+    /** The max number of times to retry. */
+    retryCount?: number;
     /** The type of the transport. */
     type: TType;
 };
-type Transport<TType extends string = string, TRpcAttributes = Record<string, any>> = <TChain extends Chain = Chain>({ chain, }: {
+type Transport<TType extends string = string, TRpcAttributes = Record<string, any>, TRequests extends BaseRpcRequests['request'] = Requests['request']> = <TChain extends Chain = Chain>({ chain, }: {
     chain?: TChain;
+    retryCount?: TransportConfig['retryCount'];
 }) => {
     config: TransportConfig<TType>;
+    request: TRequests;
     value?: TRpcAttributes;
 };
 /**
  * @description Creates an transport intended to be used with a client.
  */
-declare function createTransport<TType extends string = string, TRpcAttributes = any>(config: TransportConfig<TType>, value?: TRpcAttributes): ReturnType<Transport<TType, TRpcAttributes>>;
+declare function createTransport<TType extends string = string, TRpcAttributes = any>({ key, name, request, retryCount, retryDelay, type, }: TransportConfig<TType>, value?: TRpcAttributes): ReturnType<Transport<TType, TRpcAttributes>>;
 
 type Client<TTransport extends Transport = Transport, TChain extends Chain = Chain, TRequests extends BaseRpcRequests = Requests> = {
     /** Chain for the client. */
@@ -59,4 +65,4 @@ type ClientConfig<TTransport extends Transport = Transport, TChain extends Chain
  */
 declare function createClient<TTransport extends Transport, TChain extends Chain, TRequests extends BaseRpcRequests>({ chain, key, name, pollingInterval, transport, type, }: ClientConfig<TTransport, TChain, TRequests>): Client<TTransport, TChain, TRequests>;
 
-export { BaseRpcRequests as B, Client as C, Transport as T, ClientConfig as a, TransportConfig as b, createClient as c, createTransport as d };
+export { BaseRpcRequests as B, Client as C, TransportConfig as T, Transport as a, ClientConfig as b, createClient as c, createTransport as d };

package/dist/{createPublicClient-d3d12dc3.d.ts → createPublicClient-fd558574.d.ts}

@@ -1,6 +1,6 @@
-import { P as PublicRequests } from './eip1193-9317a312.js';
-import { T as Transport, a as ClientConfig, C as Client } from './createClient-60e3ab98.js';
-import { C as Chain } from './chain-afa13f5a.js';
+import { P as PublicRequests } from './eip1193-617a05ae.js';
+import { a as Transport, b as ClientConfig, C as Client } from './createClient-6689596e.js';
+import { C as Chain } from './chain-42de87e5.js';
 
 type PublicClientConfig<TTransport extends Transport = Transport, TChain extends Chain = Chain> = Pick<ClientConfig<TTransport, TChain>, 'chain' | 'key' | 'name' | 'pollingInterval' | 'transport'>;
 type PublicClient<TTransport extends Transport = Transport, TChain extends Chain = Chain> = Client<TTransport, TChain, PublicRequests>;

package/dist/{createTestClient-5f4532c4.d.ts → createTestClient-bc1d9028.d.ts}

@@ -1,6 +1,6 @@
-import { T as TestRequests } from './eip1193-9317a312.js';
-import { T as Transport, a as ClientConfig, C as Client } from './createClient-60e3ab98.js';
-import { C as Chain } from './chain-afa13f5a.js';
+import { T as TestRequests } from './eip1193-617a05ae.js';
+import { a as Transport, b as ClientConfig, C as Client } from './createClient-6689596e.js';
+import { C as Chain } from './chain-42de87e5.js';
 
 type TestClientModes = 'anvil' | 'hardhat';
 type TestClientConfig<TTransport extends Transport = Transport, TChain extends Chain = Chain, TMode extends TestClientModes = TestClientModes> = {

package/dist/{createWalletClient-9ec3df4f.d.ts → createWalletClient-4df88244.d.ts}

@@ -1,6 +1,6 @@
-import { S as SignableRequests, W as WalletRequests } from './eip1193-9317a312.js';
-import { T as Transport, a as ClientConfig, C as Client } from './createClient-60e3ab98.js';
-import { C as Chain } from './chain-afa13f5a.js';
+import { S as SignableRequests, W as WalletRequests } from './eip1193-617a05ae.js';
+import { a as Transport, b as ClientConfig, C as Client } from './createClient-6689596e.js';
+import { C as Chain } from './chain-42de87e5.js';
 
 type WalletClientConfig<TTransport extends Transport = Transport, TChain extends Chain = Chain> = {
     chain?: ClientConfig<TTransport, TChain>['chain'];

package/dist/decodeErrorResult-ac835649.d.ts

@@ -0,0 +1,16 @@
+import { Abi } from 'abitype';
+import { H as Hex } from './chain-42de87e5.js';
+import { A as AbiItem } from './contract-9dd2f98b.js';
+
+type DecodeErrorResultArgs = {
+    abi?: Abi;
+    data: Hex;
+};
+type DecodeErrorResultResponse = {
+    abiItem: AbiItem;
+    errorName: string;
+    args?: readonly unknown[];
+};
+declare function decodeErrorResult({ abi, data, }: DecodeErrorResultArgs): DecodeErrorResultResponse;
+
+export { DecodeErrorResultResponse as D, DecodeErrorResultArgs as a, decodeErrorResult as d };

package/dist/{eip1193-9317a312.d.ts → eip1193-617a05ae.d.ts}

@@ -1,4 +1,4 @@
-import { A as Address, a as Hash, V as Quantity, q as RpcTransactionRequest, k as RpcBlockNumber, b as BlockTag, j as RpcBlockIdentifier, H as Hex, Y as RpcEstimateGasParameters, l as RpcFeeHistory, R as RpcBlock, n as RpcLog, Z as LogTopic, o as RpcTransaction, p as RpcTransactionReceipt, r as RpcUncle } from './chain-afa13f5a.js';
+import { A as Address, a as Hash, Q as Quantity, q as RpcTransactionRequest, k as RpcBlockNumber, b as BlockTag, j as RpcBlockIdentifier, H as Hex, l as RpcFeeHistory, R as RpcBlock, n as RpcLog, G as LogTopic, o as RpcTransaction, p as RpcTransactionReceipt, r as RpcUncle } from './chain-42de87e5.js';
 
 declare class RpcError extends Error {
     code: number;
@@ -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: {
         /**

package/dist/ens.d.ts

@@ -1 +1,82 @@
-export { l as labelhash, n as namehash, a as normalize } from './normalize-ef9240c0.js';
+import { P as Prettify, A as Address } from './chain-42de87e5.js';
+import { P as PublicClient } from './createPublicClient-fd558574.js';
+import { R as ReadContractArgs } from './readContract-c460f23a.js';
+import '@wagmi/chains';
+import './eip1193-617a05ae.js';
+import './createClient-6689596e.js';
+import 'abitype';
+import './contract-9dd2f98b.js';
+import './call-3476b8ee.js';
+import './transactionRequest-f437b4ba.js';
+
+type GetEnsAddressArgs = Prettify<Pick<ReadContractArgs, 'blockNumber' | 'blockTag'> & {
+    /** ENS name to get address. */
+    name: string;
+    /** Address of ENS Universal Resolver Contract */
+    universalResolverAddress?: Address;
+}>;
+/**
+ * @description Gets address for ENS name.
+ *
+ * - Calls `resolve(bytes, bytes)` on ENS Universal Resolver Contract.
+ *
+ * @example
+ * const ensAddress = await getEnsAddress(publicClient, {
+ *   name: 'wagmi-dev.eth',
+ * })
+ * // '0xd2135CfB216b74109775236E36d4b433F1DF507B'
+ */
+declare function getEnsAddress(client: PublicClient, { blockNumber, blockTag, name, universalResolverAddress: universalResolverAddress_, }: GetEnsAddressArgs): Promise<`0x${string}`>;
+
+type GetEnsNameArgs = Prettify<Pick<ReadContractArgs, 'blockNumber' | 'blockTag'> & {
+    /** Address to get ENS name for. */
+    address: Address;
+    /** Address of ENS Universal Resolver Contract. */
+    universalResolverAddress?: Address;
+}>;
+/**
+ * @description Gets primary name for specified address.
+ *
+ * - Calls `reverse(bytes)` on ENS Universal Resolver Contract.
+ *
+ * @example
+ * const ensName = await getEnsName(publicClient, {
+ *   address: '0xd2135CfB216b74109775236E36d4b433F1DF507B',
+ * })
+ * // 'wagmi-dev.eth'
+ */
+declare function getEnsName(client: PublicClient, { address, blockNumber, blockTag, universalResolverAddress: universalResolverAddress_, }: GetEnsNameArgs): Promise<string | null>;
+
+/**
+ * @description Hashes ENS label
+ *
+ * @example
+ * labelhash('eth')
+ * '0x4f5b812789fc606be1b3b16908db13fc7a9adf7ca72641f84d75b47069d3d7f0'
+ */
+declare function labelhash(label: string): `0x${string}`;
+
+/**
+ * @description Hashes ENS name
+ *
+ * @example
+ * namehash('wagmi-dev.eth')
+ * '0xf246651c1b9a6b141d19c2604e9a58f567973833990f830d882534a747801359'
+ *
+ * @see https://eips.ethereum.org/EIPS/eip-137
+ * @see https://docs.ens.domains/contract-api-reference/name-processing#hashing-names
+ */
+declare function namehash(name: string): `0x${string}`;
+
+/**
+ * @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 { GetEnsAddressArgs, GetEnsNameArgs, getEnsAddress, getEnsName, labelhash, namehash, normalize };