impermax-sdk 1.0.1 → 1.0.2

package/lib/esm/subgraph/PoolToken.js

@@ -0,0 +1,462 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const types_1 = require("../config/types");
+const eth_1 = require("../config/eth");
+const imxes_1 = require("../config/contracts/imxes");
+const weths_1 = require("../config/contracts/weths");
+class PoolToken {
+    constructor(lendingPool, poolTokenType) {
+        this.lendingPool = lendingPool;
+        this.poolTokenType = poolTokenType;
+    }
+    // Subgraph calls
+    getPoolTokenData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPoolData = yield this.lendingPool.getLendingPoolData();
+            return lendingPoolData[this.poolTokenType];
+        });
+    }
+    // Helpers
+    getPoolTokenParam(param) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const poolTokenData = yield this.getPoolTokenData();
+            return poolTokenData[param];
+        });
+    }
+    getPoolTokenParamFloat(param) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return parseFloat(yield this.getPoolTokenParam(param));
+        });
+    }
+    getUnderlyingParam(param) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const poolTokenData = yield this.getPoolTokenData();
+            return poolTokenData.underlying[param];
+        });
+    }
+    // Name
+    getName() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.poolTokenType == types_1.PoolTokenType.Collateral) {
+                const nameA = yield this.lendingPool.poolTokens[types_1.PoolTokenType.BorrowableA].getName();
+                const nameB = yield this.lendingPool.poolTokens[types_1.PoolTokenType.BorrowableB].getName();
+                return nameA + '-' + nameB + ' LP';
+            }
+            const underlying = yield this.getUnderlyingAddress();
+            if (underlying.toLowerCase() === weths_1.WETH[this.lendingPool.subgraph.network].toLowerCase())
+                return eth_1.ETH_NAME[this.lendingPool.subgraph.network];
+            if (underlying.toLowerCase() === "0xa3fa99a148fa48d14ed51d610c367c61876997f1")
+                return "MIMATIC";
+            if (underlying.toLowerCase() === "0x2e9a6df78e42a30712c10a9dc4b1c8656f8f2879")
+                return "Maker";
+            return this.getUnderlyingParam("name");
+        });
+    }
+    // Symbol
+    getSymbol() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.poolTokenType == types_1.PoolTokenType.Collateral) {
+                const symbolA = yield this.lendingPool.poolTokens[types_1.PoolTokenType.BorrowableA].getSymbol();
+                const symbolB = yield this.lendingPool.poolTokens[types_1.PoolTokenType.BorrowableB].getSymbol();
+                return symbolA + '-' + symbolB;
+            }
+            const underlying = yield this.getUnderlyingAddress();
+            if (underlying.toLowerCase() === weths_1.WETH[this.lendingPool.subgraph.network].toLowerCase())
+                return eth_1.ETH_SYMBOL[this.lendingPool.subgraph.network];
+            if (underlying.toLowerCase() === "0xa3fa99a148fa48d14ed51d610c367c61876997f1")
+                return "MAI";
+            if (underlying.toLowerCase() === "0x2e9a6df78e42a30712c10a9dc4b1c8656f8f2879")
+                return "MKR";
+            if (underlying.toLowerCase() === "0xc165d941481e68696f43ee6e99bfb2b23e0e3114")
+                return "OXDv1";
+            if (underlying.toLowerCase() === "0xc5a9848b9d145965d821aaec8fa32aaee026492d")
+                return "OXDv2";
+            if (underlying.toLowerCase() === "0x6ae7dfc73e0dde2aa99ac063dcf7e8a63265108c")
+                return "JPYCv1";
+            if (underlying.toLowerCase() === "0x431d5dff03120afa4bdf332c61a6e1766ef37bdb")
+                return "JPYCv2";
+            return this.getUnderlyingParam("symbol");
+        });
+    }
+    // Decimals
+    getDecimals() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.poolTokenType == types_1.PoolTokenType.Collateral)
+                return 18;
+            return parseInt(yield this.getUnderlyingParam("decimals"));
+        });
+    }
+    // ExchangeRate
+    getExchangeRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getPoolTokenParamFloat("exchangeRate");
+        });
+    }
+    // Underlying Address
+    getUnderlyingAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.poolTokenType == types_1.PoolTokenType.Collateral)
+                return this.lendingPool.pairAddress;
+            return this.getUnderlyingParam("id");
+        });
+    }
+    // Total balance
+    getTotalBalance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getPoolTokenParamFloat("totalBalance");
+        });
+    }
+    getTotalBalanceUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const totalBalance = yield this.getTotalBalance();
+            const tokenPrice = yield this.getTokenPriceFast();
+            return totalBalance * tokenPrice;
+        });
+    }
+    // Reserve Factor
+    getReserveFactor() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getPoolTokenParamFloat("reserveFactor");
+        });
+    }
+    // Kink Borrow Rate
+    getKinkBorrowRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getPoolTokenParamFloat("kinkBorrowRate");
+        });
+    }
+    // Kink Utilization Rate
+    getKinkUtilizationRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getPoolTokenParamFloat("kinkUtilizationRate");
+        });
+    }
+    // Borrow Index
+    getBorrowIndex() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getPoolTokenParamFloat("borrowIndex");
+        });
+    }
+    // Accrue Timestamp
+    getAccrualTimestamp() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getPoolTokenParamFloat("accrualTimestamp");
+        });
+    }
+    // Total borrows
+    getTotalBorrows() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getPoolTokenParamFloat("totalBorrows");
+        });
+    }
+    getCurrentTotalBorrows() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const storedAmount = yield this.getTotalBorrows();
+            const accrualTimestamp = yield this.getAccrualTimestamp();
+            const borrowRate = yield this.getBorrowRate();
+            return storedAmount * (1 + (Date.now() / 1000 - accrualTimestamp) * borrowRate);
+        });
+    }
+    getTotalBorrowsUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const totalBorrows = yield this.getCurrentTotalBorrows();
+            const tokenPrice = yield this.getTokenPriceFast();
+            return totalBorrows * tokenPrice;
+        });
+    }
+    // Borrow rate
+    getBorrowRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getPoolTokenParamFloat("borrowRate");
+        });
+    }
+    getBorrowAPR() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const borrowRate = yield this.getBorrowRate();
+            return (0, utils_1.toAPR)(borrowRate);
+        });
+    }
+    getNextBorrowRate(borrowAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const totalBorrows = yield this.getTotalBorrows();
+            const supply = yield this.getSupply();
+            const UR = (borrowAmount + totalBorrows) / supply;
+            const kinkBR = yield this.getKinkBorrowRate();
+            const kinkUR = yield this.getKinkUtilizationRate();
+            if (UR < kinkUR)
+                return UR / kinkUR * kinkBR;
+            const kinkMultiplier = this.lendingPool.getKinkMultiplier();
+            return ((UR - kinkUR) / (1 - kinkUR) * (kinkMultiplier - 1) + 1) * kinkBR;
+        });
+    }
+    getNextBorrowAPR(borrowAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const borrowRate = yield this.getNextBorrowRate(borrowAmount);
+            return (0, utils_1.toAPR)(borrowRate);
+        });
+    }
+    // Supply
+    getSupply() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const totalBalance = yield this.getTotalBalance();
+            const totalBorrows = yield this.getTotalBorrows();
+            return totalBalance + totalBorrows;
+        });
+    }
+    getCurrentSupply() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const storedAmount = yield this.getSupply();
+            const accrualTimestamp = yield this.getAccrualTimestamp();
+            const supplyRate = yield this.getSupplyRate();
+            return storedAmount * (1 + (Date.now() / 1000 - accrualTimestamp) * supplyRate);
+        });
+    }
+    getSupplyUSD() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const supply = yield this.getCurrentSupply();
+            const tokenPrice = yield this.getTokenPriceFast();
+            return supply * tokenPrice;
+        });
+    }
+    // Utilization Rate
+    getUtilizationRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const supply = yield this.getSupply();
+            if (supply == 0)
+                return 0;
+            const totalBalance = yield this.getTotalBorrows();
+            return totalBalance / supply;
+        });
+    }
+    // Supply Rate
+    getSupplyRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const borrowRate = yield this.getBorrowRate();
+            const utilizationRate = yield this.getUtilizationRate();
+            const reserveFactor = yield this.getReserveFactor();
+            return borrowRate * utilizationRate * (1 - reserveFactor);
+        });
+    }
+    getSupplyAPR() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const supplyRate = yield this.getSupplyRate();
+            return (0, utils_1.toAPR)(supplyRate);
+        });
+    }
+    getNextSupplyRate(supplyAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const totalBorrows = yield this.getTotalBorrows();
+            const supply = yield this.getSupply();
+            const UR = totalBorrows / (supply + supplyAmount);
+            const kinkBR = yield this.getKinkBorrowRate();
+            const kinkUR = yield this.getKinkUtilizationRate();
+            const reserveFactor = yield this.getReserveFactor();
+            if (UR < kinkUR)
+                return UR / kinkUR * kinkBR * UR * (1 - reserveFactor);
+            const kinkMultiplier = this.lendingPool.getKinkMultiplier();
+            return ((UR - kinkUR) / (1 - kinkUR) * (kinkMultiplier - 1) + 1) * kinkBR * UR * (1 - reserveFactor);
+        });
+    }
+    getNextSupplyAPR(supplyAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const supplyRate = yield this.getNextSupplyRate(supplyAmount);
+            return (0, utils_1.toAPR)(supplyRate);
+        });
+    }
+    // Reward Speed
+    getFarmingRewardsRate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const poolTokenData = yield this.getPoolTokenData();
+            const rewards = poolTokenData.rewards;
+            if (rewards && rewards.length > 0)
+                return rewards;
+            const FINISH_DELAY = 3600 * 24;
+            const farmingPoolData = poolTokenData.farmingPool;
+            if (farmingPoolData === null)
+                return [];
+            const segmentLength = parseInt(farmingPoolData.segmentLength);
+            const epochAmount = parseFloat(farmingPoolData.epochAmount);
+            const epochBegin = parseInt(farmingPoolData.epochBegin);
+            const epochEnd = epochBegin + segmentLength;
+            const timestamp = (new Date()).getTime() / 1000;
+            if (timestamp - FINISH_DELAY > epochEnd) {
+                // How to manage better this case? Maybe check shares on distributor
+                return [];
+            }
+            return [{
+                    rewardToken: imxes_1.IMX[this.lendingPool.subgraph.network],
+                    rewardRate: epochAmount / segmentLength
+                }];
+        });
+    }
+    // Farming
+    getFarmingRewards() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getNextFarmingRewards(0);
+        });
+    }
+    getNextFarmingRewards(borrowAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const farmingRewards = yield this.getFarmingRewardsRate();
+            const currentBorrowedUSD = yield this.getTotalBorrowsUSD();
+            const tokenPrice = yield this.getTokenPriceFast();
+            const additionalBorrowsUSD = borrowAmount * tokenPrice;
+            const totalBorrowedUSD = currentBorrowedUSD + additionalBorrowsUSD;
+            if (totalBorrowedUSD === 0)
+                return [];
+            const rewards = [];
+            for (const reward of farmingRewards) {
+                const rewardPrice = yield this.lendingPool.subgraph.priceHelper.getDebankTokenPrice(reward.rewardToken);
+                rewards.push({
+                    APR: (0, utils_1.toAPR)((rewardPrice * reward.rewardRate) / totalBorrowedUSD),
+                    symbol: reward.rewardToken == "0x98878b06940ae243284ca214f92bb71a2b032b8a" ? "WMOVR" :
+                        reward.rewardToken == "0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270" ? "WMATIC" :
+                            "IMX",
+                });
+            }
+            return rewards;
+        });
+    }
+    getFarmingAPR() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getNextFarmingAPR(0);
+        });
+    }
+    getNextFarmingAPR(borrowAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rewards = yield this.getNextFarmingRewards(borrowAmount);
+            let APR = 0;
+            for (const reward of rewards) {
+                APR += reward.APR;
+            }
+            return APR;
+        });
+    }
+    // Past Data
+    getPoolTokenDataPast24h() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPoolDataPast = yield this.lendingPool.getLendingPoolDataPast24h();
+            if (!lendingPoolDataPast)
+                return undefined;
+            return lendingPoolDataPast[this.poolTokenType];
+        });
+    }
+    getPoolTokenDataPast7d() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPoolDataPast = yield this.lendingPool.getLendingPoolDataPast7d();
+            if (!lendingPoolDataPast)
+                return undefined;
+            return lendingPoolDataPast[this.poolTokenType];
+        });
+    }
+    // Average Borrow APR
+    getAverageBorrowAPR(poolTokenDataPast, fallback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (poolTokenDataPast) {
+                const accrualTimestampPast = parseFloat(poolTokenDataPast.accrualTimestamp);
+                const borrowIndexPast = parseFloat(poolTokenDataPast.borrowIndex);
+                const accrualTimestampNow = yield this.getAccrualTimestamp();
+                const borrowIndexNow = yield this.getBorrowIndex();
+                if (accrualTimestampNow > accrualTimestampPast) {
+                    const borrowRate = (borrowIndexNow / borrowIndexPast - 1) / (accrualTimestampNow - accrualTimestampPast);
+                    return borrowRate * 3600 * 24 * 365;
+                }
+            }
+            return fallback;
+        });
+    }
+    getAverage24hBorrowAPR() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const poolTokenDataPast = yield this.getPoolTokenDataPast24h();
+            return this.getAverageBorrowAPR(poolTokenDataPast, this.getBorrowAPR());
+        });
+    }
+    getAverage7dBorrowAPR() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const poolTokenDataPast = yield this.getPoolTokenDataPast7d();
+            return this.getAverageBorrowAPR(poolTokenDataPast, this.getAverage24hBorrowAPR());
+        });
+    }
+    // Average Supply APR
+    getAverageSupplyAPR(poolTokenDataPast, fallback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (poolTokenDataPast) {
+                const accrualTimestampPast = parseFloat(poolTokenDataPast.accrualTimestamp);
+                const exchangeRatePast = parseFloat(poolTokenDataPast.exchangeRate);
+                const accrualTimestampNow = yield this.getAccrualTimestamp();
+                const exchangeRateNow = yield this.getExchangeRate();
+                if (accrualTimestampNow > accrualTimestampPast) {
+                    const supplyRate = (exchangeRateNow / exchangeRatePast - 1) / (accrualTimestampNow - accrualTimestampPast);
+                    return supplyRate * 3600 * 24 * 365;
+                }
+            }
+            return fallback;
+        });
+    }
+    getAverage24hSupplyAPR() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const poolTokenDataPast = yield this.getPoolTokenDataPast24h();
+            return this.getAverageSupplyAPR(poolTokenDataPast, this.getSupplyAPR());
+        });
+    }
+    getAverage7dSupplyAPR() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const poolTokenDataPast = yield this.getPoolTokenDataPast7d();
+            return this.getAverageSupplyAPR(poolTokenDataPast, this.getAverage24hSupplyAPR());
+        });
+    }
+    // Calculate collateral price -> returns the price of the collateral, not necessarily of the underlying LP
+    calculateCollateralPrice(reserve0, reserve1, totalSupply, price0, price1) {
+        if (totalSupply === 0) {
+            console.error("Warning: totalSupply is 0");
+            return 0;
+        }
+        const reserve0USD = reserve0 * price0;
+        const reserve1USD = reserve1 * price1;
+        // adjust reserves taking the latest price passed as parameters
+        const adjustedReserveUSD = Math.sqrt(reserve0USD * reserve1USD) * 2;
+        return adjustedReserveUSD / totalSupply;
+    }
+    // Token price getters
+    getTokenPriceFast(fallback = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let tokenPrice = 0;
+            if (this.poolTokenType != types_1.PoolTokenType.Collateral) {
+                //const poolTokenData = await this.getPoolTokenData() as BorrowableData;
+                //tokenPrice = parseFloat(poolTokenData.underlying.derivedUSD);
+                let tokenAddress = yield this.getUnderlyingAddress();
+                let tokenPrices = yield this.lendingPool.subgraph.priceHelper.getSubgraphTokenPrice();
+                tokenPrice = tokenPrices[tokenAddress];
+            }
+            else {
+                tokenPrice = yield this.lendingPool.getCollateralPrice(false);
+            }
+            if (tokenPrice > 0)
+                return tokenPrice;
+            if (fallback) {
+                return this.getTokenPriceAccurate();
+            }
+            return 0;
+        });
+    }
+    getTokenPriceAccurate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.poolTokenType === types_1.PoolTokenType.Collateral) {
+                return this.lendingPool.getCollateralPrice(false);
+            }
+            let tokenAddress = yield this.getUnderlyingAddress();
+            return this.lendingPool.subgraph.priceHelper.getDebankTokenPrice(tokenAddress);
+        });
+    }
+}
+exports.default = PoolToken;

package/lib/esm/subgraph/PriceHelper.d.ts

@@ -0,0 +1,21 @@
+import Subgraph from "./index";
+import { Address } from '../config/types';
+export default class PriceHelper {
+    subgraph: Subgraph;
+    subgraphTokenPrice: Promise<{
+        [key in Address]?: number;
+    }>;
+    debankTokenPrice: {
+        [key in Address]?: Promise<number>;
+    };
+    constructor(subgraph: Subgraph);
+    cleanCache(): void;
+    private initializeSubgraphTokenPrice;
+    getSubgraphTokenPrice(): Promise<{
+        [key in Address]: number;
+    }>;
+    private getCoingeckoTokenPrice;
+    private initializeDebankTokenPrice;
+    getDebankTokenPrice(tokenAddress: Address): Promise<number>;
+    getImxPrice(): Promise<number>;
+}

package/lib/esm/subgraph/PriceHelper.js

@@ -0,0 +1,166 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const debank_ids_1 = require("../config/debank-ids");
+const imxes_1 = require("../config/contracts/imxes");
+// coingecko has priority over debank for initialized tokens
+const coingecko_ids = {
+    // Arbitrum
+    "0xb348b87b23d5977e2948e6f36ca07e1ec94d7328": "swapfish",
+    "0x2f2a2543b76a4166549f7aab2e75bef0aefc5b0f": "wrapped-bitcoin",
+};
+class PriceHelper {
+    constructor(subgraph) {
+        this.subgraph = subgraph;
+        this.debankTokenPrice = {};
+    }
+    cleanCache() {
+        this.subgraphTokenPrice = null;
+        this.debankTokenPrice = {};
+    }
+    // First source of token price: Subgraph (less accurate, faster)
+    initializeSubgraphTokenPrice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPoolsData = yield this.subgraph.getLendingPoolsData();
+            const subgraphTokenPrice = {};
+            for (const factory of Object.keys(lendingPoolsData)) {
+                for (const id of Object.keys(lendingPoolsData[factory])) {
+                    const lendingPool = lendingPoolsData[factory][id];
+                    subgraphTokenPrice[lendingPool.borrowable0.underlying.id] = parseFloat(lendingPool.borrowable0.underlying.derivedUSD);
+                    subgraphTokenPrice[lendingPool.borrowable1.underlying.id] = parseFloat(lendingPool.borrowable1.underlying.derivedUSD);
+                    for (const reward of lendingPool.pair.rewards) {
+                        subgraphTokenPrice[reward.rewardsToken.id] = parseFloat(reward.rewardsToken.derivedUSD);
+                    }
+                }
+            }
+            //fix for IMX
+            subgraphTokenPrice["0x9c67ee39e3c4954396b9142010653f17257dd39c"] = 0;
+            subgraphTokenPrice["0x7b35ce522cb72e4077baeb96cb923a5529764a00"] = 0;
+            subgraphTokenPrice["0xea6887e4a9cda1b77e70129e5fba830cdb5cddef"] = 0;
+            subgraphTokenPrice["0x60bb3d364b765c497c8ce50ae0ae3f0882c5bd05"] = 0;
+            subgraphTokenPrice["0x900f1ec5819fa087d368877cd03b265bf1802667"] = 0;
+            subgraphTokenPrice["0xea38f1ccf77bf43f352636241b05dd8f6f5f52b2"] = 0;
+            return subgraphTokenPrice;
+        });
+    }
+    getSubgraphTokenPrice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.subgraphTokenPrice)
+                this.subgraphTokenPrice = this.initializeSubgraphTokenPrice();
+            return this.subgraphTokenPrice;
+        });
+    }
+    // Second source of token price: Debank (more accurate, slower)
+    getCoingeckoTokenPrice(tokenAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const tokenId = coingecko_ids[tokenAddress];
+                const response = yield fetch("https://api.coingecko.com/api/v3/simple/price?ids=" + tokenId + "&vs_currencies=usd");
+                if (response.status != 200)
+                    return 0;
+                const data = yield response.json();
+                if (!data)
+                    return 0;
+                return data[tokenId].usd ? data[tokenId].usd : 0;
+            }
+            catch (_a) {
+                return 0;
+            }
+        });
+    }
+    initializeDebankTokenPrice(tokenAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (Object.keys(coingecko_ids).includes(tokenAddress.toLowerCase())) {
+                const result = this.getCoingeckoTokenPrice(tokenAddress.toLowerCase());
+                if (result)
+                    return result;
+            }
+            try {
+                const response = yield fetch("https://openapi.debank.com/v1/token?chain_id=" + debank_ids_1.DEBANK_IDS[this.subgraph.network] + "&id=" + tokenAddress);
+                /*const response = await fetch(
+                  "https://pro-openapi.debank.com/v1/token?chain_id=" + debank_chain_ids[this.subgraph.network] + "&id=" + tokenAddress,
+                  {headers: {"AccessKey": "0ac0fba6aeb0905b4c9a1c5cfd9d48d74fbc60e0"}}
+                );*/
+                if (response.status != 200)
+                    return 0;
+                const data = yield response.json();
+                if (!data)
+                    return 0;
+                return data.price ? data.price : 0;
+            }
+            catch (_a) {
+                return 0;
+            }
+        });
+    }
+    getDebankTokenPrice(tokenAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (tokenAddress.toLowerCase() === '0xb348b87b23d5977e2948e6f36ca07e1ec94d7328') { // fix for FISH
+                //return 0.07;
+            }
+            if (tokenAddress.toLowerCase() === '0xf28164a485b0b2c90639e47b0f377b4a438a16b1') { // fix for dQuick
+                return (yield this.getDebankTokenPrice('0x831753dd7087cac61ab5644b308642cc1c33dc13')) * 1.68;
+            }
+            if (tokenAddress.toLowerCase() === '0x63468133ed352e602beb61dd254d6060ad2fe419') { // fix for sTHO
+                return (yield this.getDebankTokenPrice('0xae4aa155d2987b454c29450ef4f862cf00907b61')) * 1.1;
+            }
+            if (tokenAddress.toLowerCase() === '0xfcef8a994209d6916eb2c86cdd2afd60aa6f54b1') { // fix for fBEETS
+                return (yield this.getDebankTokenPrice('0xf24bcf4d1e507740041c9cfd2dddb29585adce1e')) * 0.93;
+            }
+            if (tokenAddress.toLowerCase() === '0x5979d7b546e38e414f7e9822514be443a4800529') { // TEMPORARY fix for WSTETH
+                return (yield this.getDebankTokenPrice('0x82af49447d8a07e3bd95bd0d56f35241523fbab1')) / 0.92;
+            }
+            if (tokenAddress.toLowerCase() === '0x3f56e0c36d275367b8c502090edf38289b3dea0d') { // TEMPORARY fix for MAI
+                return 1;
+            }
+            if ([
+                "0x9c67ee39e3c4954396b9142010653f17257dd39c",
+                "0x7b35ce522cb72e4077baeb96cb923a5529764a00",
+                "0xea6887e4a9cda1b77e70129e5fba830cdb5cddef",
+                "0x60bb3d364b765c497c8ce50ae0ae3f0882c5bd05",
+                "0x900f1ec5819fa087d368877cd03b265bf1802667",
+                "0xea38f1ccf77bf43f352636241b05dd8f6f5f52b2",
+            ].includes(tokenAddress.toLowerCase())) { // fix for IMX
+                return 0;
+            }
+            if (tokenAddress.toLowerCase() === '0xda0053f0befcbcac208a3f867bb243716734d809') { // TEMPORARY fix for oxSOLID
+                return (yield this.getDebankTokenPrice('0x888ef71766ca594ded1f0fa3ae64ed2941740a20')) * 0.88;
+            }
+            if (tokenAddress.toLowerCase() === '0x431d5dff03120afa4bdf332c61a6e1766ef37bdb') { // TEMPORARY fix for JPYCv2
+                return (yield this.getDebankTokenPrice('0x6ae7dfc73e0dde2aa99ac063dcf7e8a63265108c'));
+            }
+            if (!this.debankTokenPrice[tokenAddress])
+                this.debankTokenPrice[tokenAddress] = this.initializeDebankTokenPrice(tokenAddress);
+            const tokenPrice = yield this.debankTokenPrice[tokenAddress];
+            if (tokenPrice === 0) {
+                // try fallback on subgraph
+                const subgraphTokenPrice = yield this.getSubgraphTokenPrice();
+                return subgraphTokenPrice[tokenAddress] ? subgraphTokenPrice[tokenAddress] : 0;
+            }
+            return tokenPrice;
+        });
+    }
+    getImxPrice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const imx = imxes_1.IMX[this.subgraph.network];
+            if (!imx)
+                return 0;
+            const imxPrice = yield this.getDebankTokenPrice(imx);
+            if (imxPrice != 0)
+                return imxPrice;
+            const subgraphTokenPrice = yield this.getSubgraphTokenPrice();
+            if (subgraphTokenPrice[imx])
+                return subgraphTokenPrice[imx];
+            return 0;
+        });
+    }
+}
+exports.default = PriceHelper;

package/lib/esm/subgraph/SolidexHelper.d.ts

@@ -0,0 +1,16 @@
+import Subgraph from "./index";
+import { Address } from "../config/types";
+export type SolidexLPDetails = {
+    [key in Address]: Array<{
+        APR: number;
+        symbol: string;
+    }>;
+};
+export default class SolidexHelper {
+    subgraph: Subgraph;
+    solidexLPDetails: Promise<SolidexLPDetails>;
+    constructor(subgraph: Subgraph);
+    cleanCache(): void;
+    private initializeSolidexLPDetails;
+    getSolidexLPDetails(): Promise<SolidexLPDetails>;
+}