@defillama/sdk 5.0.240 → 5.0.242

package/build/Balances.d.ts

@@ -0,0 +1,139 @@
+import { Balances as BalancesV1 } from "./types";
+import { Chain } from "./general";
+type BalancesOptions = {
+    skipChain?: boolean;
+    label?: string;
+    tags?: string[];
+    tag?: string;
+    id?: string;
+    isUSDValue?: boolean;
+};
+type BalancesOptionsWithLabel = BalancesOptions | string;
+export declare class Balances {
+    chain: Chain | string;
+    timestamp?: number;
+    _balances: BalancesV1;
+    _llamaBalancesObject: boolean;
+    _breakdownBalances: {
+        [key: string]: Balances;
+    };
+    _taggedBalances: {
+        [tag: string]: Balances;
+    };
+    _usdBalances: BalancesV1;
+    constructor(params: {
+        chain?: Chain | string;
+        timestamp?: number;
+    });
+    _add(token: string, balance: any, optionsOrLabel?: BalancesOptionsWithLabel, options?: BalancesOptions): void;
+    add(token: string | string[] | Balances, balance?: any, optionsOrLabel?: BalancesOptionsWithLabel, options?: BalancesOptions): void;
+    addToken(token: string, balance: any, optionsOrLabel?: BalancesOptionsWithLabel, options?: BalancesOptions): void;
+    addGasToken(balance: any, optionsOrLabel?: BalancesOptionsWithLabel, options?: BalancesOptions): void;
+    addCGToken(token: string, balance: any, optionsOrLabel?: BalancesOptionsWithLabel, options?: BalancesOptions): void;
+    addTokenVannila(token: string, balance: any, optionsOrLabel?: BalancesOptionsWithLabel, options?: BalancesOptions): void;
+    addUSDValue(balance: any, optionsOrLabel?: BalancesOptionsWithLabel, options?: BalancesOptions): void;
+    addTokens(tokens: string[], balances: any[], optionsOrLabel?: BalancesOptionsWithLabel, options?: BalancesOptions): void;
+    addBalances(balances: BalancesV1 | Balances, optionsOrLabel?: BalancesOptionsWithLabel, options?: (BalancesOptions & {
+        skipBreakdown?: boolean;
+    })): void;
+    getBalances(): BalancesV1;
+    removeTokenBalance(token: string): void;
+    getUSDValue(): Promise<number>;
+    getUSDString(): Promise<string>;
+    getUSDJSONs({ debug, debugOptions: { printTokenTable, minTokenUSDValue } }?: {
+        debug?: boolean;
+        debugOptions?: {
+            printTokenTable?: boolean;
+            minTokenUSDValue?: number;
+        };
+    }): Promise<{
+        usdTvl: number;
+        usdTokenBalances: BalancesV1;
+        rawTokenBalances: BalancesV1;
+        labelBreakdown?: {
+            [key: string]: number;
+        };
+        tagBreakdown?: {
+            [key: string]: number;
+        };
+        debugData?: {
+            tokenData: {
+                balance: string | number;
+                price: number;
+                decimals: number;
+                value: number;
+                confidence: number;
+                token: string;
+                symbol: string;
+            }[];
+        };
+    }>;
+    debug({ printTokenTable, minTokenUSDValue }?: {
+        printTokenTable?: boolean;
+        minTokenUSDValue?: number;
+    }): Promise<{
+        usdTvl: number;
+        usdTokenBalances: BalancesV1;
+        rawTokenBalances: BalancesV1;
+        labelBreakdown?: {
+            [key: string]: number;
+        };
+        tagBreakdown?: {
+            [key: string]: number;
+        };
+        debugData?: {
+            tokenData: {
+                balance: string | number;
+                price: number;
+                decimals: number;
+                value: number;
+                confidence: number;
+                token: string;
+                symbol: string;
+            }[];
+        };
+    }>;
+    resizeBy(ratio: number): this;
+    static getUSDValue(balances: BalancesV1, timestamp?: number): Promise<number>;
+    static getUSDString(balances: BalancesV1, timestamp?: number): Promise<string>;
+    static getBalanceObjects(balances: BalancesV1, timestamp?: number): Promise<{
+        usdTvl: number;
+        usdTokenBalances: BalancesV1;
+        debugData: {
+            tokenData: {
+                balance: string | number;
+                price: number;
+                decimals: number;
+                value: number;
+                confidence: number;
+                token: string;
+                symbol: string;
+            }[];
+        };
+    }>;
+    static getUSDJSONs(balances: BalancesV1, timestamp?: number): Promise<{
+        usdTvl: number;
+        usdTokenBalances: BalancesV1;
+        rawTokenBalances: BalancesV1;
+    }>;
+    clone(ratio?: number, optionsOrLabel?: BalancesOptionsWithLabel, options?: BalancesOptions): Balances;
+    subtract(balances: BalancesV1 | Balances, optionsOrLabel?: BalancesOptionsWithLabel, options?: BalancesOptions): void;
+    subtractToken(token: string, balance: any, optionsOrLabel?: BalancesOptionsWithLabel, options?: BalancesOptions): void;
+    removeNegativeBalances(): void;
+    _breakdownBalancesAction(action: string, args?: any[]): Promise<{
+        [key: string]: any;
+    }>;
+    _taggedBalancesAction(action: string, args?: any[]): Promise<{
+        [key: string]: any;
+    }>;
+    hasBreakdownBalances(): boolean;
+    hasTaggedBalances(): boolean;
+    isEmpty(): boolean;
+    getBreakdownBalances(): {
+        [key: string]: Balances;
+    };
+    getTaggedBalances(): {
+        [tag: string]: Balances;
+    };
+}
+export default Balances;

package/build/Balances.js

@@ -0,0 +1,363 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Balances = void 0;
+const generalUtil_1 = require("./generalUtil");
+const computeTVL_1 = __importDefault(require("./util/computeTVL"));
+const humanizeNumber_1 = require("./computeTVL/humanizeNumber");
+const nullAddress = '0x0000000000000000000000000000000000000000';
+// the last parameter of add function can be either a string or an object with options (or both as last two parameters)
+function getOptions({ optionsOrLabel = {}, options = {} } = {}) {
+    var _a;
+    let label;
+    if (optionsOrLabel) {
+        if (typeof optionsOrLabel === 'string') {
+            label = optionsOrLabel;
+        }
+        else {
+            options = optionsOrLabel;
+            label = options.label;
+        }
+    }
+    return {
+        ...options,
+        skipChain: (_a = options === null || options === void 0 ? void 0 : options.skipChain) !== null && _a !== void 0 ? _a : false,
+        label,
+    };
+}
+// Duck-type check that also works across module boundaries (when the same package
+// is loaded from two different node_modules copies, `instanceof Balances` returns false).
+function isLlamaBalancesObject(o) {
+    return typeof o === 'object' && o !== null && o._llamaBalancesObject === true;
+}
+class Balances {
+    constructor(params) {
+        var _a;
+        this.chain = (_a = params.chain) !== null && _a !== void 0 ? _a : 'ethereum';
+        this.timestamp = params.timestamp;
+        this._balances = {};
+        this._breakdownBalances = {};
+        this._taggedBalances = {};
+        this._usdBalances = {};
+        this._llamaBalancesObject = true;
+    }
+    _add(token, balance, optionsOrLabel, options) {
+        var _a;
+        const { label, skipChain, tag, tags = [], isUSDValue } = getOptions({ optionsOrLabel, options });
+        if (tag && typeof tag === 'string' && !tags.includes(tag))
+            tags.push(tag);
+        token = token.replace(/\//g, ':');
+        const isIBCToken = token.startsWith('ibc:');
+        let chain = this.chain;
+        if (skipChain || isIBCToken) {
+            chain = undefined;
+        }
+        if (chain === 'injective' && token.startsWith('peggy0x')) {
+            chain = 'ethereum';
+            token = token.replace('peggy', '');
+        }
+        // pad starknet token addresses back to the canonical 32 byte form
+        if (!skipChain && this.chain === 'starknet' && token.startsWith('0x') && token.length < 66) {
+            token = '0x' + token.slice(2).padStart(64, '0');
+        }
+        if (isUSDValue) {
+            (0, generalUtil_1.sumSingleBalance)(this._usdBalances, token, balance, chain);
+        }
+        else {
+            (0, generalUtil_1.sumSingleBalance)(this._balances, token, balance, chain);
+        }
+        if (label) {
+            this._breakdownBalances[label] = (_a = this._breakdownBalances[label]) !== null && _a !== void 0 ? _a : new Balances({ chain: this.chain, timestamp: this.timestamp });
+            this._breakdownBalances[label]._add(token, balance, { skipChain, isUSDValue });
+        }
+        if (tags.length > 0) {
+            tags.forEach((tag) => {
+                var _a;
+                this._taggedBalances[tag] = (_a = this._taggedBalances[tag]) !== null && _a !== void 0 ? _a : new Balances({ chain: this.chain, timestamp: this.timestamp });
+                this._taggedBalances[tag]._add(token, balance, { skipChain, isUSDValue });
+            });
+        }
+    }
+    add(token, balance, optionsOrLabel, options) {
+        if (isLlamaBalancesObject(token)) {
+            if (typeof optionsOrLabel === 'string')
+                throw new Error('When adding a Balances instance, optionsOrLabel must be an object with options, not a string');
+            this.addBalances(token, balance, optionsOrLabel);
+            return;
+        }
+        options = getOptions({ optionsOrLabel, options });
+        if (!token)
+            throw new Error('token is required');
+        if (!balance)
+            return;
+        if (Array.isArray(balance)) {
+            if (Array.isArray(token)) {
+                this.addTokens(token, balance, options);
+                return;
+            }
+            else if (typeof token === 'string') {
+                balance.forEach((v) => this._add(token, v, options));
+                return;
+            }
+        }
+        if (typeof token !== 'string')
+            throw new Error('token must be a string');
+        this._add(token, balance, options);
+    }
+    addToken(token, balance, optionsOrLabel, options) {
+        options = getOptions({ optionsOrLabel, options });
+        this._add(token, balance, options);
+    }
+    addGasToken(balance, optionsOrLabel, options) {
+        options = getOptions({ optionsOrLabel, options });
+        this._add(nullAddress, balance, options);
+    }
+    addCGToken(token, balance, optionsOrLabel, options) {
+        options = getOptions({ optionsOrLabel, options });
+        this.addTokenVannila('coingecko:' + token, balance, options);
+    }
+    addTokenVannila(token, balance, optionsOrLabel, options) {
+        options = getOptions({ optionsOrLabel, options });
+        this._add(token, balance, { ...options, skipChain: true });
+    }
+    addUSDValue(balance, optionsOrLabel, options) {
+        options = getOptions({ optionsOrLabel, options });
+        if (options.id) {
+            this.add(options.id, balance, { ...options, isUSDValue: true, skipChain: true });
+            return;
+        }
+        this.addCGToken('tether', balance, { ...options, skipChain: true });
+    }
+    addTokens(tokens, balances, optionsOrLabel, options) {
+        options = getOptions({ optionsOrLabel, options });
+        if (!Array.isArray(tokens))
+            throw new Error('tokens must be an array');
+        if (!Array.isArray(balances))
+            throw new Error('balances must be an array');
+        if (tokens.length !== balances.length)
+            throw new Error('token and balance must have the same length');
+        tokens.forEach((v, i) => this._add(v, balances[i], options));
+    }
+    addBalances(balances, optionsOrLabel, options) {
+        var _a, _b;
+        options = getOptions({ optionsOrLabel, options });
+        if (isLlamaBalancesObject(balances)) {
+            const balancesInstance = balances;
+            if (balancesInstance === this)
+                return;
+            // if balances object has breakdown by label, and overall label is not set, we copy existing breakdown balances into this instance
+            if (balancesInstance.hasBreakdownBalances() && !options.skipBreakdown && !options.label) {
+                this._breakdownBalances = (_a = this._breakdownBalances) !== null && _a !== void 0 ? _a : {};
+                const { label, ...restOptions } = options;
+                Object.entries(balancesInstance.getBreakdownBalances()).forEach(([label, breakdown]) => {
+                    var _a;
+                    this._breakdownBalances[label] = (_a = this._breakdownBalances[label]) !== null && _a !== void 0 ? _a : new Balances({ chain: this.chain, timestamp: this.timestamp });
+                    this._breakdownBalances[label].addBalances(breakdown, restOptions);
+                });
+            }
+            if (balancesInstance.hasTaggedBalances()) {
+                this._taggedBalances = (_b = this._taggedBalances) !== null && _b !== void 0 ? _b : {};
+                const { label, ...restOptions } = options;
+                Object.entries(balancesInstance.getTaggedBalances()).forEach(([tag, taggedBalance]) => {
+                    var _a;
+                    this._taggedBalances[tag] = (_a = this._taggedBalances[tag]) !== null && _a !== void 0 ? _a : new Balances({ chain: this.chain, timestamp: this.timestamp });
+                    this._taggedBalances[tag].addBalances(taggedBalance, restOptions);
+                });
+            }
+            if (Object.keys(balancesInstance._usdBalances).length > 0) {
+                Object.entries(balancesInstance._usdBalances).forEach(([token, balance]) => {
+                    this._add(token, balance, { ...options, skipChain: true, isUSDValue: true });
+                });
+            }
+            balances = balancesInstance.getBalances();
+        }
+        if (balances === this._balances)
+            return;
+        Object.entries(balances).forEach(([token, balance]) => this._add(token, balance, { ...options, skipChain: true }));
+    }
+    getBalances() {
+        return this._balances;
+    }
+    removeTokenBalance(token) {
+        const regex = new RegExp(token, 'i');
+        Object.keys(this._balances).forEach((i) => {
+            if (regex.test(i))
+                delete this._balances[i];
+        });
+        Object.keys(this._usdBalances).forEach((i) => {
+            if (regex.test(i))
+                delete this._usdBalances[i];
+        });
+        this._breakdownBalancesAction('removeTokenBalance', [token]);
+        this._taggedBalancesAction('removeTokenBalance', [token]);
+    }
+    async getUSDValue() {
+        let { usdTvl } = await (0, computeTVL_1.default)(this.getBalances(), this.timestamp);
+        usdTvl = Object.values(this._usdBalances).reduce((a, b) => a + Number(b), usdTvl);
+        return usdTvl;
+    }
+    async getUSDString() {
+        return Number(await this.getUSDValue()).toFixed(0);
+    }
+    async getUSDJSONs({ debug = false, debugOptions: { printTokenTable = true, minTokenUSDValue } = {} } = {}) {
+        let { usdTvl, usdTokenBalances, debugData } = await (0, computeTVL_1.default)(this.getBalances(), this.timestamp, { debug });
+        const response = { usdTvl, usdTokenBalances, rawTokenBalances: this.getBalances(), labelBreakdown: {} };
+        // add the USD value of tokens that were directly added as USD value (instead of raw token balances that need to be converted to USD value using price cache)
+        Object.entries(this._usdBalances).forEach(([symbol, balance]) => {
+            usdTvl += Number(balance);
+            (0, generalUtil_1.sumSingleBalance)(usdTokenBalances, symbol, balance);
+            // skipping it from debug table, unlikely that we would mix raw token balances and direct USD value in the same Balances instance, but if we do, it's cleaner to skip these from debug table since they are already in USD value and don't have price/confidence/decimals data
+            // if (debug && !isNaN(Number(balance))) debugData.tokenData.push({ symbol, value: Number(balance), token: symbol, price: 1, confidence: 1, balance, decimals: 0 })
+        });
+        response.usdTvl = usdTvl;
+        if (debug) {
+            response.debugData = debugData;
+            if (!minTokenUSDValue && minTokenUSDValue !== 0) {
+                minTokenUSDValue = usdTvl / 100; // default to 1% of total TVL
+            }
+            let tokenData = debugData.tokenData;
+            // filter out tokens with value less than minTokenUSDValue
+            if (minTokenUSDValue)
+                tokenData = tokenData.filter((i) => +i.value >= minTokenUSDValue);
+            tokenData.sort((a, b) => b.value - a.value); // sort descending by value
+            if (printTokenTable) {
+                const dataClone = tokenData.map((i) => ({ ...i, value: (0, humanizeNumber_1.humanizeNumber)(i.value), }));
+                console.log((0, generalUtil_1.tableToString)(dataClone));
+            }
+            // add a humanized value field so it's easier to read big numbers
+            tokenData.forEach((i) => {
+                i.valueHN = (0, humanizeNumber_1.humanizeNumber)(i.value);
+            });
+            debugData.tokenData = tokenData;
+        }
+        if (this.hasBreakdownBalances()) {
+            for (const [label, breakdown] of Object.entries(this.getBreakdownBalances())) {
+                const breakdownUSD = await breakdown.getUSDValue();
+                response.labelBreakdown[label] = breakdownUSD;
+            }
+        }
+        if (this.hasTaggedBalances()) {
+            response.tagBreakdown = {};
+            for (const [tag, taggedBalance] of Object.entries(this.getTaggedBalances())) {
+                const taggedUSD = await taggedBalance.getUSDValue();
+                response.tagBreakdown[tag] = taggedUSD;
+            }
+        }
+        return response;
+    }
+    async debug({ printTokenTable = true, minTokenUSDValue } = {}) {
+        return this.getUSDJSONs({ debug: true, debugOptions: { printTokenTable, minTokenUSDValue } });
+    }
+    resizeBy(ratio) {
+        Object.keys(this._balances).forEach((token) => {
+            this._balances[token] = Number(this._balances[token]) * ratio;
+        });
+        Object.keys(this._usdBalances).forEach((token) => {
+            this._usdBalances[token] = Number(this._usdBalances[token]) * ratio;
+        });
+        this._breakdownBalancesAction('resizeBy', [ratio]);
+        this._taggedBalancesAction('resizeBy', [ratio]);
+        return this;
+    }
+    static async getUSDValue(balances, timestamp) {
+        return (await (0, computeTVL_1.default)(balances, timestamp)).usdTvl;
+    }
+    static async getUSDString(balances, timestamp) {
+        return Number(await Balances.getUSDValue(balances, timestamp)).toFixed(0);
+    }
+    static async getBalanceObjects(balances, timestamp) {
+        return (0, computeTVL_1.default)(balances, timestamp);
+    }
+    static async getUSDJSONs(balances, timestamp) {
+        const { usdTvl, usdTokenBalances } = await (0, computeTVL_1.default)(balances, timestamp);
+        return { usdTvl, usdTokenBalances, rawTokenBalances: balances };
+    }
+    clone(ratio = 1, optionsOrLabel, options) {
+        options = getOptions({ optionsOrLabel, options });
+        const newBalances = new Balances({ chain: this.chain, timestamp: this.timestamp });
+        newBalances.addBalances(this, options);
+        if (ratio !== 1)
+            newBalances.resizeBy(ratio);
+        return newBalances;
+    }
+    subtract(balances, optionsOrLabel, options) {
+        options = getOptions({ optionsOrLabel, options });
+        if (isLlamaBalancesObject(balances)) {
+            if (balances === this)
+                return;
+            const balancesInstance = balances;
+            Object.entries(balancesInstance._usdBalances).forEach(([token, balance]) => {
+                this._add(token, Number(balance) * -1, { skipChain: true, label: options.label, isUSDValue: true });
+            });
+            balances = balancesInstance.getBalances();
+        }
+        Object.entries(balances).forEach(([token, balance]) => {
+            this._add(token, Number(balance) * -1, { skipChain: true, label: options.label });
+        });
+    }
+    subtractToken(token, balance, optionsOrLabel, options) {
+        options = getOptions({ optionsOrLabel, options });
+        this._add(token, Number(balance) * -1, options);
+    }
+    removeNegativeBalances() {
+        Object.keys(this._balances).forEach((token) => {
+            if (Number(this._balances[token]) <= 0)
+                delete this._balances[token];
+        });
+        Object.keys(this._usdBalances).forEach((token) => {
+            if (Number(this._usdBalances[token]) <= 0)
+                delete this._usdBalances[token];
+        });
+        this._breakdownBalancesAction('removeNegativeBalances');
+        this._taggedBalancesAction('removeNegativeBalances');
+    }
+    async _breakdownBalancesAction(action, args = []) {
+        if (!this._breakdownBalances)
+            return {};
+        const response = {};
+        const entries = Object.entries(this._breakdownBalances);
+        for (const [label, breakdown] of entries) {
+            if (typeof breakdown[action] === 'function') {
+                response[label] = breakdown[action](...args);
+                if (response[label] instanceof Promise) {
+                    response[label] = await response[label];
+                }
+            }
+        }
+        return response;
+    }
+    async _taggedBalancesAction(action, args = []) {
+        if (!this._taggedBalances)
+            return {};
+        const response = {};
+        const entries = Object.entries(this._taggedBalances);
+        for (const [label, breakdown] of entries) {
+            if (typeof breakdown[action] === 'function') {
+                response[label] = breakdown[action](...args);
+                if (response[label] instanceof Promise) {
+                    response[label] = await response[label];
+                }
+            }
+        }
+        return response;
+    }
+    hasBreakdownBalances() {
+        return Object.keys(this._breakdownBalances).length > 0 && Object.values(this._breakdownBalances).some(b => !b.isEmpty());
+    }
+    hasTaggedBalances() {
+        return Object.keys(this._taggedBalances).length > 0 && Object.values(this._taggedBalances).some(b => !b.isEmpty());
+    }
+    isEmpty() {
+        return Object.keys(this._balances).length === 0 && Object.keys(this._usdBalances).length === 0;
+    }
+    getBreakdownBalances() {
+        return this._breakdownBalances;
+    }
+    getTaggedBalances() {
+        return this._taggedBalances;
+    }
+}
+exports.Balances = Balances;
+exports.default = Balances;

package/build/ChainApi.d.ts

@@ -0,0 +1,142 @@
+import Balances from "./Balances";
+import { Chain } from "./general";
+import { Balances as BalancesV1, Block, ByteCodeCallOptions, CallOptions, FetchListOptions, MulticallOptions } from "./types";
+import { Provider } from "ethers";
+import { GetLogsOptions } from "./util/logs";
+import { GetTransactionOptions } from "./util/transactions";
+type Erc4626SumOptions = {
+    calls: string[];
+    tokenAbi?: string;
+    balanceAbi?: string;
+    balanceCalls?: any[];
+    permitFailure?: boolean;
+    isOG4626?: boolean;
+};
+type GetTokenBalancesOptions = {
+    token?: string;
+    tokens?: string[];
+    owner?: string;
+    owners?: string[];
+    tokensAndOwners?: [string, string][];
+    tokensAndOwners2?: [string[], string[]];
+    ownerTokens?: [string[], string][];
+    blacklistedTokens?: string[];
+    blacklistedOwners?: string[];
+    skipDuplicates?: boolean;
+    permitFailure?: boolean;
+    withTokenData?: boolean;
+};
+type SumTokensOptions = GetTokenBalancesOptions & {
+    balancesV2Options?: BalancesV2Options;
+};
+type DebugStats = {
+    total: number;
+    [key: string]: any;
+};
+type BalancesV2Options = {
+    skipChain?: boolean;
+    label?: string;
+};
+export declare class ChainApi {
+    block?: Block;
+    chain: Chain | string;
+    chainId?: number;
+    timestamp?: number;
+    provider: Provider;
+    _balances: Balances;
+    storedKey?: string;
+    stats: DebugStats;
+    api: ChainApi;
+    constructor(params: {
+        block?: Block;
+        chain?: Chain | string;
+        storedKey?: string;
+        timestamp?: number;
+        protocol?: string;
+    });
+    addStat(method: string, value?: any, skipTotal?: boolean): void;
+    _setBlockFromTimestamp(): Promise<void>;
+    call(params: CallOptions): Promise<any>;
+    batchCall(params: CallOptions[]): Promise<any[]>;
+    multiCall(params: MulticallOptions): Promise<any[]>;
+    fetchList(params: FetchListOptions): Promise<any>;
+    bytecodeCall(params: ByteCodeCallOptions): Promise<any>;
+    getBlock(): Promise<number>;
+    log(...args: any): void;
+    logTable(...args: any): void;
+    add(token: any, balance: any, options?: BalancesV2Options): void;
+    addToken(token: string, balance: any, options?: BalancesV2Options): void;
+    addGasToken(balance: any, options?: BalancesV2Options): void;
+    addUSDValue(balance: any, options?: BalancesV2Options): void;
+    addTokens(tokens: string[], balances: any[], options?: BalancesV2Options): void;
+    addBalances(balances: Balances | BalancesV1, options?: BalancesV2Options): void;
+    addCGToken(token: string, balance: any, options?: BalancesV2Options): void;
+    addTokenVannila(token: string, balance: any, options?: BalancesV2Options): void;
+    getBalances(): BalancesV1;
+    getChainId(): number | undefined;
+    removeTokenBalance(token: string): void;
+    deleteToken(token: string): void;
+    deleteTokens(tokens: string[]): void;
+    erc4626Sum2(options: Erc4626SumOptions): Promise<BalancesV1>;
+    erc4626Sum({ calls, tokenAbi, balanceAbi, balanceCalls, permitFailure, isOG4626 }: Erc4626SumOptions): Promise<BalancesV1>;
+    getTokenBalances({ token, tokens, owners, owner, tokensAndOwners, tokensAndOwners2, blacklistedTokens, blacklistedOwners, ownerTokens, skipDuplicates, permitFailure, withTokenData, }: GetTokenBalancesOptions): Promise<string[] | [token: string, balance: string][]>;
+    sumTokens({ balancesV2Options, ...tokenBalanceOptions }: SumTokensOptions): Promise<BalancesV1>;
+    getERC20TokenBalances(options: GetTokenBalancesOptions): Promise<string[] | [token: string, balance: string][]>;
+    getGasTokenBalance(owner: string, options?: GetTokenBalancesOptions): Promise<string | [token: string, balance: string]>;
+    getGasTokenBalances(options: GetTokenBalancesOptions): Promise<string[] | [token: string, balance: string][]>;
+    getEthBalance(owner: string, options?: GetTokenBalancesOptions): Promise<string | [token: string, balance: string]>;
+    getEthBalances(options: GetTokenBalancesOptions): Promise<string[] | [token: string, balance: string][]>;
+    getUSDValue(): Promise<number>;
+    getUSDString(): Promise<string>;
+    getUSDJSONs(): Promise<{
+        usdTvl: number;
+        usdTokenBalances: BalancesV1;
+        rawTokenBalances: BalancesV1;
+        labelBreakdown?: {
+            [key: string]: number;
+        };
+        tagBreakdown?: {
+            [key: string]: number;
+        };
+        debugData?: {
+            tokenData: {
+                balance: string | number;
+                price: number;
+                decimals: number;
+                value: number;
+                confidence: number;
+                token: string;
+                symbol: string;
+            }[];
+        };
+    }>;
+    getLogs(params: GetLogsOptions): Promise<any[] | import("ethers").EventLog[] | import("ethers").EventLog[][]>;
+    getBalancesV2(): Balances;
+    getTransactions(params: GetTransactionOptions): Promise<{
+        hash: any;
+        blockNumber: number;
+        transactionIndex: number;
+        from: any;
+        to: any;
+        value: any;
+        gasPrice: any;
+        gas: any;
+        input: any;
+        nonce: number;
+        data: any;
+        type: any;
+        maxFeePerGas: any;
+        maxPriorityFeePerGas: any;
+        baseFeePerGas: any;
+        effectiveGasPrice: any;
+        gasUsed: any;
+        cumulativeGasUsed: any;
+        status: number;
+        contractCreated: any;
+        timestamp: any;
+    }[] | null>;
+    getTransactionReceipt(tx: string): Promise<import("ethers").TransactionReceipt | null>;
+    getStats(): DebugStats;
+}
+export default ChainApi;
+export declare function getDebugStats(): Record<string, DebugStats>;