@defillama/sdk 5.0.236 → 5.0.240

package/build/abi/index.js

@@ -1,327 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.call = call;
-exports.bytecodeCall = bytecodeCall;
-exports.multiCall = multiCall;
-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 common_1 = require("../util/common");
-const env_1 = require("../util/env");
-const nullAddress = '0x0000000000000000000000000000000000000000';
-// https://docs.soliditylang.org/en/latest/abi-spec.html
-const knownTypes = [
-    'string', 'address', 'bool', 'bytes32',
-    'int', 'int8', 'int16', 'int24', 'int32', 'int64', 'int96', 'int128', 'int256',
-    'uint', 'uint8', 'uint16', 'uint24', 'uint32', 'uint64', 'uint96', 'uint128', 'uint256',
-];
-([...knownTypes]).forEach(i => knownTypes.push(i + '[]')); // support array type for all known types
-function resolveABI(providedAbi) {
-    if (!providedAbi)
-        throw new Error('Missing ABI parameter!');
-    let abi = providedAbi;
-    if (typeof abi === "string") {
-        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,
-            outputs: [
-                {
-                    internalType: outputType,
-                    name: "",
-                    type: outputType,
-                },
-            ],
-            payable: false,
-            stateMutability: "view",
-            type: "function",
-        };
-    }
-    // If type is omitted DP's sdk processes it fine but we don't, so we need to add it
-    return {
-        type: "function",
-        ...abi,
-    };
-}
-function normalizeParams(params) {
-    if (params === undefined) {
-        return [];
-    }
-    else if (typeof params === "object") {
-        return params;
-    }
-    else {
-        return [params];
-    }
-}
-function fixBlockTag(params) {
-    let { block } = params;
-    if (typeof block !== 'string' || block === 'latest')
-        return;
-    block = +block;
-    if (isNaN(block))
-        throw new Error('Invalid block: ' + params.block);
-    params.block = block;
-}
-function isValidTarget(target, chain) {
-    if (typeof target !== 'string')
-        return false;
-    return target.startsWith('0x') && target !== nullAddress;
-}
-async function call(params) {
-    var _a;
-    if (!params.abi)
-        throw new Error('Missing ABI parameter ("abis" is supported only in abi2/ChainApi)!');
-    if (params.chain === 'tron')
-        (0, common_1.fixTronCallParams)(params);
-    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, chain });
-        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, common_1.formError)(e, errorParams);
-    }
-}
-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, { chain }),
-    };
-}
-async function multiCall(params) {
-    var _a;
-    if (!params.abi)
-        throw new Error('Missing ABI parameter ("abis" is supported only in abi2/ChainApi)!');
-    fixBlockTag(params);
-    if (params.chain === 'tron')
-        (0, common_1.fixTronCallParams)(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;
-        })) {
-            // 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 chunkedCalls = (0, util_1.sliceIntoChunks)(contractCalls, chunkSize);
-    const results = await (0, util_1.runInPromisePool)({
-        items: chunkedCalls,
-        concurrency: 10,
-        processor: (calls) => (0, multicall3_1.default)(abi, calls, chain, params.block),
-        permitFailure: params.permitFailure,
-    });
-    // When an entire chunk's processor call throws (e.g. a chunk-level RPC
-    // failure, as opposed to an individual call within it), runInPromisePool
-    // returns `undefined` for that chunk's slot instead of the expected array
-    // of one result per call. If permitFailure is set, that undefined flows
-    // straight through here uncaught, and both the .filter(r => !r.success)
-    // below and the flatResults[i].output access further down crash on it -
-    // and even without the crash, replacing a whole chunk's many calls with a
-    // single slot silently shortens and misaligns the array against
-    // contractCalls. Reconstruct a properly-shaped failure entry per call in
-    // any failed chunk instead, matching what makeMultiCall itself returns on
-    // an individual call failure, so length/order stay correct either way.
-    const resultsWithFailedChunksExpanded = results.map((chunkResult, i) => {
-        if (chunkResult !== undefined)
-            return chunkResult;
-        return chunkedCalls[i].map((call) => ({
-            input: { params: call.params, target: call.contract },
-            success: false,
-            output: null,
-        }));
-    });
-    const flatResults = [].concat.apply([], resultsWithFailedChunksExpanded);
-    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, common_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
-    };
-}
-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;
-}
-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 };
-}
-const cachableAbiSet = new Set([
-    'uint8:decimals',
-]);
-function isCachableAbi(abi) {
-    if (typeof abi !== 'string')
-        return false;
-    return abi.startsWith('address:') || abi.startsWith('string:') || cachableAbiSet.has(abi);
-}

package/build/abi/multicall.d.ts

@@ -1,23 +0,0 @@
-import { Chain } from "../general";
-export declare const MULTICALL_ADDRESS_MAINNET = "0xeefba1e63905ef1d7acba5a8513c70307c1ce441";
-export declare const MULTICALL_ADDRESS_KOVAN = "0x2cc8688c5f75e365aaeeb4ea8d6a480405a48d2a";
-export declare const MULTICALL_ADDRESS_RINKEBY = "0x42ad527de7d4e9d9d011ac45b31d8551f8fe9821";
-export declare const MULTICALL_ADDRESS_GOERLI = "0x77dca2c955b15e9de4dbbcf1246b4b85b651e50e";
-export declare const MULTICALL_ADDRESS_POLYGON = "0x95028E5B8a734bb7E2071F96De89BABe75be9C8E";
-export declare const MULTICALL_ADDRESS_BSC = "0x1Ee38d535d541c55C9dae27B12edf090C608E6Fb";
-export declare const MULTICALL_ADDRESS_FANTOM = "0xb828C456600857abd4ed6C32FAcc607bD0464F4F";
-export declare const MULTICALL_ADDRESS_XDAI = "0xb5b692a88BDFc81ca69dcB1d924f59f0413A602a";
-export declare const MULTICALL_ADDRESS_HECO = "0xc9a9F768ebD123A00B52e7A0E590df2e9E998707";
-export declare const MULTICALL_ADDRESS_HARMONY = "0xFE4980f62D708c2A84D3929859Ea226340759320";
-export declare const MULTICALL_ADDRESS_ARBITRUM = "0x842eC2c7D803033Edf55E478F461FC547Bc54EB2";
-export declare const MULTICALL_ADDRESS_AVAX = "0xdf2122931FEb939FB8Cf4e67Ea752D1125e18858";
-export declare const MULTICALL_ADDRESS_MOONRIVER = "0xe05349d6fE12602F6084550995B247a5C80C0E2C";
-export declare const MULTICALL_ADDRESS_AURORA = "0xe0e3887b158F7F9c80c835a61ED809389BC08d1b";
-export declare const MULTICALL_ADDRESS_OPTIMISM = "0xD0E99f15B24F265074747B2A1444eB02b9E30422";
-export declare const AGGREGATE_SELECTOR = "0x252dba42";
-export default function makeMultiCall(functionABI: any, calls: {
-    contract: string;
-    params: any[];
-}[], chain: Chain, block?: string | number): Promise<any>;
-export declare function multicallAddressOrThrow(chain: Chain): Promise<string>;
-export declare function networkSupportsMulticall(chain: Chain): Promise<boolean>;