@defillama/sdk 5.0.235 → 5.0.236

package/build/chains/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Non-EVM chain clients. One module per chain family, all resolving endpoints
+ * through `rpc.getEndpoints` so `<CHAIN>_RPC` env vars override built-in defaults.
+ *
+ * Usage: `sdk.chains.svm.getAccounts({ chain: 'solana', accounts })`
+ */
+export * as rpc from "./rpc";
+export * as svm from "./svm";
+export * as cosmos from "./cosmos";
+export * as starknet from "./starknet";
+export * as aptos from "./aptos";
+export * as sui from "./sui";
+export * as near from "./near";
+export * as ton from "./ton";
+export * as algorand from "./algorand";
+export * as stellar from "./stellar";
+export * as xrpl from "./xrpl";
+export * as cardano from "./cardano";
+export * as tezos from "./tezos";
+export * as icp from "./icp";
+export * as substrate from "./substrate";
+export * as utxo from "./utxo";
+export * as tron from "./tron";

package/build/chains/index.js

@@ -0,0 +1,59 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tron = exports.utxo = exports.substrate = exports.icp = exports.tezos = exports.cardano = exports.xrpl = exports.stellar = exports.algorand = exports.ton = exports.near = exports.sui = exports.aptos = exports.starknet = exports.cosmos = exports.svm = exports.rpc = void 0;
+/**
+ * Non-EVM chain clients. One module per chain family, all resolving endpoints
+ * through `rpc.getEndpoints` so `<CHAIN>_RPC` env vars override built-in defaults.
+ *
+ * Usage: `sdk.chains.svm.getAccounts({ chain: 'solana', accounts })`
+ */
+exports.rpc = __importStar(require("./rpc"));
+exports.svm = __importStar(require("./svm"));
+exports.cosmos = __importStar(require("./cosmos"));
+exports.starknet = __importStar(require("./starknet"));
+exports.aptos = __importStar(require("./aptos"));
+exports.sui = __importStar(require("./sui"));
+exports.near = __importStar(require("./near"));
+exports.ton = __importStar(require("./ton"));
+exports.algorand = __importStar(require("./algorand"));
+exports.stellar = __importStar(require("./stellar"));
+exports.xrpl = __importStar(require("./xrpl"));
+exports.cardano = __importStar(require("./cardano"));
+exports.tezos = __importStar(require("./tezos"));
+exports.icp = __importStar(require("./icp"));
+exports.substrate = __importStar(require("./substrate"));
+exports.utxo = __importStar(require("./utxo"));
+exports.tron = __importStar(require("./tron"));

package/build/chains/near.d.ts

@@ -0,0 +1,192 @@
+import { JsonRpcError, Endpoints, RetryOptions } from "./rpc";
+export declare const CHAIN = "near";
+export declare const DEFAULT_ENDPOINTS: string[];
+export type BlockId = number | string;
+export interface RpcOptions extends RetryOptions {
+    /** explicit endpoint(s); overrides `NEAR_RPC` and the defaults */
+    endpoints?: Endpoints;
+    /** axios timeout in ms, default 30s */
+    timeout?: number;
+    /** skip the shared concurrency limiter */
+    skipLimiter?: boolean;
+}
+export interface QueryParams {
+    request_type: 'view_account' | 'view_code' | 'view_state' | 'view_access_key' | 'view_access_key_list' | 'call_function' | string;
+    account_id?: string;
+    /** block height or hash; when set `finality` is not sent */
+    block_id?: BlockId;
+    /** convenience alias for `block_id` */
+    blockId?: BlockId;
+    finality?: 'final' | 'optimistic' | 'near-final';
+    [key: string]: any;
+}
+export interface AccountView {
+    amount: string;
+    locked: string;
+    code_hash: string;
+    storage_usage: number;
+    storage_paid_at: number;
+    block_height: number;
+    block_hash: string;
+    [key: string]: any;
+}
+export interface TokenMetadata {
+    spec?: string;
+    name: string;
+    symbol: string;
+    icon?: string | null;
+    reference?: string | null;
+    reference_hash?: string | null;
+    decimals: number;
+    [key: string]: any;
+}
+export interface Block {
+    number: number;
+    /** unix seconds */
+    timestamp: number;
+    /** raw nanosecond timestamp as string */
+    timestampNs: string;
+    hash: string;
+    prevHash: string;
+    header: any;
+    chunks: any[];
+    author: string;
+}
+export interface AccessKey {
+    public_key: string;
+    access_key: {
+        nonce: number;
+        permission: any;
+    };
+}
+export interface StateEntry {
+    /** utf8 decoded key (lossy for binary keys) */
+    key: string;
+    /** utf8 decoded value (lossy for binary/borsh values) */
+    value: string;
+    keyBase64: string;
+    valueBase64: string;
+}
+/**
+ * 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`).
+ */
+export declare class NearRpcError extends JsonRpcError {
+    nodeError: any;
+    errorName?: string;
+    cause?: string;
+    endpoint?: string;
+    constructor(method: string, error: any, endpoint?: string, label?: string);
+}
+/**
+ * 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 `{}`.
+ */
+export declare function encodeArgs(args?: any): string;
+/**
+ * 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 -> `''`).
+ */
+export declare function decodeResult(bytes: number[] | Uint8Array | Buffer | undefined | null): any;
+/** True for a syntactically valid NEAR account id (named accounts and 64-hex implicit accounts) */
+export declare function isNearAccountId(str: any): boolean;
+/** True for a 64 char hex implicit account id */
+export declare function isImplicitAccountId(str: any): boolean;
+/** yoctoNEAR (string/bigint) -> NEAR as a number (loses precision below 1e-15 NEAR, fine for reporting) */
+export declare function yoctoToNear(amount: string | bigint | number): number;
+/** Endpoint list: `NEAR_RPC` env (comma separated) or `DEFAULT_ENDPOINTS` */
+export declare function getEndpoints(): string[];
+/**
+ * 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.
+ */
+export declare function shouldRetry(e: any): boolean;
+/**
+ * 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.
+ */
+export declare function rpc(method: string, params?: any, options?: RpcOptions): Promise<any>;
+/**
+ * The `query` RPC method. Defaults to `finality: 'final'`; when `block_id`/`blockId` is
+ * given the finality is omitted (the node rejects requests carrying both).
+ */
+export declare function query<T = any>(params: QueryParams, options?: RpcOptions): Promise<T>;
+/** `view_account`: raw account view (`amount` and `locked` are yoctoNEAR strings) */
+export declare function viewAccount({ account, blockId }: {
+    account: string;
+    blockId?: BlockId;
+}, options?: RpcOptions): Promise<AccountView>;
+/** Native balance (`amount`, yoctoNEAR string, excludes `locked` stake) */
+export declare function getBalance({ account, blockId }: {
+    account: string;
+    blockId?: BlockId;
+}, options?: RpcOptions): Promise<string>;
+/**
+ * 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, ...).
+ */
+export declare function call<T = any>({ contract, method, args, blockId }: {
+    contract: string;
+    method: string;
+    args?: any;
+    blockId?: BlockId;
+}, options?: RpcOptions): Promise<T>;
+/** Alias of `call` */
+export declare const viewFunction: typeof 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.
+ */
+export declare function getTokenBalance({ token, account, blockId }: {
+    token: string;
+    account: string;
+    blockId?: BlockId;
+}, options?: RpcOptions): Promise<string>;
+/** `ft_metadata` (NEP-148) */
+export declare function getTokenMetadata({ token, blockId }: {
+    token: string;
+    blockId?: BlockId;
+}, options?: RpcOptions): Promise<TokenMetadata>;
+/** `ft_total_supply` raw string */
+export declare function getTokenTotalSupply({ token, blockId }: {
+    token: string;
+    blockId?: BlockId;
+}, options?: RpcOptions): Promise<string>;
+/** `block` RPC: by height/hash (`blockId`) or by finality (default `final`) */
+export declare function getBlock({ blockId, finality }?: {
+    blockId?: BlockId;
+    finality?: 'final' | 'optimistic' | 'near-final';
+}, options?: RpcOptions): Promise<Block>;
+export declare function getLatestBlock(options?: RpcOptions): Promise<Block>;
+/**
+ * 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`.
+ */
+export declare function getBlockAtTimestamp({ timestamp }: {
+    timestamp: number;
+}, options?: RpcOptions): Promise<Block>;
+/** `view_access_key_list`: all access keys of an account */
+export declare function getAccessKeys({ account, blockId }: {
+    account: string;
+    blockId?: BlockId;
+}, options?: RpcOptions): Promise<AccessKey[]>;
+/**
+ * `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.
+ */
+export declare function viewState({ contract, prefix, prefixBase64, blockId }: {
+    contract: string;
+    prefix?: string;
+    prefixBase64?: string;
+    blockId?: BlockId;
+}, options?: RpcOptions): Promise<StateEntry[]>;