impermax-sdk 1.2.69 → 1.2.71

package/lib/offchain/offchainAPRHelper.js

@@ -12,44 +12,56 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("../config/types");
 // Map of OUR chains to the chain names used by llama in their `poolsOld`
 const LlamaChains = {
-    [types_1.Networks.Ropsten]: 'ropsten',
-    [types_1.Networks.Mainnet]: 'ethereum',
-    [types_1.Networks.Polygon]: 'polygon',
-    [types_1.Networks.Arbitrum]: 'arbitrum',
-    [types_1.Networks.Avalanche]: 'avalanche',
-    [types_1.Networks.Moonriver]: 'moonriver',
-    [types_1.Networks.Aurora]: 'aurora',
-    [types_1.Networks.Cronos]: 'cronos',
-    [types_1.Networks.Fantom]: 'fantom',
-    [types_1.Networks.Harmony]: 'harmony',
-    [types_1.Networks.Moonbeam]: 'moonbeam',
-    [types_1.Networks.Sxnetwork]: 'sxnetwork',
-    [types_1.Networks.Canto]: 'canto',
-    [types_1.Networks.ZksyncEra]: 'zksync era',
-    [types_1.Networks.Base]: 'base',
-    [types_1.Networks.Mantle]: 'mantle',
-    [types_1.Networks.Scroll]: 'scroll',
-    [types_1.Networks.Optimism]: 'optimism'
+    [types_1.Networks.Ropsten]: "ropsten",
+    [types_1.Networks.Mainnet]: "ethereum",
+    [types_1.Networks.Polygon]: "polygon",
+    [types_1.Networks.Arbitrum]: "arbitrum",
+    [types_1.Networks.Avalanche]: "avalanche",
+    [types_1.Networks.Moonriver]: "moonriver",
+    [types_1.Networks.Aurora]: "aurora",
+    [types_1.Networks.Cronos]: "cronos",
+    [types_1.Networks.Fantom]: "fantom",
+    [types_1.Networks.Harmony]: "harmony",
+    [types_1.Networks.Moonbeam]: "moonbeam",
+    [types_1.Networks.Sxnetwork]: "sxnetwork",
+    [types_1.Networks.Canto]: "canto",
+    [types_1.Networks.ZksyncEra]: "zksync era",
+    [types_1.Networks.Base]: "base",
+    [types_1.Networks.Mantle]: "mantle",
+    [types_1.Networks.Scroll]: "scroll",
+    [types_1.Networks.Optimism]: "optimism",
 };
 // Class to get the APR from DefiLlama directly, only makes 1 call to api and caches all pools
 class OffchainAPRHelper {
     constructor(offchain) {
         this.llamaAllPools = {};
         this.initialized = null;
+        this.chainTvls = {};
+        this.tvlInitialized = null;
         this.offchain = offchain;
     }
     cleanCache() {
         this.llamaAllPools = {};
         this.initialized = null;
+        this.chainTvls = {};
+        this.tvlInitialized = null;
+    }
+    // Blacklist certain projects which might report same pool as dex (aggregators, etc.)
+    isBlacklisted(project) {
+        // Names from llama's response.project
+        const blacklistedProjects = new Set(["extra-finance", "beefy"]);
+        return blacklistedProjects.has(project);
     }
     // Initializes all llama pools
-    initializeLlamaAllPools() {
+    initializeYields() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const response = yield fetch('https://yields.llama.fi/poolsOld').then(i => i.json());
+                const response = yield fetch("https://yields.llama.fi/poolsOld").then((i) => i.json());
                 const pools = response.data;
-                // `i.pool_old` is the pool address with sometimes `-{chain}` separator if contracts exists on diff chains
-                this.llamaAllPools = pools.reduce((acc, i) => {
+                const filteredPools = pools.filter((i) => !this.isBlacklisted(i.project));
+                // i.pool_old is the pool address with sometimes -{chain} separator if
+                // contracts exists on diff chains
+                this.llamaAllPools = filteredPools.reduce((acc, i) => {
                     const pool = i.pool_old.split("-")[0];
                     const llamaChain = i.chain;
                     const llamaId = pool.toLowerCase() + "-" + llamaChain.toLowerCase();
@@ -58,27 +70,55 @@ class OffchainAPRHelper {
                 }, {});
             }
             catch (err) {
-                console.warn("The llamas are down?");
+                console.warn("The llamas pools down?");
                 this.llamaAllPools = {};
             }
         });
     }
-    getLlamaPools() {
+    // Initializes all our chain tvl and borrows from llama
+    initializeTvls() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield fetch("https://api.llama.fi/protocol/impermax-finance").then((i) => i.json());
+                const currentChainTvls = response.currentChainTvls;
+                this.chainTvls = Object.entries(currentChainTvls).reduce((acc, [key, tvl]) => {
+                    // Llama capitalizes these for some reason
+                    acc[key.toLowerCase()] = tvl;
+                    return acc;
+                }, {});
+            }
+            catch (err) {
+                console.warn("The llamas TVL down?");
+                this.chainTvls = {};
+            }
+        });
+    }
+    getLlamaYields() {
         return __awaiter(this, void 0, void 0, function* () {
             // First call initializes
             if (!this.initialized)
-                this.initialized = this.initializeLlamaAllPools();
+                this.initialized = this.initializeYields();
             // async mutex to only call llama api once
             yield this.initialized;
             return this.llamaAllPools;
         });
     }
-    // Given a DefiLlama ID get the latest APR
+    getLlamaTvls() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // First call initializes
+            if (!this.tvlInitialized)
+                this.tvlInitialized = this.initializeTvls();
+            // async mutex to only call llama api once
+            yield this.tvlInitialized;
+            return this.chainTvls;
+        });
+    }
+    // ---------------- Getters ---------------- //
     getLlamaAPR(pool, chain) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             // Get or initialize the pools
-            const llamaAllPools = yield this.getLlamaPools();
+            const llamaAllPools = yield this.getLlamaYields();
             // Map to llama chain names, if not supported, then fetch native way
             const llamaChain = LlamaChains[chain];
             if (!llamaChain)
@@ -91,5 +131,36 @@ class OffchainAPRHelper {
             return apy || 0;
         });
     }
+    getLlamaTvlAndBorrows(chain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get or initialize the tvl for all chains
+            const llamaTvls = yield this.getLlamaTvls();
+            const llamaChain = LlamaChains[chain];
+            if (!llamaChain)
+                return { tvl: 0, borrowed: 0 };
+            const tvl = llamaTvls[llamaChain];
+            const borrowed = llamaTvls[llamaChain.concat("-borrowed")];
+            return { tvl, borrowed };
+        });
+    }
+    // Overall Cross-chain stats
+    getImpermaxBorrows() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const llamaTvls = yield this.getLlamaTvls();
+            return llamaTvls.borrowed;
+        });
+    }
+    getImpermaxTvl() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const llamaTvls = yield this.getLlamaTvls();
+            let crossChainTvl = 0;
+            // LLama key is `{chain}` or `{chain}-borrowed`, need to manually add the tvl
+            for (const [chain, tvl] of Object.entries(llamaTvls)) {
+                if (!chain.includes("borrowed"))
+                    crossChainTvl += tvl;
+            }
+            return crossChainTvl;
+        });
+    }
 }
 exports.default = OffchainAPRHelper;

package/lib/offchain/offchainPriceHelper.js

@@ -42,6 +42,7 @@ const coingecko_ids = {
     "0xa25b25548b4c98b0c7d3d27dca5d5ca743d68b7f": "wrapped-rseth",
     "0x80137510979822322193fc997d400d5a6c747bf7": "stakestone-ether",
     "0x2b6a85cd35d15691357eea61d88cb3f401a92fc3": "surveyor-dao",
+    "0x7dbd14115baf4240aab8c4ef31bf71f76c708420": "uk-real-estate",
     // base
     "0x940181a94a35a4569e4529a3cdfb74e38fd98631": "aerodrome-finance",
     "0x4ed4E862860beD51a9570b96d89aF5E1B0Efefed": "degen-base",
@@ -50,6 +51,8 @@ const coingecko_ids = {
     "0xa3d1a8deb97b111454b294e2324efad13a9d8396": "overnight-finance",
     "0x4154550f4db74dc38d1fe98e1f3f28ed6dad627d": "jarvis-synthetic-euro",
     "0xa61beb4a3d02decb01039e378237032b351125b4": "eura",
+    "0x7002458b1df59eccb57387bc79ffc7c29e22e6f7": "origin-protocol",
+    "0xdbfefd2e8460a6ee4955a68582f85708baea60a3": "super-oeth",
     // optimism
     "0x9560e827af36c94d2ac33a39bce1fe78631088db": "velodrome-finance",
     "0x4200000000000000000000000000000000000042": "optimism",

package/lib/offchain/poolToken.d.ts

@@ -0,0 +1,20 @@
+import { Address } from '../config/types';
+import { PoolTokenData } from './types';
+import Offchain from './index';
+export default abstract class PoolToken {
+    abstract getOffchain(): Offchain;
+    abstract getPoolTokenData(): Promise<PoolTokenData>;
+    protected getPoolTokenParam(param: string): Promise<string>;
+    protected getPoolTokenParamFloat(param: string): Promise<number>;
+    protected getUnderlyingParam(param: string): Promise<string>;
+    getName(): Promise<string>;
+    getSymbol(): Promise<string>;
+    getDecimals(): Promise<number>;
+    getExchangeRate(): Promise<number>;
+    getUnderlyingAddress(): Promise<Address>;
+    getTotalBalance(): Promise<number>;
+    getTotalBalanceUSD(): Promise<number>;
+    calculateCollateralPrice(reserve0: number, reserve1: number, totalSupply: number, price0: number, price1: number): number;
+    getTokenPriceFast(fallback?: boolean): Promise<number>;
+    abstract getTokenPriceAccurate(): Promise<number>;
+}

package/lib/offchain/poolToken.js

@@ -0,0 +1,120 @@
+"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 eth_1 = require("../config/eth");
+const weths_1 = require("../config/contracts/weths");
+class PoolToken {
+    // 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* () {
+            const underlying = yield this.getUnderlyingAddress();
+            if (underlying.toLowerCase() === weths_1.WETH[this.getOffchain().network].toLowerCase())
+                return eth_1.ETH_NAME[this.getOffchain().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* () {
+            const underlying = yield this.getUnderlyingAddress();
+            if (underlying.toLowerCase() === weths_1.WETH[this.getOffchain().network].toLowerCase())
+                return eth_1.ETH_SYMBOL[this.getOffchain().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* () {
+            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* () {
+            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;
+        });
+    }
+    // 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* () {
+            if (fallback) {
+                return this.getTokenPriceAccurate();
+            }
+            return 0;
+        });
+    }
+}
+exports.default = PoolToken;

package/lib/offchain/priceHelper.d.ts

@@ -0,0 +1,21 @@
+import Offchain from "./index";
+import { Address } from '../config/types';
+export default class PriceHelper {
+    offchain: Offchain;
+    subgraphTokensPrice: Promise<{
+        [key in Address]?: number;
+    }> | null;
+    debankTokensPrice: {
+        [key in Address]?: Promise<number>;
+    };
+    constructor(offchain: Offchain);
+    cleanCache(): void;
+    private addPriceIfMissing;
+    private initializeSubgraphTokenPrice;
+    getSubgraphTokensPrice(): Promise<{
+        [key in Address]: number | undefined;
+    }>;
+    private getCoingeckoTokenPrice;
+    private initializeDebankTokenPrice;
+    getDebankTokenPrice(tokenAddress: Address): Promise<number>;
+}

package/lib/offchain/priceHelper.js

@@ -0,0 +1,195 @@
+"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");
+// coingecko has priority over debank for initialized tokens
+const coingecko_ids = {
+    // Arbitrum
+    "0xb348b87b23d5977e2948e6f36ca07e1ec94d7328": "swapfish",
+    "0x2f2a2543b76a4166549f7aab2e75bef0aefc5b0f": "wrapped-bitcoin",
+    "0x463913d3a3d3d291667d53b8325c598eb88d3b0e": "solidlizard",
+    "0xaaa6c1e32c55a7bfa8066a6fae9b42650f262418": "ramses-exchange",
+    "0xd5954c3084a1ccd70b4da011e67760b8e78aee84": "arbitrum-exchange",
+    "0xff191514a9baba76bfd19e3943a4d37e8ec9a111": "auragi",
+    "0x15b2fb8f08e4ac1ce019eadae02ee92aedf06851": "chronos-finance",
+    "0xaae0c3856e665ff9b3e2872b6d75939d810b7e40": "yieldfarming-index",
+    "0xe80772eaf6e2e18b651f160bc9158b2a5cafca65": "usd",
+    // Avalanche
+    "0x3712871408a829c5cd4e86da1f4ce727efcd28f6": "glacier",
+    // ZkSync
+    "0x503234f203fc7eb888eec8513210612a43cf6115": "liquity-usd",
+    "0x85d84c774cf8e9ff85342684b0e795df72a24908": "velocore",
+    "0x5756a28e2aae01f600fc2c01358395f5c1f8ad3a": "vesync",
+};
+class PriceHelper {
+    constructor(offchain) {
+        this.offchain = offchain;
+        this.debankTokensPrice = {};
+    }
+    cleanCache() {
+        this.subgraphTokensPrice = null;
+        this.debankTokensPrice = {};
+    }
+    // First source of token price: Offchain (less accurate, faster)
+    addPriceIfMissing(offchainTokenPrice, token) {
+        if (offchainTokenPrice[token.id])
+            return;
+        offchainTokenPrice[token.id] = parseFloat(token.derivedUSD);
+    }
+    initializeSubgraphTokenPrice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lendingPoolsData = yield this.offchain.getLendingPoolsData();
+            const offchainTokenPrice = {};
+            for (const factory in lendingPoolsData) {
+                for (const id in lendingPoolsData[factory]) {
+                    const lendingPool = lendingPoolsData[factory][id];
+                    this.addPriceIfMissing(offchainTokenPrice, lendingPool.borrowable0.underlying);
+                    this.addPriceIfMissing(offchainTokenPrice, lendingPool.borrowable1.underlying);
+                    for (const reward of lendingPool.pair.rewards) {
+                        this.addPriceIfMissing(offchainTokenPrice, reward.rewardsToken);
+                    }
+                }
+            }
+            //fix for IMX
+            offchainTokenPrice["0x9c67ee39e3c4954396b9142010653f17257dd39c"] = 0;
+            offchainTokenPrice["0x7b35ce522cb72e4077baeb96cb923a5529764a00"] = 0;
+            offchainTokenPrice["0xea6887e4a9cda1b77e70129e5fba830cdb5cddef"] = 0;
+            offchainTokenPrice["0x60bb3d364b765c497c8ce50ae0ae3f0882c5bd05"] = 0;
+            offchainTokenPrice["0x900f1ec5819fa087d368877cd03b265bf1802667"] = 0;
+            offchainTokenPrice["0xea38f1ccf77bf43f352636241b05dd8f6f5f52b2"] = 0;
+            return offchainTokenPrice;
+        });
+    }
+    getSubgraphTokensPrice() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.subgraphTokensPrice)
+                this.subgraphTokensPrice = this.initializeSubgraphTokenPrice();
+            return this.subgraphTokensPrice;
+        });
+    }
+    // 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 = yield 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.offchain.network] + "&id=" + tokenAddress);
+                /*const response = await fetch(
+                  "https://pro-openapi.debank.com/v1/token?chain_id=" + debank_chain_ids[this.offchain.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() === '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 (tokenAddress.toLowerCase() === '0xc71aaf8e486e3f33841bb56ca3fd2ac3fa8d29a8') { // TEMPORARY fix for WSTETH Canto
+                return (yield this.getDebankTokenPrice('0x5fd55a1b9fc24967c4db09c513c3ba0dfa7ff687')) * 1.12;
+            }
+            if (tokenAddress.toLowerCase() === '0x152b9d0fdc40c096757f570a51e494bd4b943e50') { // TEMPORARY fix for BTC.b AVAX
+                return (yield this.getDebankTokenPrice('0x50b7545627a5162f82a992c33b87adc75187b218'));
+            }
+            if (tokenAddress.toLowerCase() === '0x9fc3104f6fc188fee65c85bbc4b94a48282ae76d') { // TEMPORARY fix for SATIN
+                return 0;
+            }
+            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.debankTokensPrice[tokenAddress])
+                this.debankTokensPrice[tokenAddress] = this.initializeDebankTokenPrice(tokenAddress);
+            const tokenPrice = yield this.debankTokensPrice[tokenAddress];
+            if (tokenPrice === 0) {
+                //manual fallback
+                if (tokenAddress.toLowerCase() === '0xaaa6c1e32c55a7bfa8066a6fae9b42650f262418') { // fix for RAM
+                    return 0.02;
+                }
+                if (tokenAddress.toLowerCase() === '0xd5954c3084a1ccd70b4da011e67760b8e78aee84') { // fix for ARX
+                    return 0.5;
+                }
+                if (tokenAddress.toLowerCase() === '0xe80772eaf6e2e18b651f160bc9158b2a5cafca65') { // fix for USD+
+                    return 1;
+                }
+                if (tokenAddress.toLowerCase() === '0x3712871408a829c5cd4e86da1f4ce727efcd28f6') { // fix for GLCR
+                    return 0.011;
+                }
+                if (tokenAddress.toLowerCase() === '0x5756a28e2aae01f600fc2c01358395f5c1f8ad3a') { // fix for VS
+                    return 0.05;
+                }
+                if (tokenAddress.toLowerCase() === '0x1c28edf9e0d66f3124f141a3cf3ef1217f7019c4') { // fix for SLNA
+                    return 0.00045;
+                }
+                // try fallback on offchain
+                const subgraphTokensPrice = yield this.getSubgraphTokensPrice();
+                const subgraphTokenPrice = subgraphTokensPrice[tokenAddress];
+                return subgraphTokenPrice ? subgraphTokenPrice : 0;
+            }
+            return tokenPrice;
+        });
+    }
+}
+exports.default = PriceHelper;