@defillama/sdk 5.0.9 → 5.0.11

package/build/abi/rpcCall.js

@@ -1,115 +1,52 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-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 (g && (g = 0, op[0] && (_ = 0)), _) 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 debugLog_1 = require("../util/debugLog");
-var env_1 = require("../util/env");
-var COUNTERS = {};
-var emitter = new events_1.EventEmitter();
+const events_1 = require("events");
+const debugLog_1 = require("../util/debugLog");
+const env_1 = require("../util/env");
+const COUNTERS = {};
+const emitter = new events_1.EventEmitter();
 emitter.setMaxListeners(500000);
-function call(provider, data, block, chain, options) {
+async function call(provider, data, block, chain, options = { retry: true }) {
     var _a;
-    if (options === void 0) { options = { retry: true }; }
-    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);
-            }
+    const retry = (_a = options.retry) !== null && _a !== void 0 ? _a : true;
+    data.blockTag = block;
+    if (!chain)
+        chain = 'noChain';
+    const counter = getChainCounter(chain);
+    const currentId = counter.requestCount++;
+    const eventId = `${chain}-${currentId}`;
+    let chainMaxParallelCalls = (0, env_1.getMaxParallelRequests)(chain);
+    if (counter.activeWorkers > chainMaxParallelCalls) {
+        counter.queue.push(eventId);
+        await (0, events_1.once)(emitter, eventId);
+    }
+    counter.activeWorkers++;
+    if (debugLog_1.DEBUG_ENABLED) {
+        const showEveryX = counter.queue.length > 100 ? 50 : 10; // show log fewer times if lot more are queued up
+        if (currentId % showEveryX === 0)
+            (0, debugLog_1.debugLog)(`chain: ${chain} request #: ${currentId} queue: ${counter.queue.length} active requests: ${counter.activeWorkers}`);
+    }
+    let response;
+    try {
+        response = await provider.call(data, block);
+        onComplete();
+    }
+    catch (e) {
+        onComplete();
+        if (retry)
+            return call(provider, data, block, chain, { ...options, retry: false });
+        throw e;
+    }
+    return response;
+    function onComplete() {
+        counter.activeWorkers--;
+        if (counter.queue.length) {
+            const nextRequestId = counter.pickFromTop ? counter.queue.shift() : counter.queue.pop();
+            counter.pickFromTop = !counter.pickFromTop;
+            emitter.emit(nextRequestId);
         }
-        var retry, counter, currentId, eventId, chainMaxParallelCalls, showEveryX, response, e_1;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    retry = (_a = options.retry) !== null && _a !== void 0 ? _a : true;
-                    data.blockTag = block;
-                    if (!chain)
-                        chain = 'noChain';
-                    counter = getChainCounter(chain);
-                    currentId = counter.requestCount++;
-                    eventId = "".concat(chain, "-").concat(currentId);
-                    chainMaxParallelCalls = (0, env_1.getMaxParallelRequests)(chain);
-                    if (!(counter.activeWorkers > chainMaxParallelCalls)) return [3 /*break*/, 2];
-                    counter.queue.push(eventId);
-                    return [4 /*yield*/, (0, events_1.once)(emitter, eventId)];
-                case 1:
-                    _b.sent();
-                    _b.label = 2;
-                case 2:
-                    counter.activeWorkers++;
-                    if (debugLog_1.DEBUG_ENABLED) {
-                        showEveryX = counter.queue.length > 100 ? 50 : 10 // show log fewer times if lot more are queued up
-                        ;
-                        if (currentId % showEveryX === 0)
-                            (0, debugLog_1.debugLog)("chain: ".concat(chain, " request #: ").concat(currentId, " queue: ").concat(counter.queue.length, " active requests: ").concat(counter.activeWorkers));
-                    }
-                    _b.label = 3;
-                case 3:
-                    _b.trys.push([3, 5, , 6]);
-                    return [4 /*yield*/, provider.call(data, block)];
-                case 4:
-                    response = _b.sent();
-                    onComplete();
-                    return [3 /*break*/, 6];
-                case 5:
-                    e_1 = _b.sent();
-                    onComplete();
-                    if (retry)
-                        return [2 /*return*/, call(provider, data, block, chain, __assign(__assign({}, options), { retry: false }))];
-                    throw e_1;
-                case 6: return [2 /*return*/, response];
-            }
-        });
-    });
+    }
 }
 exports.call = call;
 function getChainCounter(chain) {

package/build/abi/tron.js

@@ -1,283 +1,167 @@
 "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 (g && (g = 0, op[0] && (_ = 0)), _) 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 };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getBalances = exports.getBalance = exports.multiCall = exports.call = void 0;
-var node_fetch_1 = __importDefault(require("node-fetch"));
-var ethers_1 = require("ethers");
-var tron_format_address_1 = require("tron-format-address");
-var convertResults_1 = __importDefault(require("./convertResults"));
-var debugLog_1 = require("../util/debugLog");
-var util_1 = require("../util");
-var general_1 = require("../general");
-var p_limit_1 = __importDefault(require("p-limit"));
-var env_1 = require("../util/env");
-var limitRPCCalls = (0, p_limit_1.default)(+(0, env_1.getEnvValue)('TRON_RPC_CONCURRENCY_LIMIT', '5'));
-var ownerAddress = 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t';
-var MULTICALL_ADDRESS = 'TGXuuKAb4bnrn137u39EKbYzKNXvdCes98';
-var getEndpoint = function () { return (0, env_1.getEnvRPC)('tron'); };
-function call(options) {
+const axios_1 = __importDefault(require("axios"));
+const ethers_1 = require("ethers");
+const tron_format_address_1 = require("tron-format-address");
+const convertResults_1 = __importDefault(require("./convertResults"));
+const debugLog_1 = require("../util/debugLog");
+const util_1 = require("../util");
+const general_1 = require("../general");
+const p_limit_1 = __importDefault(require("p-limit"));
+const env_1 = require("../util/env");
+const limitRPCCalls = (0, p_limit_1.default)(+(0, env_1.getEnvValue)('TRON_RPC_CONCURRENCY_LIMIT', '5'));
+const ownerAddress = 'TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t';
+const MULTICALL_ADDRESS = 'TGXuuKAb4bnrn137u39EKbYzKNXvdCes98';
+const getEndpoint = () => (0, env_1.getEnvRPC)('tron');
+async function call(options) {
     var _a, _b;
-    return __awaiter(this, void 0, void 0, function () {
-        var target, abi, params, isMulticall, contractInterface, functionABI, inputTypes, outputTypes, callData, body, data, decodedResult;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    target = options.target, abi = options.abi, params = options.params, isMulticall = options.isMulticall;
-                    target = unhexifyTarget(target);
-                    contractInterface = new ethers_1.ethers.Interface([abi]);
-                    functionABI = ethers_1.ethers.FunctionFragment.from(abi);
-                    inputTypes = ((_a = abi.inputs) !== null && _a !== void 0 ? _a : []).map(function (i) { return i.type; });
-                    if (isMulticall)
-                        inputTypes = [ethers_1.ethers.ParamType.from({
-                                components: [
-                                    { name: "target", type: "address" },
-                                    { name: "callData", type: "bytes" },
-                                ],
-                                name: "data",
-                                type: "tuple[]",
-                            })];
-                    outputTypes = ((_b = abi.outputs) !== null && _b !== void 0 ? _b : []).map(function (i) { return i.type; });
-                    params.forEach(function (v, i) {
-                        if (inputTypes[i] === 'address' && !v.startsWith('0x'))
-                            params[i] = (0, tron_format_address_1.toHex)(v);
-                    });
-                    callData = contractInterface._encodeParams(inputTypes, params);
-                    body = {
-                        owner_address: ownerAddress,
-                        contract_address: target,
-                        function_selector: contractInterface.fragments[0].format(),
-                        parameter: callData.slice(2),
-                        visible: true,
-                    };
-                    return [4 /*yield*/, limitRPCCalls(function () { return post(body); })];
-                case 1:
-                    data = (_c.sent()).constant_result[0];
-                    decodedResult = contractInterface.decodeFunctionResult(functionABI, '0x' + data);
-                    decodedResult = __spreadArray([], decodedResult, true);
-                    decodedResult.forEach(function (v, i) {
-                        if (outputTypes[i] === 'address' && v.startsWith('0x')) {
-                            v = (0, tron_format_address_1.fromHex)(v);
-                            decodedResult[i] = v;
-                        }
-                        var outputName = abi.outputs[i].name;
-                        if (outputName && outputName.length)
-                            decodedResult[outputName] = v;
-                    });
-                    return [2 /*return*/, {
-                            output: (0, convertResults_1.default)(decodedResult, functionABI),
-                        }];
-            }
-        });
+    let { target, abi, params, isMulticall, } = options;
+    target = unhexifyTarget(target);
+    const contractInterface = new ethers_1.ethers.Interface([abi]);
+    const functionABI = ethers_1.ethers.FunctionFragment.from(abi);
+    let inputTypes = ((_a = abi.inputs) !== null && _a !== void 0 ? _a : []).map((i) => i.type);
+    if (isMulticall)
+        inputTypes = [ethers_1.ethers.ParamType.from({
+                components: [
+                    { name: "target", type: "address" },
+                    { name: "callData", type: "bytes" },
+                ],
+                name: "data",
+                type: "tuple[]",
+            })];
+    const outputTypes = ((_b = abi.outputs) !== null && _b !== void 0 ? _b : []).map((i) => i.type);
+    params.forEach((v, i) => {
+        if (inputTypes[i] === 'address' && !v.startsWith('0x'))
+            params[i] = (0, tron_format_address_1.toHex)(v);
+    });
+    const callData = contractInterface._encodeParams(inputTypes, params);
+    const body = {
+        owner_address: ownerAddress,
+        contract_address: target,
+        function_selector: contractInterface.fragments[0].format(),
+        parameter: callData.slice(2),
+        visible: true,
+    };
+    const { constant_result: [data] } = await limitRPCCalls(() => post(body));
+    let decodedResult = contractInterface.decodeFunctionResult(functionABI, '0x' + data);
+    decodedResult = [...decodedResult];
+    decodedResult.forEach((v, i) => {
+        if (outputTypes[i] === 'address' && v.startsWith('0x')) {
+            v = (0, tron_format_address_1.fromHex)(v);
+            decodedResult[i] = v;
+        }
+        let outputName = abi.outputs[i].name;
+        if (outputName && outputName.length)
+            decodedResult[outputName] = v;
     });
+    return {
+        output: (0, convertResults_1.default)(decodedResult, functionABI),
+    };
 }
 exports.call = call;
-function multiCall(functionABI, calls) {
+async function multiCall(functionABI, calls) {
     var _a;
-    return __awaiter(this, void 0, void 0, function () {
-        var inputs_1, returnValues;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    if ((_a = functionABI.inputs) === null || _a === void 0 ? void 0 : _a.length) {
-                        inputs_1 = functionABI.inputs;
-                        calls.forEach(function (call) {
-                            var _a;
-                            (_a = call.params) === null || _a === void 0 ? void 0 : _a.forEach(function (v, i) {
-                                if (inputs_1[i].type === 'address')
-                                    call.params[i] = hexifyTarget(v);
-                            });
-                        });
-                    }
-                    return [4 /*yield*/, executeCalls(functionABI, calls)];
-                case 1:
-                    returnValues = _b.sent();
-                    return [2 /*return*/, returnValues.map(function (output, index) {
-                            return {
-                                input: {
-                                    params: calls[index].params,
-                                    target: calls[index].contract,
-                                },
-                                success: output !== null,
-                                output: output,
-                            };
-                        })];
-            }
+    if ((_a = functionABI.inputs) === null || _a === void 0 ? void 0 : _a.length) {
+        const inputs = functionABI.inputs;
+        calls.forEach((call) => {
+            var _a;
+            (_a = call.params) === null || _a === void 0 ? void 0 : _a.forEach((v, i) => {
+                if (inputs[i].type === 'address')
+                    call.params[i] = hexifyTarget(v);
+            });
         });
+    }
+    const returnValues = await executeCalls(functionABI, calls);
+    return returnValues.map((output, index) => {
+        return {
+            input: {
+                params: calls[index].params,
+                target: calls[index].contract,
+            },
+            success: output !== null,
+            output,
+        };
     });
 }
 exports.multiCall = multiCall;
-function getBalance(params) {
+async function getBalance(params) {
     var _a, _b, _c;
-    return __awaiter(this, void 0, void 0, function () {
-        var data, balance;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0: return [4 /*yield*/, limitRPCCalls(function () { return post({ address: params.target, visible: true, }, '/wallet/getaccount'); })];
-                case 1:
-                    data = _d.sent();
-                    balance = (((_a = data.balance) !== null && _a !== void 0 ? _a : 0) + ((_c = (_b = data.frozen) === null || _b === void 0 ? void 0 : _b.reduce(function (t, _a) {
-                        var frozen_balance = _a.frozen_balance;
-                        return t + frozen_balance;
-                    }, 0)) !== null && _c !== void 0 ? _c : 0)).toString();
-                    return [2 /*return*/, {
-                            output: (0, general_1.handleDecimals)(balance, params.decimals),
-                        }];
-            }
-        });
-    });
+    const data = await limitRPCCalls(() => post({ address: params.target, visible: true, }, '/wallet/getaccount'));
+    const balance = (((_a = data.balance) !== null && _a !== void 0 ? _a : 0) + ((_c = (_b = data.frozen) === null || _b === void 0 ? void 0 : _b.reduce((t, { frozen_balance }) => t + frozen_balance, 0)) !== null && _c !== void 0 ? _c : 0)).toString();
+    return {
+        output: (0, general_1.handleDecimals)(balance, params.decimals),
+    };
 }
 exports.getBalance = getBalance;
-function getBalances(params) {
-    return __awaiter(this, void 0, void 0, function () {
-        var targets, decimals, res;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    targets = params.targets, decimals = params.decimals;
-                    return [4 /*yield*/, Promise.all(targets.map(function (i) { return getBalance({ target: i, decimals: decimals }); }))];
-                case 1:
-                    res = _a.sent();
-                    return [2 /*return*/, {
-                            output: res.map(function (v, i) { return ({ target: targets[i], balance: v.output }); }),
-                        }];
-            }
-        });
-    });
+async function getBalances(params) {
+    const { targets, decimals } = params;
+    const res = await Promise.all(targets.map(i => getBalance({ target: i, decimals })));
+    return {
+        output: res.map((v, i) => ({ target: targets[i], balance: v.output })),
+    };
 }
 exports.getBalances = getBalances;
-function executeCalls(functionABI, calls) {
-    return __awaiter(this, void 0, void 0, function () {
-        var contractInterface, fd, contractCalls, _a, _, returnData, e_1, chunkSize, chunks, response;
-        var _this = this;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    contractInterface = new ethers_1.ethers.Interface([functionABI]);
-                    fd = contractInterface.fragments[0];
-                    contractCalls = calls.map(function (call) {
-                        var data = contractInterface.encodeFunctionData(fd, call.params);
-                        return {
-                            to: call.contract,
-                            data: data,
-                        };
-                    });
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 3, , 6]);
-                    return [4 /*yield*/, call({ target: MULTICALL_ADDRESS, params: [contractCalls.map(function (call) { return ({ target: hexifyTarget(call.to), callData: call.data, isMulticall: true }); })], abi: MULTICALL_ABI, isMulticall: true })];
-                case 2:
-                    _a = (_b.sent()).output, _ = _a[0], returnData = _a[1];
-                    return [2 /*return*/, returnData.map(function (v) {
-                            var _a;
-                            var decodedResult = contractInterface.decodeFunctionResult(functionABI, v);
-                            var outputTypes = ((_a = functionABI.outputs) !== null && _a !== void 0 ? _a : []).map(function (i) { return i.type; });
-                            var output = __spreadArray([], decodedResult, true);
-                            output.forEach(function (v, i) {
-                                if (outputTypes[i] === 'address' && v.startsWith('0x')) {
-                                    v = (0, tron_format_address_1.fromHex)(v);
-                                    output[i] = v;
-                                }
-                                var outputName = functionABI.outputs[i].name;
-                                if (outputName && outputName.length)
-                                    output[outputName] = v;
-                            });
-                            return (0, convertResults_1.default)(output, fd);
-                        })];
-                case 3:
-                    e_1 = _b.sent();
-                    console.error(e_1);
-                    if (!(calls.length > 10)) return [3 /*break*/, 5];
-                    chunkSize = Math.ceil(calls.length / 5);
-                    chunks = (0, util_1.sliceIntoChunks)(calls, chunkSize);
-                    (0, debugLog_1.debugLog)("Multicall failed, call size: ".concat(contractCalls.length, ", splitting into smaller chunks and trying again, new call size: ").concat(chunks[0].length));
-                    return [4 /*yield*/, (0, util_1.runInPromisePool)({
-                            items: chunks,
-                            concurrency: 2,
-                            processor: function (calls) { return executeCalls(functionABI, calls); }
-                        })];
-                case 4:
-                    response = _b.sent();
-                    return [2 /*return*/, response.flat()];
-                case 5:
-                    (0, debugLog_1.debugLog)("Multicall failed, defaulting to single transactions...");
-                    return [3 /*break*/, 6];
-                case 6: return [2 /*return*/, (0, util_1.runInPromisePool)({
-                        items: calls,
-                        concurrency: 3,
-                        processor: function (_a) {
-                            var contract = _a.contract, params = _a.params;
-                            return __awaiter(_this, void 0, void 0, function () {
-                                var result, e_2;
-                                return __generator(this, function (_b) {
-                                    switch (_b.label) {
-                                        case 0:
-                                            result = null;
-                                            _b.label = 1;
-                                        case 1:
-                                            _b.trys.push([1, 3, , 4]);
-                                            return [4 /*yield*/, call({ target: contract, params: params, abi: functionABI })];
-                                        case 2:
-                                            result = (_b.sent()).output;
-                                            return [3 /*break*/, 4];
-                                        case 3:
-                                            e_2 = _b.sent();
-                                            (0, debugLog_1.debugLog)(e_2);
-                                            return [3 /*break*/, 4];
-                                        case 4: return [2 /*return*/, result];
-                                    }
-                                });
-                            });
-                        }
-                    })];
-            }
+async function executeCalls(functionABI, calls) {
+    const contractInterface = new ethers_1.ethers.Interface([functionABI]);
+    let fd = contractInterface.fragments[0];
+    const contractCalls = calls.map((call) => {
+        const data = contractInterface.encodeFunctionData(fd, call.params);
+        return {
+            to: call.contract,
+            data: data,
+        };
+    });
+    try {
+        const { output: [_, returnData] } = await call({ target: MULTICALL_ADDRESS, params: [contractCalls.map((call) => ({ target: hexifyTarget(call.to), callData: call.data, isMulticall: true }))], abi: MULTICALL_ABI, isMulticall: true });
+        return returnData.map((v) => {
+            var _a;
+            let decodedResult = contractInterface.decodeFunctionResult(functionABI, v);
+            const outputTypes = ((_a = functionABI.outputs) !== null && _a !== void 0 ? _a : []).map((i) => i.type);
+            let output = [...decodedResult];
+            output.forEach((v, i) => {
+                if (outputTypes[i] === 'address' && v.startsWith('0x')) {
+                    v = (0, tron_format_address_1.fromHex)(v);
+                    output[i] = v;
+                }
+                let outputName = functionABI.outputs[i].name;
+                if (outputName && outputName.length)
+                    output[outputName] = v;
+            });
+            return (0, convertResults_1.default)(output, fd);
         });
+    }
+    catch (e) {
+        console.error(e);
+        if (calls.length > 10) {
+            const chunkSize = Math.ceil(calls.length / 5);
+            const chunks = (0, util_1.sliceIntoChunks)(calls, chunkSize);
+            (0, debugLog_1.debugLog)(`Multicall failed, call size: ${contractCalls.length}, splitting into smaller chunks and trying again, new call size: ${chunks[0].length}`);
+            const response = await (0, util_1.runInPromisePool)({
+                items: chunks,
+                concurrency: 2,
+                processor: (calls) => executeCalls(functionABI, calls)
+            });
+            return response.flat();
+        }
+        (0, debugLog_1.debugLog)("Multicall failed, defaulting to single transactions...");
+    }
+    return (0, util_1.runInPromisePool)({
+        items: calls,
+        concurrency: 3,
+        processor: async ({ contract, params }) => {
+            let result = null;
+            try {
+                result = (await call({ target: contract, params, abi: functionABI })).output;
+            }
+            catch (e) {
+                (0, debugLog_1.debugLog)(e);
+            }
+            return result;
+        }
     });
 }
 function unhexifyTarget(address) {
@@ -290,33 +174,19 @@ function hexifyTarget(address) {
         return (0, tron_format_address_1.toHex)(address);
     return address;
 }
-function post(body, endpoint) {
-    if (body === void 0) { body = {}; }
-    if (endpoint === void 0) { endpoint = '/wallet/triggerconstantcontract'; }
-    return __awaiter(this, void 0, void 0, function () {
-        var host, headers, apiKey, response;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    host = getEndpoint();
-                    headers = { 'Content-Type': 'application/json' };
-                    apiKey = (0, env_1.getEnvValue)('TRON_PRO_API_KEY');
-                    if (apiKey)
-                        headers['TRON-PRO-API-KEY'] = apiKey;
-                    return [4 /*yield*/, (0, node_fetch_1.default)(host + endpoint, {
-                            method: 'post',
-                            body: JSON.stringify(body),
-                            headers: headers,
-                        })];
-                case 1:
-                    response = _a.sent();
-                    return [2 /*return*/, response.json()];
-            }
-        });
+async function post(body = {}, endpoint = '/wallet/triggerconstantcontract') {
+    const host = getEndpoint();
+    const headers = { 'Content-Type': 'application/json' };
+    const apiKey = (0, env_1.getEnvValue)('TRON_PRO_API_KEY');
+    if (apiKey)
+        headers['TRON-PRO-API-KEY'] = apiKey;
+    const { data } = await axios_1.default.post(host + endpoint, body, {
+        headers,
     });
+    return data;
 }
 // this is needed else correct function identifier wont be picked up while calling
-var MULTICALL_ABI = {
+const MULTICALL_ABI = {
     "inputs": [
         {
             "components": [

package/build/api.js

@@ -28,9 +28,8 @@ exports.util = __importStar(require("./util"));
 exports.eth = __importStar(require("./eth"));
 exports.erc20 = __importStar(require("./erc20"));
 exports.abi = __importStar(require("./abi"));
-var general_1 = require("./general");
-var config = {
-    setProvider: general_1.setProvider,
-    getProvider: general_1.getProvider,
+const general_1 = require("./general");
+const config = {
+    setProvider: general_1.setProvider, getProvider: general_1.getProvider,
 };
 exports.config = config;