@defillama/sdk 2.3.53 → 2.3.56

package/build/abi/index.js

@@ -56,6 +56,7 @@ var ethers_1 = require("ethers");
 var general_1 = require("../general");
 var multicall_1 = __importDefault(require("./multicall"));
 var convertResults_1 = __importDefault(require("./convertResults"));
+var promise_pool_1 = require("@supercharge/promise-pool");
 function resolveABI(providedAbi) {
     var abi = providedAbi;
     if (typeof abi === "string") {
@@ -106,9 +107,9 @@ function call(params) {
 }
 exports.call = call;
 function multiCall(params) {
-    var _a;
     return __awaiter(this, void 0, void 0, function () {
-        var abi, contractCalls, multicallCalls, result, _loop_1, i, flatResults, failed, newResults_1;
+        var abi, contractCalls, chunkSize, contractChunks, i, _a, results, errors, flatResults, failed, newResults_1;
+        var _this = this;
         return __generator(this, function (_b) {
             switch (_b.label) {
                 case 0:
@@ -121,43 +122,25 @@ function multiCall(params) {
                             contract: (_a = call.target) !== null && _a !== void 0 ? _a : params.target,
                         };
                     });
-                    multicallCalls = [];
-                    result = [];
-                    _loop_1 = function (i) {
-                        var pendingResult;
-                        return __generator(this, function (_c) {
-                            switch (_c.label) {
-                                case 0:
-                                    pendingResult = multicall_1.default(abi, contractCalls.slice(i, i + 500), (_a = params.chain) !== null && _a !== void 0 ? _a : "ethereum", params.block).then(function (partialCalls) {
-                                        result[i / 500] = partialCalls;
-                                    });
-                                    multicallCalls.push(pendingResult);
-                                    if (!(i % 20000)) return [3 /*break*/, 2];
-                                    return [4 /*yield*/, Promise.all(multicallCalls)];
-                                case 1:
-                                    _c.sent(); // It would be faster to just await on all of them, but if we do that at some point node crashes without error message, so to prevent that we have to periodically await smaller sets of calls
-                                    multicallCalls = []; // Clear them from memory
-                                    _c.label = 2;
-                                case 2: return [2 /*return*/];
-                            }
-                        });
-                    };
-                    i = 0;
-                    _b.label = 1;
+                    chunkSize = 500;
+                    contractChunks = [];
+                    for (i = 0; i < contractCalls.length; i += chunkSize)
+                        contractChunks.push(contractCalls.slice(i, i + chunkSize));
+                    return [4 /*yield*/, promise_pool_1.PromisePool
+                            .withConcurrency(20)
+                            .for(contractChunks)
+                            .process(function (calls, i) { return __awaiter(_this, void 0, void 0, function () {
+                            var _a;
+                            return __generator(this, function (_b) {
+                                return [2 /*return*/, multicall_1.default(abi, calls, (_a = params.chain) !== null && _a !== void 0 ? _a : "ethereum", params.block)];
+                            });
+                        }); })];
                 case 1:
-                    if (!(i < contractCalls.length)) return [3 /*break*/, 4];
-                    return [5 /*yield**/, _loop_1(i)];
-                case 2:
-                    _b.sent();
-                    _b.label = 3;
-                case 3:
-                    i += 500;
-                    return [3 /*break*/, 1];
-                case 4: return [4 /*yield*/, Promise.all(multicallCalls)];
-                case 5:
-                    _b.sent();
-                    flatResults = [].concat.apply([], result);
-                    if (!(params.requery === true && flatResults.some(function (r) { return !r.success; }))) return [3 /*break*/, 7];
+                    _a = _b.sent(), results = _a.results, errors = _a.errors;
+                    if (errors.length)
+                        throw errors[0];
+                    flatResults = [].concat.apply([], results);
+                    if (!(params.requery === true && flatResults.some(function (r) { return !r.success; }))) return [3 /*break*/, 3];
                     failed = flatResults.map(function (r, i) { return [r, i]; }).filter(function (r) { return !r[0].success; });
                     return [4 /*yield*/, multiCall({
                             abi: params.abi,
@@ -169,13 +152,13 @@ function multiCall(params) {
                             var output = _a.output;
                             return output;
                         })];
-                case 6:
+                case 2:
                     newResults_1 = _b.sent();
                     failed.forEach(function (f, i) {
                         flatResults[f[1]] = newResults_1[i];
                     });
-                    _b.label = 7;
-                case 7: return [2 /*return*/, {
+                    _b.label = 3;
+                case 3: return [2 /*return*/, {
                         output: flatResults, // flatten array
                     }];
             }

package/build/abi/multicall.js

@@ -44,6 +44,7 @@ var ethers_1 = require("ethers");
 var utils_1 = require("ethers/lib/utils");
 var general_1 = require("../general");
 var convertResults_1 = __importDefault(require("./convertResults"));
+var rpcCall_1 = require("./rpcCall");
 exports.MULTICALL_ADDRESS_MAINNET = "0xeefba1e63905ef1d7acba5a8513c70307c1ce441";
 exports.MULTICALL_ADDRESS_KOVAN = "0x2cc8688c5f75e365aaeeb4ea8d6a480405a48d2a";
 exports.MULTICALL_ADDRESS_RINKEBY = "0x42ad527de7d4e9d9d011ac45b31d8551f8fe9821";
@@ -130,7 +131,7 @@ function executeCalls(contractCalls, chain, block) {
                         to: address,
                         data: callData,
                     };
-                    return [4 /*yield*/, general_1.getProvider(chain).call(tx, block !== null && block !== void 0 ? block : "latest")];
+                    return [4 /*yield*/, rpcCall_1.call(general_1.getProvider(chain), tx, block !== null && block !== void 0 ? block : "latest", chain)];
                 case 4:
                     returnData = _b.sent();
                     _a = ethers_1.ethers.utils.defaultAbiCoder.decode(["uint256", "bytes[]"], returnData), blockNumber = _a[0], returnValues = _a[1];
@@ -141,21 +142,24 @@ function executeCalls(contractCalls, chain, block) {
                         console.log("Multicall failed, defaulting to single transactions...");
                     }
                     return [3 /*break*/, 6];
-                case 6: return [4 /*yield*/, Promise.all(contractCalls.map(function (call) { return __awaiter(_this, void 0, void 0, function () {
-                        var e_2;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    _a.trys.push([0, 2, , 3]);
-                                    return [4 /*yield*/, general_1.getProvider(chain).call({ to: call.to, data: call.data }, block !== null && block !== void 0 ? block : "latest")];
-                                case 1: return [2 /*return*/, _a.sent()];
-                                case 2:
-                                    e_2 = _a.sent();
-                                    return [2 /*return*/, null];
-                                case 3: return [2 /*return*/];
-                            }
+                case 6: return [4 /*yield*/, Promise.all(contractCalls.map(function (_a) {
+                        var to = _a.to, data = _a.data;
+                        return __awaiter(_this, void 0, void 0, function () {
+                            var e_2;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        _b.trys.push([0, 2, , 3]);
+                                        return [4 /*yield*/, rpcCall_1.call(general_1.getProvider(chain), { to: to, data: data }, block !== null && block !== void 0 ? block : "latest", chain)];
+                                    case 1: return [2 /*return*/, _b.sent()];
+                                    case 2:
+                                        e_2 = _b.sent();
+                                        return [2 /*return*/, null];
+                                    case 3: return [2 /*return*/];
+                                }
+                            });
                         });
-                    }); }))];
+                    }))];
                 case 7:
                     values = _b.sent();
                     return [2 /*return*/, values];

package/build/abi/rpcCall.d.ts

@@ -0,0 +1,3 @@
+import { Deferrable } from "@ethersproject/properties";
+import { BaseProvider, BlockTag, TransactionRequest } from "@ethersproject/providers";
+export declare function call(provider: BaseProvider, data: Deferrable<TransactionRequest>, block: BlockTag, chain?: string): Promise<string>;

package/build/abi/rpcCall.js

@@ -0,0 +1,106 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.call = void 0;
+var events_1 = require("events");
+var DEBUG_MODE_ENABLED = !!process.env.LLAMA_DEBUG_MODE;
+var maxParallelCalls = !!process.env.LLAMA_SDK_MAX_PARALLEL ? +process.env.LLAMA_SDK_MAX_PARALLEL : 100;
+var COUNTERS = {};
+var emitter = new events_1.EventEmitter();
+emitter.setMaxListeners(500000);
+function call(provider, data, block, chain) {
+    return __awaiter(this, void 0, void 0, function () {
+        function onComplete() {
+            counter.activeWorkers--;
+            if (counter.queue.length) {
+                var nextRequestId = counter.pickFromTop ? counter.queue.shift() : counter.queue.pop();
+                counter.pickFromTop = !counter.pickFromTop;
+                emitter.emit(nextRequestId);
+            }
+        }
+        var counter, currentId, eventId, showEveryX, response, e_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!chain)
+                        chain = 'noChain';
+                    counter = getChainCounter(chain);
+                    currentId = counter.requestCount++;
+                    eventId = chain + "-" + currentId;
+                    if (!(counter.activeWorkers > maxParallelCalls)) return [3 /*break*/, 2];
+                    counter.queue.push(eventId);
+                    return [4 /*yield*/, events_1.once(emitter, eventId)];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2:
+                    counter.activeWorkers++;
+                    if (DEBUG_MODE_ENABLED) {
+                        showEveryX = counter.queue.length > 100 ? 50 : 10 // show log fewer times if lot more are queued up
+                        ;
+                        if (currentId % showEveryX === 0)
+                            console.log("chain: " + chain + " request #: " + currentId + " queue: " + counter.queue.length + " active requests: " + counter.activeWorkers);
+                    }
+                    _a.label = 3;
+                case 3:
+                    _a.trys.push([3, 5, , 6]);
+                    return [4 /*yield*/, provider.call(data, block)];
+                case 4:
+                    response = _a.sent();
+                    onComplete();
+                    return [3 /*break*/, 6];
+                case 5:
+                    e_1 = _a.sent();
+                    onComplete();
+                    throw e_1;
+                case 6: return [2 /*return*/, response];
+            }
+        });
+    });
+}
+exports.call = call;
+function getChainCounter(chain) {
+    if (!COUNTERS[chain])
+        COUNTERS[chain] = {
+            activeWorkers: 0,
+            queue: [],
+            requestCount: 0,
+            pickFromTop: true,
+        };
+    return COUNTERS[chain];
+}

package/build/computeTVL/index.d.ts

@@ -47,6 +47,7 @@ export declare const chainToCoingeckoId: {
     telos: string;
     moonbeam: string;
     velas: string;
+    milkomeda: string;
 };
 export default function (rawBalances: Balances, timestamp: number | "now", verbose?: boolean, knownTokenPrices?: TokenPrices, getCoingeckoLock?: GetCoingeckoLog, coingeckoMaxRetries?: number): Promise<{
     usdTvl: number;

package/build/computeTVL/index.js

@@ -109,6 +109,7 @@ exports.chainToCoingeckoId = {
     telos: "telos",
     moonbeam: "moonbeam",
     velas: "velas",
+    milkomeda: "milkomeda-cardano",
 };
 var chains = Object.keys(exports.chainToCoingeckoId);
 function getHistoricalChainPrices(ids, timestamp, knownTokenPrices, getCoingeckoLock, coingeckoMaxRetries) {

package/build/general.js

@@ -44,7 +44,7 @@ exports.providers = {
     celo: createProvider("celo", "https://forno.celo.org", 42220),
     iotex: createProvider("iotex", "https://babel-api.mainnet.iotex.io", 4689),
     moonriver: createProvider("moonriver", "https://rpc.api.moonriver.moonbeam.network/,https://moonriver.api.onfinality.io/public", 1285),
-    shiden: createProvider("shiden", "https://rpc.shiden.astar.network:8545/", 336),
+    shiden: createProvider("shiden", "https://rpc.astar.network:8545,https://astar.api.onfinality.io/public", 336),
     palm: createProvider("palm", "https://palm-mainnet.infura.io/v3/3a961d6501e54add9a41aa53f15de99b", 11297108109),
     energyweb: createProvider("energyweb", "https://rpc.energyweb.org", 246),
     songbird: createProvider("songbird", "https://songbird.towolabs.com/rpc", 19),
@@ -80,11 +80,12 @@ exports.providers = {
     moonbeam: createProvider("moonbeam", 'https://rpc.api.moonbeam.network', 1284),
     curio: createProvider("curio", 'https://mainnet-api.skalenodes.com/v1/fit-betelgeuse', 836542336838601),
     astar: createProvider("astar", "https://rpc.astar.network:8545", 592),
-    godwoken: createProvider("godwoken", "https://mainnet.godwoken.io/rpc/eth-wallet", 71394),
+    godwoken: createProvider("godwoken", "https://mainnet.godwoken.io/rpc", 71394),
     evmos: createProvider("evmos", "https://eth.bd.evmos.org:8545/", 9001),
     conflux: createProvider("conflux", "https://evm.confluxrpc.com", 1030),
     milkomeda: createProvider("milkomeda", "https://rpc-mainnet-cardano-evm.c1.milkomeda.com", 2001),
     dfk: createProvider("dfk", "https://subnets.avax.network/defi-kingdoms/dfk-chain/rpc", 53935),
+    crab: createProvider("crab", "https://crab-rpc.darwinia.network", 44),
 };
 function getProvider(chain) {
     if (chain === void 0) { chain = "ethereum"; }

package/build/util/index.js

@@ -115,19 +115,23 @@ function getLatestBlock(chain) {
     });
 }
 exports.getLatestBlock = getLatestBlock;
+var intialBlocks = {
+    terra: 4724001,
+    crab: 4969901
+};
 function lookupBlock(timestamp, extraParams) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     if (extraParams === void 0) { extraParams = {}; }
     return __awaiter(this, void 0, void 0, function () {
         var provider, lastBlock, high, low, block, mid, e_1;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
+        return __generator(this, function (_f) {
+            switch (_f.label) {
                 case 0:
-                    _d.trys.push([0, 6, , 7]);
+                    _f.trys.push([0, 6, , 7]);
                     provider = getExtraProvider(extraParams.chain);
                     return [4 /*yield*/, getBlock(provider, "latest", extraParams.chain)];
                 case 1:
-                    lastBlock = _d.sent();
+                    lastBlock = _f.sent();
                     if ((lastBlock.timestamp - timestamp) < -30 * 60) {
                         throw new Error("Last block of chain \"" + extraParams.chain + "\" is further than 30 minutes into the past. Provider is \"" + ((_b = (_a = provider) === null || _a === void 0 ? void 0 : _a.connection) === null || _b === void 0 ? void 0 : _b.url) + "\"");
                     }
@@ -139,24 +143,24 @@ function lookupBlock(timestamp, extraParams) {
                             }];
                     }
                     high = lastBlock.number;
-                    low = (extraParams === null || extraParams === void 0 ? void 0 : extraParams.chain) === "terra" ? 4724001 : 0;
+                    low = (_d = intialBlocks[(_c = extraParams === null || extraParams === void 0 ? void 0 : extraParams.chain) !== null && _c !== void 0 ? _c : "ethereum"]) !== null && _d !== void 0 ? _d : 0;
                     block = void 0;
-                    _d.label = 2;
+                    _f.label = 2;
                 case 2:
                     mid = Math.floor((high + low) / 2);
                     return [4 /*yield*/, getBlock(provider, mid, extraParams.chain)];
                 case 3:
-                    block = _d.sent();
+                    block = _f.sent();
                     if (block.timestamp < timestamp) {
                         low = mid + 1;
                     }
                     else {
                         high = mid - 1;
                     }
-                    _d.label = 4;
+                    _f.label = 4;
                 case 4:
                     if (high - low > 4) return [3 /*break*/, 2];
-                    _d.label = 5;
+                    _f.label = 5;
                 case 5:
                     if (Math.abs(block.timestamp - timestamp) > 3600) {
                         throw new Error("Block selected is more than 1 hour away from the requested timestamp");
@@ -166,9 +170,9 @@ function lookupBlock(timestamp, extraParams) {
                             timestamp: block.timestamp,
                         }];
                 case 6:
-                    e_1 = _d.sent();
+                    e_1 = _f.sent();
                     console.log(e_1);
-                    throw new Error("Couldn't find block height for chain " + ((_c = extraParams.chain) !== null && _c !== void 0 ? _c : 'ethereum') + ", RPC node rugged");
+                    throw new Error("Couldn't find block height for chain " + ((_e = extraParams.chain) !== null && _e !== void 0 ? _e : 'ethereum') + ", RPC node rugged");
                 case 7: return [2 /*return*/];
             }
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defillama/sdk",
-  "version": "2.3.53",
+  "version": "2.3.56",
   "description": "SDK for calculating TVL",
   "main": "build/index.js",
   "scripts": {
@@ -22,6 +22,7 @@
     "build"
   ],
   "dependencies": {
+    "@supercharge/promise-pool": "^2.1.0",
     "ethers": "^5.4.5",
     "graphql": "^15.5.0",
     "graphql-request": "^3.4.0",