@defillama/sdk 5.0.149 → 5.0.150

package/build/Balances.d.ts

@@ -1,30 +1,32 @@
 import { Balances as BalancesV1 } from "./types";
 import { Chain } from "./general";
+type BalancesOptions = {
+    skipChain?: boolean;
+    label?: string;
+};
+type BalancesOptionsWithLabel = BalancesOptions | string;
 export declare class Balances {
     chain: Chain | string;
     timestamp?: number;
     _balances: BalancesV1;
+    _breakdownBalances: {
+        [key: string]: Balances;
+    };
     constructor(params: {
         chain?: Chain | string;
         timestamp?: number;
     });
-    _add(token: string, balance: any, { skipChain }?: {
-        skipChain?: boolean | undefined;
-    }): void;
-    add(token: string | string[], balance: any, { skipChain }?: {
-        skipChain?: boolean | undefined;
-    }): void;
-    addToken(token: string, balance: any, { skipChain }?: {
-        skipChain?: boolean | undefined;
-    }): void;
-    addGasToken(balance: any): void;
-    addCGToken(token: string, balance: any): void;
-    addTokenVannila(token: string, balance: any): void;
-    addUSDValue(balance: any): void;
-    addTokens(tokens: string[], balances: any[], { skipChain }?: {
-        skipChain?: boolean | undefined;
-    }): void;
-    addBalances(balances: BalancesV1 | Balances): void;
+    _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>;
@@ -52,5 +54,12 @@ export declare class Balances {
         skipChain?: boolean | undefined;
     }): void;
     removeNegativeBalances(): void;
+    _breakdownBalancesAction(action: string, args?: any[]): Promise<{
+        [key: string]: any;
+    }>;
+    hasBreakdownBalances(): boolean;
+    getBreakdownBalances(): {
+        [key: string]: Balances;
+    };
 }
 export default Balances;

package/build/Balances.js

@@ -7,14 +7,36 @@ exports.Balances = void 0;
 const generalUtil_1 = require("./generalUtil");
 const computeTVL_1 = __importDefault(require("./util/computeTVL"));
 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,
+    };
+}
 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 = {};
     }
-    _add(token, balance, { skipChain = false } = {}) {
+    _add(token, balance, optionsOrLabel, options) {
+        var _a;
+        const { label, skipChain } = getOptions({ optionsOrLabel, options });
         token = token.replace(/\//g, ':');
         const isIBCToken = token.startsWith('ibc:');
         let chain = this.chain;
@@ -30,59 +52,88 @@ class Balances {
             token = token.replace('0x', '0x0');
         }
         (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 });
+        }
     }
-    add(token, balance, { skipChain = false } = {}) {
+    add(token, balance, optionsOrLabel, options) {
+        if (token instanceof Balances) {
+            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, { skipChain });
+                this.addTokens(token, balance, options);
                 return;
             }
             else if (typeof token === 'string') {
-                balance.forEach((v) => this._add(token, v, { skipChain }));
+                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, { skipChain });
+        this._add(token, balance, options);
     }
-    addToken(token, balance, { skipChain = false } = {}) {
-        this._add(token, balance, { skipChain });
+    addToken(token, balance, optionsOrLabel, options) {
+        options = getOptions({ optionsOrLabel, options });
+        this._add(token, balance, options);
     }
-    addGasToken(balance) {
-        this._add(nullAddress, balance);
+    addGasToken(balance, optionsOrLabel, options) {
+        options = getOptions({ optionsOrLabel, options });
+        this._add(nullAddress, balance, options);
     }
-    addCGToken(token, balance) {
-        this.addTokenVannila('coingecko:' + token, balance);
+    addCGToken(token, balance, optionsOrLabel, options) {
+        options = getOptions({ optionsOrLabel, options });
+        this.addTokenVannila('coingecko:' + token, balance, options);
     }
-    addTokenVannila(token, balance) {
-        this._add(token, balance, { skipChain: true });
+    addTokenVannila(token, balance, optionsOrLabel, options) {
+        options = getOptions({ optionsOrLabel, options });
+        this._add(token, balance, { ...options, skipChain: true });
     }
-    addUSDValue(balance) {
-        this.addCGToken('tether', balance);
+    addUSDValue(balance, optionsOrLabel, options) {
+        options = getOptions({ optionsOrLabel, options });
+        this.addCGToken('tether', balance, { ...options, skipChain: true });
     }
-    addTokens(tokens, balances, { skipChain = false } = {}) {
+    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], { skipChain }));
+        tokens.forEach((v, i) => this._add(v, balances[i], options));
     }
-    addBalances(balances) {
+    addBalances(balances, optionsOrLabel, options) {
+        var _a;
+        options = getOptions({ optionsOrLabel, options });
         if (balances instanceof Balances) {
             if (balances === this)
                 return;
+            // if balances object has breakdown by label, and overall label is not set, we copy existing breakdown balances into this instance
+            if (balances.hasBreakdownBalances() && !options.skipBreakdown && !options.label) {
+                this._breakdownBalances = (_a = this._breakdownBalances) !== null && _a !== void 0 ? _a : {};
+                const { label, ...restOptions } = options;
+                Object.entries(balances.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);
+                });
+            }
             balances = balances.getBalances();
         }
         if (balances === this._balances)
             return;
-        Object.entries(balances).forEach(([token, balance]) => this._add(token, balance, { skipChain: true }));
+        Object.entries(balances).forEach(([token, balance]) => this._add(token, balance, { ...options, skipChain: true }));
     }
     getBalances() {
         return this._balances;
@@ -93,6 +144,7 @@ class Balances {
             if (regex.test(i))
                 delete this._balances[i];
         });
+        this._breakdownBalancesAction('removeTokenBalance', [token]);
     }
     async getUSDValue() {
         const { usdTvl } = await (0, computeTVL_1.default)(this.getBalances(), this.timestamp);
@@ -109,6 +161,7 @@ class Balances {
         Object.keys(this._balances).forEach((token) => {
             this._balances[token] = Number(this._balances[token]) * ratio;
         });
+        this._breakdownBalancesAction('resizeBy', [ratio]);
         return this;
     }
     static async getUSDValue(balances, timestamp) {
@@ -149,6 +202,30 @@ class Balances {
             if (Number(this._balances[token]) <= 0)
                 delete this._balances[token];
         });
+        if (this._breakdownBalances) {
+            Object.values(this._breakdownBalances).forEach((breakdown) => breakdown.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;
+    }
+    hasBreakdownBalances() {
+        return Object.keys(this._breakdownBalances).length > 0;
+    }
+    getBreakdownBalances() {
+        return this._breakdownBalances;
     }
 }
 exports.Balances = Balances;

package/build/abi/multicall3.js

@@ -201,6 +201,11 @@ const DEPLOYMENT_BLOCK = {
     lens: 1,
     basecamp: 1,
     platon: 1,
+    xrplevm: 1,
+    katana: 1,
+    mint: 1,
+    btnx: 1,
+    vechain: 22103870,
 };
 async function makeMultiCall(functionABI, calls, chain, block) {
     if (chain === 'tron')
@@ -344,6 +349,12 @@ function getMulticallAddress(chain, block) {
         case 'hedera':
             multicallAddress = '0x18fa376d92511dd04090566ab6144847c03557d8';
             break;
+        case 'xrplevm':
+            multicallAddress = '0xaB3a12b26e72F4D6D9B579aCb5027a0918eF1114';
+            break;
+        case 'vechain':
+            multicallAddress = '0x8B2fF167683c5e1DFD6717d934B560F20cf9F2a3';
+            break;
     }
     return multicallAddress;
 }