viem 0.0.1-cjs.10 → 0.0.1-sushi.25

package/contract/package.json

@@ -0,0 +1,4 @@
+{
+  "module": "../dist/contract.mjs",
+  "main": "../dist/contract.js"
+}

package/dist/call-ac509982.d.ts

@@ -0,0 +1,23 @@
+import { C as Chain, A as Address, b as BlockTag, H as Hex, O as Formatter, S as MergeIntersectionProperties, V as Formatted, s as TransactionRequest } from './chain-f16512e8.js';
+import { P as PublicClient } from './createPublicClient-b732194e.js';
+import { T as TransactionRequestFormatter } from './transactionRequest-c7794f5e.js';
+
+type FormattedCall<TFormatter extends Formatter | undefined = Formatter> = MergeIntersectionProperties<Formatted<TFormatter, TransactionRequest, true>, TransactionRequest>;
+type CallArgs<TChain extends Chain = Chain> = FormattedCall<TransactionRequestFormatter<TChain>> & {
+    chain?: TChain;
+    from?: Address;
+} & ({
+    /** The balance of the account at a block number. */
+    blockNumber?: bigint;
+    blockTag?: never;
+} | {
+    blockNumber?: never;
+    /** The balance of the account at a block tag. */
+    blockTag?: BlockTag;
+});
+type CallResponse = {
+    data: Hex | undefined;
+};
+declare function call<TChain extends Chain>(client: PublicClient, { blockNumber, blockTag, chain, from, accessList, data, gas, gasPrice, maxFeePerGas, maxPriorityFeePerGas, nonce, to, value, ...rest }: CallArgs<TChain>): Promise<CallResponse>;
+
+export { CallArgs as C, CallResponse as a, call as c };

package/dist/chain-c4ccb458.d.ts

@@ -0,0 +1,5 @@
+import { M as Formatters, C as Chain } from './chain-f16512e8.js';
+
+declare function defineChain<TFormatters extends Formatters = Formatters, TChain extends Chain<TFormatters> = Chain<TFormatters>>(chain: TChain): TChain;
+
+export { defineChain as d };

package/dist/{rpc-b77c5aee.d.ts → chain-f16512e8.d.ts}

@@ -1,25 +1,62 @@
-declare const etherUnits: {
-    gwei: number;
-    wei: number;
-};
-declare const gweiUnits: {
-    ether: number;
-    wei: number;
-};
-declare const weiUnits: {
-    ether: number;
-    gwei: number;
+import { Chain as Chain$1 } from '@wagmi/chains';
+
+type Address = `0x${string}`;
+type ByteArray = Uint8Array;
+type Hex = `0x${string}`;
+type Hash = `0x${string}`;
+type LogTopic = Hex | Hex[] | null;
+
+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>;
+declare function defineFormatter<TSource extends Record<string, unknown>, TFormatted>({ format, }: {
+    format: (data: TSource) => TFormatted;
+}): <TFormat extends Formatter<TSource, Partial<TFormatted> & {
+    [key: string]: unknown;
+}>, TExclude extends (keyof TSource)[] = []>({ exclude, format: formatOverride, }: {
+    exclude?: TExclude | undefined;
+    format?: TFormat | undefined;
+}) => (data: TSource & {
+    [key: string]: unknown;
+}) => TFormatted & ReturnType<TFormat> & { [K in TExclude[number]]: never; };
+
+type TransactionFormatter<TChain extends Chain = Chain> = ExtractFormatter<TChain, 'transaction', NonNullable<Formatters['transaction']>>;
+type FormattedTransaction<TFormatter extends Formatter | undefined = Formatter> = Formatted<TFormatter, Transaction>;
 declare const transactionType: {
     readonly '0x0': "legacy";
     readonly '0x1': "eip2930";
     readonly '0x2': "eip1559";
 };
-
-type Address = `0x${string}`;
-type ByteArray = Uint8Array;
-type Hex = `0x${string}`;
-type Hash = `0x${string}`;
+declare function formatTransaction(transaction: Partial<RpcTransaction>): Transaction<bigint, number>;
+declare const defineTransaction: <TFormat extends Formatter<Partial<RpcTransaction>, Partial<Transaction<bigint, number>> & {
+    [key: string]: unknown;
+}>, TExclude extends ("type" | "blockHash" | "blockNumber" | "gas" | "hash" | "value" | "from" | "input" | "nonce" | "r" | "s" | "to" | "transactionIndex" | "v" | "gasPrice" | "maxFeePerGas" | "maxPriorityFeePerGas" | "accessList")[] = []>({ exclude, format: formatOverride, }: {
+    exclude?: TExclude | undefined;
+    format?: TFormat | undefined;
+}) => (data: Partial<RpcTransaction> & {
+    [key: string]: unknown;
+}) => Transaction<bigint, number> & ReturnType<TFormat> & { [K in TExclude[number]]: never; };
 
 type EstimateGasParameters<TQuantity = bigint> = {
     /** Contract code or a hashed method call with encoded args */
@@ -104,6 +141,35 @@ type OptionalNullable<T> = {
 } & {
     [K in keyof T as T[K] extends NonNullable<unknown> ? never : K]?: T[K];
 };
+/**
+ * @description Constructs a type by excluding `undefined` from `T`.
+ *
+ * @example
+ * NoUndefined<string | undefined>
+ * => string
+ */
+type NoUndefined<T> = T extends undefined ? never : T;
+/**
+ * @description Combines members of an intersection into a readable type.
+ *
+ * @link https://twitter.com/mattpocockuk/status/1622730173446557697?s=20&t=NdpAcmEFXY01xkqU3KO0Mg
+ * @example
+ * Prettify<{ a: string } | { b: string } | { c: number, d: bigint }>
+ * => { a: string, b: string, c: number, d: bigint }
+ */
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type TrimLeft<T, Chars extends string = ' '> = T extends `${Chars}${infer R}` ? TrimLeft<R> : T;
+type TrimRight<T, Chars extends string = ' '> = T extends `${infer R}${Chars}` ? TrimRight<R> : T;
+/**
+ * @description Trims empty space from type T.
+ *
+ * @example
+ * Trim<'      lol  '>
+ * => 'lol'
+ */
+type Trim<T, Chars extends string = ' '> = TrimLeft<TrimRight<T, Chars>, Chars>;
 /**
  * @description Creates a type that extracts the values of T.
  *
@@ -289,4 +355,18 @@ 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, 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 };
+type Formatter<TSource = any, TTarget = any> = (value: TSource & {
+    [key: string]: unknown;
+}) => TTarget;
+type Formatters = {
+    block?: Formatter<RpcBlock, Block>;
+    transaction?: Formatter<RpcTransaction, Transaction>;
+    transactionReceipt?: Formatter<RpcTransactionReceipt, TransactionReceipt>;
+    transactionRequest?: Formatter<TransactionRequest, RpcTransactionRequest>;
+};
+
+type Chain<TFormatters extends Formatters = Formatters> = Chain$1 & {
+    formatters?: TFormatters;
+};
+
+export { defineTransaction as $, Address as A, ByteArray as B, Chain as C, TransactionEIP2930 as D, TransactionLegacy as E, FeeHistory as F, LogTopic as G, Hex as H, Trim as I, RpcEstimateGasParameters as J, TransactionType$1 as K, Log as L, Formatters as M, NoUndefined as N, Formatter as O, Prettify as P, Quantity as Q, RpcBlock as R, MergeIntersectionProperties as S, TransactionReceipt as T, Uncle as U, Formatted as V, ExtractFormatter as W, EstimateGasParameters as X, FormattedTransaction as Y, TransactionFormatter as Z, defineFormatter as _, Hash as a, format as a0, formatTransaction as a1, transactionType as a2, BlockTag as b, AccessList as c, Block as d, BlockIdentifier as e, BlockNumber as f, FeeValues as g, FeeValuesEIP1559 as h, FeeValuesLegacy as i, RpcBlockIdentifier as j, RpcBlockNumber as k, RpcFeeHistory as l, RpcFeeValues as m, RpcLog as n, RpcTransaction as o, RpcTransactionReceipt as p, RpcTransactionRequest as q, RpcUncle as r, TransactionRequest as s, TransactionRequestBase as t, TransactionRequestEIP1559 as u, TransactionRequestEIP2930 as v, TransactionRequestLegacy as w, Transaction as x, TransactionBase as y, TransactionEIP1559 as z };