@defillama/sdk 5.0.238 → 5.0.240

package/build/ChainApi.js

@@ -1,310 +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.ChainApi = void 0;
-exports.getDebugStats = getDebugStats;
-const abi2_1 = require("./abi/abi2");
-const Balances_1 = __importDefault(require("./Balances"));
-const blocks_1 = require("./computeTVL/blocks");
-const general_1 = require("./general");
-const providers_json_1 = __importDefault(require("./providers.json"));
-const eth_1 = require("./eth");
-const common_1 = require("./util/common");
-const debugLog_1 = require("./util/debugLog");
-const logs_1 = __importDefault(require("./util/logs"));
-const transactions_1 = require("./util/transactions");
-const callStatsByProject = {};
-const nullAddress = '0x0000000000000000000000000000000000000000';
-// ERC-20 views of the native coin: balanceOf returns the same balance as eth_getBalance, so when summing
-// they are read as the native coin and deduped per owner, otherwise listing both counts the coin twice
-const nativeTokenAliases = {
-    polygon: '0x0000000000000000000000000000000000001010', // POL (MRC20)
-    celo: '0x471ece3750da237f93b8e339c536989b8978a438', // CELO (GoldToken)
-    metis: '0xdeaddeaddeaddeaddeaddeaddeaddeaddead0000', // METIS
-    arc: '0x3600000000000000000000000000000000000000', // USDC (6 decimals, native is 18)
-    stable: '0x779ded0c9e1022225f8e0630b35a9b54be713736', // USDT0 (6 decimals, native is 18)
-};
-class ChainApi {
-    constructor(params) {
-        var _a, _b;
-        this.block = params.block;
-        this.chain = (_a = params.chain) !== null && _a !== void 0 ? _a : 'ethereum';
-        this.timestamp = params.timestamp;
-        this.provider = (0, general_1.getProvider)(this.chain);
-        this._balances = new Balances_1.default({ chain: this.chain, timestamp: this.timestamp });
-        // @ts-ignore
-        this.chainId = (_b = providers_json_1.default[this.chain]) === null || _b === void 0 ? void 0 : _b.chainId;
-        this.storedKey = params.storedKey;
-        this.api = this;
-        const uKey = this.storedKey ? `${params.protocol}:${this.storedKey}` : (params.protocol ? `${params.protocol}` : `chain-${this.chain}`);
-        const stats = {
-            meta: {
-                chain: this.chain,
-                storedKey: this.storedKey,
-                protocol: params.protocol,
-            },
-            label: uKey,
-            total: 0,
-        };
-        callStatsByProject[uKey] = stats;
-        this.stats = stats;
-    }
-    addStat(method, value = 1, skipTotal = false) {
-        if (!skipTotal)
-            this.stats.total += value;
-        if (!this.stats[method])
-            this.stats[method] = 0;
-        this.stats[method] += value;
-    }
-    // autoset block if timestamp is older than 2 hours
-    async _setBlockFromTimestamp() {
-        if (this.timestamp && !this.block) {
-            const twoHoursAgo = Date.now() / 1000 - 2 * 60 * 60;
-            if (this.timestamp > twoHoursAgo)
-                return;
-            await this.getBlock();
-        }
-    }
-    async call(params) {
-        await this._setBlockFromTimestamp();
-        this.addStat('call');
-        return (0, abi2_1.call)({
-            ...params,
-            block: this.block,
-            chain: this.chain,
-        });
-    }
-    async batchCall(params) {
-        return Promise.all(params.map(i => this.call(i)));
-    }
-    async multiCall(params) {
-        this.addStat('multiCall', params.calls.length, true);
-        this.addStat('call');
-        await this._setBlockFromTimestamp();
-        return (0, abi2_1.multiCall)({
-            ...params,
-            block: this.block,
-            chain: this.chain,
-        });
-    }
-    async fetchList(params) {
-        this.addStat('fetchList');
-        await this._setBlockFromTimestamp();
-        return (0, abi2_1.fetchList)({
-            ...params,
-            block: this.block,
-            chain: this.chain,
-        });
-    }
-    async bytecodeCall(params) {
-        await this._setBlockFromTimestamp();
-        return (0, abi2_1.bytecodeCall)({
-            ...params,
-            block: this.block,
-            chain: this.chain,
-        });
-    }
-    async getBlock() {
-        if (!this.block)
-            this.addStat('getBlock');
-        if (!this.block)
-            this.block = await (0, blocks_1.getBlockNumber)(this.chain, this.timestamp);
-        return this.block;
-    }
-    log(...args) {
-        (0, debugLog_1.debugLog)(...args);
-    }
-    logTable(...args) {
-        (0, debugLog_1.debugTable)(...args);
-    }
-    add(token, balance, options = {}) {
-        this._balances.add(token, balance, options);
-    }
-    addToken(token, balance, options = {}) {
-        this.add(token, balance, options);
-    }
-    addGasToken(balance, options = {}) {
-        this.add(nullAddress, balance, options);
-    }
-    addUSDValue(balance, options = {}) {
-        this._balances.addUSDValue(balance, options);
-    }
-    addTokens(tokens, balances, options = {}) {
-        this.add(tokens, balances, options);
-    }
-    addBalances(balances, options = {}) {
-        this._balances.addBalances(balances, options);
-    }
-    addCGToken(token, balance, options = {}) {
-        this._balances.addCGToken(token, balance, options);
-    }
-    addTokenVannila(token, balance, options = {}) {
-        this._balances.addTokenVannila(token, balance, options);
-    }
-    getBalances() {
-        return this._balances.getBalances();
-    }
-    getChainId() {
-        return this.chainId;
-    }
-    removeTokenBalance(token) {
-        this._balances.removeTokenBalance(token);
-    }
-    deleteToken(token) {
-        this._balances.removeTokenBalance(token);
-    }
-    deleteTokens(tokens) {
-        tokens.forEach(i => this.deleteToken(i));
-    }
-    async erc4626Sum2(options) {
-        if (options.isOG4626 !== false)
-            options.isOG4626 = true;
-        return this.erc4626Sum(options);
-    }
-    async erc4626Sum({ calls, tokenAbi, balanceAbi, balanceCalls, permitFailure = false, isOG4626 = false }) {
-        if (isOG4626 && !tokenAbi && !balanceAbi) {
-            tokenAbi = 'asset';
-            balanceAbi = 'totalAssets';
-        }
-        if (!tokenAbi)
-            tokenAbi = 'address:token';
-        if (!balanceAbi)
-            balanceAbi = 'uint256:balance';
-        if (typeof tokenAbi === 'string' && (!tokenAbi.includes(':') && !tokenAbi.includes('(')))
-            tokenAbi = `address:${tokenAbi}`;
-        if (typeof balanceAbi === 'string' && (!balanceAbi.includes(':') && !balanceAbi.includes('(')))
-            balanceAbi = `uint256:${balanceAbi}`;
-        const tokens = await this.multiCall({ calls, abi: tokenAbi, permitFailure });
-        const balances = await this.multiCall({ calls: calls !== null && calls !== void 0 ? calls : balanceCalls, abi: balanceAbi, permitFailure });
-        if (!permitFailure)
-            this.addTokens(tokens, balances);
-        else
-            tokens.forEach((i, j) => {
-                if (i && balances[j])
-                    this.addToken(i, balances[j]);
-            });
-        return this.getBalances();
-    }
-    async getTokenBalances({ token, tokens = [], owners = [], owner, tokensAndOwners = [], tokensAndOwners2 = [], blacklistedTokens = [], blacklistedOwners = [], ownerTokens = [], skipDuplicates = false, permitFailure = false, withTokenData = false, }) {
-        await this._setBlockFromTimestamp();
-        if (tokensAndOwners2.length)
-            tokensAndOwners.push(...tokensAndOwners2[0].map((i, j) => [i, tokensAndOwners2[1][j]]));
-        if (token)
-            tokens.push(token);
-        if (tokens.length) {
-            if (owner)
-                owners.push(owner);
-            tokensAndOwners.push(...tokens.map(i => owners.map(j => [i, j])).flat());
-        }
-        for (const [tokens, owner] of ownerTokens)
-            tokens.forEach((i) => tokensAndOwners.push([i, owner]));
-        if (skipDuplicates)
-            tokensAndOwners = getUniqueTokensAndOwners(tokensAndOwners, this.chain);
-        blacklistedOwners.push(nullAddress); // skip nullAddress owners
-        blacklistedOwners = (0, common_1.getUniqueAddresses)(blacklistedOwners, this.chain);
-        blacklistedTokens = (0, common_1.getUniqueAddresses)(blacklistedTokens, this.chain);
-        tokensAndOwners = tokensAndOwners.filter(i => !blacklistedTokens.includes(i[0]) && !blacklistedOwners.includes(i[1]));
-        // only when summing: plain balance lookups expect the alias's own (ERC-20 decimals) value back
-        const nativeAlias = nativeTokenAliases[this.chain];
-        if (skipDuplicates && nativeAlias)
-            tokensAndOwners = getUniqueTokensAndOwners(tokensAndOwners.map(([t, o]) => [t === nativeAlias ? nullAddress : t, o]), this.chain);
-        const tokenBalances = [];
-        const erc20TokensResponseIndex = [];
-        const ethBalanceResponseIndex = [];
-        const erc20TokensAndOwners = [];
-        const ethBalOwners = [];
-        tokensAndOwners.forEach((i, j) => {
-            if (i[0] !== nullAddress) {
-                erc20TokensAndOwners.push(i);
-                erc20TokensResponseIndex.push(j);
-            }
-            else {
-                ethBalOwners.push(i[1]);
-                ethBalanceResponseIndex.push(j);
-            }
-        });
-        this.addStat('sumTokens', erc20TokensAndOwners.length + ethBalOwners.length, true);
-        const bals = await this.multiCall({
-            calls: erc20TokensAndOwners.map(([token, owner]) => ({ target: token, params: [owner] })),
-            abi: 'erc20:balanceOf',
-            permitFailure,
-        });
-        bals.forEach((i, j) => {
-            if (!i)
-                i = '0';
-            const token = erc20TokensAndOwners[j][0];
-            const responseIndex = erc20TokensResponseIndex[j];
-            tokenBalances[responseIndex] = [token, i];
-        });
-        if (ethBalOwners.length) {
-            let ethBals = (await (0, eth_1.getBalances)({ chain: this.chain, targets: ethBalOwners, block: this.block, permitFailure })).output.map((i) => i.balance);
-            ethBals.map((i, idx) => tokenBalances[ethBalanceResponseIndex[idx]] = [nullAddress, i]);
-        }
-        if (!withTokenData)
-            return tokenBalances.map(i => i[1]);
-        return tokenBalances;
-    }
-    async sumTokens({ balancesV2Options = {}, ...tokenBalanceOptions }) {
-        const tokenBalances = await this.getTokenBalances({ ...tokenBalanceOptions, skipDuplicates: true, withTokenData: true });
-        tokenBalances.forEach(([token, balance]) => this.addToken(token, balance, balancesV2Options));
-        return this.getBalances();
-    }
-    async getERC20TokenBalances(options) {
-        return this.getTokenBalances(options);
-    }
-    async getGasTokenBalance(owner, options) {
-        return (await this.getGasTokenBalances({ ...options, owner, }))[0];
-    }
-    async getGasTokenBalances(options) {
-        return this.getTokenBalances({ ...options, token: nullAddress });
-    }
-    async getEthBalance(owner, options) {
-        return this.getGasTokenBalance(owner, options !== null && options !== void 0 ? options : {});
-    }
-    async getEthBalances(options) {
-        return this.getGasTokenBalances(options);
-    }
-    async getUSDValue() {
-        return this._balances.getUSDValue();
-    }
-    async getUSDString() {
-        return this._balances.getUSDString();
-    }
-    async getUSDJSONs() {
-        return this._balances.getUSDJSONs();
-    }
-    async getLogs(params) {
-        var _a;
-        this.addStat('getLogs', ((_a = params.targets) === null || _a === void 0 ? void 0 : _a.length) || 1);
-        params.chain = this.chain;
-        return (0, logs_1.default)(params);
-    }
-    getBalancesV2() {
-        return this._balances;
-    }
-    async getTransactions(params) {
-        this.addStat('getTransactions');
-        return (0, transactions_1.getTransactions)({ ...params, chain: this.chain });
-    }
-    async getTransactionReceipt(tx) {
-        this.addStat('getTransactionReceipt');
-        return this.provider.getTransactionReceipt(tx);
-    }
-    getStats() {
-        return this.stats;
-    }
-}
-exports.ChainApi = ChainApi;
-exports.default = ChainApi;
-function getUniqueTokensAndOwners(toa, chain) {
-    if (!toa.length)
-        return [];
-    const mergedToa = toa.map(i => i.join('~'));
-    const uniqueMerged = (0, common_1.getUniqueAddresses)(mergedToa, chain);
-    return uniqueMerged.map(i => i.split('~'));
-}
-function getDebugStats() {
-    return callStatsByProject;
-}

package/build/abi/abi2.d.ts

@@ -1,5 +0,0 @@
-import { CallOptions, MulticallOptions, FetchListOptions, ByteCodeCallOptions } from "../types";
-export declare function call(params: CallOptions): Promise<any>;
-export declare function multiCall(params: MulticallOptions): Promise<any[]>;
-export declare function fetchList(params: FetchListOptions): Promise<any>;
-export declare function bytecodeCall(params: ByteCodeCallOptions): Promise<any>;

package/build/abi/abi2.js

@@ -1,215 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.call = call;
-exports.multiCall = multiCall;
-exports.fetchList = fetchList;
-exports.bytecodeCall = bytecodeCall;
-const abi1 = __importStar(require("./index"));
-async function call(params) {
-    if (params.abis)
-        return callWithAlternateAbis();
-    try {
-        const response = await abi1.call(params); // abi v1 doesnt have support for 'abis' param
-        if (params.field)
-            response.output = response.output[params.field];
-        if (params.withMetadata)
-            return response;
-        return response.output;
-    }
-    catch (e) {
-        if (!params.permitFailure)
-            throw e;
-        if (params.withMetadata)
-            return { success: false, error: e };
-        return null;
-    }
-    async function callWithAlternateAbis() {
-        const { abis, ...restParams } = params;
-        if (!abis || abis.length === 0)
-            throw new Error('No alternate ABIs provided!');
-        for (let i = 0; i < abis.length - 1; i++) {
-            const res = await call({ ...restParams, abi: abis[i], permitFailure: true, withMetadata: true });
-            const response = params.withMetadata ? res : res.output;
-            if (res.success !== false)
-                return response;
-        }
-        const lastAbi = abis[abis.length - 1];
-        return call({ ...restParams, abi: lastAbi, });
-    }
-}
-async function multiCall(params) {
-    if (params.excludeFailed)
-        params.permitFailure = true;
-    if (params.abis)
-        return multiCallWithAlternateAbis();
-    params.calls = params.calls.map(i => {
-        if (typeof i === 'object')
-            return i;
-        if (typeof i === 'string') {
-            if (params.target)
-                return { params: i };
-            return { target: i };
-        }
-        return { params: i };
-    });
-    let { output } = await abi1.multiCall(params);
-    if (params.excludeFailed)
-        output = output.filter((i) => i.success);
-    if (params.field)
-        output.forEach((i) => i.output = i.output[params.field]);
-    if (params.withMetadata)
-        return output;
-    return output.map((i) => i.output);
-    async function multiCallWithAlternateAbis() {
-        const { abis, ...restParams } = params;
-        if (!abis || abis.length === 0)
-            throw new Error('No alternate ABIs provided!');
-        const outputs = [];
-        for (let i = 0; i < abis.length; i++) {
-            const res = await multiCall({ ...restParams, abi: abis[i], permitFailure: true, withMetadata: true, excludeFailed: false, });
-            outputs.push(res);
-        }
-        let finalOutput;
-        const permitFailure = params.permitFailure || params.excludeFailed;
-        outputs.forEach((res) => {
-            if (!finalOutput) { // First iteration
-                finalOutput = res;
-                return;
-            }
-            res.forEach((callRes, idx) => {
-                var _a;
-                if ((_a = finalOutput[idx]) === null || _a === void 0 ? void 0 : _a.success)
-                    return; // Already succeeded with an earlier ABI
-                finalOutput[idx] = callRes;
-            });
-        });
-        if (!permitFailure)
-            finalOutput.forEach((data) => {
-                if (!(data === null || data === void 0 ? void 0 : data.success))
-                    throw new Error(`All ABI alternatives failed for multiCall! Last error: ${data === null || data === void 0 ? void 0 : data.error}`);
-            });
-        if (params.excludeFailed)
-            finalOutput = finalOutput.filter((i) => i === null || i === void 0 ? void 0 : i.success);
-        if (params.withMetadata)
-            return finalOutput;
-        return finalOutput.map((i) => i.output);
-    }
-}
-async function fetchList(params) {
-    // itemAbi2 is used when we need to make a second call to get the final result
-    let { startFrom = 0, lengthAbi, itemAbi, withMetadata, startFromOne = false, itemCount, target, targets, calls: _targets, chain, block, permitFailure, groupedByInput, excludeFailed, itemAbi2, field, field2, } = params;
-    if (!targets)
-        targets = _targets;
-    const _groupedByInputOrignal = groupedByInput;
-    if (targets && itemAbi2)
-        groupedByInput = true;
-    permitFailure = permitFailure || excludeFailed;
-    if (excludeFailed && groupedByInput)
-        throw new Error('excludeFailed and groupedByInput cannot be used together!');
-    if (withMetadata && groupedByInput)
-        throw new Error('withMetadata and groupedByInput cannot be used together!');
-    if (typeof lengthAbi === 'string' && (!lengthAbi.includes(':') && !lengthAbi.includes('(')))
-        lengthAbi = `uint256:${lengthAbi}`;
-    if (typeof itemAbi === 'string' && (!itemAbi.includes(':') && !itemAbi.includes('(')))
-        itemAbi = `function ${itemAbi}(uint256) view returns (address)`;
-    let itemLength, itemLengths;
-    const calls = [];
-    if (!target && !targets)
-        throw new Error('Need to provide either target or targets parameter!');
-    if (target) {
-        if (itemCount)
-            itemLength = itemCount;
-        else
-            itemLength = await call({ chain, block, target, abi: lengthAbi, });
-        // debugLog('length: ', itemLength)
-        if (startFromOne) {
-            itemLength++;
-            if (startFrom === 0)
-                startFrom = 1;
-        }
-        for (let i = startFrom; i < itemLength; i++)
-            calls.push({ target, params: [i] });
-        const response = await multiCall({ chain, block, permitFailure, abi: itemAbi, calls, withMetadata, excludeFailed, field, });
-        if (!itemAbi2)
-            return response;
-        return multiCall({ chain, block, target, permitFailure, abi: itemAbi2, calls: response, withMetadata, excludeFailed, field: field2, });
-    }
-    if (itemCount)
-        itemLengths = targets.map(() => itemCount);
-    else
-        itemLengths = await multiCall({ chain, block, calls: targets, abi: lengthAbi, });
-    // debugLog('itemLengths: ', itemLengths)
-    let groupedByRes = itemLengths.map(() => []);
-    const indexToTargetMapping = {};
-    let k = 0;
-    for (let i = 0; i < itemLengths.length; i++) {
-        let itemLength = itemLengths[i];
-        if (startFromOne) {
-            itemLength++;
-            if (startFrom === 0)
-                startFrom = 1;
-        }
-        for (let j = startFrom; j < itemLength; j++) {
-            calls.push({ target: targets[i], params: [j] });
-            indexToTargetMapping[k] = i;
-            k++;
-        }
-    }
-    const res = await multiCall({ chain, block, permitFailure, abi: itemAbi, calls, withMetadata, excludeFailed, field, });
-    if (!groupedByInput)
-        return res;
-    res.forEach((i, idx) => groupedByRes[indexToTargetMapping[idx]].push(i));
-    if (!itemAbi2)
-        return groupedByRes;
-    const calls2 = [];
-    for (let i = 0; i < targets.length; i++) {
-        for (let j = 0; j < groupedByRes[i].length; j++) {
-            calls2.push({ target: targets[i], params: groupedByRes[i][j] });
-        }
-    }
-    const res2 = await multiCall({ chain, block, permitFailure, abi: itemAbi2, calls: calls2, withMetadata, excludeFailed, field: field2, });
-    if (!_groupedByInputOrignal)
-        return res2;
-    groupedByRes = itemLengths.map(() => []);
-    res2.forEach((i, idx) => groupedByRes[indexToTargetMapping[idx]].push(i));
-    return groupedByRes;
-}
-async function bytecodeCall(params) {
-    const response = await abi1.bytecodeCall(params);
-    if (params.withMetadata)
-        return response;
-    return response.output;
-}

package/build/abi/cachedABIs.d.ts

@@ -1,4 +0,0 @@
-declare const _default: {
-    [method: string]: any | undefined;
-};
-export default _default;

package/build/abi/cachedABIs.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = {
-    "erc20:symbol": "string:symbol",
-    "erc20:decimals": "uint8:decimals",
-    "erc20:balanceOf": "function balanceOf(address account) view returns (uint256)",
-    "erc20:totalSupply": "uint256:totalSupply",
-};

package/build/abi/convertResults.d.ts

@@ -1,5 +0,0 @@
-import { ethers } from "ethers";
-export default function (results: ethers.Result, { functionABI, chain }?: {
-    functionABI?: ethers.FunctionFragment;
-    chain?: string;
-}): any;

package/build/abi/convertResults.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = default_1;
-const common_1 = require("../util/common");
-function isNumberOrBigNumber(value) {
-    return typeof value === 'bigint' || typeof value === "number";
-}
-function stringifyBigNumbers(result) {
-    let final = { ...result };
-    if (Array.isArray(result))
-        final = [...result];
-    Object.keys(result).forEach((key) => {
-        if (isNumberOrBigNumber(result[key]))
-            final[key] = result[key].toString();
-        else if (typeof result[key] === "object")
-            final[key] = stringifyBigNumbers(result[key]);
-        else
-            final[key] = result[key];
-    });
-    return final;
-}
-function default_1(results, { functionABI, chain } = {}) {
-    let response;
-    if (typeof results === "string" || typeof results === "boolean")
-        return results;
-    if (isNumberOrBigNumber(results))
-        return results.toString();
-    response = stringifyBigNumbers(results);
-    if (functionABI && functionABI.outputs) {
-        functionABI.outputs.map((componentDefinition, i) => {
-            setComponentDetails(response[i], componentDefinition, chain);
-            setNameAndTranformAddress({ response, componentDefinition, chain, index: i });
-        });
-    }
-    if (response instanceof Array)
-        if (response.length === 1)
-            return response[0];
-    return response;
-}
-function setComponentDetails(component, componentDefinition, chain) {
-    if (componentDefinition.type === "tuple[]")
-        return component.map((item) => setDetails(item, chain));
-    if (componentDefinition.type === "tuple")
-        return setDetails(component, chain);
-    function setDetails(value, chain) {
-        const definitions = componentDefinition.components || componentDefinition.arrayChildren.components;
-        definitions.map((def, i) => {
-            setComponentDetails(value[i], def, chain);
-            setNameAndTranformAddress({ response: value, componentDefinition: def, chain, index: i });
-        });
-    }
-}
-function setNameAndTranformAddress({ response, componentDefinition, chain, index }) {
-    if (chain === 'tron' && componentDefinition.type === 'address') {
-        response[index] = (0, common_1.evmToTronAddress)(response[index]);
-    }
-    if (componentDefinition === null || componentDefinition === void 0 ? void 0 : componentDefinition.name)
-        response[componentDefinition.name] = response[index];
-    return response;
-}

package/build/abi/index.d.ts

@@ -1,31 +0,0 @@
-import { Address, ByteCodeCallOptions, LogArray } from "../types";
-import { Chain } from "../general";
-type CallParams = any;
-type CallOptions = {
-    target: Address;
-    abi: string | any;
-    block?: number | string;
-    params?: CallParams;
-    chain?: Chain | string;
-    skipCache?: boolean;
-    logArray?: LogArray;
-};
-type MulticallOptions = {
-    abi: string | any;
-    calls: {
-        target?: Address;
-        params?: CallParams;
-    }[];
-    block?: number | string;
-    target?: Address;
-    chain?: Chain | string;
-    chunkSize?: number;
-    skipCache?: boolean;
-    contractCalls?: any;
-    permitFailure?: boolean;
-    logArray?: LogArray;
-};
-export declare function call(params: CallOptions): Promise<any>;
-export declare function bytecodeCall(params: ByteCodeCallOptions): Promise<any>;
-export declare function multiCall(params: MulticallOptions): Promise<any>;
-export {};