@defillama/sdk 5.0.240 → 5.0.244

package/build/chains/near.js

@@ -0,0 +1,446 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.viewFunction = exports.NearRpcError = exports.DEFAULT_ENDPOINTS = exports.CHAIN = void 0;
+exports.encodeArgs = encodeArgs;
+exports.decodeResult = decodeResult;
+exports.isNearAccountId = isNearAccountId;
+exports.isImplicitAccountId = isImplicitAccountId;
+exports.yoctoToNear = yoctoToNear;
+exports.getEndpoints = getEndpoints;
+exports.shouldRetry = shouldRetry;
+exports.rpc = rpc;
+exports.query = query;
+exports.viewAccount = viewAccount;
+exports.getBalance = getBalance;
+exports.call = call;
+exports.getTokenBalance = getTokenBalance;
+exports.getTokenMetadata = getTokenMetadata;
+exports.getTokenTotalSupply = getTokenTotalSupply;
+exports.getBlock = getBlock;
+exports.getLatestBlock = getLatestBlock;
+exports.getBlockAtTimestamp = getBlockAtTimestamp;
+exports.getAccessKeys = getAccessKeys;
+exports.viewState = viewState;
+/**
+ * NEAR JSON-RPC client.
+ *
+ * Replaces (and unifies) the ad-hoc NEAR helpers spread across the llama repos:
+ * - DefiLlama-Adapters   `projects/helper/chain/near.js` (endpoints, failover, view_account, call, getTokenBalance)
+ * - dimension-adapters   `helpers/near.ts` (nearView: 8 attempts, exponential backoff + jitter, round-robin cursor, p-limit(3))
+ * - peggedassets-server  `src/adapters/peggedAssets/helper/near.js` (call)
+ * - server/coins         `src/adapters/yield/apiDerivs.ts` (inline `ft_price` call_function)
+ *
+ * TVL specific pieces of the adapters helper (coingecko `tokenMapping`, `transformAddress`,
+ * `sumSingleBalance`, `sumTokens`, `addTokenBalances`) are intentionally NOT ported: this module
+ * only talks to the chain and returns raw chain data.
+ *
+ * Transport: every request goes through a shared p-limit(3) limiter (`NEAR_RPC_CONCURRENCY`
+ * overrides it), rotates over the endpoint list with a module level round-robin cursor and
+ * retries transient failures up to 8 times with exponential backoff (400ms * 2^attempt + jitter).
+ * `NEAR_RPC` (comma separated) overrides the default endpoint list.
+ *
+ * Usage: `sdk.chains.near.call({ contract: 'wrap.near', method: 'ft_metadata' })`
+ */
+const axios_1 = __importDefault(require("axios"));
+const debugLog_1 = require("../util/debugLog");
+const rpc_1 = require("./rpc");
+exports.CHAIN = 'near';
+// rpc.mainnet.near.org is deprecated (429 heavy) and near.lava.build answers 410 (discontinued);
+// both are kept last as a fallback only, the transport rotates past them on failure.
+exports.DEFAULT_ENDPOINTS = [
+    'https://free.rpc.fastnear.com',
+    'https://near.drpc.org',
+    'https://rpc.mainnet.near.org',
+    'https://near.lava.build',
+];
+const MAX_ATTEMPTS = 8;
+const BASE_DELAY = 400;
+const CONCURRENCY = 3;
+const DEFAULT_TIMEOUT = 30000;
+const YOCTO_PER_NEAR = BigInt('1000000000000000000000000');
+/**
+ * Error returned by a NEAR node (`error` member of the JSON-RPC response, or the
+ * `result.error` string of a failed `call_function`). Extends `JsonRpcError` so the
+ * shared retry helper keeps it intact. `nodeError` is the raw error object, `cause`
+ * mirrors NEAR's structured `error.cause.name` (e.g. `UNKNOWN_ACCOUNT`, `CONTRACT_EXECUTION_ERROR`).
+ */
+class NearRpcError extends rpc_1.JsonRpcError {
+    constructor(method, error, endpoint, label) {
+        var _a;
+        super(method, error);
+        this.name = 'NearRpcError';
+        this.nodeError = error;
+        this.errorName = error === null || error === void 0 ? void 0 : error.name;
+        this.cause = (_a = error === null || error === void 0 ? void 0 : error.cause) === null || _a === void 0 ? void 0 : _a.name;
+        this.endpoint = endpoint;
+        this.message = `NEAR ${label !== null && label !== void 0 ? label : method} failed: ${formatNodeError(error)}`;
+    }
+}
+exports.NearRpcError = NearRpcError;
+// ---------------------------------------------------------------------------
+// pure helpers
+// ---------------------------------------------------------------------------
+/**
+ * Encode `call_function` arguments to base64. Objects are JSON serialised, a
+ * `Buffer`/`Uint8Array` is taken as raw bytes, a string is assumed to be base64 already
+ * (pass `''` for methods without arguments), `undefined`/`null` become `{}`.
+ */
+function encodeArgs(args) {
+    if (args === undefined || args === null)
+        args = {};
+    if (typeof args === 'string')
+        return args;
+    if (Buffer.isBuffer(args) || args instanceof Uint8Array)
+        return Buffer.from(args).toString('base64');
+    return Buffer.from(JSON.stringify(args)).toString('base64');
+}
+/**
+ * Decode the `result` byte array of a `call_function` response. Returns the parsed JSON
+ * when the payload is JSON, otherwise the utf8 string (empty payload -> `''`).
+ */
+function decodeResult(bytes) {
+    if (!bytes)
+        return '';
+    const text = Buffer.from(bytes).toString('utf8');
+    if (!text.length)
+        return '';
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+// https://nomicon.io/DataStructures/Account#account-id-rules
+const ACCOUNT_ID_REGEX = /^(([a-z\d]+[-_])*[a-z\d]+\.)*([a-z\d]+[-_])*[a-z\d]+$/;
+/** True for a syntactically valid NEAR account id (named accounts and 64-hex implicit accounts) */
+function isNearAccountId(str) {
+    if (typeof str !== 'string')
+        return false;
+    if (str.length < 2 || str.length > 64)
+        return false;
+    return ACCOUNT_ID_REGEX.test(str);
+}
+/** True for a 64 char hex implicit account id */
+function isImplicitAccountId(str) {
+    return typeof str === 'string' && /^[0-9a-f]{64}$/.test(str);
+}
+/** yoctoNEAR (string/bigint) -> NEAR as a number (loses precision below 1e-15 NEAR, fine for reporting) */
+function yoctoToNear(amount) {
+    const value = typeof amount === 'bigint' ? amount : BigInt(String(amount).split('.')[0] || '0');
+    const whole = value / YOCTO_PER_NEAR;
+    const frac = value % YOCTO_PER_NEAR;
+    return Number(whole) + Number(frac) / 1e24;
+}
+function formatNodeError(error) {
+    var _a, _b;
+    if (!error)
+        return 'unknown error';
+    if (typeof error === 'string')
+        return error;
+    const parts = [];
+    if (error.message)
+        parts.push(String(error.message));
+    if (error.name && error.name !== error.message)
+        parts.push(String(error.name));
+    if ((_a = error.cause) === null || _a === void 0 ? void 0 : _a.name)
+        parts.push(String(error.cause.name));
+    if (((_b = error.cause) === null || _b === void 0 ? void 0 : _b.info) && Object.keys(error.cause.info).length)
+        parts.push(JSON.stringify(error.cause.info));
+    if (error.data !== undefined && error.data !== null)
+        parts.push(typeof error.data === 'string' ? error.data : JSON.stringify(error.data));
+    return parts.join(' | ').slice(0, 1000);
+}
+// ---------------------------------------------------------------------------
+// transport
+// ---------------------------------------------------------------------------
+/** Endpoint list: `NEAR_RPC` env (comma separated) or `DEFAULT_ENDPOINTS` */
+function getEndpoints() {
+    return (0, rpc_1.getEndpoints)(exports.CHAIN, exports.DEFAULT_ENDPOINTS);
+}
+let rpcCursor = 0;
+let requestId = 0;
+// node side errors that another endpoint / a later attempt may resolve
+const RETRYABLE_CAUSES = new Set(['INTERNAL_ERROR', 'TIMEOUT_ERROR', 'NO_SYNCED_BLOCKS', 'UNAVAILABLE_SHARD', 'UNKNOWN_BLOCK', 'GARBAGE_COLLECTED_BLOCK', 'NOT_SYNCED_YET']);
+/**
+ * Decide whether a failed attempt should be retried. Transport/HTTP level failures
+ * (network errors, timeouts, 4xx/5xx from a gateway - e.g. the 410 of a discontinued
+ * provider, 429 rate limits) always rotate to the next endpoint; node errors only when
+ * another node might have the data (missing/garbage collected block, node not synced,
+ * internal error). Contract level errors (unknown account, method not found, execution
+ * failure) are deterministic and fail fast.
+ */
+function shouldRetry(e) {
+    var _a;
+    if ((0, rpc_1.isRateLimitError)(e))
+        return true;
+    if (e instanceof NearRpcError) {
+        if (e.cause && RETRYABLE_CAUSES.has(e.cause))
+            return true;
+        if (e.errorName === 'INTERNAL_ERROR')
+            return true;
+        // legacy (unstructured) error format: `Server error` + data string
+        const data = typeof ((_a = e.nodeError) === null || _a === void 0 ? void 0 : _a.data) === 'string' ? e.nodeError.data : '';
+        if (/not synced|unavailable|timeout|internal error|garbage collected|unknown block|DB Not Found/i.test(data))
+            return true;
+        return false;
+    }
+    if (e instanceof rpc_1.JsonRpcError)
+        return false;
+    return true;
+}
+/**
+ * Raw NEAR JSON-RPC call. Returns `result`, throws `NearRpcError` when the node answers with
+ * an `error`. Rotates endpoints (round-robin), retries with exponential backoff and runs
+ * under the shared concurrency limiter.
+ */
+async function rpc(method, params = {}, options = {}) {
+    var _a, _b;
+    const explicit = (0, rpc_1.toEndpointList)(options.endpoints);
+    const endpoints = explicit.length ? explicit : getEndpoints();
+    const start = rpcCursor++;
+    const body = { jsonrpc: '2.0', id: `llama-sdk-${++requestId}`, method, params };
+    const timeout = (_a = options.timeout) !== null && _a !== void 0 ? _a : DEFAULT_TIMEOUT;
+    const label = (_b = options.label) !== null && _b !== void 0 ? _b : `${exports.CHAIN} ${method}${(params === null || params === void 0 ? void 0 : params.request_type) ? `/${params.request_type}` : ''}`;
+    const run = () => {
+        var _a, _b, _c, _d, _e;
+        return (0, rpc_1.withRetry)(async (attempt) => {
+            const endpoint = endpoints[(start + attempt) % endpoints.length];
+            const { data } = await axios_1.default.post(endpoint, body, { timeout });
+            if (data === undefined || data === null || typeof data !== 'object')
+                throw new Error(`${label}: unexpected response from ${(0, rpc_1.shortUrl)(endpoint)}`);
+            if (data.error) {
+                const err = new NearRpcError(method, data.error, endpoint, label);
+                (0, debugLog_1.debugLog)(`[chains.near] ${label} node error from ${(0, rpc_1.shortUrl)(endpoint)}: ${err.message}`);
+                throw err;
+            }
+            return data.result;
+        }, {
+            retries: (_a = options.retries) !== null && _a !== void 0 ? _a : MAX_ATTEMPTS,
+            delay: (_b = options.delay) !== null && _b !== void 0 ? _b : BASE_DELAY,
+            backoff: (_c = options.backoff) !== null && _c !== void 0 ? _c : 2,
+            maxDelay: (_d = options.maxDelay) !== null && _d !== void 0 ? _d : 10000,
+            shouldRetry: (_e = options.shouldRetry) !== null && _e !== void 0 ? _e : shouldRetry,
+            label,
+        });
+    };
+    if (options.skipLimiter)
+        return run();
+    return (0, rpc_1.getLimiter)(exports.CHAIN.toUpperCase(), CONCURRENCY)(run);
+}
+// ---------------------------------------------------------------------------
+// query helpers
+// ---------------------------------------------------------------------------
+function blockParams(blockId, finality) {
+    if (blockId !== undefined && blockId !== null && blockId !== '')
+        return { block_id: normaliseBlockId(blockId) };
+    return { finality: finality !== null && finality !== void 0 ? finality : 'final' };
+}
+function normaliseBlockId(blockId) {
+    if (typeof blockId === 'string' && /^\d+$/.test(blockId))
+        return +blockId;
+    return blockId;
+}
+/**
+ * The `query` RPC method. Defaults to `finality: 'final'`; when `block_id`/`blockId` is
+ * given the finality is omitted (the node rejects requests carrying both).
+ */
+async function query(params, options) {
+    const { blockId, block_id, finality, ...rest } = params;
+    const target = blockParams(block_id !== null && block_id !== void 0 ? block_id : blockId, finality);
+    return rpc('query', { ...rest, ...target }, options);
+}
+/** `view_account`: raw account view (`amount` and `locked` are yoctoNEAR strings) */
+async function viewAccount({ account, blockId }, options) {
+    return query({ request_type: 'view_account', account_id: account, blockId }, options);
+}
+/** Native balance (`amount`, yoctoNEAR string, excludes `locked` stake) */
+async function getBalance({ account, blockId }, options) {
+    const { amount } = await viewAccount({ account, blockId }, options);
+    return amount;
+}
+/**
+ * View call (`call_function`). `args` are JSON serialised and base64 encoded, the returned
+ * byte array is decoded to JSON (or a string). Throws `NearRpcError` carrying the node
+ * error message on failure (unknown account/method, execution error, ...).
+ */
+async function call({ contract, method, args, blockId }, options) {
+    const label = `${contract}.${method}`;
+    const res = await query({
+        request_type: 'call_function',
+        account_id: contract,
+        method_name: method,
+        args_base64: encodeArgs(args),
+        blockId,
+    }, { label: `${exports.CHAIN} ${label}`, ...options });
+    // older nodes report contract execution failures inside `result` with a 200 status
+    if (res === null || res === void 0 ? void 0 : res.error)
+        throw new NearRpcError('query', { message: 'Contract execution error', cause: { name: 'CONTRACT_EXECUTION_ERROR' }, data: res.error }, undefined, label);
+    if (!Array.isArray(res === null || res === void 0 ? void 0 : res.result))
+        throw new Error(`NEAR ${label}: unexpected response shape`);
+    return decodeResult(res.result);
+}
+/** Alias of `call` */
+exports.viewFunction = call;
+/**
+ * `ft_balance_of` raw balance string. Mirrors the adapters helper: when the token
+ * contract does not exist the balance is `'0'` instead of an error.
+ */
+async function getTokenBalance({ token, account, blockId }, options) {
+    try {
+        const res = await call({ contract: token, method: 'ft_balance_of', args: { account_id: account }, blockId }, options);
+        return String(res !== null && res !== void 0 ? res : '0');
+    }
+    catch (e) {
+        if (isMissingAccountError(e)) {
+            (0, debugLog_1.debugLog)(`[chains.near] ${token}.ft_balance_of(${account}): token contract does not exist, returning 0`);
+            return '0';
+        }
+        throw e;
+    }
+}
+/** `ft_metadata` (NEP-148) */
+async function getTokenMetadata({ token, blockId }, options) {
+    return call({ contract: token, method: 'ft_metadata', blockId }, options);
+}
+/** `ft_total_supply` raw string */
+async function getTokenTotalSupply({ token, blockId }, options) {
+    const res = await call({ contract: token, method: 'ft_total_supply', blockId }, options);
+    return String(res);
+}
+function isMissingAccountError(e) {
+    var _a;
+    if (e instanceof NearRpcError) {
+        if (e.cause === 'UNKNOWN_ACCOUNT' || e.cause === 'NO_CONTRACT_CODE')
+            return true;
+    }
+    return /does not exist while viewing/i.test(String((_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : ''));
+}
+// ---------------------------------------------------------------------------
+// blocks
+// ---------------------------------------------------------------------------
+function toBlock(raw) {
+    var _a, _b;
+    const header = raw === null || raw === void 0 ? void 0 : raw.header;
+    if (!header)
+        throw new Error('NEAR block: unexpected response shape');
+    const ns = String((_a = header.timestamp_nanosec) !== null && _a !== void 0 ? _a : header.timestamp);
+    return {
+        number: header.height,
+        timestamp: Math.floor(Number(BigInt(ns) / BigInt(1000000000))),
+        timestampNs: ns,
+        hash: header.hash,
+        prevHash: header.prev_hash,
+        header,
+        chunks: (_b = raw.chunks) !== null && _b !== void 0 ? _b : [],
+        author: raw.author,
+    };
+}
+/** `block` RPC: by height/hash (`blockId`) or by finality (default `final`) */
+async function getBlock({ blockId, finality } = {}, options) {
+    const raw = await rpc('block', blockParams(blockId, finality), options);
+    return toBlock(raw);
+}
+async function getLatestBlock(options) {
+    return getBlock({}, options);
+}
+function isUnknownBlockError(e) {
+    var _a;
+    if (e instanceof NearRpcError) {
+        if (e.cause === 'UNKNOWN_BLOCK' || e.cause === 'GARBAGE_COLLECTED_BLOCK')
+            return true;
+    }
+    return /unknown block|DB Not Found|garbage collected/i.test(String((_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : ''));
+}
+/**
+ * Fetch the block at `height`, or the next existing one (NEAR skips heights when a block
+ * producer misses its slot). Returns `undefined` when nothing exists up to `maxHeight`.
+ */
+async function getBlockAtOrAfter(height, maxHeight, options) {
+    const maxSteps = 200;
+    for (let h = height, i = 0; h <= maxHeight && i < maxSteps; h++, i++) {
+        try {
+            return await getBlock({ blockId: h }, { ...options, retries: 2, shouldRetry: (e) => !isUnknownBlockError(e) && shouldRetry(e) });
+        }
+        catch (e) {
+            if (!isUnknownBlockError(e))
+                throw e;
+        }
+    }
+    return undefined;
+}
+/**
+ * Last block produced at or before `timestamp` (unix seconds). Binary search on heights;
+ * missing heights are skipped by stepping forward. Non archival nodes only keep ~5 epochs
+ * (a few days) of history, older timestamps need an archival `NEAR_RPC`.
+ */
+async function getBlockAtTimestamp({ timestamp }, options) {
+    if (!timestamp || !Number.isFinite(timestamp))
+        throw new Error('NEAR getBlockAtTimestamp: invalid timestamp');
+    if (timestamp > 1e12)
+        timestamp = Math.floor(timestamp / 1000); // ms -> s
+    const latest = await getLatestBlock(options);
+    if (latest.timestamp <= timestamp)
+        return latest;
+    // bracket: guess a lower bound assuming >= 0.5s per block, widen until it precedes the target
+    let hi = latest;
+    let span = Math.max(100, Math.ceil((latest.timestamp - timestamp) * 2));
+    let lo;
+    while (true) {
+        const loHeight = Math.max(1, hi.number - span);
+        const candidate = await getBlockAtOrAfter(loHeight, hi.number, options);
+        if (!candidate)
+            throw new Error(`NEAR getBlockAtTimestamp: no block found around height ${loHeight}, node may not be archival`);
+        if (candidate.timestamp <= timestamp) {
+            lo = candidate;
+            break;
+        }
+        if (loHeight <= 1)
+            throw new Error(`NEAR getBlockAtTimestamp: timestamp ${timestamp} predates the chain`);
+        hi = candidate;
+        span *= 2;
+    }
+    // binary search between lo (<= target) and hi (> target)
+    while (hi.number - lo.number > 1) {
+        const mid = lo.number + Math.floor((hi.number - lo.number) / 2);
+        const block = await getBlockAtOrAfter(mid, hi.number - 1, options);
+        if (!block) {
+            hi = { ...hi, number: mid };
+            continue;
+        } // heights (mid, hi) are all missing; shrink from the top
+        if (block.timestamp <= timestamp)
+            lo = block;
+        else
+            hi = block;
+    }
+    (0, debugLog_1.debugLog)(`[chains.near] getBlockAtTimestamp(${timestamp}) -> height ${lo.number} @ ${lo.timestamp}`);
+    return lo;
+}
+// ---------------------------------------------------------------------------
+// keys / state
+// ---------------------------------------------------------------------------
+/** `view_access_key_list`: all access keys of an account */
+async function getAccessKeys({ account, blockId }, options) {
+    var _a;
+    const res = await query({ request_type: 'view_access_key_list', account_id: account, blockId }, options);
+    return (_a = res === null || res === void 0 ? void 0 : res.keys) !== null && _a !== void 0 ? _a : [];
+}
+/**
+ * `view_state`: contract storage entries whose key starts with `prefix` (utf8 string, or
+ * raw bytes / base64 via `prefixBase64`). Keys and values are returned base64 and utf8 decoded.
+ */
+async function viewState({ contract, prefix = '', prefixBase64, blockId }, options) {
+    var _a;
+    const prefix_base64 = prefixBase64 !== null && prefixBase64 !== void 0 ? prefixBase64 : Buffer.from(prefix, 'utf8').toString('base64');
+    const res = await query({ request_type: 'view_state', account_id: contract, prefix_base64, blockId }, options);
+    const values = (_a = res === null || res === void 0 ? void 0 : res.values) !== null && _a !== void 0 ? _a : [];
+    return values.map((entry) => ({
+        key: Buffer.from(entry.key, 'base64').toString('utf8'),
+        value: Buffer.from(entry.value, 'base64').toString('utf8'),
+        keyBase64: entry.key,
+        valueBase64: entry.value,
+    }));
+}

package/build/chains/rpc.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Shared transport for the non-EVM chain modules under `sdk.chains.*`.
+ *
+ * Every chain module resolves its endpoints through `getEndpoints`. When
+ * `<CHAIN>_WHITELISTED_RPC` is set only those endpoints are used; otherwise the
+ * `<CHAIN>_RPC` env var (and the `SDK_` / `LLAMA_SDK_` prefixed variants read by
+ * `getEnvValue`) is tried first, followed by the module's built-in defaults.
+ * Comma separated values give a list; `jsonRpc` / `httpGet` / `httpPost` start
+ * at the first entry, rotate to the next on failure and retry with backoff.
+ */
+import { AxiosRequestConfig } from "axios";
+import pLimit from "p-limit";
+import { sleep } from "../util/common";
+export type Endpoints = string | string[] | undefined;
+export interface RetryOptions {
+    /** total attempts across all endpoints, default 3 */
+    retries?: number;
+    /** base delay in ms between attempts, default 500 */
+    delay?: number;
+    /** multiplier applied to delay after every failed attempt, default 2 */
+    backoff?: number;
+    /** max delay in ms, default 10_000 */
+    maxDelay?: number;
+    /** return false to abort retrying for a given error */
+    shouldRetry?: (error: any, attempt: number) => boolean;
+    /** label used in error messages */
+    label?: string;
+}
+export interface HttpOptions extends RetryOptions {
+    timeout?: number;
+    headers?: Record<string, string>;
+    /** axios `params` (query string) */
+    params?: Record<string, any>;
+    /** extra axios config merged last */
+    axiosConfig?: AxiosRequestConfig;
+    /** return the full axios response (data, headers, status) instead of only `data` */
+    withMetadata?: boolean;
+}
+export interface JsonRpcOptions extends HttpOptions {
+    /** chain key, used to look up `<CHAIN>_RPC` and passed to `getEndpoints` */
+    chain?: string;
+    /** explicit endpoint(s); overrides `chain` */
+    endpoints?: Endpoints;
+    /** module defaults used when neither env nor `endpoints` is set */
+    defaultEndpoints?: Endpoints;
+    id?: number | string;
+}
+export interface JsonRpcCall {
+    method: string;
+    params?: any;
+    id?: number | string;
+}
+export declare function toEndpointList(value: Endpoints): string[];
+/**
+ * Resolve the endpoint list for a chain. `<CHAIN>_WHITELISTED_RPC` wins outright
+ * when set. Otherwise env (`<CHAIN>_RPC` or `envKey`, comma separated) comes
+ * first followed by the module defaults, then the generic fallback.
+ * Throws when nothing is configured so a misconfigured chain fails loudly.
+ */
+export declare function getEndpoints(chain: string | undefined, defaults?: Endpoints, { envKey, fallback, }?: {
+    envKey?: string;
+    fallback?: Endpoints;
+}): string[];
+/** First endpoint of `getEndpoints` */
+export declare function getEndpoint(chain: string | undefined, defaults?: Endpoints, options?: {
+    envKey?: string;
+    fallback?: Endpoints;
+}): string;
+export declare function stripTrailingSlash(url: string): string;
+export declare function joinUrl(base: string, path: string): string;
+export declare function isRateLimitError(e: any): boolean;
+export declare function isRetryableError(e: any): boolean;
+/**
+ * Run `fn` with retries and exponential backoff. `fn` receives the attempt index.
+ */
+export declare function withRetry<T>(fn: (attempt: number) => Promise<T>, options?: RetryOptions): Promise<T>;
+/**
+ * Lazily created per-key concurrency limiter. Concurrency can be overridden with
+ * the `<KEY>_RPC_CONCURRENCY` env var.
+ */
+export declare function getLimiter(key: string, concurrency?: number): pLimit.Limit;
+export declare function sliceIntoChunks<T>(arr: T[], chunkSize?: number): T[][];
+/**
+ * Process `items` in chunks, sequentially or with limited concurrency, keeping
+ * result order. `fn` receives one chunk and returns an array (flattened) or any value.
+ */
+export declare function runInChunks<T, R>(items: T[], fn: (chunk: T[], index: number) => Promise<R[] | R>, { chunkSize, concurrency, sleepTime }?: {
+    chunkSize?: number;
+    concurrency?: number;
+    sleepTime?: number;
+}): Promise<R[]>;
+/**
+ * GET `url` (or rotate over several base urls when `url` is an array; `path` is
+ * appended to each). Retries transient failures.
+ */
+export declare function httpGet(url: string | string[], options?: HttpOptions & {
+    path?: string;
+}): Promise<any>;
+/**
+ * POST `body` to `url` (or rotate over several urls). Retries transient failures.
+ */
+export declare function httpPost(url: string | string[], body: any, options?: HttpOptions & {
+    path?: string;
+}): Promise<any>;
+export declare class JsonRpcError extends Error {
+    code?: number;
+    data?: any;
+    method: string;
+    constructor(method: string, error: any);
+}
+/**
+ * Single JSON-RPC 2.0 call. Returns `result`; throws `JsonRpcError` when the node
+ * returns an `error` object. Rotates endpoints and retries on transport errors.
+ */
+export declare function jsonRpc(method: string, params?: any, options?: JsonRpcOptions): Promise<any>;
+/**
+ * JSON-RPC 2.0 batch call. Returns results in call order. Individual `error`
+ * entries throw unless `permitFailure` is set, in which case they resolve to `undefined`.
+ */
+export declare function jsonRpcBatch(calls: JsonRpcCall[], options?: JsonRpcOptions & {
+    permitFailure?: boolean;
+    chunkSize?: number;
+}): Promise<any[]>;
+export declare function shortUrl(url: string): string;
+export { sleep };