@gibs/common 1.13.0 → 1.17.0

package/README.md

@@ -48,11 +48,33 @@ A collection of essential blockchain utilities and helpers that provide foundati
 ## 📦 Installation
 
 ```sh
-npm install @gibs/common
+npm install @gibs/common viem
 # or
-yarn add @gibs/common
+yarn add @gibs/common viem
 ```
 
+## Ways to use the package
+
+The package ships two builds of the same code. The `exports` map picks one, so
+you need no configuration.
+
+| Option | What you write | What loads |
+|---|---|---|
+| ECMAScript modules | `import { memoizeByKey } from '@gibs/common/cache'` | `dist/cache.js` |
+| CommonJS | `const { memoizeByKey } = require('@gibs/common/cache')` | `dist/cjs/cache.js` |
+| React Native (Metro) | either of the above | `import` gets `dist/`, `require` gets `dist/cjs/` |
+| React Native (jest) | either of the above | `dist/cjs/` |
+
+React Native 0.77 or later needs no change to `metro.config.js`, no
+`resolveRequest` hook, no jest `transformIgnorePatterns` and no polyfill.
+It runs on React Native's own `URL` and `URLSearchParams`, which React Native
+0.77 implements only in part: no code in the package reads them.
+Metro's default configuration in React Native 0.79 or later reads the
+`exports` map. Metro in React Native 0.77 and 0.78 ignores
+`exports`: it reads the `react-native` field for the root, and a folder the
+package ships for each subpath, such as `cache/package.json`, which points at
+the CommonJS build.
+
 ## 📖 API Examples
 
 ### Client (`@gibs/common/client`)
@@ -445,6 +467,7 @@ console.log(defaultBatchConfig)
 | `@gibs/common/serialize` | JSON serialization with BigInt support |
 | `@gibs/common/multicall` | Batch contract call utilities |
 | `@gibs/common/types` | TypeScript type definitions |
+| `@gibs/common/url` | Request addresses built and read without `URL` or `URLSearchParams` |
 
 ### Key Functions
 
@@ -493,6 +516,12 @@ function ttlMemoizeSingle<A extends unknown[], B>(
   fn: (...a: A) => B,
   ttl?: number
 ): (...a: A) => B
+
+// One answer per resolver key, never expired; `cache` is a Map you can evict from
+function memoizeByKey<A extends unknown[], B, K>(
+  fn: (...args: A) => B,
+  resolver: (...args: A) => K
+): ((...args: A) => B) & { cache: Map<K, B> }
 ```
 
 #### Serialization
@@ -560,8 +589,9 @@ interface SerializedBigInt {
 
 ## 🔗 Dependencies
 
-- `viem`: Type-safe Ethereum library for blockchain interactions
-- `lodash`: Utility functions for data manipulation and memoization
+- `viem` (peer dependency): Type-safe Ethereum library for blockchain interactions
+
+There are no other runtime dependencies.
 
 ## 📝 Best Practices
 

package/cache/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../dist/cjs/cache.js",
+  "module": "../dist/cache.js",
+  "types": "../dist/cache.d.ts",
+  "react-native": "../dist/cjs/cache.js"
+}

package/client/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../dist/cjs/client.js",
+  "module": "../dist/client.js",
+  "types": "../dist/client.d.ts",
+  "react-native": "../dist/cjs/client.js"
+}

package/dist/cache.d.ts

@@ -12,3 +12,28 @@ export declare const maxMemoize: <A extends unknown[], B>(fn: (...a: A) => B, ma
  * @returns the memoized function
  */
 export declare const ttlMemoizeSingle: <A extends unknown[], B>(fn: (...a: A) => B, ttl?: number) => (...a: A) => B;
+/**
+ * A memoized function, with the cache it reads exposed so a caller can evict
+ * one answer or drop them all.
+ */
+export type KeyedMemoized<A extends unknown[], B, K> = ((...args: A) => B) & {
+    /**
+     * The answers held so far, keyed by the resolver's output. Each call reads
+     * this property afresh, so assigning a new `Map` resets the cache.
+     */
+    cache: Map<K, B>;
+};
+/**
+ * Memoizes a function under a key the caller computes from its arguments.
+ *
+ * This is the subset of `lodash.memoize` the packages used: one answer per
+ * key, never expired, with `cache.delete` and `cache.clear` for eviction. As
+ * with lodash, the `cache` property may be replaced outright. It
+ * exists so the published packages carry no lodash-es, whose ECMAScript-module
+ * only build a React Native jest run cannot load from `node_modules`.
+ *
+ * @param fn - the function to memoize
+ * @param resolver - computes the cache key from the arguments
+ * @returns the memoized function, with its `cache`
+ */
+export declare const memoizeByKey: <A extends unknown[], B, K>(fn: (...args: A) => B, resolver: (...args: A) => K) => KeyedMemoized<A, B, K>;

package/dist/cache.js

@@ -42,3 +42,30 @@ export const ttlMemoizeSingle = (fn, ttl = hour1) => {
         return result;
     };
 };
+/**
+ * Memoizes a function under a key the caller computes from its arguments.
+ *
+ * This is the subset of `lodash.memoize` the packages used: one answer per
+ * key, never expired, with `cache.delete` and `cache.clear` for eviction. As
+ * with lodash, the `cache` property may be replaced outright. It
+ * exists so the published packages carry no lodash-es, whose ECMAScript-module
+ * only build a React Native jest run cannot load from `node_modules`.
+ *
+ * @param fn - the function to memoize
+ * @param resolver - computes the cache key from the arguments
+ * @returns the memoized function, with its `cache`
+ */
+export const memoizeByKey = (fn, resolver) => {
+    const memoized = Object.assign((...args) => {
+        const key = resolver(...args);
+        // Read the property on every call: a caller may have replaced the Map.
+        const { cache } = memoized;
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        const result = fn(...args);
+        cache.set(key, result);
+        return result;
+    }, { cache: new Map() });
+    return memoized;
+};

package/dist/cjs/assert.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Asserts that a value is defined (not null, undefined, or falsy)
+ * Throws a descriptive error if the value is falsy
+ *
+ * @param value - The value to check
+ * @param context - Context description for the error message
+ * @returns The value if defined
+ * @throws Error if value is falsy
+ */
+export declare function ensureResult<T>(value: T | null | undefined | false | 0, context: string): T;
+/**
+ * Type guard that asserts a value is defined
+ * Similar to ensureResult but uses TypeScript's asserts syntax
+ *
+ * @param value - The value to check
+ * @param message - Error message if assertion fails
+ */
+export declare function assertDefined<T>(value: T | null | undefined, message: string): asserts value is T;

package/dist/cjs/assert.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureResult = ensureResult;
+exports.assertDefined = assertDefined;
+/**
+ * Asserts that a value is defined (not null, undefined, or falsy)
+ * Throws a descriptive error if the value is falsy
+ *
+ * @param value - The value to check
+ * @param context - Context description for the error message
+ * @returns The value if defined
+ * @throws Error if value is falsy
+ */
+function ensureResult(value, context) {
+    if (!value) {
+        throw new Error(`${context}: Expected result but got ${value}`);
+    }
+    return value;
+}
+/**
+ * Type guard that asserts a value is defined
+ * Similar to ensureResult but uses TypeScript's asserts syntax
+ *
+ * @param value - The value to check
+ * @param message - Error message if assertion fails
+ */
+function assertDefined(value, message) {
+    if (value === null || value === undefined) {
+        throw new Error(message);
+    }
+}

package/dist/cjs/cache.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Memoize a function result and return a single value
+ * @param fn the function to memoize
+ * @param max the maximum number of values to cache
+ * @returns the memoized function
+ */
+export declare const maxMemoize: <A extends unknown[], B>(fn: (...a: A) => B, max?: number) => (...a: A) => B | undefined;
+/**
+ * Memoize a function result and return a single value
+ * @param fn the function to memoize
+ * @param ttl the time to live for the cache
+ * @returns the memoized function
+ */
+export declare const ttlMemoizeSingle: <A extends unknown[], B>(fn: (...a: A) => B, ttl?: number) => (...a: A) => B;
+/**
+ * A memoized function, with the cache it reads exposed so a caller can evict
+ * one answer or drop them all.
+ */
+export type KeyedMemoized<A extends unknown[], B, K> = ((...args: A) => B) & {
+    /**
+     * The answers held so far, keyed by the resolver's output. Each call reads
+     * this property afresh, so assigning a new `Map` resets the cache.
+     */
+    cache: Map<K, B>;
+};
+/**
+ * Memoizes a function under a key the caller computes from its arguments.
+ *
+ * This is the subset of `lodash.memoize` the packages used: one answer per
+ * key, never expired, with `cache.delete` and `cache.clear` for eviction. As
+ * with lodash, the `cache` property may be replaced outright. It
+ * exists so the published packages carry no lodash-es, whose ECMAScript-module
+ * only build a React Native jest run cannot load from `node_modules`.
+ *
+ * @param fn - the function to memoize
+ * @param resolver - computes the cache key from the arguments
+ * @returns the memoized function, with its `cache`
+ */
+export declare const memoizeByKey: <A extends unknown[], B, K>(fn: (...args: A) => B, resolver: (...args: A) => K) => KeyedMemoized<A, B, K>;

package/dist/cjs/cache.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoizeByKey = exports.ttlMemoizeSingle = exports.maxMemoize = void 0;
+const serialize_js_1 = require("./serialize.js");
+/**
+ * Memoize a function result and return a single value
+ * @param fn the function to memoize
+ * @param max the maximum number of values to cache
+ * @returns the memoized function
+ */
+const maxMemoize = (fn, max = 1024) => {
+    const cache = new Map();
+    return (...a) => {
+        const key = JSON.stringify(a, serialize_js_1.jsonAnyStringify);
+        const existing = cache.get(key);
+        if (cache.has(key)) {
+            return existing;
+        }
+        for (const k of cache.keys()) {
+            if (cache.size < max)
+                break;
+            cache.delete(k);
+        }
+        const result = fn(...a);
+        cache.set(key, result);
+        return result;
+    };
+};
+exports.maxMemoize = maxMemoize;
+const hour1 = 1000 * 60 * 60;
+/**
+ * Memoize a function result and return a single value
+ * @param fn the function to memoize
+ * @param ttl the time to live for the cache
+ * @returns the memoized function
+ */
+const ttlMemoizeSingle = (fn, ttl = hour1) => {
+    let cache = null;
+    return (...a) => {
+        const now = Date.now();
+        if (cache && cache.timestamp + ttl > now) {
+            return cache.result;
+        }
+        const result = fn(...a);
+        cache = { timestamp: now, result };
+        return result;
+    };
+};
+exports.ttlMemoizeSingle = ttlMemoizeSingle;
+/**
+ * Memoizes a function under a key the caller computes from its arguments.
+ *
+ * This is the subset of `lodash.memoize` the packages used: one answer per
+ * key, never expired, with `cache.delete` and `cache.clear` for eviction. As
+ * with lodash, the `cache` property may be replaced outright. It
+ * exists so the published packages carry no lodash-es, whose ECMAScript-module
+ * only build a React Native jest run cannot load from `node_modules`.
+ *
+ * @param fn - the function to memoize
+ * @param resolver - computes the cache key from the arguments
+ * @returns the memoized function, with its `cache`
+ */
+const memoizeByKey = (fn, resolver) => {
+    const memoized = Object.assign((...args) => {
+        const key = resolver(...args);
+        // Read the property on every call: a caller may have replaced the Map.
+        const { cache } = memoized;
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        const result = fn(...args);
+        cache.set(key, result);
+        return result;
+    }, { cache: new Map() });
+    return memoized;
+};
+exports.memoizeByKey = memoizeByKey;

package/dist/cjs/client.d.ts

@@ -0,0 +1,48 @@
+import { type Chain, type HttpTransportConfig, type PublicClient } from 'viem';
+export { MAX_SAME_METHOD_CALLS_PER_SECOND } from './rpcPacer.js';
+/**
+ * JSON-RPC request batching config. When enabled, viem coalesces requests made
+ * within `wait` milliseconds (up to `batchSize`) into ONE HTTP POST carrying a
+ * JSON-RPC array body. This is the default because it sharply cuts request
+ * volume on nodes that support it.
+ *
+ * Note: some public nodes (notably some Binance Smart Chain endpoints) reject the
+ * array-wrapped body — even for a single request — which makes every call fail
+ * and get retried, BURNING through requests. Such chains must construct their
+ * client with `batch: false` (see {@link clientFromChain}'s `batch` option) so
+ * requests are sent as plain JSON-RPC objects the node accepts.
+ */
+export declare const defaultRpcBatch: {
+    readonly wait: 10;
+    readonly batchSize: 32;
+};
+/** The default batch config for the client */
+export declare const defaultBatchConfig: {
+    batch: {
+        readonly wait: 10;
+        readonly batchSize: 32;
+    };
+};
+/**
+ * Returns the chain key for the given chain id and urls
+ * @param chainId - the chain id
+ * @param urls - the urls
+ * @returns the chain key
+ */
+export declare const chainKey: (chainId: number, urls: string[]) => string;
+/** The client cache for the given chain id */
+export declare const clientCache: Map<number, {
+    key: string;
+    client: PublicClient;
+}>;
+export declare const clientFromChain: ({ chain, urls, batch, }: {
+    chain: Chain;
+    urls: string[];
+    /**
+     * JSON-RPC request batching for this client's transport. Defaults to
+     * {@link defaultRpcBatch}. Pass `false` for chains whose RPC nodes reject the
+     * array-wrapped batch body (some Binance Smart Chain endpoints), so requests
+     * are sent as plain JSON-RPC objects and are not failed-and-retried.
+     */
+    batch?: HttpTransportConfig["batch"];
+}) => PublicClient;

package/dist/cjs/client.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clientFromChain = exports.clientCache = exports.chainKey = exports.defaultBatchConfig = exports.defaultRpcBatch = exports.MAX_SAME_METHOD_CALLS_PER_SECOND = void 0;
+const viem_1 = require("viem");
+const rpcPacer_js_1 = require("./rpcPacer.js");
+const url_js_1 = require("./url.js");
+var rpcPacer_js_2 = require("./rpcPacer.js");
+Object.defineProperty(exports, "MAX_SAME_METHOD_CALLS_PER_SECOND", { enumerable: true, get: function () { return rpcPacer_js_2.MAX_SAME_METHOD_CALLS_PER_SECOND; } });
+/**
+ * JSON-RPC request batching config. When enabled, viem coalesces requests made
+ * within `wait` milliseconds (up to `batchSize`) into ONE HTTP POST carrying a
+ * JSON-RPC array body. This is the default because it sharply cuts request
+ * volume on nodes that support it.
+ *
+ * Note: some public nodes (notably some Binance Smart Chain endpoints) reject the
+ * array-wrapped body — even for a single request — which makes every call fail
+ * and get retried, BURNING through requests. Such chains must construct their
+ * client with `batch: false` (see {@link clientFromChain}'s `batch` option) so
+ * requests are sent as plain JSON-RPC objects the node accepts.
+ */
+exports.defaultRpcBatch = {
+    wait: 10,
+    batchSize: 32,
+};
+/** The default batch config for the client */
+exports.defaultBatchConfig = {
+    batch: exports.defaultRpcBatch,
+};
+/**
+ * Returns the chain key for the given chain id and urls
+ * @param chainId - the chain id
+ * @param urls - the urls
+ * @returns the chain key
+ */
+const chainKey = (chainId, urls) => {
+    return `${chainId},${urls.join(',')}`.toLowerCase();
+};
+exports.chainKey = chainKey;
+/** The client cache for the given chain id */
+exports.clientCache = new Map();
+/**
+ * Returns the client for the given chain and urls
+ * @param chain - the chain
+ * @param urls - the urls
+ * @returns the client
+ */
+/**
+ * The one pacer for the whole application.
+ *
+ * MODULE LEVEL, DELIBERATELY. The endpoint keys its budget on the METHOD, not
+ * the chain — six `eth_blockNumber` on PulseChain plus six on Ethereum were
+ * answered exactly eight times, the same as twelve on one chain. A pacer per
+ * client would let two chains spend one budget twice and neither would know it
+ * had.
+ *
+ * It is built with the same ceiling the batch size uses, so the two can never
+ * describe different limits.
+ */
+const pacer = (0, rpcPacer_js_1.createRpcPacer)({ ceiling: rpcPacer_js_1.MAX_SAME_METHOD_CALLS_PER_SECOND });
+/**
+ * Holds a request until its methods fit under the ceiling.
+ *
+ * WIRED HERE RATHER THAN AROUND THE CALLERS because this is the only place that
+ * sees the FINAL body: viem coalesces separate reads into one post, so a limiter
+ * upstream of the transport would count intentions and this counts what is
+ * actually sent.
+ *
+ * Returning nothing leaves the request untouched — the hook exists to delay, not
+ * to rewrite.
+ */
+const paceRequest = async (request) => {
+    // The HOST, not the full url: one proxy serves every chain from one budget,
+    // so `/evm/1` and `/evm/369` must count against the same tally.
+    const { host } = (0, url_js_1.splitUrl)(request.url);
+    await pacer.reserve(host, (0, rpcPacer_js_1.countMethods)(await request.clone().text().catch(() => null)));
+};
+/**
+ * Spreads requests across a chain's endpoints instead of resting on the first.
+ *
+ * WHAT `fallback` ACTUALLY DOES, and why it is not this. With `rank: false` it
+ * sends every request to entry zero and moves on only when that entry ERRORS. So
+ * the spares behind a chain carry no load at all: on Ethereum, `valve.city` took
+ * one hundred percent of every read while two perfectly good nodes sat idle, and
+ * the only way traffic ever reached them was a refusal — a wasted round trip
+ * spent discovering a spare we could have used on purpose.
+ *
+ * That matters because the first entry is a SHARED proxy. Its key is published
+ * on chainlist.org, so its per-second budget is not ours alone: measured at a
+ * refusal, our own calls in the preceding second were seven against a ceiling of
+ * eight. We were not over the limit. Somebody else was using the rest of it, and
+ * no amount of pacing on our side fixes that — only using less of that host
+ * does.
+ *
+ * ROUND ROBIN, AND FALLBACK STILL INTACT. Each request starts at the next
+ * endpoint in rotation and walks the rest on failure, so a dead host costs one
+ * attempt exactly as it did before while a healthy one now carries its share.
+ *
+ * NOT `rank: true`, which is viem's own answer to this and is the wrong one
+ * here: ranking pings EVERY url on EVERY chain every few seconds forever, which
+ * on an idle page was once the entire outbound traffic and is what spent the
+ * shared budget in the first place. It also reorders a list this project curates
+ * deliberately.
+ */
+const balanced = (transports) => {
+    if (transports.length === 1)
+        return transports[0];
+    return (config) => {
+        const instances = transports.map((transport) => transport(config));
+        // Module-level rotation per client, not per call site: every reader on the
+        // page shares one cursor, which is what makes the split even rather than
+        // each caller starting at zero and piling onto the same host.
+        let cursor = 0;
+        return (0, viem_1.createTransport)({
+            key: 'balanced',
+            name: 'Balanced',
+            type: 'balanced',
+            // CAST AT THE BOUNDARY, deliberately. `EIP1193RequestFn` is generic over
+            // the method being called and resolves its own return type; a rotation
+            // cannot preserve that relationship because it does not know which
+            // transport will answer until it has tried one. The delegates below are
+            // fully typed and the shape passing through is unchanged — only the
+            // compiler's ability to follow it across the loop is lost.
+            request: (async (args) => {
+                const start = cursor;
+                cursor = (cursor + 1) % instances.length;
+                let lastError;
+                for (let offset = 0; offset < instances.length; offset += 1) {
+                    try {
+                        return await instances[(start + offset) % instances.length].request(args);
+                    }
+                    catch (error) {
+                        // KEPT AND RETHROWN AT THE END, not swallowed. If every endpoint
+                        // refuses, the caller must see a real error — a rotation that
+                        // returns undefined when all its hosts are down turns an outage
+                        // into a silently empty read.
+                        lastError = error;
+                    }
+                }
+                throw lastError;
+            }),
+        });
+    };
+};
+const clientFromChain = ({ chain, urls, batch = exports.defaultRpcBatch, }) => {
+    const key = (0, exports.chainKey)(chain.id, urls);
+    const existing = exports.clientCache.get(chain.id);
+    if (existing && existing.key === key) {
+        return existing.client;
+    }
+    const transport = !urls?.length
+        ? (0, viem_1.http)()
+        : balanced(urls.map((rpc) => rpc.startsWith('http')
+            ? (0, viem_1.http)(rpc, { batch, onFetchRequest: paceRequest })
+            : (0, viem_1.webSocket)(rpc, {
+                keepAlive: true,
+                reconnect: true,
+                retryDelay: 250,
+                retryCount: 10,
+                timeout: 4_000,
+            })));
+    const client = (0, viem_1.createPublicClient)({
+        chain,
+        transport,
+    });
+    exports.clientCache.set(chain.id, {
+        key,
+        client,
+    });
+    return client;
+};
+exports.clientFromChain = clientFromChain;

package/dist/cjs/erc20.d.ts

@@ -0,0 +1,18 @@
+import { type Chain, type Hex, type PublicClient } from 'viem';
+import type { Erc20Metadata } from './types.js';
+/** The erc20 metadata calls */
+export declare const erc20MetadataCalls: {
+    functionName: string;
+}[];
+/**
+ * The multicall for the erc20 metadata.
+ *
+ * The annotation spells out the plain call signature, which keeps the
+ * memoization an implementation detail: no caller touches the `.cache`
+ * property it would otherwise publish.
+ */
+export declare const multicallErc20: (inputs: {
+    client: PublicClient;
+    target: Hex;
+    chain: Chain;
+}) => Promise<Erc20Metadata>;

package/dist/cjs/erc20.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.multicallErc20 = exports.erc20MetadataCalls = void 0;
+const viem_1 = require("viem");
+const cache_js_1 = require("./cache.js");
+const multicall_js_1 = require("./multicall.js");
+/** The erc20 metadata calls */
+exports.erc20MetadataCalls = [
+    { functionName: 'name' },
+    { functionName: 'symbol' },
+    { functionName: 'decimals' },
+];
+/**
+ * The multicall for the erc20 metadata.
+ *
+ * The annotation spells out the plain call signature, which keeps the
+ * memoization an implementation detail: no caller touches the `.cache`
+ * property it would otherwise publish.
+ */
+exports.multicallErc20 = (0, cache_js_1.memoizeByKey)(async ({ client, target, chain }) => {
+    const options = {
+        chain: chain,
+        client: client,
+        abi: viem_1.erc20Abi,
+        target,
+        calls: exports.erc20MetadataCalls,
+    };
+    try {
+        return await (0, multicall_js_1.multicallRead)(options);
+    }
+    catch {
+        return await (0, multicall_js_1.multicallRead)({
+            ...options,
+            abi: viem_1.erc20Abi_bytes32,
+        });
+    }
+}, ({ target, chain }) => {
+    return !target ? chain.id : (0, viem_1.getAddress)(target, chain.id);
+});

package/dist/cjs/index.d.ts

@@ -0,0 +1,8 @@
+export * from './assert.js';
+export * from './cache.js';
+export * from './client.js';
+export * from './erc20.js';
+export * from './multicall.js';
+export * from './serialize.js';
+export * from './types.js';
+export * from './url.js';

package/dist/cjs/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./assert.js"), exports);
+__exportStar(require("./cache.js"), exports);
+__exportStar(require("./client.js"), exports);
+__exportStar(require("./erc20.js"), exports);
+__exportStar(require("./multicall.js"), exports);
+__exportStar(require("./serialize.js"), exports);
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./url.js"), exports);