@defillama/sdk 5.0.236 → 5.0.240

package/build/chains/near.js

@@ -1,446 +0,0 @@
-"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

@@ -1,125 +0,0 @@
-/**
- * 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 };