viem 0.0.1-alpha.2 → 0.0.1-alpha.21

package/chains/package.json

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

package/clients/package.json

@@ -1,4 +1,4 @@
 {
-  "type": "module",
+  "module": "../dist/clients/index.mjs",
   "main": "../dist/clients/index.js"
 }

package/dist/{rpc-655c0ba4.d.ts → chain-32f56cfa.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" | "hash" | "value" | "gas" | "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,16 @@ type OptionalNullable<T> = {
 } & {
     [K in keyof T as T[K] extends NonNullable<unknown> ? never : K]?: 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 +336,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, 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 };
+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, BlockNumber as B, TransactionEIP2930 as C, TransactionLegacy as D, FormattedTransaction as E, FeeHistory as F, formatTransaction as G, Hash as H, transactionType as I, Chain as J, Formatter as K, Log as L, MergeIntersectionProperties as M, Formatted as N, EstimateGasParameters as O, TransactionFormatter as P, ExtractFormatter as Q, RpcBlock as R, TransactionType$1 as S, TransactionReceipt as T, Uncle as U, Formatters as V, Trim as W, Quantity as X, RpcEstimateGasParameters as Y, LogTopic as Z, defineFormatter as _, BlockTag as a, format as a0, Hex as b, ByteArray as c, AccessList as d, Block as e, BlockIdentifier 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 };

package/dist/chain-f12cdc7f.d.ts

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