@defillama/sdk 5.0.14 → 5.0.16

package/build/abi/rpcCall.d.ts

@@ -1,4 +1,4 @@
 import { ethers } from "ethers";
-export declare function call(provider: ethers.Provider, data: ethers.JsonRpcTransactionRequest, block?: string | number, chain?: string, options?: {
+export declare function call(provider: ethers.AbstractProvider, data: ethers.JsonRpcTransactionRequest, block?: string | number, chain?: string, options?: {
     retry: boolean;
 }): Promise<any>;

package/build/abi/rpcCall.js

@@ -29,7 +29,7 @@ async function call(provider, data, block, chain, options = { retry: true }) {
     }
     let response;
     try {
-        response = await provider.call(data, block);
+        response = await provider.call(data);
         onComplete();
     }
     catch (e) {

package/build/general.d.ts

@@ -1,15 +1,5 @@
-import { Provider } from "ethers";
-type ProviderWrapped = {
-    rpcList: string;
-    _provider: Provider;
-};
-export declare const providers: {
-    [chain: string]: ProviderWrapped;
-};
-export type Chain = string;
-export declare function getProvider(chain?: Chain, getArchivalNode?: boolean): Provider;
+export { providers, setProvider, getProvider, } from './util/LlamaProvider';
+export { Chain } from './types';
 export declare const TEN: bigint;
 export declare function handleDecimals(num: any, decimals?: number): string;
 export declare const ETHER_ADDRESS = "0x0000000000000000000000000000000000000000";
-export declare function setProvider(chain: Chain, provider: Provider): void;
-export {};

package/build/general.js

@@ -1,122 +1,10 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setProvider = exports.ETHER_ADDRESS = exports.handleDecimals = exports.TEN = exports.getProvider = exports.providers = void 0;
-const debugLog_1 = require("./util/debugLog");
-const ethers_1 = require("ethers");
-const providers_json_1 = __importDefault(require("./providers.json"));
-const env_1 = require("./util/env");
-function createProvider(name, rpcString, chainId = 400069) {
-    chainId = (0, env_1.getChainId)(name, chainId);
-    const networkish = { name, chainId };
-    const 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);
-    }
-    else {
-        try {
-            const providerList = rpcList.map((url, i) => ({ provider: getProviderObject(url, name), chainId, }));
-            return new ethers_1.ethers.FallbackProvider(providerList, networkish, { cacheTimeout: 5 * 1000, quorum: 1, eventQuorum: 1, });
-        }
-        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) {
-        /**
-         *  Options for configuring a [[JsonRpcApiProvider]]. Much of this
-         *  is targetted towards sub-classes, which often will not expose
-         *  any of these options to their consumers.
-         *
-         *  **``polling``** - use the polling strategy is used immediately
-         *  for events; otherwise, attempt to use filters and fall back onto
-         *  polling (default: ``false``)
-         *
-         *  **``staticNetwork``** - do not request chain ID on requests to
-         *  validate the underlying chain has not changed (default: ``null``)
-         *
-         *  This should **ONLY** be used if it is **certain** that the network
-         *  cannot change, such as when using INFURA (since the URL dictates the
-         *  network). If the network is assumed static and it does change, this
-         *  can have tragic consequences. For example, this **CANNOT** be used
-         *  with MetaMask, since the used can select a new network from the
-         *  drop-down at any time.
-         *
-         *  **``batchStallTime``** - how long (ms) to aggregate requests into a
-         *  single batch. ``0`` indicates batching will only encompass the current
-         *  event loop. If ``batchMaxCount = 1``, this is ignored. (default: ``10``)
-         *
-         *  **``batchMaxSize``** - target maximum size (bytes) to allow per batch
-         *  request (default: 1Mb)
-         *
-         *  **``batchMaxCount``** - maximum number of requests to allow in a batch.
-         *  If ``batchMaxCount = 1``, then batching is disabled. (default: ``100``)
-         *
-         *  **``cacheTimeout``** - passed as [[AbstractProviderOptions]].
-          *  **``cacheTimeout``** - how long to cache a low-level ``_perform``
-          *  for, based on input parameters. This reduces the number of calls
-          *  to getChainId and getBlockNumber, but may break test chains which
-          *  can perform operations (internally) synchronously. Use ``-1`` to
-          *  disable, ``0`` will only buffer within the same event loop and
-          *  any other value is in ms. (default: ``250``)
-         */
-        // const batchMaxSize = 10 * (1024 * 1024) // 10Mb
-        // some rpcs throw error if batchMaxCount is set higher than 100
-        const batchMaxCount = (0, env_1.getBatchMaxCount)(chain);
-        const jsonRpcApiProviderOptions = { staticNetwork: true, batchStallTime: 42, batchMaxCount, };
-        if (url.startsWith('wss://')) {
-            delete jsonRpcApiProviderOptions.batchMaxCount;
-            return new ethers_1.ethers.WebSocketProvider(url, networkish, jsonRpcApiProviderOptions);
-        }
-        return new ethers_1.ethers.JsonRpcProvider(url, networkish, jsonRpcApiProviderOptions);
-    }
-}
-exports.providers = {};
-const archivalProviders = {};
-function getProvider(chain = "ethereum", getArchivalNode = false) {
-    var _a, _b, _c;
-    if (getArchivalNode) {
-        if (archivalProviders[chain])
-            return archivalProviders[chain]._provider;
-        let rpcList = (0, env_1.getArchivalRPCs)(chain);
-        if (rpcList.length) {
-            // shuffle rpcList
-            rpcList = rpcList.sort(() => Math.random() - 0.5);
-            const provider = createProvider(chain, rpcList.join(','), (_a = providers_json_1.default[chain]) === null || _a === void 0 ? void 0 : _a.chainId);
-            if (rpcList.length === 1)
-                archivalProviders[chain] = { rpcList: rpcList[0], _provider: provider };
-            return provider;
-        }
-    }
-    if (exports.providers[chain] && !getArchivalNode)
-        return exports.providers[chain]._provider;
-    // use RPC from env variable if set else use RPC from providers.json
-    let rpcList = (0, env_1.getChainRPCs)(chain, (_b = providers_json_1.default[chain]) === null || _b === void 0 ? void 0 : _b.rpc);
-    if (!rpcList) {
-        // in case provider was set using `setProvider` function
-        if (exports.providers[chain])
-            return exports.providers[chain]._provider;
-        // @ts-ignore (throwing error here would alter function behavior and have side effects)
-        return null;
-    }
-    if (!exports.providers[chain] || exports.providers[chain].rpcList !== rpcList) {
-        exports.providers[chain] = {
-            rpcList,
-            _provider: createProvider(chain, rpcList, (_c = providers_json_1.default[chain]) === null || _c === void 0 ? void 0 : _c.chainId)
-        };
-    }
-    return exports.providers[chain]._provider;
-}
-exports.getProvider = getProvider;
+exports.ETHER_ADDRESS = exports.handleDecimals = exports.TEN = exports.getProvider = exports.setProvider = exports.providers = void 0;
+var LlamaProvider_1 = require("./util/LlamaProvider");
+Object.defineProperty(exports, "providers", { enumerable: true, get: function () { return LlamaProvider_1.providers; } });
+Object.defineProperty(exports, "setProvider", { enumerable: true, get: function () { return LlamaProvider_1.setProvider; } });
+Object.defineProperty(exports, "getProvider", { enumerable: true, get: function () { return LlamaProvider_1.getProvider; } });
 exports.TEN = BigInt(10);
 function handleDecimals(num, decimals) {
     if (typeof num !== 'number')
@@ -130,10 +18,3 @@ function handleDecimals(num, decimals) {
 }
 exports.handleDecimals = handleDecimals;
 exports.ETHER_ADDRESS = "0x0000000000000000000000000000000000000000";
-function setProvider(chain, provider) {
-    exports.providers[chain] = {
-        rpcList: "",
-        _provider: provider
-    };
-}
-exports.setProvider = setProvider;

package/build/generalUtil.d.ts

@@ -22,6 +22,6 @@ type ChainBlocks = {
 export declare function sumChainTvls(chainTvls: Array<(timestamp: number, ethBlock: number, chainBlocks: ChainBlocks, params: any) => Promise<Balances>>): (timestamp: number, ethBlock: number, chainBlocks: ChainBlocks, params: any) => Promise<any>;
 export { blocks, humanizeNumber, };
 export declare function getUniqueAddresses(addresses: string[], chain?: string): string[];
-export declare function getProviderUrl(provider: any): string;
+export declare function getProviderUrl(provider: any): any;
 export declare function formErrorString(e: any, errorParams?: any): any;
 export declare function formError(e: any, errorParams?: any): Error;

package/build/generalUtil.js

@@ -154,6 +154,8 @@ function getUniqueAddresses(addresses, chain) {
 }
 exports.getUniqueAddresses = getUniqueAddresses;
 function getProviderUrl(provider) {
+    if (provider === null || provider === void 0 ? void 0 : provider.isCustomLlamaProvider)
+        return provider.rpcs.map((i) => i.url).join(', ');
     if (provider instanceof ethers.FallbackProvider)
         provider = provider.providerConfigs[0].provider;
     if (provider instanceof ethers.JsonRpcProvider)
@@ -182,6 +184,11 @@ function formErrorString(e, errorParams = {}) {
         }
         return '';
     }
+    if (e.llamaRPCError) {
+        const errorString = `Llama RPC error!`;
+        const errors = e.errors.map((i) => `- host: ${e.host} error: ${e.toString()}`);
+        return errorString + '\n' + errors.join('\n');
+    }
     let errorString = e.toString();
     if (typeof e !== 'object')
         return errorString;
@@ -254,7 +261,7 @@ function formError(e, errorParams = {}) {
     }
     catch (e) { }
     error._isCustomError = true;
-    error.message = shortenString(error.message, 999);
+    error.message = shortenString(error.message, 2999);
     error.stack = '';
     return error;
 }