@defillama/sdk 5.0.236 → 5.0.240

package/build/types.d.ts

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

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

package/build/util/LlamaProvider.d.ts

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

@@ -1,365 +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.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"));
-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 {
-                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]];
-    }
-    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);
-}
-const httpRPC = {
-    getBlockNumber: async (rpc) => {
-        const getData = async () => {
-            const data = (await axios_1.default.post(rpc, {
-                jsonrpc: '2.0', id: 1, params: [],
-                method: 'eth_blockNumber',
-            }, {
-                timeout: +(0, env_1.getEnvValue)('LLAMA_PROVIDER_RPC_GET_BLOCKNUMBER_TIMEOUT', '30000')
-            })).data;
-            if (data.error)
-                throw data.error;
-            return data.result;
-        };
-        let data;
-        try {
-            data = await getData();
-        }
-        catch (e) {
-            // try again
-            data = await getData();
-        }
-        return parseInt(data);
-    },
-    getBlock: async (rpc, params) => {
-        params[0] = toHex(params[0]);
-        const { data: { result, error } } = await axios_1.default.post(rpc, {
-            jsonrpc: '2.0', id: 1, params,
-            method: 'eth_getBlockByNumber',
-        }, {
-            timeout: +(0, env_1.getEnvValue)('LLAMA_PROVIDER_RPC_GET_BLOCK_TIMEOUT', '60000')
-        });
-        if (error)
-            throw error;
-        result.number = parseInt(result.number);
-        result.timestamp = parseInt(result.timestamp);
-        return result;
-    },
-    getBalance: async (rpc, params) => {
-        params[1] = toHex(params[1]);
-        const { data: { result, error } } = await axios_1.default.post(rpc, {
-            jsonrpc: '2.0', id: 1, params,
-            method: 'eth_getBalance',
-        }, {
-            timeout: +(0, env_1.getEnvValue)('LLAMA_PROVIDER_RPC_GET_BALANCE_TIMEOUT', '30000')
-        });
-        if (error)
-            throw error;
-        return BigInt(result).toString();
-    },
-    call: async (rpc, params) => {
-        params[1] = toHex(params[1]);
-        const { data } = await axios_1.default.post(rpc, {
-            jsonrpc: '2.0', id: 1, params,
-            method: 'eth_call',
-        }, {
-            timeout: +(0, env_1.getEnvValue)('LLAMA_PROVIDER_RPC_CALL_TIMEOUT', '30000')
-        });
-        if (data.error)
-            throw data.error;
-        return data.result;
-    },
-    getLogs: async (rpc, params) => {
-        params[0].fromBlock = toHex(params[0].fromBlock);
-        params[0].toBlock = toHex(params[0].toBlock);
-        const { data: { result, error } } = await axios_1.default.post(rpc, {
-            jsonrpc: '2.0', id: 1, params,
-            method: 'eth_getLogs',
-        }, {
-            timeout: +(0, env_1.getEnvValue)('LLAMA_PROVIDER_RPC_GET_LOGS_TIMEOUT', '30000')
-        });
-        if (error)
-            throw error;
-        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 { data: { result, error } } = await axios_1.default.post(rpc, {
-            jsonrpc: '2.0', id: 1, params,
-            method: 'eth_getTransactionByHash',
-        }, {
-            timeout: +(0, env_1.getEnvValue)('LLAMA_PROVIDER_RPC_GET_TRANSACTION_TIMEOUT', '180000')
-        });
-        if (error)
-            throw error;
-        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 { data: { result, error } } = await axios_1.default.post(rpc, {
-            jsonrpc: '2.0', id: 1, params,
-            method: 'eth_getTransactionReceipt',
-        }, {
-            timeout: +(0, env_1.getEnvValue)('LLAMA_PROVIDER_RPC_GET_TXN_RECEIPT_TIMEOUT', '180000')
-        });
-        if (error)
-            throw error;
-        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

@@ -1,36 +0,0 @@
-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 {};