@gibs/common 1.19.0 → 1.20.0

package/dist/cjs/url.js

@@ -1,33 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isHttpUrl = exports.splitUrl = exports.buildUrl = exports.setQueryParameter = exports.buildQuery = exports.parseQuery = exports.decodeQueryComponent = exports.encodeQueryComponent = void 0;
-/**
- * Request addresses, built and read with plain string work.
- *
- * WHY THIS EXISTS: React Native 0.77 installs its own `URL` and
- * `URLSearchParams` (react-native/Libraries/Blob/URL.js), and both are partial.
- * `new URL(x).protocol`, `.host`, `.pathname` and `.search` throw "not
- * implemented". `searchParams` is always a new, empty list, so a reader of it
- * silently sees no parameters. `URLSearchParams` can only append and
- * serialize: `get`, `set`, `has` and `delete` throw, and a string passed to
- * its constructor is ignored. A package that uses either class needs a
- * polyfill in a wallet. These functions need nothing from the runtime but
- * `encodeURIComponent` and `decodeURIComponent`.
- *
- * Their output matches what the WHATWG classes produce for the addresses the
- * Gibs packages build: a lowercase `http:` or `https:` origin with a plain
- * path. A query is encoded exactly as `URLSearchParams` encodes it, as
- * `application/x-www-form-urlencoded`: a space becomes `+`, and only letters,
- * digits and `*-._` stay as they are. They do not normalize the address
- * itself: an uppercase host or a `..` path segment passes through as written.
- */
-/** A surrogate pair, or a lone surrogate half. */
 const surrogates = /[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDFFF]/g;
-/** The characters `encodeURIComponent` keeps that a form encoder escapes. */
 const formEscapedCharacters = /[!'()~]/g;
-/** A run of percent-encoded bytes. */
 const percentEncodedRun = /(?:%[0-9A-Fa-f]{2})+/g;
-/** The port each special scheme leaves out of its host. */
 const defaultPorts = Object.freeze({
     http: '80',
     https: '443',
@@ -35,39 +11,12 @@ const defaultPorts = Object.freeze({
     wss: '443',
     ftp: '21',
 });
-/**
- * Replaces each lone surrogate half with U+FFFD, as the WHATWG classes do
- * before they encode. `encodeURIComponent` would throw on one instead.
- *
- * @param text - any string
- * @returns the string, well formed
- */
 const toWellFormed = (text) => text.replace(surrogates, (match) => (match.length === 2 ? match : '�'));
-/**
- * Percent-encodes one character as two uppercase hex digits.
- *
- * @param character - a single ASCII character
- * @returns the character as `%XX`
- */
 const percentEncodeCharacter = (character) => `%${character.charCodeAt(0).toString(16).toUpperCase().padStart(2, '0')}`;
-/**
- * Encodes a query name or value exactly as `URLSearchParams.toString` does.
- *
- * @param text - the raw name or value
- * @returns the encoded text
- */
 const encodeQueryComponent = (text) => encodeURIComponent(toWellFormed(text))
     .replace(formEscapedCharacters, percentEncodeCharacter)
     .replace(/%20/g, '+');
 exports.encodeQueryComponent = encodeQueryComponent;
-/**
- * Counts the continuation bytes a UTF-8 lead byte announces, and the bounds
- * the first of them must fall in. The bounds reject overlong forms and
- * surrogates, as the WHATWG decoder does.
- *
- * @param lead - the first byte of a sequence
- * @returns the count, the lead byte's own bits, and the first continuation byte's bounds; null for a byte that cannot start one
- */
 const utf8Lead = (lead) => {
     if (lead >= 0xc2 && lead <= 0xdf)
         return { count: 1, bits: lead & 0x1f, lower: 0x80, upper: 0xbf };
@@ -85,14 +34,6 @@ const utf8Lead = (lead) => {
         return { count: 3, bits: lead & 0x07, lower: 0x80, upper: 0xbf };
     return null;
 };
-/**
- * Decodes UTF-8 bytes as the WHATWG decoder does: each malformed part becomes
- * one U+FFFD, and a byte that ends a malformed part is read again as the
- * start of the next. Only reached when `decodeURIComponent` refuses a run.
- *
- * @param bytes - the bytes
- * @returns the decoded text
- */
 const decodeUtf8Leniently = (bytes) => {
     const decode = (index, decoded) => {
         if (index >= bytes.length)
@@ -120,12 +61,6 @@ const decodeUtf8Leniently = (bytes) => {
     };
     return decode(0, '');
 };
-/**
- * Decodes one run of `%XX` bytes.
- *
- * @param run - consecutive `%XX` sequences
- * @returns the text they encode
- */
 const decodePercentRun = (run) => {
     try {
         return decodeURIComponent(run);
@@ -134,23 +69,8 @@ const decodePercentRun = (run) => {
         return decodeUtf8Leniently(run.slice(1).split('%').map((pair) => Number.parseInt(pair, 16)));
     }
 };
-/**
- * Decodes a query name or value as the WHATWG URL standard says
- * `URLSearchParams` must: `+` is a space, a valid `%XX` is a byte, a `%` that
- * starts no valid sequence stays as it is, and each malformed UTF-8 part, or
- * lone surrogate half, becomes U+FFFD.
- *
- * @param text - the encoded name or value
- * @returns the decoded text
- */
 const decodeQueryComponent = (text) => toWellFormed(text).replace(/\+/g, ' ').replace(percentEncodedRun, decodePercentRun);
 exports.decodeQueryComponent = decodeQueryComponent;
-/**
- * Lists the parameters of a query, decoded and in order.
- *
- * @param query - a query, with or without its leading `?`
- * @returns each parameter's name and value; a parameter with no `=` has an empty value
- */
 const parseQuery = (query) => query
     .replace(/^\?/, '')
     .split('&')
@@ -162,37 +82,15 @@ const parseQuery = (query) => query
     return [(0, exports.decodeQueryComponent)(name), (0, exports.decodeQueryComponent)(value)];
 });
 exports.parseQuery = parseQuery;
-/**
- * Turns query parameters into ordered pairs.
- *
- * @param parameters - a record or pairs; see {@link QueryParameters}
- * @returns the pairs, with every `undefined` record value left out
- */
 const toEntries = (parameters) => {
     if (Array.isArray(parameters))
         return parameters;
     return Object.entries(parameters).filter((entry) => entry[1] !== undefined);
 };
-/**
- * Writes a query, as `new URLSearchParams(parameters).toString()` does.
- *
- * @param parameters - a record or pairs; see {@link QueryParameters}
- * @returns the encoded query, with no leading `?`; empty for no parameters
- */
 const buildQuery = (parameters) => toEntries(parameters)
     .map(([name, value]) => `${(0, exports.encodeQueryComponent)(name)}=${(0, exports.encodeQueryComponent)(value)}`)
     .join('&');
 exports.buildQuery = buildQuery;
-/**
- * Sets one parameter in a query, as `URLSearchParams.set` does: the first
- * parameter of that name takes the value and any later ones are removed, or
- * the parameter is appended when none has the name.
- *
- * @param query - an encoded query, with or without its leading `?`
- * @param name - the parameter's name
- * @param value - its value
- * @returns the encoded query, with no leading `?`
- */
 const setQueryParameter = (query, name, value) => {
     const entries = (0, exports.parseQuery)(query);
     const firstAt = entries.findIndex(([entryName]) => entryName === name);
@@ -205,12 +103,6 @@ const setQueryParameter = (query, name, value) => {
     }));
 };
 exports.setQueryParameter = setQueryParameter;
-/**
- * Splits an address at its first `#` and then at its first `?`.
- *
- * @param address - any address
- * @returns everything before the query, the query and the fragment, each without its delimiter
- */
 const splitAtQuery = (address) => {
     const fragmentAt = address.indexOf('#');
     const beforeFragment = fragmentAt === -1 ? address : address.slice(0, fragmentAt);
@@ -220,15 +112,6 @@ const splitAtQuery = (address) => {
         return { beforeQuery: beforeFragment, query: '', fragment };
     return { beforeQuery: beforeFragment.slice(0, queryAt), query: beforeFragment.slice(queryAt + 1), fragment };
 };
-/**
- * Adds query parameters to an address, as `url.searchParams.set` does for
- * each one in turn. A query already on the address is kept, and a fragment
- * stays at the end.
- *
- * @param address - the address, with or without a query
- * @param parameters - a record or pairs; see {@link QueryParameters}
- * @returns the address with the parameters set; the address unchanged when there are none
- */
 const buildUrl = (address, parameters) => {
     const entries = toEntries(parameters);
     if (entries.length === 0)
@@ -238,15 +121,6 @@ const buildUrl = (address, parameters) => {
     return `${beforeQuery}?${updated}${fragment === '' ? '' : `#${fragment}`}`;
 };
 exports.buildUrl = buildUrl;
-/**
- * Reads the host the WHATWG `URL` reports from an authority: lowercase, with
- * any user name and password dropped, and the port dropped when it is the
- * scheme's default.
- *
- * @param authority - the text between `//` and the path
- * @param scheme - the lowercase scheme
- * @returns the host
- */
 const hostOfAuthority = (authority, scheme) => {
     const hostAndPort = authority.slice(authority.lastIndexOf('@') + 1).toLowerCase();
     const port = /:(\d*)$/.exec(hostAndPort);
@@ -258,12 +132,6 @@ const hostOfAuthority = (authority, scheme) => {
     const portNumber = String(Number(port[1]));
     return portNumber === defaultPorts[scheme] ? hostname : `${hostname}:${portNumber}`;
 };
-/**
- * Splits an address into its parts, without the WHATWG `URL` class.
- *
- * @param address - any address; leading and trailing spaces and control characters are ignored, as the WHATWG parser ignores them
- * @returns the parts; see {@link UrlParts}
- */
 const splitUrl = (address) => {
     const trimmed = address.replace(/^[\u0000- ]+|[\u0000- ]+$/g, '');
     const { beforeQuery, query, fragment } = splitAtQuery(trimmed);
@@ -278,13 +146,6 @@ const splitUrl = (address) => {
     return { scheme, host: hostOfAuthority(authority, scheme), path, query, fragment };
 };
 exports.splitUrl = splitUrl;
-/**
- * Says whether a value is an absolute `http:` or `https:` address with a host.
- * It reads the scheme by its prefix, so it needs no `URL` class.
- *
- * @param value - any string
- * @returns true for an absolute `http:` or `https:` address
- */
 const isHttpUrl = (value) => {
     const { scheme, host } = (0, exports.splitUrl)(value);
     return (scheme === 'http' || scheme === 'https') && host !== '';

package/dist/client.js

@@ -2,119 +2,32 @@ import { createPublicClient, createTransport, http, webSocket, } from 'viem';
 import { countMethods, createRpcPacer, MAX_SAME_METHOD_CALLS_PER_SECOND, } from './rpcPacer.js';
 import { splitUrl } from './url.js';
 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 const defaultRpcBatch = {
     wait: 10,
     batchSize: 32,
 };
-/** The default batch config for the client */
 export const defaultBatchConfig = {
     batch: 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
- */
 export const chainKey = (chainId, urls) => {
     return `${chainId},${urls.join(',')}`.toLowerCase();
 };
-/** The client cache for the given chain id */
 export const 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 = createRpcPacer({ ceiling: 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 } = splitUrl(request.url);
     await pacer.reserve(host, 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 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;
@@ -124,10 +37,6 @@ const balanced = (transports) => {
                         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;
                     }
                 }

package/dist/erc20.js

@@ -1,19 +1,11 @@
 import { erc20Abi, erc20Abi_bytes32, getAddress, } from 'viem';
 import { memoizeByKey } from './cache.js';
 import { multicallRead } from './multicall.js';
-/** The erc20 metadata calls */
 export const 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.
- */
 export const multicallErc20 = memoizeByKey(async ({ client, target, chain }) => {
     const options = {
         chain: chain,

package/dist/multicall.js

@@ -1,90 +1,10 @@
 import { decodeFunctionResult, encodeFunctionData, getContract, multicall3Abi, } from 'viem';
 import { ensureResult } from './assert.js';
-/**
- * The largest request body the leading endpoint accepts, in bytes. MEASURED,
- * not assumed.
- *
- * `one.valve.city` answers a 102,400 byte body with 200 and a 102,656 byte body
- * with 413, bisected on 2026-09-12. That is the 100 kibibyte default of
- * `express.json`, and the proxy leads every chain list this application ships,
- * so it is the number every other budget here has to clear.
- *
- * THE PREVIOUS VALUE WAS A GUESS AND IT WAS FIVE TIMES TOO LARGE. It said "the
- * one-megabyte body limit that is the default in the reverse proxies these
- * endpoints sit behind", which is Nginx's default, not Express's — and the
- * endpoint in front is Express. Nobody had asked the endpoint.
- */
 const ENDPOINT_BODY_LIMIT_BYTES = 100 * 1024;
-/**
- * How large a single HTTP request body to the node may get, in bytes.
- *
- * Nothing bounded this before, so the whole call list went out at once and the
- * size followed whatever the caller happened to be reading. The token picker
- * reads a balance per token, and PulseChain's list runs to about eleven and a
- * half thousand of them: a single 8.5 MB `eth_call`, repeated on every open,
- * which `rpc.pulsechain.com` answered with HTTP 413. The caller catches that and
- * falls back to an empty map, so the visible result was not an error — it was
- * every balance quietly missing.
- *
- * Four kibibytes under {@link ENDPOINT_BODY_LIMIT_BYTES}, because the budget
- * below counts only the calls: `aggregate3` adds a fixed header of its own and
- * the JSON-RPC envelope wraps the lot, and neither is charged to a call.
- */
 const HTTP_BODY_TARGET_BYTES = ENDPOINT_BODY_LIMIT_BYTES - 4 * 1024;
-/**
- * How many chunks may be in flight at once.
- *
- * Splitting a request is only an improvement if the pieces do not arrive as a
- * burst; an endpoint that rejected one large body will just as happily rate-limit
- * two dozen small ones.
- *
- * ONE, AND RUNNING MORE BUYS NOTHING. The transport coalesces calls made in the
- * same tick into one post, so four chunks at a quarter of the budget each arrive
- * as ONE post of the same total size as a single full-budget chunk — the same
- * bytes, in the same round trip, at four times the call count. The proxy's
- * budget counts CALLS, not posts and not bytes, so the wider setting spent four
- * times the rate limit for identical throughput.
- *
- * Measured on one token-picker open, 2026-09-12: at a concurrency of four the
- * peak was eleven calls of one method in a second against a ceiling of eight,
- * and one post was refused; at one the peak was seven and every post was
- * answered. Request bytes fell from 737,057 to 638,890 in the same comparison,
- * because nothing had to be resent to a fallback endpoint.
- */
 const CHUNK_CONCURRENCY = 1;
-/**
- * How much encoded call data one `aggregate3` may carry.
- *
- * Divided by the concurrency rather than set directly, because the transport
- * COALESCES calls made in the same tick into one HTTP body. Chunking to a
- * quarter-megabyte budget and running four at a time was measured arriving as a
- * single 1.37 MB request — the split was real, and then undone at the layer
- * below. What the node sees is this budget multiplied by the concurrency, so
- * that is the relationship worth writing down; changing either constant alone
- * cannot silently blow the target.
- *
- * STILL TRUE AT A CONCURRENCY OF ONE, and that is why the division stays rather
- * than being folded away: raising the concurrency again without cutting this
- * budget would put the target back over the endpoint's limit, and the division
- * is what stops that being silent.
- */
 const CALLDATA_BUDGET_BYTES = Math.floor(HTTP_BODY_TARGET_BYTES / CHUNK_CONCURRENCY);
-/**
- * Bytes of request body a single call costs beyond its own encoded data.
- * MEASURED against a real `aggregate3` encoding, not estimated.
- *
- * `aggregate3` spends five thirty-two byte words per call — the head offset, the
- * target, the failure flag, the data offset and the data length — which is 320
- * hexadecimal characters, plus up to 63 more padding the call data out to a word
- * boundary. A `balanceOf` whose own call data is 74 characters was measured
- * costing 448.6 bytes of body, so the real overhead is about 375 and the old
- * value of 200 UNDERSTATED IT BY NEARLY A HALF.
- *
- * That is how a chunk budgeted at 128 kibibytes went out as a 214 kilobyte body.
- * Four hundred keeps a small margin over the measurement.
- */
 const PER_CALL_OVERHEAD_BYTES = 400;
-/** The size limits, exported so tests assert against the real values. */
 export const multicallLimits = {
     endpointBodyLimitBytes: ENDPOINT_BODY_LIMIT_BYTES,
     httpBodyTargetBytes: HTTP_BODY_TARGET_BYTES,
@@ -92,22 +12,6 @@ export const multicallLimits = {
     chunkConcurrency: CHUNK_CONCURRENCY,
     perCallOverheadBytes: PER_CALL_OVERHEAD_BYTES,
 };
-/**
- * Splits encoded calls into groups whose combined request body stays under
- * {@link CALLDATA_BUDGET_BYTES}.
- *
- * Grouped by measured size rather than by a fixed count on purpose: callers
- * differ by more than an order of magnitude in how large one call encodes to — a
- * bare `balanceOf` against a router quote carrying a swap path — so any single
- * call limit would be far too cautious for one caller and useless for another.
- *
- * A call that exceeds the budget on its own still gets its own group; splitting
- * it further is not possible, and refusing to send it would turn an oversized
- * request into a missing result.
- *
- * @param encoded - the calls to group, in order
- * @returns groups preserving the original order
- */
 export const chunkBySize = (encoded) => {
     const chunks = [];
     let current = [];
@@ -126,14 +30,6 @@ export const chunkBySize = (encoded) => {
         chunks.push(current);
     return chunks;
 };
-/**
- * Runs `task` over every item with at most `concurrency` in flight, preserving
- * input order in the result.
- *
- * @param items - the work items
- * @param concurrency - how many may run at once
- * @param task - what to do with one item
- */
 const mapWithConcurrency = async (items, concurrency, task) => {
     const results = new Array(items.length);
     let next = 0;
@@ -147,33 +43,16 @@ const mapWithConcurrency = async (items, concurrency, task) => {
     await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, worker));
     return results;
 };
-/**
- * Reads many contract calls through Multicall3, splitting the work across as
- * many requests as the size budget needs and reassembling the results in order.
- *
- * Chunking is invisible to callers: the returned array lines up with `calls`
- * one-for-one exactly as it did when every call went out together, and a chunk
- * that rejects still rejects the whole read rather than returning a short array
- * that a caller would silently misread as "these tokens have no balance".
- *
- * @param options.chain - the chain, used for its Multicall3 deployment
- * @param options.client - the public client to read through
- * @param options.abi - the default ABI, when a call does not carry its own
- * @param options.calls - the calls to make, in the order results are wanted
- * @param options.target - the default contract, when a call does not name one
- */
 export const multicallRead = async ({ chain, client, abi, calls, target, }) => {
     const multicall = getContract({
         abi: multicall3Abi,
         address: chain.contracts.multicall3.address,
-        // this seems like a bug in viem, it should be able to infer the type of the client
         client: client,
     });
     const arg = calls.map((call) => ({
         callData: encodeFunctionData({
             abi: call.abi || abi,
             functionName: call.functionName,
-            // this seems like a bug in viem, it should be able to infer the type of the args
             args: (call.args || []),
         }),
         allowFailure: call.allowFailure || false,
@@ -198,9 +77,6 @@ export const multicallRead = async ({ chain, client, abi, calls, target, }) => {
             }));
     }
     catch (err) {
-        // Deliberately a summary rather than the calls themselves: a failing read can
-        // hold tens of thousands of them, and dumping the array cost more than the
-        // failure did.
         console.error('Multicall aggregate3 failed', {
             chainId: client.chain?.id,
             target,