@defillama/sdk 5.0.9 → 5.0.11

package/build/abi/index.js

@@ -1,15 +1,4 @@
 "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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -33,90 +22,45 @@ 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 __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.multiCall = exports.bytecodeCall = exports.call = void 0;
-var cachedABIs_1 = __importDefault(require("./cachedABIs"));
-var ethers_1 = require("ethers");
-var general_1 = require("../general");
-var multicall3_1 = __importDefault(require("./multicall3"));
-var convertResults_1 = __importDefault(require("./convertResults"));
-var debugLog_1 = require("../util/debugLog");
-var internal_cache_1 = require("../util/internal-cache");
-var util_1 = require("../util");
-var Tron = __importStar(require("./tron"));
-var generalUtil_1 = require("../generalUtil");
-var env_1 = require("../util/env");
-var nullAddress = '0x0000000000000000000000000000000000000000';
+const cachedABIs_1 = __importDefault(require("./cachedABIs"));
+const ethers_1 = require("ethers");
+const general_1 = require("../general");
+const multicall3_1 = __importDefault(require("./multicall3"));
+const convertResults_1 = __importDefault(require("./convertResults"));
+const debugLog_1 = require("../util/debugLog");
+const internal_cache_1 = require("../util/internal-cache");
+const util_1 = require("../util");
+const Tron = __importStar(require("./tron"));
+const generalUtil_1 = require("../generalUtil");
+const env_1 = require("../util/env");
+const nullAddress = '0x0000000000000000000000000000000000000000';
 // https://docs.soliditylang.org/en/latest/abi-spec.html
-var knownTypes = [
+const knownTypes = [
     'string', 'address', 'bool',
     'int', 'int8', 'int16', 'int32', 'int64', 'int128', 'int256',
     'uint', 'uint8', 'uint16', 'uint32', 'uint64', 'uint128', 'uint256',
 ];
-(__spreadArray([], knownTypes, true)).forEach(function (i) { return knownTypes.push(i + '[]'); }); // support array type for all known types
+([...knownTypes]).forEach(i => knownTypes.push(i + '[]')); // support array type for all known types
 function resolveABI(providedAbi) {
     if (!providedAbi)
         throw new Error('Missing ABI parameter!');
-    var abi = providedAbi;
+    let abi = providedAbi;
     if (typeof abi === "string") {
-        var _a = providedAbi.split(':'), outputType = _a[0], name_1 = _a[1];
-        if (!knownTypes.includes(outputType) || !name_1) {
-            var contractInterface = new ethers_1.ethers.Interface([providedAbi]);
-            var jsonAbi = contractInterface.formatJson();
+        const [outputType, name] = providedAbi.split(':');
+        if (!knownTypes.includes(outputType) || !name) {
+            const contractInterface = new ethers_1.ethers.Interface([providedAbi]);
+            const jsonAbi = contractInterface.formatJson();
             return JSON.parse(jsonAbi)[0];
         }
         abi = {
             constant: true,
             inputs: [],
-            name: name_1,
+            name,
             outputs: [
                 {
                     internalType: outputType,
@@ -130,7 +74,10 @@ function resolveABI(providedAbi) {
         };
     }
     // If type is omitted DP's sdk processes it fine but we don't, so we need to add it
-    return __assign({ type: "function" }, abi);
+    return {
+        type: "function",
+        ...abi,
+    };
 }
 function normalizeParams(params) {
     if (params === undefined) {
@@ -144,7 +91,7 @@ function normalizeParams(params) {
     }
 }
 function fixBlockTag(params) {
-    var block = params.block;
+    let { block } = params;
     if (typeof block !== 'string' || block === 'latest')
         return;
     block = +block;
@@ -159,269 +106,216 @@ function isValidTarget(target, chain) {
         return true;
     return target.startsWith('0x') && target !== nullAddress;
 }
-function call(params) {
+async function call(params) {
     var _a;
-    return __awaiter(this, void 0, void 0, function () {
-        var chain, errorParams, abi, callParams, contractInterface, functionABI, callData, provider, result, decodedResult, output, e_1;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    if (!isValidTarget(params.target, params.chain))
-                        throw new Error('Invalid target: ' + params.target);
-                    fixBlockTag(params);
-                    chain = (_a = params.chain) !== null && _a !== void 0 ? _a : "ethereum";
-                    if (cachedABIs_1.default[params.abi])
-                        params.abi = cachedABIs_1.default[params.abi];
-                    errorParams = __assign({}, params);
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 3, , 4]);
-                    if (!params.skipCache)
-                        return [2 /*return*/, cachedCall(params)];
-                    abi = resolveABI(params.abi);
-                    callParams = normalizeParams(params.params);
-                    if (chain === 'tron')
-                        return [2 /*return*/, Tron.call(__assign(__assign({}, params), { abi: abi, params: callParams }))];
-                    contractInterface = new ethers_1.ethers.Interface([abi]);
-                    functionABI = ethers_1.ethers.FunctionFragment.from(abi);
-                    callData = contractInterface.encodeFunctionData(functionABI, callParams);
-                    provider = (0, general_1.getProvider)(chain);
-                    errorParams.provider = provider;
-                    return [4 /*yield*/, provider.call({
-                            to: params.target,
-                            data: callData,
-                            blockTag: params.block,
-                        })];
-                case 2:
-                    result = _b.sent();
-                    errorParams.result = result;
-                    decodedResult = contractInterface.decodeFunctionResult(abi, result);
-                    output = (0, convertResults_1.default)(decodedResult, functionABI);
-                    if (params.logArray && abi.name == 'balanceOf' && abi.outputs[0].type == 'uint256')
-                        params.logArray.push({
-                            chain: chain,
-                            token: params.target,
-                            holder: Array.isArray(params.params) ? params.params[0] : params.params,
-                            amount: output
-                        });
-                    return [2 /*return*/, {
-                            output: output,
-                        }];
-                case 3:
-                    e_1 = _b.sent();
-                    errorParams.isCallError = true;
-                    throw (0, generalUtil_1.formError)(e_1, errorParams);
-                case 4: return [2 /*return*/];
-            }
+    if (!isValidTarget(params.target, params.chain))
+        throw new Error('Invalid target: ' + params.target);
+    fixBlockTag(params);
+    const chain = (_a = params.chain) !== null && _a !== void 0 ? _a : "ethereum";
+    if (cachedABIs_1.default[params.abi])
+        params.abi = cachedABIs_1.default[params.abi];
+    let errorParams = { ...params };
+    try {
+        if (!params.skipCache)
+            return cachedCall(params);
+        const abi = resolveABI(params.abi);
+        const callParams = normalizeParams(params.params);
+        if (chain === 'tron')
+            return Tron.call({ ...params, abi, params: callParams });
+        const contractInterface = new ethers_1.ethers.Interface([abi]);
+        const functionABI = ethers_1.ethers.FunctionFragment.from(abi);
+        const callData = contractInterface.encodeFunctionData(functionABI, callParams);
+        const provider = (0, general_1.getProvider)(chain);
+        errorParams.provider = provider;
+        const result = await provider.call({
+            to: params.target,
+            data: callData,
+            blockTag: params.block,
         });
-    });
+        errorParams.result = result;
+        const decodedResult = contractInterface.decodeFunctionResult(abi, result);
+        const output = (0, convertResults_1.default)(decodedResult, functionABI);
+        if (params.logArray && abi.name == 'balanceOf' && abi.outputs[0].type == 'uint256')
+            params.logArray.push({
+                chain,
+                token: params.target,
+                holder: Array.isArray(params.params) ? params.params[0] : params.params,
+                amount: output
+            });
+        return {
+            output,
+        };
+    }
+    catch (e) {
+        errorParams.isCallError = true;
+        throw (0, generalUtil_1.formError)(e, errorParams);
+    }
 }
 exports.call = call;
-function bytecodeCall(params) {
-    return __awaiter(this, void 0, void 0, function () {
-        var block, bytecode, inputTypes, inputs, outputTypes, chain, inputData, callData, result, decodedResult;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    fixBlockTag(params);
-                    block = params.block, bytecode = params.bytecode, inputTypes = params.inputTypes, inputs = params.inputs, outputTypes = params.outputTypes, chain = params.chain;
-                    if (!bytecode)
-                        throw new Error('Missing bytecode parameter!');
-                    if (chain === 'tron')
-                        throw new Error('Bytecode call is not supported on Tron');
-                    inputData = ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(inputTypes, inputs);
-                    callData = '0x' + bytecode.concat(inputData.slice(2));
-                    return [4 /*yield*/, (0, general_1.getProvider)(chain).call({ data: callData, blockTag: block })];
-                case 1:
-                    result = _a.sent();
-                    decodedResult = ethers_1.ethers.AbiCoder.defaultAbiCoder().decode(outputTypes, result);
-                    return [2 /*return*/, {
-                            output: (0, convertResults_1.default)(decodedResult),
-                        }];
-            }
-        });
-    });
+async function bytecodeCall(params) {
+    fixBlockTag(params);
+    const { block, bytecode, inputTypes, inputs, outputTypes, chain } = params;
+    if (!bytecode)
+        throw new Error('Missing bytecode parameter!');
+    if (chain === 'tron')
+        throw new Error('Bytecode call is not supported on Tron');
+    const inputData = ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(inputTypes, inputs);
+    const callData = '0x' + bytecode.concat(inputData.slice(2));
+    const result = await (0, general_1.getProvider)(chain).call({ data: callData, blockTag: block });
+    const decodedResult = ethers_1.ethers.AbiCoder.defaultAbiCoder().decode(outputTypes, result);
+    return {
+        output: (0, convertResults_1.default)(decodedResult),
+    };
 }
 exports.bytecodeCall = bytecodeCall;
-function multiCall(params) {
+async function multiCall(params) {
     var _a;
-    return __awaiter(this, void 0, void 0, function () {
-        var chain, chunkSize, contractCalls, abi, results, flatResults, failedQueries;
-        var _b;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    fixBlockTag(params);
-                    if (cachedABIs_1.default[params.abi])
-                        params.abi = cachedABIs_1.default[params.abi];
-                    chain = (_a = params.chain) !== null && _a !== void 0 ? _a : 'ethereum';
-                    if (!params.calls)
-                        throw new Error('Missing calls parameter');
-                    if (params.target && !isValidTarget(params.target, chain))
-                        throw new Error('Invalid target: ' + params.target);
-                    if (!params.calls.length) {
-                        return [2 /*return*/, { output: [] }];
-                    }
-                    chunkSize = params.chunkSize;
-                    if (!params.chunkSize) {
-                        // Only a max of around 500 calls are supported by multicall, we have to split bigger batches
-                        chunkSize = (0, env_1.getDefaultChunkSize)(chain);
-                    }
-                    if (!params.target && !params.permitFailure) {
-                        // check if target adddress is missing for one of the calls
-                        if (params.calls.some(function (i) {
-                            if (typeof i === 'string' && i.startsWith('0x'))
-                                return !isValidTarget(i, params.chain);
-                            if (typeof i === 'object')
-                                return !isValidTarget(i.target, params.chain);
-                            return true;
-                        })) {
-                            (0, debugLog_1.debugLog)('Multicall is missing target', JSON.stringify(params, null, 2));
-                            throw new Error('Multicall is missing a target');
-                        }
-                    }
-                    contractCalls = params.contractCalls;
-                    if (!contractCalls) {
-                        contractCalls = (params.calls).map(function (call) {
-                            var _a;
-                            var callParams = normalizeParams(call.params);
-                            return {
-                                params: callParams,
-                                contract: (_a = call.target) !== null && _a !== void 0 ? _a : params.target,
-                            };
-                        });
-                        params.contractCalls = contractCalls;
-                    }
-                    if (!params.skipCache)
-                        return [2 /*return*/, cachedMultiCall(params)];
-                    abi = resolveABI(params.abi);
-                    return [4 /*yield*/, (0, util_1.runInPromisePool)({
-                            items: (0, util_1.sliceIntoChunks)(contractCalls, chunkSize),
-                            concurrency: 10,
-                            processor: function (calls) { return (0, multicall3_1.default)(abi, calls, chain, params.block); }
-                        })];
-                case 1:
-                    results = _c.sent();
-                    flatResults = [].concat.apply([], results);
-                    failedQueries = flatResults.filter(function (r) { return !r.success; });
-                    if (failedQueries.length) {
-                        // debugLog(`[chain: ${params.chain ?? "ethereum"}] [abi: ${params.abi}] Failed multicalls:`, failedQueries.map(r => r.input))
-                        if (!params.permitFailure) {
-                            params.failedQueries = failedQueries;
-                            params.isMultiCallError = true;
-                            throw (0, generalUtil_1.formError)(null, params);
-                        }
-                    }
-                    if (params.logArray && abi.name == 'balanceOf' && abi.outputs[0].type == 'uint256')
-                        (_b = params.logArray).push.apply(_b, contractCalls.map(function (c, i) { return ({
-                            chain: chain,
-                            holder: c.params.length ? c.params[0] : c.params,
-                            token: c.contract,
-                            amount: flatResults[i].output
-                        }); }));
-                    return [2 /*return*/, {
-                            output: flatResults, // flatten array
-                        }];
-            }
+    fixBlockTag(params);
+    if (cachedABIs_1.default[params.abi])
+        params.abi = cachedABIs_1.default[params.abi];
+    const chain = (_a = params.chain) !== null && _a !== void 0 ? _a : 'ethereum';
+    if (!params.calls)
+        throw new Error('Missing calls parameter');
+    if (params.target && !isValidTarget(params.target, chain))
+        throw new Error('Invalid target: ' + params.target);
+    if (!params.calls.length) {
+        return { output: [] };
+    }
+    let chunkSize = params.chunkSize;
+    if (!params.chunkSize) {
+        // Only a max of around 500 calls are supported by multicall, we have to split bigger batches
+        chunkSize = (0, env_1.getDefaultChunkSize)(chain);
+    }
+    if (!params.target && !params.permitFailure) {
+        // check if target adddress is missing for one of the calls
+        if (params.calls.some((i) => {
+            if (typeof i === 'string' && i.startsWith('0x'))
+                return !isValidTarget(i, params.chain);
+            if (typeof i === 'object')
+                return !isValidTarget(i.target, params.chain);
+            return true;
+        })) {
+            (0, debugLog_1.debugLog)('Multicall is missing target', JSON.stringify(params, null, 2));
+            throw new Error('Multicall is missing a target');
+        }
+    }
+    let contractCalls = params.contractCalls;
+    if (!contractCalls) {
+        contractCalls = (params.calls).map((call) => {
+            var _a;
+            const callParams = normalizeParams(call.params);
+            return {
+                params: callParams,
+                contract: (_a = call.target) !== null && _a !== void 0 ? _a : params.target,
+            };
         });
+        params.contractCalls = contractCalls;
+    }
+    if (!params.skipCache)
+        return cachedMultiCall(params);
+    const abi = resolveABI(params.abi);
+    const results = await (0, util_1.runInPromisePool)({
+        items: (0, util_1.sliceIntoChunks)(contractCalls, chunkSize),
+        concurrency: 10,
+        processor: (calls) => (0, multicall3_1.default)(abi, calls, chain, params.block)
     });
+    const flatResults = [].concat.apply([], results);
+    const failedQueries = flatResults.filter(r => !r.success);
+    if (failedQueries.length) {
+        // debugLog(`[chain: ${params.chain ?? "ethereum"}] [abi: ${params.abi}] Failed multicalls:`, failedQueries.map(r => r.input))
+        if (!params.permitFailure) {
+            params.failedQueries = failedQueries;
+            params.isMultiCallError = true;
+            throw (0, generalUtil_1.formError)(null, params);
+        }
+    }
+    if (params.logArray && abi.name == 'balanceOf' && abi.outputs[0].type == 'uint256')
+        params.logArray.push(...contractCalls.map((c, i) => ({
+            chain,
+            holder: c.params.length ? c.params[0] : c.params,
+            token: c.contract,
+            amount: flatResults[i].output
+        })));
+    return {
+        output: flatResults, // flatten array
+    };
 }
 exports.multiCall = multiCall;
-function cachedCall(params) {
-    return __awaiter(this, void 0, void 0, function () {
-        var cacheObject, cachedValue, value;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    params.skipCache = true;
-                    if (!isCachableAbi(params.abi))
-                        return [2 /*return*/, call(params)];
-                    cacheObject = {
-                        abi: params.abi,
-                        chain: params.chain,
-                        address: params.target,
-                    };
-                    cachedValue = (0, internal_cache_1.getCache)(cacheObject);
-                    if (cachedValue)
-                        return [2 /*return*/, {
-                                output: cachedValue
-                            }];
-                    return [4 /*yield*/, call(params)];
-                case 1:
-                    value = _a.sent();
-                    if (value) {
-                        cacheObject.value = value.output;
-                        (0, internal_cache_1.setCache)(cacheObject);
-                    }
-                    return [2 /*return*/, value];
-            }
-        });
-    });
+async function cachedCall(params) {
+    params.skipCache = true;
+    if (!isCachableAbi(params.abi))
+        return call(params);
+    const cacheObject = {
+        abi: params.abi,
+        chain: params.chain,
+        address: params.target,
+    };
+    const cachedValue = (0, internal_cache_1.getCache)(cacheObject);
+    if (cachedValue)
+        return {
+            output: cachedValue
+        };
+    const value = await call(params);
+    if (value) {
+        cacheObject.value = value.output;
+        (0, internal_cache_1.setCache)(cacheObject);
+    }
+    return value;
 }
-function cachedMultiCall(params) {
-    return __awaiter(this, void 0, void 0, function () {
-        var isCacheable, response, missing, missingIndices, response_;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    params.skipCache = true;
-                    isCacheable = isCachableAbi(params.abi);
-                    response = [];
-                    missing = [];
-                    missingIndices = [];
-                    params.contractCalls.forEach(function (value, i) {
-                        if (!isValidTarget(value.contract, params.chain)) {
-                            response[i] = {
-                                input: { target: value.contract, params: value.params, },
-                                output: null,
-                                success: false,
-                            };
-                            (0, debugLog_1.debugLog)(params.abi, 'Bad target passed:', value.contract, 'skipping call and returning null output for this');
-                            return;
-                        }
-                        if (isCacheable) {
-                            var cacheObject = {
-                                abi: params.abi,
-                                chain: params.chain,
-                                address: value.contract,
-                            };
-                            var cachedValue = (0, internal_cache_1.getCache)(cacheObject);
-                            if (cachedValue) {
-                                response[i] = {
-                                    input: { target: value.contract, params: value.params, },
-                                    output: cachedValue,
-                                    success: true,
-                                };
-                                return;
-                            }
-                        }
-                        missing.push(value);
-                        missingIndices.push(i);
-                    });
-                    if (!missing.length)
-                        return [2 /*return*/, { output: response }];
-                    params.contractCalls = missing;
-                    return [4 /*yield*/, multiCall(params)];
-                case 1:
-                    response_ = _a.sent();
-                    response_.output.forEach(function (value, i) {
-                        if (isCacheable) {
-                            var cacheObject = {
-                                abi: params.abi,
-                                chain: params.chain,
-                                address: value.input.target,
-                                value: value.output
-                            };
-                            (0, internal_cache_1.setCache)(cacheObject);
-                        }
-                        response[missingIndices[i]] = value;
-                    });
-                    return [2 /*return*/, { output: response }];
+async function cachedMultiCall(params) {
+    params.skipCache = true;
+    const isCacheable = isCachableAbi(params.abi);
+    const response = [];
+    const missing = [];
+    const missingIndices = [];
+    params.contractCalls.forEach((value, i) => {
+        if (!isValidTarget(value.contract, params.chain)) {
+            response[i] = {
+                input: { target: value.contract, params: value.params, },
+                output: null,
+                success: false,
+            };
+            (0, debugLog_1.debugLog)(params.abi, 'Bad target passed:', value.contract, 'skipping call and returning null output for this');
+            return;
+        }
+        if (isCacheable) {
+            const cacheObject = {
+                abi: params.abi,
+                chain: params.chain,
+                address: value.contract,
+            };
+            const cachedValue = (0, internal_cache_1.getCache)(cacheObject);
+            if (cachedValue) {
+                response[i] = {
+                    input: { target: value.contract, params: value.params, },
+                    output: cachedValue,
+                    success: true,
+                };
+                return;
             }
-        });
+        }
+        missing.push(value);
+        missingIndices.push(i);
+    });
+    if (!missing.length)
+        return { output: response };
+    params.contractCalls = missing;
+    const response_ = await multiCall(params);
+    response_.output.forEach((value, i) => {
+        if (isCacheable) {
+            const cacheObject = {
+                abi: params.abi,
+                chain: params.chain,
+                address: value.input.target,
+                value: value.output
+            };
+            (0, internal_cache_1.setCache)(cacheObject);
+        }
+        response[missingIndices[i]] = value;
     });
+    return { output: response };
 }
-var cachableAbiSet = new Set([
+const cachableAbiSet = new Set([
     'uint8:decimals',
 ]);
 function isCachableAbi(abi) {