@defillama/sdk 5.0.236 → 5.0.240

package/build/chains/rpc.js

@@ -1,326 +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.sleep = exports.JsonRpcError = void 0;
-exports.toEndpointList = toEndpointList;
-exports.getEndpoints = getEndpoints;
-exports.getEndpoint = getEndpoint;
-exports.stripTrailingSlash = stripTrailingSlash;
-exports.joinUrl = joinUrl;
-exports.isRateLimitError = isRateLimitError;
-exports.isRetryableError = isRetryableError;
-exports.withRetry = withRetry;
-exports.getLimiter = getLimiter;
-exports.sliceIntoChunks = sliceIntoChunks;
-exports.runInChunks = runInChunks;
-exports.httpGet = httpGet;
-exports.httpPost = httpPost;
-exports.jsonRpc = jsonRpc;
-exports.jsonRpcBatch = jsonRpcBatch;
-exports.shortUrl = shortUrl;
-/**
- * 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.
- */
-const axios_1 = __importDefault(require("axios"));
-const p_limit_1 = __importDefault(require("p-limit"));
-const env_1 = require("../util/env");
-const common_1 = require("../util/common");
-Object.defineProperty(exports, "sleep", { enumerable: true, get: function () { return common_1.sleep; } });
-const debugLog_1 = require("../util/debugLog");
-const DEFAULT_TIMEOUT = 60000;
-// ---------------------------------------------------------------------------
-// endpoint resolution
-// ---------------------------------------------------------------------------
-function toEndpointList(value) {
-    if (!value)
-        return [];
-    const list = Array.isArray(value) ? value : value.split(',');
-    return list.map(i => i.trim()).filter(Boolean);
-}
-/**
- * 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.
- */
-function getEndpoints(chain, defaults, { envKey, fallback, } = {}) {
-    if (chain) {
-        const whitelisted = toEndpointList((0, env_1.getWhitelistedRPCs)(chain));
-        if (whitelisted.length)
-            return whitelisted;
-    }
-    let fromEnv;
-    if (envKey)
-        fromEnv = (0, env_1.getEnvValue)(envKey);
-    else if (chain)
-        fromEnv = (0, env_1.getEnvRPC)(chain);
-    const list = [...new Set([...toEndpointList(fromEnv), ...toEndpointList(defaults)])];
-    if (list.length)
-        return list;
-    const fallbackList = toEndpointList(fallback);
-    if (fallbackList.length)
-        return fallbackList;
-    throw new Error(`No RPC endpoint configured for chain "${chain !== null && chain !== void 0 ? chain : '-'}"${envKey ? ` (env ${envKey})` : chain ? ` (env ${chain.toUpperCase()}_RPC)` : ''}`);
-}
-/** First endpoint of `getEndpoints` */
-function getEndpoint(chain, defaults, options) {
-    return getEndpoints(chain, defaults, options)[0];
-}
-function stripTrailingSlash(url) {
-    return url.replace(/\/+$/, '');
-}
-function joinUrl(base, path) {
-    if (!path)
-        return base;
-    return stripTrailingSlash(base) + '/' + path.replace(/^\/+/, '');
-}
-// ---------------------------------------------------------------------------
-// retry / concurrency
-// ---------------------------------------------------------------------------
-function isRateLimitError(e) {
-    var _a, _b, _c, _d;
-    const status = (_b = (_a = e === null || e === void 0 ? void 0 : e.response) === null || _a === void 0 ? void 0 : _a.status) !== null && _b !== void 0 ? _b : e === null || e === void 0 ? void 0 : e.status;
-    if (status === 429)
-        return true;
-    const message = String((_d = (_c = e === null || e === void 0 ? void 0 : e.message) !== null && _c !== void 0 ? _c : e) !== null && _d !== void 0 ? _d : '').toLowerCase();
-    return message.includes('429') || message.includes('rate limit') || message.includes('too many requests');
-}
-function isRetryableError(e) {
-    var _a, _b;
-    const status = (_b = (_a = e === null || e === void 0 ? void 0 : e.response) === null || _a === void 0 ? void 0 : _a.status) !== null && _b !== void 0 ? _b : e === null || e === void 0 ? void 0 : e.status;
-    if (status && status < 500 && status !== 429 && status !== 408)
-        return false;
-    return true;
-}
-/**
- * Run `fn` with retries and exponential backoff. `fn` receives the attempt index.
- */
-async function withRetry(fn, options = {}) {
-    const { retries = 3, delay = 500, backoff = 2, maxDelay = 10000, shouldRetry = isRetryableError, label = 'request' } = options;
-    const attempts = Math.max(1, retries);
-    let wait = delay;
-    let lastError;
-    for (let attempt = 0; attempt < attempts; attempt++) {
-        try {
-            return await fn(attempt);
-        }
-        catch (e) {
-            lastError = e;
-            const isLast = attempt === attempts - 1;
-            if (isLast || !shouldRetry(e, attempt))
-                break;
-            const jitter = Math.floor(Math.random() * Math.min(wait, 250));
-            (0, debugLog_1.debugLog)(`[chains.rpc] ${label} failed (attempt ${attempt + 1}/${attempts}), retrying in ${wait}ms: ${shortMessage(e)}`);
-            await (0, common_1.sleep)(Math.min(wait, maxDelay) + jitter);
-            wait = Math.min(wait * backoff, maxDelay);
-        }
-    }
-    // keep typed errors (JsonRpcError etc) intact, only reformat transport errors
-    if (lastError instanceof JsonRpcError)
-        throw lastError;
-    throw (0, common_1.formError)(lastError);
-}
-const limiters = {};
-/**
- * Lazily created per-key concurrency limiter. Concurrency can be overridden with
- * the `<KEY>_RPC_CONCURRENCY` env var.
- */
-function getLimiter(key, concurrency = 10) {
-    if (!limiters[key]) {
-        const envValue = (0, env_1.getEnvValue)(`${key}_RPC_CONCURRENCY`);
-        limiters[key] = (0, p_limit_1.default)(envValue ? +envValue : concurrency);
-    }
-    return limiters[key];
-}
-function sliceIntoChunks(arr, chunkSize = 100) {
-    const res = [];
-    for (let i = 0; i < arr.length; i += chunkSize)
-        res.push(arr.slice(i, i + chunkSize));
-    return res;
-}
-/**
- * Process `items` in chunks, sequentially or with limited concurrency, keeping
- * result order. `fn` receives one chunk and returns an array (flattened) or any value.
- */
-async function runInChunks(items, fn, { chunkSize = 100, concurrency = 1, sleepTime = 0 } = {}) {
-    const chunks = sliceIntoChunks(items, chunkSize);
-    const limit = (0, p_limit_1.default)(Math.max(1, concurrency));
-    const results = await Promise.all(chunks.map((chunk, i) => limit(async () => {
-        if (sleepTime && i > 0 && concurrency === 1)
-            await (0, common_1.sleep)(sleepTime);
-        return fn(chunk, i);
-    })));
-    return results.flat();
-}
-// ---------------------------------------------------------------------------
-// http
-// ---------------------------------------------------------------------------
-function buildAxiosConfig(options) {
-    const { timeout = DEFAULT_TIMEOUT, headers, params, axiosConfig } = options;
-    return { timeout, headers, params, ...axiosConfig };
-}
-/**
- * GET `url` (or rotate over several base urls when `url` is an array; `path` is
- * appended to each). Retries transient failures.
- */
-async function httpGet(url, options = {}) {
-    var _a;
-    const urls = Array.isArray(url) ? url : [url];
-    if (!urls.length)
-        throw new Error('httpGet: no url');
-    const config = buildAxiosConfig(options);
-    return withRetry(async (attempt) => {
-        const base = urls[attempt % urls.length];
-        const fullUrl = options.path ? joinUrl(base, options.path) : base;
-        const res = await axios_1.default.get(fullUrl, config);
-        return options.withMetadata ? res : res.data;
-    }, { label: `GET ${shortUrl(urls[0])}`, retries: (_a = options.retries) !== null && _a !== void 0 ? _a : Math.max(3, urls.length), ...pickRetry(options) });
-}
-/**
- * POST `body` to `url` (or rotate over several urls). Retries transient failures.
- */
-async function httpPost(url, body, options = {}) {
-    var _a;
-    const urls = Array.isArray(url) ? url : [url];
-    if (!urls.length)
-        throw new Error('httpPost: no url');
-    const config = buildAxiosConfig(options);
-    return withRetry(async (attempt) => {
-        const base = urls[attempt % urls.length];
-        const fullUrl = options.path ? joinUrl(base, options.path) : base;
-        const res = await axios_1.default.post(fullUrl, body, config);
-        return options.withMetadata ? res : res.data;
-    }, { label: `POST ${shortUrl(urls[0])}`, retries: (_a = options.retries) !== null && _a !== void 0 ? _a : Math.max(3, urls.length), ...pickRetry(options) });
-}
-// ---------------------------------------------------------------------------
-// json-rpc
-// ---------------------------------------------------------------------------
-class JsonRpcError extends Error {
-    constructor(method, error) {
-        var _a;
-        super(`JSON-RPC ${method} failed: ${(_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : JSON.stringify(error)}`);
-        this.name = 'JsonRpcError';
-        this.code = error === null || error === void 0 ? void 0 : error.code;
-        this.data = error === null || error === void 0 ? void 0 : error.data;
-        this.method = method;
-    }
-}
-exports.JsonRpcError = JsonRpcError;
-function resolveRpcEndpoints(options) {
-    const explicit = toEndpointList(options.endpoints);
-    if (explicit.length)
-        return explicit;
-    return getEndpoints(options.chain, options.defaultEndpoints);
-}
-/**
- * Single JSON-RPC 2.0 call. Returns `result`; throws `JsonRpcError` when the node
- * returns an `error` object. Rotates endpoints and retries on transport errors.
- */
-async function jsonRpc(method, params = [], options = {}) {
-    var _a, _b, _c, _d;
-    const endpoints = resolveRpcEndpoints(options);
-    const body = { jsonrpc: '2.0', id: (_a = options.id) !== null && _a !== void 0 ? _a : 1, method, params };
-    const config = buildAxiosConfig(options);
-    return withRetry(async (attempt) => {
-        const endpoint = endpoints[attempt % endpoints.length];
-        const { data } = await axios_1.default.post(endpoint, body, config);
-        if (data === null || data === void 0 ? void 0 : data.error)
-            throw new JsonRpcError(method, data.error);
-        if (data === undefined || data === null || typeof data !== 'object')
-            throw new Error(`JSON-RPC ${method}: empty response from ${shortUrl(endpoint)}`);
-        return data.result;
-    }, {
-        label: `${(_b = options.chain) !== null && _b !== void 0 ? _b : shortUrl(endpoints[0])} ${method}`,
-        retries: (_c = options.retries) !== null && _c !== void 0 ? _c : Math.max(3, endpoints.length),
-        ...pickRetry(options),
-        shouldRetry: (_d = options.shouldRetry) !== null && _d !== void 0 ? _d : ((e) => !(e instanceof JsonRpcError) || isRateLimitError(e) || isNodeSideRetryable(e)),
-    });
-}
-/**
- * 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`.
- */
-async function jsonRpcBatch(calls, options = {}) {
-    var _a, _b, _c;
-    if (!calls.length)
-        return [];
-    const endpoints = resolveRpcEndpoints(options);
-    const config = buildAxiosConfig(options);
-    const chunkSize = (_a = options.chunkSize) !== null && _a !== void 0 ? _a : calls.length;
-    const chunks = sliceIntoChunks(calls, chunkSize);
-    const results = [];
-    for (const chunk of chunks) {
-        const body = chunk.map((c, i) => { var _a, _b; return ({ jsonrpc: '2.0', id: (_a = c.id) !== null && _a !== void 0 ? _a : i, method: c.method, params: (_b = c.params) !== null && _b !== void 0 ? _b : [] }); });
-        const data = await withRetry(async (attempt) => {
-            const endpoint = endpoints[attempt % endpoints.length];
-            const { data } = await axios_1.default.post(endpoint, body, config);
-            if (!Array.isArray(data)) {
-                if (data === null || data === void 0 ? void 0 : data.error)
-                    throw new JsonRpcError('batch', data.error);
-                throw new Error(`JSON-RPC batch: unexpected response from ${shortUrl(endpoint)}`);
-            }
-            return data;
-        }, { label: `${(_b = options.chain) !== null && _b !== void 0 ? _b : shortUrl(endpoints[0])} batch(${chunk.length})`, retries: (_c = options.retries) !== null && _c !== void 0 ? _c : Math.max(3, endpoints.length), ...pickRetry(options) });
-        const byId = new Map();
-        data.forEach((r) => byId.set(String(r.id), r));
-        chunk.forEach((c, i) => {
-            var _a;
-            const r = byId.get(String((_a = c.id) !== null && _a !== void 0 ? _a : i));
-            if (!r) {
-                if (options.permitFailure)
-                    return results.push(undefined);
-                throw new Error(`JSON-RPC batch: missing response for ${c.method}`);
-            }
-            if (r.error) {
-                if (options.permitFailure)
-                    return results.push(undefined);
-                throw new JsonRpcError(c.method, r.error);
-            }
-            results.push(r.result);
-        });
-    }
-    return results;
-}
-// ---------------------------------------------------------------------------
-// misc
-// ---------------------------------------------------------------------------
-function isNodeSideRetryable(e) {
-    const code = e === null || e === void 0 ? void 0 : e.code;
-    // -32005 node is behind / limit exceeded, -32603 internal error, -32000 server error
-    return code === -32005 || code === -32603 || code === -32000;
-}
-function pickRetry(options) {
-    const { delay, backoff, maxDelay, shouldRetry } = options;
-    const res = {};
-    if (delay !== undefined)
-        res.delay = delay;
-    if (backoff !== undefined)
-        res.backoff = backoff;
-    if (maxDelay !== undefined)
-        res.maxDelay = maxDelay;
-    if (shouldRetry !== undefined)
-        res.shouldRetry = shouldRetry;
-    return res;
-}
-function shortUrl(url) {
-    try {
-        const u = new URL(url);
-        return u.host;
-    }
-    catch {
-        return String(url).slice(0, 60);
-    }
-}
-function shortMessage(e) {
-    var _a;
-    return String((_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : e).slice(0, 200);
-}

package/build/chains/starknet.d.ts

@@ -1,205 +0,0 @@
-export declare const CHAIN = "starknet";
-export declare const DEFAULT_ENDPOINTS: string[];
-export declare const DEFAULT_MULTICALL_ADDRESS = "0x01a33330996310a1e3fa1df5b16c1e07f0491fdd20c441126e02613b948f0225";
-export declare const AGGREGATE_CHUNK_SIZE = 50;
-export declare const BATCH_CHUNK_SIZE = 25;
-export declare function getEndpoints(): string[];
-export declare function getMulticallAddress(): string;
-export interface AbiParam {
-    name?: string;
-    type: string;
-    /** Cairo 0 struct members carry `offset`; kept open for other metadata */
-    [key: string]: any;
-}
-export interface AbiEntry {
-    name: string;
-    type?: string;
-    inputs?: AbiParam[];
-    outputs?: AbiParam[];
-    members?: AbiParam[];
-    variants?: AbiParam[];
-    stateMutability?: string;
-    state_mutability?: string;
-    /** 'address': params are passed through as raw felts, skipping encodeCalldata */
-    customInput?: string;
-    /** post-processing of a single output: 'address' pads, 'Uint256' | 'number' cast to number */
-    customType?: string;
-    [key: string]: any;
-}
-export type BlockTag = 'latest' | 'pending' | 'pre_confirmed' | 'l1_accepted';
-export type BlockId = BlockTag | number | string | {
-    block_number: number;
-} | {
-    block_hash: string;
-};
-export interface CallOptions {
-    abi: AbiEntry;
-    target: string;
-    params?: any;
-    allAbi?: AbiEntry[];
-    permitFailure?: boolean;
-    block?: BlockId;
-}
-export interface MultiCallItem {
-    target?: string;
-    params?: any;
-    abi?: AbiEntry;
-    allAbi?: AbiEntry[];
-}
-export interface MultiCallOptions {
-    abi?: AbiEntry;
-    target?: string;
-    calls: (MultiCallItem | string)[];
-    allAbi?: AbiEntry[];
-    permitFailure?: boolean;
-    useAggregator?: boolean;
-    block?: BlockId;
-}
-export interface StarknetEvent {
-    block_number?: number;
-    block_hash?: string;
-    transaction_hash: string;
-    from_address: string;
-    keys: string[];
-    data: string[];
-}
-export interface GetLogsOptions {
-    target: string;
-    fromBlock: number;
-    toBlock?: number;
-    /** event selectors (any of them): shorthand for keys: [topics] */
-    topics?: (string | bigint | number)[];
-    /** raw starknet_getEvents keys filter (positional, each an OR list) */
-    keys?: (string | bigint | number | (string | bigint | number)[])[];
-    /** kept for signature parity with the adapters helper (used there as cache-key segment); ignored */
-    extraKey?: string;
-    /** page size for starknet_getEvents (default 1000; halved and retried when the provider rejects it) */
-    chunkSize?: number;
-}
-export declare const ADDR_BOUND: bigint;
-export declare const FIELD_PRIME: bigint;
-export type BigNumberish = string | number | bigint | boolean;
-export declare function toBigInt(value: BigNumberish): bigint;
-export declare function toHex(value: BigNumberish): string;
-export declare function addAddressPadding(address: BigNumberish): string;
-export declare function validateAndParseAddress(address: BigNumberish): string;
-/**
- * Loose check for a Starknet address: 0x-prefixed hex, non-zero, inside the
- * address bound, and not shaped like an EVM address (exactly 40 hex chars).
- */
-export declare function isStarknetAddress(value: any): boolean;
-/** starknet_keccak: keccak256 of the utf8 name, masked to 250 bits */
-export declare function starknetKeccak(str: string): bigint;
-export declare function getSelectorFromName(name: string): string;
-/** u256 as { low, high } object or [low, high] felt pair -> bigint */
-export declare function parseUint256(value: {
-    low: BigNumberish;
-    high: BigNumberish;
-} | BigNumberish[] | BigNumberish): bigint;
-/** Cairo short string (<= 31 utf8 bytes) -> hex felt */
-export declare function shortStringToFelt(str: string): string;
-/** hex/decimal/bigint felt -> utf8 short string (leading zero bytes dropped) */
-export declare function feltToShortString(felt: BigNumberish): string;
-/** concatenate an array of short-string felts (e.g. a felt* name) */
-export declare function feltArrToStr(felts: BigNumberish[]): string;
-export declare const number: {
-    toHex: typeof toHex;
-    toBigInt: typeof toBigInt;
-    toBN: typeof toBigInt;
-    hexToDecimalString: (v: BigNumberish) => string;
-};
-/**
- * Encode function arguments into calldata (array of hex felts).
- * @param fnAbi   function abi entry (or just its `inputs` array)
- * @param params  positional arguments
- * @param allAbi  struct/enum definitions referenced by the function
- */
-export declare function encodeCalldata(fnAbi: AbiEntry | AbiParam[], params?: any, allAbi?: AbiEntry[]): string[];
-/**
- * Decode a starknet_call result according to the function abi.
- * @param fnAbi   function abi entry (or just its `outputs` array)
- * @param result  array of felts returned by the node
- * @param allAbi  struct/enum definitions referenced by the function
- */
-export declare function decodeOutput(fnAbi: AbiEntry | AbiParam[], result: any[], allAbi?: AbiEntry[]): any;
-export declare function toBlockId(block?: BlockId): any;
-export interface StarknetCallRequest {
-    contract_address: string;
-    entry_point_selector: string;
-    calldata: string[];
-}
-/**
- * Build a `starknet_call` JSON-RPC request. `abi.customInput === 'address'`
- * passes params through as raw felts (u256 inputs pre-split by the caller).
- */
-export declare function formCallBody({ abi, target, params, allAbi, block }: CallOptions, id?: number | string): {
-    jsonrpc: string;
-    id: string | number;
-    method: string;
-    params: any[];
-};
-/**
- * Decode a call result and apply the legacy post-processing: BigInts at depth 1
- * become strings, a single non-Cairo 1 output is unwrapped, `Uint256` outputs
- * (or `customType: 'Uint256' | 'number'`) become numbers, `customType: 'address'`
- * is padded.
- */
-export declare function parseOutput(result: any, abi: AbiEntry, allAbi?: AbiEntry[], { permitFailure, error }?: {
-    permitFailure?: boolean;
-    error?: any;
-}): any;
-/** Raw JSON-RPC call against the Starknet endpoints (STARKNET_RPC rotation + retries) */
-export declare function rpc(method: string, params?: any): Promise<any>;
-export declare function getBlockNumber(): Promise<number>;
-export declare function getBlock({ blockNumber, block }?: {
-    blockNumber?: number | 'latest';
-    block?: BlockId;
-}): Promise<{
-    number: number;
-    timestamp: number;
-    hash?: string;
-}>;
-/** Last block whose timestamp is <= `timestamp` (binary search, no cache) */
-export declare function getBlockAtTimestamp({ timestamp }: {
-    timestamp: number;
-}): Promise<{
-    number: number;
-    timestamp: number;
-}>;
-export declare function getNonce({ address, block }: {
-    address: string;
-    block?: BlockId;
-}): Promise<string>;
-export declare function getClassHashAt({ address, block }: {
-    address: string;
-    block?: BlockId;
-}): Promise<string>;
-export declare function call({ abi, target, params, allAbi, permitFailure, block }: CallOptions): Promise<any>;
-/**
- * Run many `starknet_call`s. By default one on-chain `aggregate` call per 50
- * sub-calls; if the aggregator reverts (any sub-call reverting reverts the whole
- * batch) or `useAggregator` is false, falls back to JSON-RPC batches of 25 so
- * `permitFailure` still applies per call. Results are in call order.
- */
-export declare function multiCall(options: MultiCallOptions): Promise<any[]>;
-/** starknet_getEvents page size; public providers reject larger pages ("Requested page size is too big") */
-export declare const DEFAULT_EVENTS_CHUNK_SIZE = 1000;
-/**
- * Fetch events emitted by `target` via `starknet_getEvents`, following
- * `continuation_token` until the range [fromBlock, toBlock] is exhausted.
- * Returns raw events: { block_number, transaction_hash, from_address, keys, data }.
- */
-export declare function getLogs({ target, fromBlock, toBlock, topics, keys, chunkSize }: GetLogsOptions): Promise<StarknetEvent[]>;
-/**
- * Cairo 0 style ERC20 ABIs (camelCase entrypoints, `felt` / `Uint256` types).
- * `balanceOf` uses `customInput: 'address'` so the owner felt is passed through
- * untouched; `decimals` casts to a number.
- */
-export declare const erc20Abis: Record<string, AbiEntry>;
-/**
- * Cairo 1 style ERC20 ABIs (snake_case entrypoints, `core::` types). u256
- * outputs decode to a bigint (returned as a decimal string by `call`).
- */
-export declare const erc20AbisCairo1: Record<string, AbiEntry>;
-/** alias matching the coins repo export */
-export declare const cairoErc20Abis: Record<string, AbiEntry>;