@defillama/sdk 5.0.9 → 5.0.11

package/build/abi/multicall.js

@@ -22,55 +22,19 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.networkSupportsMulticall = exports.multicallAddressOrThrow = exports.AGGREGATE_SELECTOR = exports.MULTICALL_ADDRESS_OPTIMISM = exports.MULTICALL_ADDRESS_AURORA = exports.MULTICALL_ADDRESS_MOONRIVER = exports.MULTICALL_ADDRESS_AVAX = exports.MULTICALL_ADDRESS_ARBITRUM = exports.MULTICALL_ADDRESS_HARMONY = exports.MULTICALL_ADDRESS_HECO = exports.MULTICALL_ADDRESS_XDAI = exports.MULTICALL_ADDRESS_FANTOM = exports.MULTICALL_ADDRESS_BSC = exports.MULTICALL_ADDRESS_POLYGON = exports.MULTICALL_ADDRESS_GOERLI = exports.MULTICALL_ADDRESS_RINKEBY = exports.MULTICALL_ADDRESS_KOVAN = exports.MULTICALL_ADDRESS_MAINNET = void 0;
-var ethers_1 = require("ethers");
-var general_1 = require("../general");
-var convertResults_1 = __importDefault(require("./convertResults"));
-var rpcCall_1 = require("./rpcCall");
-var debugLog_1 = require("../util/debugLog");
-var util_1 = require("../util");
-var Tron = __importStar(require("./tron"));
-var env_1 = require("../util/env");
+const ethers_1 = require("ethers");
+const general_1 = require("../general");
+const convertResults_1 = __importDefault(require("./convertResults"));
+const rpcCall_1 = require("./rpcCall");
+const debugLog_1 = require("../util/debugLog");
+const util_1 = require("../util");
+const Tron = __importStar(require("./tron"));
+const env_1 = require("../util/env");
 exports.MULTICALL_ADDRESS_MAINNET = "0xeefba1e63905ef1d7acba5a8513c70307c1ce441";
 exports.MULTICALL_ADDRESS_KOVAN = "0x2cc8688c5f75e365aaeeb4ea8d6a480405a48d2a";
 exports.MULTICALL_ADDRESS_RINKEBY = "0x42ad527de7d4e9d9d011ac45b31d8551f8fe9821";
@@ -87,188 +51,122 @@ exports.MULTICALL_ADDRESS_MOONRIVER = "0xe05349d6fE12602F6084550995B247a5C80C0E2
 exports.MULTICALL_ADDRESS_AURORA = "0xe0e3887b158F7F9c80c835a61ED809389BC08d1b";
 exports.MULTICALL_ADDRESS_OPTIMISM = "0xD0E99f15B24F265074747B2A1444eB02b9E30422";
 exports.AGGREGATE_SELECTOR = "0x252dba42";
-function makeMultiCall(functionABI, calls, chain, block) {
-    return __awaiter(this, void 0, void 0, function () {
-        var contractInterface, fd, contractCalls, returnValues;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (chain === 'tron')
-                        return [2 /*return*/, Tron.multiCall(functionABI, calls)];
-                    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,
-                        };
-                    });
-                    return [4 /*yield*/, executeCalls(contractCalls, chain, block)];
-                case 1:
-                    returnValues = _a.sent();
-                    return [2 /*return*/, returnValues.map(function (values, index) {
-                            var output;
-                            var error = undefined;
-                            try {
-                                output = (0, convertResults_1.default)(contractInterface.decodeFunctionResult(fd, values), fd);
-                            }
-                            catch (e) {
-                                output = null;
-                                error = e;
-                            }
-                            var res = {
-                                input: {
-                                    params: calls[index].params,
-                                    target: calls[index].contract,
-                                },
-                                success: output !== null,
-                                output: output,
-                            };
-                            if (error)
-                                res.error = error;
-                            return res;
-                        })];
-            }
-        });
+async function makeMultiCall(functionABI, calls, chain, block) {
+    if (chain === 'tron')
+        return Tron.multiCall(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,
+        };
+    });
+    const returnValues = await executeCalls(contractCalls, chain, block);
+    return returnValues.map((values, index) => {
+        let output;
+        let error = undefined;
+        try {
+            output = (0, convertResults_1.default)(contractInterface.decodeFunctionResult(fd, values), fd);
+        }
+        catch (e) {
+            output = null;
+            error = e;
+        }
+        const res = {
+            input: {
+                params: calls[index].params,
+                target: calls[index].contract,
+            },
+            success: output !== null,
+            output,
+        };
+        if (error)
+            res.error = error;
+        return res;
     });
 }
 exports.default = makeMultiCall;
-function executeCalls(contractCalls, chain, block) {
-    return __awaiter(this, void 0, void 0, function () {
-        var multicallData, address, callData, tx, returnData, _a, blockNumber, returnValues, e_1, chunkSize, chunks, response, _b;
-        var _c;
-        var _this = this;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0: return [4 /*yield*/, networkSupportsMulticall(chain)];
-                case 1:
-                    if (!_d.sent()) return [3 /*break*/, 8];
-                    _d.label = 2;
-                case 2:
-                    _d.trys.push([2, 5, , 8]);
-                    multicallData = ethers_1.ethers.AbiCoder.defaultAbiCoder().encode([
-                        ethers_1.ethers.ParamType.from({
-                            components: [
-                                { name: "target", type: "address" },
-                                { name: "callData", type: "bytes" },
-                            ],
-                            name: "data",
-                            type: "tuple[]",
-                        }),
-                    ], [contractCalls.map(function (call) { return [call.to, call.data]; })]);
-                    return [4 /*yield*/, multicallAddressOrThrow(chain)];
-                case 3:
-                    address = _d.sent();
-                    callData = exports.AGGREGATE_SELECTOR + multicallData.substr(2);
-                    tx = {
-                        to: address,
-                        data: callData,
-                    };
-                    return [4 /*yield*/, (0, rpcCall_1.call)((0, general_1.getProvider)(chain), tx, block, chain)];
-                case 4:
-                    returnData = _d.sent();
-                    _a = ethers_1.ethers.AbiCoder.defaultAbiCoder().decode(["uint256", "bytes[]"], returnData), blockNumber = _a[0], returnValues = _a[1];
-                    return [2 /*return*/, returnValues];
-                case 5:
-                    e_1 = _d.sent();
-                    if (!(contractCalls.length > 10)) return [3 /*break*/, 7];
-                    chunkSize = Math.ceil(contractCalls.length / 5);
-                    chunks = (0, util_1.sliceIntoChunks)(contractCalls, 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(calls, chain, block); }
-                        })];
-                case 6:
-                    response = _d.sent();
-                    return [2 /*return*/, response.flat()];
-                case 7:
-                    (0, debugLog_1.debugLog)("Multicall failed, defaulting to single transactions...");
-                    return [3 /*break*/, 8];
-                case 8:
-                    _b = util_1.runInPromisePool;
-                    _c = {
-                        items: contractCalls
-                    };
-                    return [4 /*yield*/, networkSupportsMulticall(chain)];
-                case 9: return [2 /*return*/, _b.apply(void 0, [(_c.concurrency = (_d.sent()) ? 2 : 10,
-                            _c.processor = function (_a) {
-                                var to = _a.to, data = _a.data;
-                                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*/, (0, rpcCall_1.call)((0, general_1.getProvider)(chain), { to: to, data: data }, block, chain)];
-                                            case 2:
-                                                result = _b.sent();
-                                                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];
-                                        }
-                                    });
-                                });
-                            },
-                            _c)])];
+async function executeCalls(contractCalls, chain, block) {
+    if (await networkSupportsMulticall(chain)) {
+        try {
+            const multicallData = ethers_1.ethers.AbiCoder.defaultAbiCoder().encode([
+                ethers_1.ethers.ParamType.from({
+                    components: [
+                        { name: "target", type: "address" },
+                        { name: "callData", type: "bytes" },
+                    ],
+                    name: "data",
+                    type: "tuple[]",
+                }),
+            ], [contractCalls.map((call) => [call.to, call.data])]);
+            const address = await multicallAddressOrThrow(chain);
+            const callData = exports.AGGREGATE_SELECTOR + multicallData.substr(2);
+            const tx = {
+                to: address,
+                data: callData,
+            };
+            const returnData = await (0, rpcCall_1.call)((0, general_1.getProvider)(chain), tx, block, chain);
+            const [blockNumber, returnValues] = ethers_1.ethers.AbiCoder.defaultAbiCoder().decode(["uint256", "bytes[]"], returnData);
+            return returnValues;
+        }
+        catch (e) {
+            if (contractCalls.length > 10) {
+                const chunkSize = Math.ceil(contractCalls.length / 5);
+                const chunks = (0, util_1.sliceIntoChunks)(contractCalls, 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(calls, chain, block)
+                });
+                return response.flat();
             }
-        });
-    });
-}
-function multicallAddressOrThrow(chain) {
-    return __awaiter(this, void 0, void 0, function () {
-        var multicallEnv, network, address, msg;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    multicallEnv = (0, env_1.getEnvMulticallAddress)(chain);
-                    if (multicallEnv)
-                        return [2 /*return*/, multicallEnv];
-                    return [4 /*yield*/, (0, general_1.getProvider)(chain).getNetwork()];
-                case 1:
-                    network = _a.sent();
-                    address = multicallAddress(network === null || network === void 0 ? void 0 : network.chainId);
-                    if (address === null) {
-                        msg = "multicall is not available on the network ".concat(network.chainId);
-                        console.error(msg);
-                        throw new Error(msg);
-                    }
-                    return [2 /*return*/, address];
+            (0, debugLog_1.debugLog)("Multicall failed, defaulting to single transactions...");
+        }
+    }
+    return (0, util_1.runInPromisePool)({
+        items: contractCalls,
+        concurrency: await networkSupportsMulticall(chain) ? 2 : 10,
+        processor: async ({ to, data }) => {
+            let result = null;
+            try {
+                result = await (0, rpcCall_1.call)((0, general_1.getProvider)(chain), { to, data }, block, chain);
             }
-        });
+            catch (e) {
+                (0, debugLog_1.debugLog)(e);
+            }
+            return result;
+        }
     });
 }
+async function multicallAddressOrThrow(chain) {
+    const multicallEnv = (0, env_1.getEnvMulticallAddress)(chain);
+    if (multicallEnv)
+        return multicallEnv;
+    const network = await (0, general_1.getProvider)(chain).getNetwork();
+    const address = multicallAddress(network === null || network === void 0 ? void 0 : network.chainId);
+    if (address === null) {
+        const msg = `multicall is not available on the network ${network.chainId}`;
+        console.error(msg);
+        throw new Error(msg);
+    }
+    return address;
+}
 exports.multicallAddressOrThrow = multicallAddressOrThrow;
-var networkMulticallCache = {};
-function networkSupportsMulticall(chain) {
+const networkMulticallCache = {};
+async function networkSupportsMulticall(chain) {
     var _a;
-    return __awaiter(this, void 0, void 0, function () {
-        var multicallEnv, network, address;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    multicallEnv = (0, env_1.getEnvMulticallAddress)(chain);
-                    if (multicallEnv)
-                        networkMulticallCache[chain] = true;
-                    if (!!networkMulticallCache.hasOwnProperty(chain)) return [3 /*break*/, 2];
-                    return [4 /*yield*/, ((_a = (0, general_1.getProvider)(chain)) === null || _a === void 0 ? void 0 : _a.getNetwork())];
-                case 1:
-                    network = _b.sent();
-                    address = multicallAddress(network === null || network === void 0 ? void 0 : network.chainId);
-                    networkMulticallCache[chain] = address !== null;
-                    _b.label = 2;
-                case 2: return [2 /*return*/, networkMulticallCache[chain]];
-            }
-        });
-    });
+    const multicallEnv = (0, env_1.getEnvMulticallAddress)(chain);
+    if (multicallEnv)
+        networkMulticallCache[chain] = true;
+    if (!networkMulticallCache.hasOwnProperty(chain)) {
+        const network = await ((_a = (0, general_1.getProvider)(chain)) === null || _a === void 0 ? void 0 : _a.getNetwork());
+        const address = multicallAddress(network === null || network === void 0 ? void 0 : network.chainId);
+        networkMulticallCache[chain] = address !== null;
+    }
+    return networkMulticallCache[chain];
 }
 exports.networkSupportsMulticall = networkSupportsMulticall;
 function multicallAddress(chainId) {

package/build/abi/multicall3.js

@@ -22,56 +22,20 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMulticallAddress = exports.isMulticallV3Supported = void 0;
-var ethers_1 = require("ethers");
-var convertResults_1 = __importDefault(require("./convertResults"));
-var multicall_1 = __importDefault(require("./multicall"));
-var Tron = __importStar(require("./tron"));
-var index_1 = require("./index");
+const ethers_1 = require("ethers");
+const convertResults_1 = __importDefault(require("./convertResults"));
+const multicall_1 = __importDefault(require("./multicall"));
+const Tron = __importStar(require("./tron"));
+const index_1 = require("./index");
 // https://github.com/mds1/multicall
 // https://www.multicall3.com/deployments
-var MULTICALL_V3_ADDRESS = '0xca11bde05977b3631167028862be2a173976ca11';
-var DEPLOYMENT_BLOCK = {
+const MULTICALL_V3_ADDRESS = '0xca11bde05977b3631167028862be2a173976ca11';
+const DEPLOYMENT_BLOCK = {
     ethereum: 14353601,
     ethf: 14353601,
     arbitrum: 7654707,
@@ -148,90 +112,62 @@ var DEPLOYMENT_BLOCK = {
     callisto: 13811517,
     bittorrent: 31078552,
 };
-function makeMultiCall(functionABI, calls, chain, block) {
-    return __awaiter(this, void 0, void 0, function () {
-        function _call() {
-            return __awaiter(this, void 0, void 0, function () {
-                var multicallAddress, returnData;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            multicallAddress = getMulticallAddress(chain, block);
-                            return [4 /*yield*/, (0, index_1.call)({ chain: chain, block: block, target: multicallAddress, abi: 'function tryAggregate(bool requireSuccess, tuple(address target, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)', params: [false, contractCalls.map(function (call) { return [call.to, call.data]; })] })];
-                        case 1:
-                            returnData = (_a.sent()).output;
-                            returnValues = returnData;
-                            return [2 /*return*/];
-                    }
-                });
-            });
+async function makeMultiCall(functionABI, calls, chain, block) {
+    if (chain === 'tron')
+        return Tron.multiCall(functionABI, calls);
+    if (!functionABI)
+        throw new Error('Missing ABI parameter');
+    if (calls.some(i => !i.contract))
+        throw new Error('Missing target, abi:' + functionABI);
+    if (!isMulticallV3Supported(chain, block))
+        return (0, multicall_1.default)(functionABI, calls, chain, block);
+    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,
+        };
+    });
+    let returnValues;
+    try {
+        await _call();
+    }
+    catch (e) {
+        // debugLog(chain, 'Multicall failed, retrying call...')
+        await _call();
+    }
+    return returnValues.map(([success, values], index) => {
+        let output = null;
+        let error = null;
+        try {
+            output = (0, convertResults_1.default)(contractInterface.decodeFunctionResult(fd, values), fd);
         }
-        var contractInterface, fd, contractCalls, returnValues, e_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (chain === 'tron')
-                        return [2 /*return*/, Tron.multiCall(functionABI, calls)];
-                    if (!functionABI)
-                        throw new Error('Missing ABI parameter');
-                    if (calls.some(function (i) { return !i.contract; }))
-                        throw new Error('Missing target, abi:' + functionABI);
-                    if (!isMulticallV3Supported(chain, block))
-                        return [2 /*return*/, (0, multicall_1.default)(functionABI, calls, chain, block)];
-                    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,
-                        };
-                    });
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 5]);
-                    return [4 /*yield*/, _call()];
-                case 2:
-                    _a.sent();
-                    return [3 /*break*/, 5];
-                case 3:
-                    e_1 = _a.sent();
-                    // debugLog(chain, 'Multicall failed, retrying call...')
-                    return [4 /*yield*/, _call()];
-                case 4:
-                    // debugLog(chain, 'Multicall failed, retrying call...')
-                    _a.sent();
-                    return [3 /*break*/, 5];
-                case 5: return [2 /*return*/, returnValues.map(function (_a, index) {
-                        var success = _a[0], values = _a[1];
-                        var output = null;
-                        var error = null;
-                        try {
-                            output = (0, convertResults_1.default)(contractInterface.decodeFunctionResult(fd, values), fd);
-                        }
-                        catch (e) {
-                            error = e;
-                            success = false;
-                        }
-                        var res = {
-                            input: {
-                                params: calls[index].params,
-                                target: calls[index].contract,
-                            },
-                            success: success,
-                            output: output,
-                        };
-                        if (error)
-                            res.error = error;
-                        return res;
-                    })];
-            }
-        });
+        catch (e) {
+            error = e;
+            success = false;
+        }
+        const res = {
+            input: {
+                params: calls[index].params,
+                target: calls[index].contract,
+            },
+            success, output,
+        };
+        if (error)
+            res.error = error;
+        return res;
     });
+    async function _call() {
+        const multicallAddress = getMulticallAddress(chain, block);
+        const { output: returnData } = await (0, index_1.call)({ chain, block, target: multicallAddress, abi: 'function tryAggregate(bool requireSuccess, tuple(address target, bytes callData)[] calls) payable returns (tuple(bool success, bytes returnData)[] returnData)', params: [false, contractCalls.map((call) => [call.to, call.data])] });
+        returnValues = returnData;
+    }
 }
 exports.default = makeMultiCall;
 function isMulticallV3Supported(chain, block) {
-    var startBlock = DEPLOYMENT_BLOCK[chain];
+    const startBlock = DEPLOYMENT_BLOCK[chain];
     if (!startBlock)
         return false;
     if (!block)
@@ -244,7 +180,7 @@ exports.isMulticallV3Supported = isMulticallV3Supported;
 function getMulticallAddress(chain, block) {
     if (!isMulticallV3Supported(chain, block))
         return null;
-    var multicallAddress = MULTICALL_V3_ADDRESS;
+    let multicallAddress = MULTICALL_V3_ADDRESS;
     switch (chain) {
         case 'onus':
             multicallAddress = '0x748c384f759cc596f0d9fa96dcabe8a11e443b30';