@defillama/sdk 5.0.10 → 5.0.12

package/build/Balances.d.ts

@@ -30,5 +30,15 @@ export declare class Balances {
         usdTokenBalances: BalancesV1;
         rawTokenBalances: BalancesV1;
     }>;
+    static getUSDValue(balances: BalancesV1, timestamp?: number): Promise<number>;
+    static getBalanceObjects(balances: BalancesV1, timestamp?: number): Promise<{
+        usdTvl: number;
+        usdTokenBalances: BalancesV1;
+    }>;
+    static getUSDJSONs(balances: BalancesV1, timestamp?: number): Promise<{
+        usdTvl: number;
+        usdTokenBalances: BalancesV1;
+        rawTokenBalances: BalancesV1;
+    }>;
 }
 export default Balances;

package/build/Balances.js

@@ -1,60 +1,23 @@
 "use strict";
-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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Balances = void 0;
-var generalUtil_1 = require("./generalUtil");
-var computeTVL_1 = __importDefault(require("./util/computeTVL"));
-var nullAddress = '0x0000000000000000000000000000000000000000';
-var Balances = /** @class */ (function () {
-    function Balances(params) {
+const generalUtil_1 = require("./generalUtil");
+const computeTVL_1 = __importDefault(require("./util/computeTVL"));
+const nullAddress = '0x0000000000000000000000000000000000000000';
+class Balances {
+    constructor(params) {
         var _a;
         this.chain = (_a = params.chain) !== null && _a !== void 0 ? _a : 'ethereum';
         this.timestamp = params.timestamp;
         this._balances = {};
     }
-    Balances.prototype._add = function (token, balance, _a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b.skipChain, skipChain = _c === void 0 ? false : _c;
+    _add(token, balance, { skipChain = false } = {}) {
         token = token.replace(/\//g, ':');
-        var isIBCToken = token.startsWith('ibc:');
-        var chain = this.chain;
+        const isIBCToken = token.startsWith('ibc:');
+        let chain = this.chain;
         if (skipChain || isIBCToken) {
             chain = undefined;
         }
@@ -63,48 +26,42 @@ var Balances = /** @class */ (function () {
             token = token.replace('peggy', '');
         }
         (0, generalUtil_1.sumSingleBalance)(this._balances, token, balance, chain);
-    };
-    Balances.prototype.add = function (token, balance, _a) {
-        var _this = this;
-        var _b = _a === void 0 ? {} : _a, _c = _b.skipChain, skipChain = _c === void 0 ? false : _c;
+    }
+    add(token, balance, { skipChain = false } = {}) {
         if (!token)
             throw new Error('token is required');
         if (!balance)
             return;
         if (Array.isArray(balance)) {
             if (Array.isArray(token)) {
-                this.addTokens(token, balance, { skipChain: skipChain });
+                this.addTokens(token, balance, { skipChain });
                 return;
             }
             else if (typeof token === 'string') {
-                balance.forEach(function (v) { return _this._add(token, v, { skipChain: skipChain }); });
+                balance.forEach((v) => this._add(token, v, { skipChain }));
                 return;
             }
         }
         if (typeof token !== 'string')
             throw new Error('token must be a string');
-        this._add(token, balance, { skipChain: skipChain });
-    };
-    Balances.prototype.addToken = function (token, balance, _a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b.skipChain, skipChain = _c === void 0 ? false : _c;
-        this._add(token, balance, { skipChain: skipChain });
-    };
-    Balances.prototype.addGasToken = function (balance) {
+        this._add(token, balance, { skipChain });
+    }
+    addToken(token, balance, { skipChain = false } = {}) {
+        this._add(token, balance, { skipChain });
+    }
+    addGasToken(balance) {
         this._add(nullAddress, balance);
-    };
-    Balances.prototype.addTokens = function (tokens, balances, _a) {
-        var _this = this;
-        var _b = _a === void 0 ? {} : _a, _c = _b.skipChain, skipChain = _c === void 0 ? false : _c;
+    }
+    addTokens(tokens, balances, { skipChain = false } = {}) {
         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(function (v, i) { return _this._add(v, balances[i], { skipChain: skipChain }); });
-    };
-    Balances.prototype.addBalances = function (balances) {
-        var _this = this;
+        tokens.forEach((v, i) => this._add(v, balances[i], { skipChain }));
+    }
+    addBalances(balances) {
         if (balances instanceof Balances) {
             if (balances === this)
                 return;
@@ -112,49 +69,36 @@ var Balances = /** @class */ (function () {
         }
         if (balances === this._balances)
             return;
-        Object.entries(balances).forEach(function (_a) {
-            var token = _a[0], balance = _a[1];
-            return _this._add(token, balance, { skipChain: true });
-        });
-    };
-    Balances.prototype.getBalances = function () {
+        Object.entries(balances).forEach(([token, balance]) => this._add(token, balance, { skipChain: true }));
+    }
+    getBalances() {
         return this._balances;
-    };
-    Balances.prototype.removeTokenBalance = function (token) {
-        var _this = this;
-        var regex = new RegExp(token, 'i');
-        Object.keys(this._balances).forEach(function (i) {
+    }
+    removeTokenBalance(token) {
+        const regex = new RegExp(token, 'i');
+        Object.keys(this._balances).forEach((i) => {
             if (regex.test(i))
-                delete _this._balances[i];
-        });
-    };
-    Balances.prototype.getUSDValue = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var usdTvl;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, (0, computeTVL_1.default)(this.getBalances(), this.timestamp)];
-                    case 1:
-                        usdTvl = (_a.sent()).usdTvl;
-                        return [2 /*return*/, usdTvl];
-                }
-            });
+                delete this._balances[i];
         });
-    };
-    Balances.prototype.getUSDJSONs = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, usdTvl, usdTokenBalances;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, (0, computeTVL_1.default)(this.getBalances(), this.timestamp)];
-                    case 1:
-                        _a = _b.sent(), usdTvl = _a.usdTvl, usdTokenBalances = _a.usdTokenBalances;
-                        return [2 /*return*/, { usdTvl: usdTvl, usdTokenBalances: usdTokenBalances, rawTokenBalances: this.getBalances() }];
-                }
-            });
-        });
-    };
-    return Balances;
-}());
+    }
+    async getUSDValue() {
+        const { usdTvl } = await (0, computeTVL_1.default)(this.getBalances(), this.timestamp);
+        return usdTvl;
+    }
+    async getUSDJSONs() {
+        const { usdTvl, usdTokenBalances } = await (0, computeTVL_1.default)(this.getBalances(), this.timestamp);
+        return { usdTvl, usdTokenBalances, rawTokenBalances: this.getBalances() };
+    }
+    static async getUSDValue(balances, timestamp) {
+        return (await (0, computeTVL_1.default)(balances, timestamp)).usdTvl;
+    }
+    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 };
+    }
+}
 exports.Balances = Balances;
 exports.default = Balances;

package/build/ChainApi.d.ts

@@ -64,5 +64,6 @@ export declare class ChainApi {
         rawTokenBalances: BalancesV1;
     }>;
     getLogs(params: GetLogsOptions): Promise<any[] | import("ethers").EventLog[] | import("ethers").EventLog[][]>;
+    getBalancesV2(): Balances;
 }
 export default ChainApi;