@defillama/sdk 5.0.240 → 5.0.244

package/build/types.d.ts

@@ -0,0 +1,76 @@
+export type Address = string;
+export type StringNumber = string;
+export type Block = number | string;
+export type Balances = {
+    [address: string]: StringNumber | number;
+};
+type CallParams = string | number | (string | number)[] | undefined;
+export type CallsParams = {
+    target?: Address;
+    params?: CallParams;
+};
+export type CallOptions = {
+    target: Address;
+    abi?: string | any;
+    abis?: string[];
+    block?: Block;
+    params?: CallParams;
+    chain?: Chain | string;
+    withMetadata?: boolean;
+    skipCache?: boolean;
+    logArray?: LogArray;
+    permitFailure?: boolean;
+    field?: string;
+};
+export type Chain = string;
+export type MulticallOptions = {
+    abi?: string | any;
+    abis?: string[];
+    calls: CallsParams[] | (string | number)[];
+    block?: Block;
+    target?: Address;
+    chain?: Chain | string;
+    requery?: boolean;
+    withMetadata?: boolean;
+    skipCache?: boolean;
+    permitFailure?: boolean;
+    excludeFailed?: boolean;
+    logArray?: LogArray;
+    field?: string;
+};
+export type FetchListOptions = {
+    lengthAbi?: string | any;
+    itemAbi: string | any;
+    itemAbi2?: string | any;
+    block?: Block;
+    startFrom?: number;
+    target?: Address;
+    calls?: Address[];
+    targets?: Address[];
+    chain?: Chain | string;
+    withMetadata?: boolean;
+    startFromOne?: boolean;
+    itemCount?: number;
+    permitFailure?: boolean;
+    logArray?: LogArray;
+    groupedByInput?: boolean;
+    excludeFailed?: boolean;
+    field?: string;
+    field2?: string;
+};
+export type ByteCodeCallOptions = {
+    bytecode: string;
+    inputTypes: string[];
+    inputs: any[];
+    block?: number | string;
+    chain?: Chain | string;
+    outputTypes: string[];
+    withMetadata?: boolean;
+};
+export type LogArray = {
+    token: Address;
+    holder: Address;
+    chain: Chain;
+    amount: any;
+}[];
+export {};

package/build/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/util/LlamaProvider.d.ts

@@ -0,0 +1,46 @@
+import { AbstractProvider, AddressLike, Block, BlockTag, FallbackProvider, Filter, FilterByBlockHash, Log, TransactionRequest } from "ethers";
+import { Chain } from "../types";
+type ProviderWithURL = {
+    url: string;
+    provider: AbstractProvider;
+};
+type ProviderConfigMap = {
+    [chain: string]: {
+        rpc?: string[];
+        chainId?: number;
+        explorer?: string;
+    };
+};
+export declare class LlamaProvider extends FallbackProvider {
+    isCustomLlamaProvider: boolean;
+    rpcs: ProviderWithURL[];
+    archivalRPCs: ProviderWithURL[];
+    _isReady: Promise<void>;
+    chainName: string;
+    chainId: number;
+    constructor({ providers, chainId, chainName, archivalRPCs, }: {
+        providers: ProviderWithURL[];
+        archivalRPCs: ProviderWithURL[];
+        chainId: number;
+        chainName: string;
+    }, fallbackConfig?: any);
+    getNetwork(): any;
+    _removeProvider(rpc: string): void;
+    _ready(): Promise<void>;
+    call(_tx: TransactionRequest): Promise<string>;
+    getBalance(address: AddressLike, blockTag?: BlockTag): Promise<bigint>;
+    getBlock(block: BlockTag, prefetchTxs?: boolean | undefined): Promise<Block | null>;
+    getLogs(_filter: Filter | FilterByBlockHash): Promise<Log[]>;
+    getTransaction(_hash: string): Promise<any>;
+    getTransactionReceipt(_hash: string): Promise<any>;
+    _performAction(method: string, params: any, attempts?: number): Promise<any>;
+}
+export declare function getEVMProvidersConfigMap(): ProviderConfigMap;
+export declare function getEVMChainSet(): Set<string>;
+export declare function isEvmChain(chain: string): boolean;
+export declare const providers: {
+    [chain: string]: AbstractProvider;
+};
+export declare function setProvider(chain: Chain, provider: AbstractProvider): void;
+export declare function getProvider(chain?: Chain, _getArchivalNode?: boolean): AbstractProvider;
+export {};

package/build/util/LlamaProvider.js

@@ -0,0 +1,343 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.providers = exports.LlamaProvider = void 0;
+exports.getEVMProvidersConfigMap = getEVMProvidersConfigMap;
+exports.getEVMChainSet = getEVMChainSet;
+exports.isEvmChain = isEvmChain;
+exports.setProvider = setProvider;
+exports.getProvider = getProvider;
+const ethers_1 = require("ethers");
+const providers_json_1 = __importDefault(require("../providers.json"));
+const env_1 = require("./env");
+const debugLog_1 = require("./debugLog");
+const axios_1 = __importDefault(require("axios"));
+const callStats_1 = require("./callStats");
+let buildProviders = undefined;
+if (process.env['TEST_MODE']) {
+    buildProviders = require('../../build/providers.json');
+}
+const rpcRequestCounter = {};
+class LlamaProvider extends ethers_1.FallbackProvider {
+    constructor({ providers, chainId, chainName, archivalRPCs, }, fallbackConfig) {
+        const networkish = { name: chainName, chainId };
+        super(providers.map(i => i.provider), networkish, fallbackConfig);
+        this.isCustomLlamaProvider = true;
+        this.rpcs = providers;
+        this.archivalRPCs = archivalRPCs;
+        this.chainName = chainName;
+        this.chainId = chainId;
+        this._isReady = this._ready();
+    }
+    getNetwork() {
+        return { chainId: this.chainId, name: this.chainName };
+    }
+    _removeProvider(rpc) {
+        this.rpcs = this.rpcs.filter(i => i.url !== rpc);
+        this.archivalRPCs = this.archivalRPCs.filter(i => i.url !== rpc);
+    }
+    async _ready() {
+        if (process.env["SKIP_RPC_CHECK"] === "true") {
+            return;
+        }
+        const outOfSyncLimit = 1000;
+        const _this = this;
+        const currentBlocks = {};
+        await Promise.all(this.rpcs.map(checkRPCWorks));
+        if (this.archivalRPCs.length) {
+            await Promise.all(this.archivalRPCs.map(checkRPCWorks));
+        }
+        // we are doing this because I noticed that one of the rpcs can go rouge and return very high block number
+        const medianBlockValue = getMedianBlockValue(Object.values(currentBlocks));
+        Object.entries(currentBlocks).forEach(([url, block]) => {
+            if (medianBlockValue - block > outOfSyncLimit) {
+                (0, debugLog_1.debugLog)(`RPC ${url} is out of sync by ${medianBlockValue - block} blocks`);
+                _this.rpcs = _this.rpcs.filter(i => i.url !== url);
+                _this.archivalRPCs = _this.archivalRPCs.filter(i => i.url !== url);
+            }
+        });
+        async function checkRPCWorks({ url, provider }) {
+            try {
+                const block = await httpRPC.getBlockNumber(url);
+                currentBlocks[url] = block;
+            }
+            catch (e) {
+                if (env_1.ENV_CONSTANTS.LOG_LLAMA_PROVIDER_CALLS)
+                    (0, debugLog_1.debugLog)(`${_this.chainName} skipping RPC ${url} is not working, error: ${e.message}`);
+                _this._removeProvider(url);
+            }
+        }
+    }
+    async call(_tx) {
+        var _a;
+        return this._performAction('call', [{ to: _tx.to, data: _tx.data }, (_a = _tx.blockTag) !== null && _a !== void 0 ? _a : 'latest']);
+    }
+    async getBalance(address, blockTag = 'latest') {
+        return this._performAction('getBalance', [address, blockTag]);
+    }
+    async getBlock(block, prefetchTxs) {
+        return this._performAction('getBlock', [block, false]);
+    }
+    async getLogs(_filter) {
+        return this._performAction('getLogs', [_filter], 7);
+    }
+    async getTransaction(_hash) {
+        return this._performAction('getTransaction', [_hash]);
+    }
+    async getTransactionReceipt(_hash) {
+        return this._performAction('getTransactionReceipt', [_hash]);
+    }
+    async _performAction(method, params, attempts = 7) {
+        var _a;
+        if (!rpcRequestCounter[this.chainName])
+            rpcRequestCounter[this.chainName] = 0;
+        rpcRequestCounter[this.chainName]++;
+        await this._isReady;
+        let runners = [...this.rpcs];
+        if (method === 'getLogs') {
+            runners = [...this.archivalRPCs];
+            this.rpcs.filter(i => !runners.map(i => i.url).includes(i.url)).forEach(i => runners.push(i)); // ensure that there are no duplicates
+            runners = runners.filter(i => !i.url.includes('llamarpc.com'));
+        }
+        if (!runners.length)
+            throw new Error('No RPCs available for ' + this.chainName);
+        let primaryRunner = runners[0];
+        let errors = [];
+        if (method === 'getLogs') {
+            runners = runners.slice(1).concat(this.rpcs);
+            runners = runners.sort(() => Math.random() - 0.5); // randomize order of runners
+        }
+        else
+            runners = runners.slice(1).sort(() => Math.random() - 0.5); // randomize order of runners
+        const isArchivalRequest = ['call', 'getBalance'].includes(method) && params[1] !== 'latest';
+        // check if domain name of primaryRunner.url is llama
+        const isLlamaRPC = primaryRunner.url.includes('llama');
+        let noPlayingAround = (0, env_1.getEnvValue)('RPC_NO_PLAYING_AROUND') === 'true' || isLlamaRPC || method === 'getLogs' || isArchivalRequest;
+        if (noPlayingAround) {
+            // if primary runner is llama.fi or alchemy, then try it first
+            runners.unshift(primaryRunner);
+        }
+        else {
+            // add it as second runner
+            runners.splice(1, 0, primaryRunner);
+        }
+        runners = runners.slice(0, attempts);
+        // print stats every 5 minutes
+        let currentTimeMS = Date.now();
+        if (currentTimeMS - lastPrintTimeMS > 1000 * 60 * 5) {
+            lastPrintTimeMS = currentTimeMS;
+            printRPCCallStats();
+        }
+        // if (this.chainName === 'rsk' && method === 'getLogs') {
+        //   const hostString = getEnvValue('RSK_ARCHIVAL_RPC')
+        //   if (!hostString) 
+        //     throw new Error('RSK public nodes dont support getLogs. need to set RSK_ARCHIVAL_RPC');
+        //   (runners as any) = hostString.split(',').map(host => ({ url: host  }))
+        // }
+        for (const runner of runners) {
+            try {
+                (0, callStats_1.recordMethod)(method, this.chainName); // per attempt: call stats count requests, not successes
+                const result = await httpRPC[method](runner.url, params);
+                return result;
+            }
+            catch (e) {
+                // console.log('failed', runner.url, (e as any).message)
+                errors.push({ host: runner.url, error: ((_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : e) });
+            }
+        }
+        throw { llamaRPCError: true, errors, method, };
+    }
+}
+exports.LlamaProvider = LlamaProvider;
+function getEVMProvidersConfigMap() {
+    return buildProviders !== null && buildProviders !== void 0 ? buildProviders : providers_json_1.default;
+}
+let evmChainSet = null;
+function getEVMChainSet() {
+    if (!evmChainSet) {
+        const pList = getEVMProvidersConfigMap();
+        evmChainSet = new Set(Object.keys(pList));
+    }
+    return evmChainSet;
+}
+function isEvmChain(chain) {
+    const pList = getEVMProvidersConfigMap();
+    if (pList[chain])
+        return true;
+    // check if we have RPC config for this chain via env variable
+    // let rpcList: (string | undefined) = getChainRPCs(chain, undefined)  // skip this check as it can be true for non-evm chains like solana as well
+    return false;
+}
+function createProvider(name, rpcString, chainId = 400069, archivalRPCList = []) {
+    chainId = (0, env_1.getChainId)(name, chainId);
+    const networkish = { name, chainId };
+    let rpcList = rpcString.split(',');
+    if ((0, env_1.getEnvValue)('HISTORICAL')) {
+        if (chainId === 1) {
+            (0, debugLog_1.debugLog)("RPC providers set to historical, only the first RPC provider will be used");
+        }
+        // return getProviderObject(rpcList[0], name)
+        rpcList = [rpcList[0]];
+    }
+    (0, callStats_1.registerEndpoints)(name, [...rpcList, ...archivalRPCList]); // so http level call stats are attributed to this chain
+    try {
+        const fallbackConfig = { cacheTimeout: 5 * 1000, quorum: 1, eventQuorum: 1, };
+        const getProviderWithURL = (url) => ({ url, provider: getProviderObject(url, name) });
+        const providers = rpcList.map(getProviderWithURL);
+        const archivalRPCs = archivalRPCList.map(getProviderWithURL);
+        return new LlamaProvider({ providers, archivalRPCs, chainId, chainName: name, }, fallbackConfig);
+        // return new FallbackProvider(providers, networkish, fallbackConfig)
+    }
+    catch (e) {
+        // debugLog(`Error creating provider for ${name} with RPCs: ${rpcList.join(', ')}`)
+        // we dont throw errors for chains not present in providers.json, these can be non-evm chains like solana
+        if (providers_json_1.default[name])
+            throw e;
+        return null;
+    }
+    function getProviderObject(url, chain) {
+        const jsonRpcApiProviderOptions = { staticNetwork: true, batchMaxCount: 1, };
+        if (url.startsWith('wss://')) {
+            return null; // websocket provider is not supported
+            // return new WebSocketProvider(url, networkish, jsonRpcApiProviderOptions)
+        }
+        return new ethers_1.JsonRpcProvider(url, networkish, jsonRpcApiProviderOptions);
+    }
+}
+exports.providers = {};
+function setProvider(chain, provider) {
+    exports.providers[chain] = provider;
+}
+function getProvider(chain = "ethereum", _getArchivalNode = false) {
+    var _a, _b;
+    const rpcKey = chain === 'tron' ? 'tron_evm' : chain;
+    let chainKey = chain;
+    if ((0, env_1.getEnvValue)('HISTORICAL'))
+        chainKey = chain + '_historical';
+    if (exports.providers[chainKey])
+        return exports.providers[chainKey];
+    const pList = getEVMProvidersConfigMap();
+    // use RPC from env variable if set else use RPC from providers.json
+    let rpcList = (0, env_1.getChainRPCs)(rpcKey, (_a = pList[chain]) === null || _a === void 0 ? void 0 : _a.rpc);
+    let archivalRPCList = (0, env_1.getArchivalRPCs)(rpcKey);
+    let whitelistedRPCList = (0, env_1.getWhitelistedRPCs)(rpcKey);
+    if (whitelistedRPCList === null || whitelistedRPCList === void 0 ? void 0 : whitelistedRPCList.length) {
+        rpcList = [...whitelistedRPCList].join(',');
+        archivalRPCList = whitelistedRPCList;
+    }
+    if (!rpcList) {
+        // @ts-ignore (throwing error here would alter function behavior and have side effects)
+        return null;
+    }
+    if (!exports.providers[chainKey])
+        exports.providers[chainKey] = createProvider(chain, rpcList, (_b = providers_json_1.default[chain]) === null || _b === void 0 ? void 0 : _b.chainId, archivalRPCList);
+    return exports.providers[chainKey];
+}
+function toHex(n) {
+    if (typeof n === 'string')
+        return n;
+    return '0x' + n.toString(16);
+}
+// A public RPC behind a dead or re-routed domain can answer HTTP 200 with an HTML page, an empty body or a JSON object without `result`
+// (seen on mainnet.telos.net/evm). Reading `data.result` off that gave `undefined`, which the caller treated as a successful
+// call and handed to the ABI decoder, so the error surfaced as "invalid BytesLike value null" / a multicall failure instead of the
+// provider moving on to the next RPC. Anything that is not a JSON-RPC envelope with a `result` is therefore thrown here.
+async function rpcPost(rpc, method, params, timeoutEnvKey, defaultTimeout) {
+    const { data } = await axios_1.default.post(rpc, { jsonrpc: '2.0', id: 1, params, method }, {
+        timeout: +(0, env_1.getEnvValue)(timeoutEnvKey, defaultTimeout)
+    });
+    if (!data || typeof data !== 'object' || Array.isArray(data))
+        throw new Error(`${method} on ${rpc}: not a JSON-RPC response: ${String(data).slice(0, 120)}`);
+    if (data.error)
+        throw data.error;
+    if (!Object.prototype.hasOwnProperty.call(data, 'result'))
+        throw new Error(`${method} on ${rpc}: response has no result field: ${JSON.stringify(data).slice(0, 120)}`);
+    return data.result;
+}
+const httpRPC = {
+    getBlockNumber: async (rpc) => {
+        const getData = async () => {
+            const result = await rpcPost(rpc, 'eth_blockNumber', [], 'LLAMA_PROVIDER_RPC_GET_BLOCKNUMBER_TIMEOUT', '30000');
+            const block = parseInt(result);
+            if (isNaN(block))
+                throw new Error(`eth_blockNumber on ${rpc}: bad result ${JSON.stringify(result)}`);
+            return block;
+        };
+        try {
+            return await getData();
+        }
+        catch (e) {
+            // try again
+            return await getData();
+        }
+    },
+    getBlock: async (rpc, params) => {
+        params[0] = toHex(params[0]);
+        const result = await rpcPost(rpc, 'eth_getBlockByNumber', params, 'LLAMA_PROVIDER_RPC_GET_BLOCK_TIMEOUT', '60000');
+        if (!result)
+            throw new Error(`block ${params[0]} not found`); // pruned or not yet synced, let callers recognise it
+        result.number = parseInt(result.number);
+        result.timestamp = parseInt(result.timestamp);
+        return result;
+    },
+    getBalance: async (rpc, params) => {
+        params[1] = toHex(params[1]);
+        const result = await rpcPost(rpc, 'eth_getBalance', params, 'LLAMA_PROVIDER_RPC_GET_BALANCE_TIMEOUT', '30000');
+        return BigInt(result).toString();
+    },
+    call: async (rpc, params) => {
+        params[1] = toHex(params[1]);
+        const result = await rpcPost(rpc, 'eth_call', params, 'LLAMA_PROVIDER_RPC_CALL_TIMEOUT', '30000');
+        // eth_call always returns hex data (`0x` when the target has no code); a null here is a broken node, not an empty return
+        if (typeof result !== 'string')
+            throw new Error(`eth_call on ${rpc}: bad result ${JSON.stringify(result)}`);
+        return result;
+    },
+    getLogs: async (rpc, params) => {
+        params[0].fromBlock = toHex(params[0].fromBlock);
+        params[0].toBlock = toHex(params[0].toBlock);
+        const result = await rpcPost(rpc, 'eth_getLogs', params, 'LLAMA_PROVIDER_RPC_GET_LOGS_TIMEOUT', '30000');
+        if (!Array.isArray(result))
+            throw new Error(`eth_getLogs on ${rpc}: bad result ${JSON.stringify(result)}`);
+        result.forEach((i) => {
+            i.blockNumber = parseInt(i.blockNumber);
+            i.transactionIndex = parseInt(i.transactionIndex);
+            i.logIndex = parseInt(i.logIndex);
+            i.index = i.logIndex;
+        });
+        return result;
+    },
+    getTransaction: async (rpc, params) => {
+        const result = await rpcPost(rpc, 'eth_getTransactionByHash', params, 'LLAMA_PROVIDER_RPC_GET_TRANSACTION_TIMEOUT', '180000');
+        if (!result)
+            return null;
+        result.blockNumber = parseInt(result.blockNumber);
+        result.transactionIndex = parseInt(result.transactionIndex);
+        result.data = result.input;
+        return result;
+    },
+    getTransactionReceipt: async (rpc, params) => {
+        const result = await rpcPost(rpc, 'eth_getTransactionReceipt', params, 'LLAMA_PROVIDER_RPC_GET_TXN_RECEIPT_TIMEOUT', '180000');
+        if (!result)
+            return null;
+        result.blockNumber = parseInt(result.blockNumber);
+        result.transactionIndex = parseInt(result.transactionIndex);
+        return result;
+    }
+};
+function getMedianBlockValue(blocks) {
+    blocks.sort((a, b) => a - b);
+    const mid = Math.floor(blocks.length / 3);
+    return blocks.length % 2 !== 0 ? blocks[mid] : (blocks[mid - 1] + blocks[mid]) / 2;
+}
+let lastPrintTimeMS = Date.now();
+function printRPCCallStats() {
+    const entries = Object.entries(rpcRequestCounter).map(([chain, count]) => ({ chain, count })).filter(i => i.count > 50);
+    if (entries.length > 7) {
+        (0, debugLog_1.debugLog)('RPC request count per chain (only over 100)');
+        (0, debugLog_1.debugTable)(entries);
+    }
+}
+process.on('exit', printRPCCallStats);

package/build/util/blocks.d.ts

@@ -0,0 +1,36 @@
+import { Chain } from "../general";
+export declare const chainsForBlocks: string[];
+export declare function getChainBlocks(timestamp: number | undefined, chains?: Chain[]): Promise<{
+    [chain: string]: number;
+}>;
+export declare function getBlocks(timestamp: number, chains?: Chain[] | undefined): Promise<{
+    ethereumBlock: number;
+    chainBlocks: {
+        [chain: string]: number;
+    };
+}>;
+export declare function getCurrentBlocks(chains?: Chain[] | undefined): Promise<{
+    timestamp: number;
+    ethereumBlock: number;
+    chainBlocks: {
+        [chain: string]: number;
+    };
+}>;
+export declare function getBlock(chain: Chain, timestamp?: number, options?: LookupBlockOptionalParams): Promise<Block>;
+export declare function getBlockNumber(chain: Chain, timestamp?: number): Promise<number>;
+export declare function getCurrentChainBlock(chain?: Chain): Promise<Block>;
+export declare const getLatestBlock: typeof getCurrentChainBlock;
+type LookupBlockOptionalParams = {
+    chain?: Chain | "kava" | "algorand";
+    allowedTimeRange?: number;
+    acceptableBlockImprecision?: number;
+};
+export declare function lookupBlock(timestamp: number, extraParams?: LookupBlockOptionalParams): Promise<Block>;
+export declare function getTimestamp(height: number, chain: Chain): Promise<number>;
+export type Block = {
+    timestamp: number;
+    block: number;
+    hash?: string;
+    number: number;
+};
+export {};