@merkl/api 0.10.129 → 0.10.131

package/dist/src/utils/prices/priceFetcherFactory.js

@@ -0,0 +1,29 @@
+import { PriceSourceMethod } from "../../../database/api/.generated";
+import CoingeckoService from "./services/coinGeckoService";
+import DefillamaService from "./services/defillamaService";
+import DexScreenerService from "./services/dexScreenerService";
+import ERC4626Service from "./services/erc4626Service";
+import IndexCoop from "./services/indexCoopService";
+/**
+ * @description Factory pattern to get the correct price fetcher
+ */
+export default class PriceFetcherFactory {
+    static instance = new PriceFetcherFactory();
+    constructor() { }
+    get(type) {
+        switch (type) {
+            case PriceSourceMethod.COINGECKO:
+                return CoingeckoService.instance;
+            case PriceSourceMethod.DEFILLAMA:
+                return DefillamaService.instance;
+            case PriceSourceMethod.ERC4626:
+                return ERC4626Service.instance;
+            case PriceSourceMethod.DEXSCREENER:
+                return DexScreenerService.instance;
+            case PriceSourceMethod.INDEXCOOP:
+                return IndexCoop.instance;
+            default:
+                throw new Error(`Price reader service not found for ${type}`);
+        }
+    }
+}

package/dist/src/utils/prices/priceService.js

@@ -0,0 +1,328 @@
+import { PriceService as PriceSourceService } from "../../modules/v4/price";
+import { PriceSourceMethod } from "../../../database/api/.generated";
+import { BN2Number, ChainId, Stable, registry } from "@sdk";
+import axios from "axios";
+import { Contract } from "ethers";
+import { constantChain } from "../../constants";
+import { getTokensListWithCache } from "../../libs/getTokensList";
+import { log } from "../logger";
+import { providers } from "../providers";
+import { getChainlinkLatestPrice } from "./chainlinkRead";
+import { getVirtualPrice } from "./curveVirtualPrice";
+import { getDQUICKPrice } from "./getDQUICK";
+import PriceFetcherFactory from "./priceFetcherFactory";
+import { getERC4626Price } from "./services/getERC4626";
+import { getCurveV2Price, getUniV2Price } from "./uniV2Price";
+export default class PriceService {
+    static instance = new PriceService();
+    _prices = {};
+    constructor() { }
+    get prices() {
+        return this._prices;
+    }
+    setPrices = (res) => {
+        res.forEach(tokenPrice => {
+            this._prices[tokenPrice.token] = tokenPrice.rate;
+        });
+    };
+    async fetchPrices() {
+        const tokenPriceSources = await PriceSourceService.getManyPriceSources();
+        /**
+         * @description Factory pricer's call to get prices from different sources
+         */
+        try {
+            for (const method of Object.values(PriceSourceMethod)) {
+                if (method !== PriceSourceMethod.CONSTANT && method !== PriceSourceMethod.EQUAL_TO) {
+                    await PriceFetcherFactory.instance
+                        .get(PriceSourceMethod[method])
+                        .getPrice(tokenPriceSources)
+                        .then(this.setPrices);
+                }
+            }
+        }
+        catch (e) {
+            log.error("Error fetching prices", e);
+        }
+        /** San Token Prices */
+        this._prices["sanUSDC_EUR"] = 1.2120307 * this._prices["USDC"];
+        this._prices["sanDAI_EUR"] = 1.0926287 * this._prices["DAI"];
+        this._prices["sanFRAX_EUR"] = 1.077969 * this._prices["FRAX"];
+        this._prices["sanFEI_EUR"] = 1.02814 * this._prices["FEI"];
+        this._prices["sanWETH_EUR"] = 6.732341 * this._prices["ETH"];
+        const promises = [];
+        /** Sushiswap & UniV2 Prices */
+        promises.push(getUniV2Price(ChainId.MAINNET, this._prices[Stable.EUR], this._prices["ANGLE"], "0x1f4c763bde1d4832b3ea0640e66da00b98831355").then(sushiEURA_ANGLE => {
+            if (!!sushiEURA_ANGLE) {
+                this._prices["Sushi EURA-ANGLE LP"] = sushiEURA_ANGLE;
+            }
+        }));
+        promises.push(getUniV2Price(ChainId.MAINNET, this._prices["ANGLE"], this._prices["ETH"], "0xfb55af0ef0dcdec92bd3752e7a9237dfefb8acc0").then(sushiANGLE_ETH => {
+            if (!!sushiANGLE_ETH) {
+                this._prices["Sushi ANGLE-ETH LP"] = sushiANGLE_ETH;
+            }
+        }));
+        promises.push(getUniV2Price(ChainId.MAINNET, this._prices[Stable.EUR], this._prices["FEI"], "0xf89ce5ed65737da8440411544b0499c9fad323b2").then(uni_EURA_FEI => {
+            if (!!uni_EURA_FEI) {
+                this._prices["Uni-V2 EURA-FEI LP"] = uni_EURA_FEI;
+            }
+        }));
+        promises.push(getUniV2Price(ChainId.MAINNET, this._prices["stTAO"], this._prices["WETH"], "0xAe57eB8DD23C90769962d413A8802Ba68181aD0F").then(uni_stTAO_WETH => {
+            if (!!uni_stTAO_WETH) {
+                this._prices["0xAe57eB8DD23C90769962d413A8802Ba68181aD0F"] = uni_stTAO_WETH;
+            }
+        }));
+        promises.push(getUniV2Price(ChainId.BLAST, this._prices["WETH"], this._prices["YIELD"], "0x3Df8AAC90Eb2FeeA4378368D46a72AF47eBDc268").then(uni_WETH_YIELD => {
+            if (!!uni_WETH_YIELD) {
+                this._prices["0x3Df8AAC90Eb2FeeA4378368D46a72AF47eBDc268"] = uni_WETH_YIELD;
+            }
+        }));
+        promises.push((async () => {
+            try {
+                const d = await new Contract("0x3a29cab2e124919d14a6f735b6033a3aad2b260f", ["function discount() external view returns(uint256)"], providers[ChainId.POLYGON]).discount();
+                this._prices["oRETRO"] = this._prices["RETRO"] * (1 - Number.parseInt(d.toString()) / 100);
+            }
+            catch (e) {
+                log.error(`❌ error fetching oRetro discount:`, e);
+                this._prices["oRETRO"] = this._prices["RETRO"] * 0.6;
+            }
+        })());
+        this.setConstantPrices(tokenPriceSources);
+        this.setEqualsToPrices(tokenPriceSources);
+        /** Hardcoded prices  */
+        this._prices["oICL"] = 0.5 * this._prices["ICL"];
+        this._prices["$ERA"] = 0.001;
+        this._prices["Bridged mstETH"] = this._prices["mstETH"];
+        // Mock collats
+        this._prices["MockCollat0"] = this._prices["EUR"];
+        this._prices["MockCollat1"] = this._prices["EUR"];
+        this._prices["MockCollat2"] = this._prices["EUR"];
+        // USDA price
+        this._prices[Stable.USD] = 1;
+        this._prices["agUSD"] = 1;
+        // veANGLE price
+        this._prices["veANGLE"] = this._prices["ANGLE"];
+        // Hardcoded prices
+        this._prices["KAI"] = 0.015;
+        this._prices["USSD"] = 1;
+        this._prices["crvUSD"] = 1;
+        for (const id in ChainId) {
+            const chainId = Number(id);
+            const savingsAddressUSD = registry(chainId)?.USD?.Savings;
+            const savingsAddressEUR = registry(chainId)?.EUR?.Savings;
+            if (!!savingsAddressUSD) {
+                promises.push(getERC4626Price(chainId, savingsAddressUSD).then(sharePrice => {
+                    this._prices[`stUSD-${chainId}`] = sharePrice * this._prices[Stable.USD];
+                    this._prices[`STUSD-${chainId}`] = this._prices[`stUSD-${chainId}`];
+                }));
+            }
+            if (!!savingsAddressEUR) {
+                promises.push(getERC4626Price(chainId, savingsAddressEUR).then(sharePrice => {
+                    this._prices[`stEUR-${chainId}`] = sharePrice * this._prices[Stable.EUR];
+                    this._prices[`STEUR-${chainId}`] = this._prices[`stEUR-${chainId}`];
+                }));
+            }
+        }
+        promises.push(getERC4626Price(ChainId.MAINNET, "0xBEEF01735c132Ada46AA9aA4c54623cAA92A64CB", 6, 18).then(sharePrice => {
+            this._prices["steakUSDC"] = sharePrice * this._prices["USDC"];
+            this._prices["STEAKUSDC"] = this._prices["steakUSDC"];
+            this._prices["Steakhouse USDC"] = this._prices["steakUSDC"];
+        }));
+        promises.push(getERC4626Price(ChainId.BASE, "0xbEEfa1aBfEbE621DF50ceaEF9f54FdB73648c92C", 18, 18).then(sharePrice => {
+            this._prices["steakUSDA"] = sharePrice * this._prices["USDA"];
+            this._prices["STEAKUSDA"] = this._prices["steakUSDA"];
+            this._prices["Steakhouse USDA"] = this._prices["steakUSDA"];
+        }));
+        promises.push(getERC4626Price(ChainId.BASE, "0xBEeFA28D5e56d41D35df760AB53B94D9FfD7051F", 18, 18).then(sharePrice => {
+            this._prices["steakEURA"] = sharePrice * this._prices["EURA"];
+            this._prices["STEAKEURA"] = this._prices["steakEURA"];
+            this._prices["Steakhouse EURA"] = this._prices["steakEURA"];
+        }));
+        promises.push(getERC4626Price(ChainId.MAINNET, "0x125D41A6e5dbf455cD9Df8F80BCC6fd172D52Cc6", 18, 18).then(sharePrice => {
+            this._prices["gtUSDAcore"] = sharePrice;
+            this._prices["Gauntlet USDA Core"] = sharePrice;
+        }));
+        promises.push(getERC4626Price(ChainId.MAINNET, "0x89D80f5e9BC88d8021b352064ae73F0eAf79EBd8", 18, 18).then(sharePrice => {
+            this._prices["Re7USDA"] = sharePrice;
+            this._prices["Re7 USDA"] = sharePrice;
+        }));
+        promises.push(getDQUICKPrice(ChainId.POLYGON, "0x958d208Cdf087843e9AD98d23823d32E17d723A1").then(sharePrice => {
+            this._prices["dQUICK"] = sharePrice * this._prices["QUICK"];
+            this._prices["DQUICK"] = this._prices["dQUICK"];
+        }));
+        promises.push(getVirtualPrice(ChainId.MAINNET, "0xb9446c4Ef5EBE66268dA6700D26f96273DE3d571").then(virtualPrice => {
+            this._prices["Curve 3EUR LP"] = virtualPrice * this._prices[Stable.EUR];
+        }));
+        promises.push(getVirtualPrice(ChainId.MAINNET, "0xB37D6c07482Bc11cd28a1f11f1a6ad7b66Dec933").then(virtualPrice => {
+            this._prices["Curve EURA-ibEUR LP"] = virtualPrice * this._prices[Stable.EUR];
+        }));
+        promises.push(getVirtualPrice(ChainId.MAINNET, constantChain[ChainId.MAINNET].crvANGLESDANGLE).then(virtualPrice => {
+            this._prices["Curve sdANGLE-ANGLE LP"] = virtualPrice * this._prices["ANGLE"];
+        }));
+        promises.push(getVirtualPrice(ChainId.MAINNET, constantChain[ChainId.MAINNET].crvEuropool).then(virtualPrice => {
+            this._prices["Curve Europool LP"] = virtualPrice * this._prices[Stable.EUR];
+        }));
+        promises.push(getVirtualPrice(ChainId.MAINNET, constantChain[ChainId.MAINNET].crvEURAEUROC).then(virtualPrice => {
+            this._prices["Curve EURA-EUROC LP"] = virtualPrice * this._prices[Stable.EUR];
+        }));
+        promises.push(getVirtualPrice(ChainId.MAINNET, constantChain[ChainId.MAINNET].crvEURAEURe).then(virtualPrice => {
+            this._prices["Curve EURA-EURe LP"] = virtualPrice * this._prices[Stable.EUR];
+        }));
+        promises.push(getChainlinkLatestPrice(ChainId.MAINNET, "0x32d1463EB53b73C095625719Afa544D5426354cB").then(chainlinkPrice => {
+            this._prices["bIB01"] = chainlinkPrice;
+            this._prices["IB01"] = chainlinkPrice;
+        }));
+        promises.push(getChainlinkLatestPrice(ChainId.ARBITRUM, "0x1940fEd49cDBC397941f2D336eb4994D599e568B").then(chainlinkPrice => {
+            this._prices["zZRO"] = chainlinkPrice;
+        }));
+        promises.push(getChainlinkLatestPrice(ChainId.MAINNET, "0x9E8E794ad6Ecdb6d5c7eaBE059D30E907F58859b").then(chainlinkPrice => {
+            this._prices["bHIGH"] = chainlinkPrice * this._prices["EUR"];
+            this._prices["HIGH"] = chainlinkPrice * this._prices["EUR"];
+        }));
+        promises.push(getChainlinkLatestPrice(ChainId.MAINNET, "0x6E27A25999B3C665E44D903B2139F5a4Be2B6C26").then(chainlinkPrice => {
+            this._prices["bC3M"] = chainlinkPrice * this._prices["EUR"];
+            this._prices["C3M"] = chainlinkPrice * this._prices["EUR"];
+        }));
+        promises.push(getChainlinkLatestPrice(ChainId.MAINNET, "0x475855DAe09af1e3f2d380d766b9E630926ad3CE").then(chainlinkPrice => {
+            this._prices["bERNX"] = chainlinkPrice * this._prices["EUR"];
+            this._prices["ERNX"] = chainlinkPrice * this._prices["EUR"];
+        }));
+        promises.push(getChainlinkLatestPrice(ChainId.MAINNET, "0x2674Cc47786740432b895a70D92CFDfB1d5BF798").then(chainlinkPrice => {
+            this._prices["bERNA"] = chainlinkPrice;
+            this._prices["ERNA"] = chainlinkPrice;
+        }));
+        promises.push(getChainlinkLatestPrice(ChainId.ARBITRUM, "0x395D5c5D552Df670dc4B2B1cef0c4EABfFba492f").then(chainlinkPrice => {
+            this._prices["gmBTC"] = chainlinkPrice;
+        }));
+        promises.push(getChainlinkLatestPrice(ChainId.ARBITRUM, "0xfB3264D1129824933a52374c2C1696F4470D041e").then(chainlinkPrice => {
+            this._prices["gmETH"] = chainlinkPrice;
+        }));
+        promises.push(getCurveV2Price(ChainId.MAINNET, this._prices, "0x58257e4291F95165184b4beA7793a1d6F8e7b627", constantChain[ChainId.MAINNET].crvFRAXEURA).then(virtualPrice => {
+            this._prices["Curve EURA-FRAXBP LP"] = virtualPrice * this._prices[Stable.EUR];
+        }));
+        await Promise.allSettled(promises);
+        /** Camelot API price completion */
+        try {
+            await axios
+                .get("https://api.camelot.exchange/tokens")
+                .then(res => {
+                if (!!res.data.data.tokens) {
+                    for (const x of Object.values(res.data.data.tokens)) {
+                        if (this._prices[x.symbol] === undefined || this._prices[x.symbol] === null) {
+                            this._prices[x.symbol] = x.price;
+                        }
+                    }
+                }
+            });
+        }
+        catch (error) {
+            log.error("❌ call to fetch camelot api price failed", error);
+        }
+        /** Retro API price completion */
+        try {
+            await axios
+                .get("https://retro-backend.stabl.finance/api/v1/assets")
+                .then(res => {
+                if (res.data.success) {
+                    for (const x of res.data.data) {
+                        if (this._prices[x.symbol] === undefined || this._prices[x.symbol] === null) {
+                            this._prices[x.symbol] = x.price;
+                        }
+                    }
+                }
+            });
+        }
+        catch (error) {
+            log.error("❌ call to fetch retro api price failed", error);
+        }
+        /** Blueprint API price completion */
+        try {
+            await axios
+                .get("https://blue-backend.stabl.finance/api/v1/assets")
+                .then(res => {
+                if (res.data.success) {
+                    for (const x of res.data.data) {
+                        if (this._prices[x.symbol] === undefined || this._prices[x.symbol] === null) {
+                            this._prices[x.symbol] = x.price;
+                        }
+                    }
+                }
+            });
+        }
+        catch (error) {
+            log.error("❌ call to fetch blueprint api price failed", error);
+        }
+        promises.push((async () => {
+            try {
+                const d = await new Contract("0xEdb73D4ED90bE7A49D06d0D940055e6d181d22fa", ["function discount() external view returns(uint256)"], providers[ChainId.MAINNET]).discount();
+                this._prices["oBLUE"] = this._prices["BLUE"] * (1 - Number.parseInt(d.toString()) / 100);
+            }
+            catch (e) {
+                log.error("❌ error fetching oBLUE discount:", e);
+                this._prices["oBLUE"] = this._prices["BLUE"] * 0.6;
+            }
+        })());
+        this._prices["bveBLUE"] = this._prices["oBLUE"] * 0.85;
+        this._prices["BVEBLUE"] = this._prices["bveBLUE"];
+        /** Flux price completion */
+        promises.push((async () => {
+            try {
+                const d = await new Contract("0x465a5a630482f3abD6d3b84B39B29b07214d19e5", ["function exchangeRateStored() external view returns(uint256)"], providers[ChainId.MAINNET]).exchangeRateStored();
+                this._prices["fUSDC"] = this._prices["USDC"] * BN2Number(d) * 100;
+                this._prices["FUSDC"] = this._prices["fUSDC"];
+            }
+            catch (e) { }
+        })());
+        // Radiant prices
+        this._prices["rUSDCn"] = this._prices["USDC"];
+        for (const x of ["USDC", "USDT", "wstETH", "ARB", "wBTC", "DAI", "ETH"]) {
+            this._prices[`r${x}n`] = this._prices[x];
+            this._prices[`variableDebt${x}n`] = this._prices[x];
+            this._prices[`r${x}`] = this._prices[x];
+            this._prices[`variableDebt${x}`] = this._prices[x];
+            const xUpper = x.toUpperCase();
+            this._prices[`r${xUpper}n`] = this._prices[x];
+            this._prices[`variableDebt${xUpper}n`] = this._prices[x];
+            this._prices[`r${xUpper}`] = this._prices[x];
+            this._prices[`variableDebt${xUpper}`] = this._prices[x];
+        }
+        /** Fill all BorrowStaker prices */
+        const tokens = await getTokensListWithCache();
+        for (const chainIdString of Object.keys(tokens)) {
+            const chainId = Number.parseInt(chainIdString);
+            for (const token of Object.values(tokens?.[chainId] ?? {})) {
+                if (token.wrappingMethod === "BorrowStaker" && !!token.underlyingTokens) {
+                    this._prices[token.address] = this._prices[token.underlyingTokens[0]];
+                }
+            }
+        }
+        return this._prices;
+    }
+    setConstantPrices(tokens) {
+        const filteredTokens = tokens.filter(token => token.method === PriceSourceMethod.CONSTANT);
+        if (filteredTokens.length === 0)
+            return [];
+        return filteredTokens.forEach(token => {
+            const args = token.args;
+            if (args.value !== null && args.value !== undefined) {
+                this._prices[token.symbol] = args.value;
+            }
+            else
+                log.warn(`❌ constant price ${token.symbol} has incorrect value in database`);
+        });
+    }
+    setEqualsToPrices(tokens) {
+        const filteredTokens = tokens.filter(tokenPriceSource => tokenPriceSource.method === PriceSourceMethod.EQUAL_TO);
+        if (filteredTokens.length === 0)
+            return [];
+        return filteredTokens
+            .filter(token => token.method === PriceSourceMethod.EQUAL_TO)
+            .forEach(token => {
+            const args = token.args;
+            if (args.token !== null && args.token !== undefined) {
+                this._prices[token.symbol] = this._prices[args.token];
+            }
+            else
+                log.warn(`❌ equalsTo price ${token.symbol} has incorrect value in database`);
+        });
+    }
+}

package/dist/src/utils/prices/services/coinGeckoService.js

@@ -0,0 +1,53 @@
+import { PriceSourceMethod } from "../../../../database/api/.generated";
+import axios from "axios";
+import { log } from "../../logger";
+export default class CoingeckoService {
+    static instance = new CoingeckoService();
+    constructor() { }
+    baseUrl = "https://coins.llama.fi/prices/current/";
+    async getPrice(tickers) {
+        const filteredTokens = tickers.filter(tokenPriceSource => tokenPriceSource.method === PriceSourceMethod.COINGECKO);
+        if (filteredTokens.length === 0)
+            return [];
+        return await this.fetchprices(filteredTokens);
+    }
+    buildUrl(tokens) {
+        const tikerParams = tokens
+            .map(token => {
+            const args = token.args;
+            if (!args?.ticker)
+                return log.warn(`❌ CoingeckoService ticker not found for ${token.symbol}`);
+            return `coingecko:${args.ticker}`;
+        })
+            .join(",");
+        return this.baseUrl.concat(tikerParams);
+    }
+    async fetchprices(tickers) {
+        const url = this.buildUrl(tickers);
+        return axios
+            .get(url, { timeout: 10000 })
+            .then(res => this.formatResponse(res, tickers))
+            .catch(err => {
+            log.error("❌ CoingeckoService not responding", err);
+            throw "❌ CoingeckoService not responding";
+        });
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation> Need to be typed according to coinguekko answer type
+    formatResponse(data, tokens) {
+        return tokens
+            .map(token => {
+            const args = token.args;
+            if (!args?.ticker)
+                return;
+            if (!data.data.coins[`coingecko:${args.ticker}`]?.price) {
+                log.warn(`❌ CoinGecko data failed for ${token.symbol} with ticker ${args.ticker}`);
+                return;
+            }
+            return {
+                token: token.symbol,
+                rate: data.data.coins[`coingecko:${args.ticker}`].price ?? -1,
+            };
+        })
+            .filter(item => item !== undefined);
+    }
+}

package/dist/src/utils/prices/services/defillamaService.js

@@ -0,0 +1,53 @@
+import { PriceSourceMethod } from "../../../../database/api/.generated";
+import axios from "axios";
+import { log } from "../../logger";
+export default class DefillamaService {
+    static instance = new DefillamaService();
+    constructor() { }
+    baseUrl = "https://coins.llama.fi/prices/current/";
+    async getPrice(sources) {
+        const filteredTokens = sources.filter(tokenPriceSource => tokenPriceSource.method === PriceSourceMethod.DEFILLAMA);
+        if (filteredTokens.length === 0)
+            return [];
+        return await this.fetchprices(filteredTokens);
+    }
+    buildUrl(tokens) {
+        const tikerParams = tokens
+            .map(token => {
+            const args = token.args;
+            if (!args?.address || !args?.chain)
+                return log.warn(`❌ DefillamaService address not found for ${token.symbol}`);
+            return `${args?.chain}:${args.address}`;
+        })
+            .join(",");
+        return this.baseUrl.concat(tikerParams);
+    }
+    async fetchprices(sources) {
+        const url = this.buildUrl(sources);
+        return axios
+            .get(url, { timeout: 10000 })
+            .then(res => this.formatResponse(res, sources))
+            .catch(err => {
+            log.error("❌ DefillamaService not responding", err);
+            throw "❌ DefillamaService not responding";
+        });
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: <explanation> Need to be typed according to coinguekko answer type
+    formatResponse(data, tokens) {
+        return tokens
+            .map(token => {
+            const args = token.args;
+            if (!args?.address || !args?.chain)
+                return;
+            if (!data.data.coins[`${args?.chain}:${args.address}`]?.price) {
+                log.warn(`❌ DefillamaService data failed for ${token.symbol} with address ${args.address}`);
+                return;
+            }
+            return {
+                token: token.symbol,
+                rate: data.data.coins[`${args?.chain}:${args.address}`].price ?? -1,
+            };
+        })
+            .filter(item => item !== undefined);
+    }
+}

package/dist/src/utils/prices/services/dexScreenerService.js

@@ -0,0 +1,62 @@
+import { PriceSourceMethod } from "../../../../database/api/.generated";
+import axios from "axios";
+import { log } from "../../logger";
+export default class DexScreenerService {
+    static instance = new DexScreenerService();
+    baseUrl = "https://api.dexscreener.com/latest/dex/pairs/";
+    constructor() { }
+    async getPrice(tokens) {
+        const filteredTokens = tokens.filter(tokenPriceSource => tokenPriceSource.method === PriceSourceMethod.DEXSCREENER);
+        if (filteredTokens.length === 0)
+            return [];
+        const tokensByChain = this.getTokenByChain(filteredTokens); // supports only one chain at a time
+        if (tokensByChain === undefined)
+            return [];
+        return this.fetchPrices(tokensByChain);
+    }
+    getTokenByChain(tokens) {
+        const tokensByChain = {};
+        for (const token of tokens) {
+            const args = token.args;
+            if (args?.chain && args?.pair) {
+                const chain = args.chain.toLowerCase();
+                const pair = args.pair;
+                // Initialize array if it doesn't exist for the chain
+                if (!tokensByChain[chain])
+                    tokensByChain[chain] = [];
+                tokensByChain[chain].push(pair);
+            }
+            else
+                log.warn(`⚠️ DexScrenner Invalid token args: ${JSON.stringify(token.args)}`);
+        }
+        return tokensByChain;
+    }
+    /** @description Create a list by chain dexscreener only supports one chain at a time */
+    async fetchPrices(tokensByChain) {
+        // let tickerCallResult: AxiosResponse;
+        const res = [];
+        const fetchPromises = Object.entries(tokensByChain).map(async ([chain, pairs]) => {
+            const url = `${this.baseUrl}${chain.toLowerCase()}/${pairs.join(",")}`;
+            try {
+                const { data } = await axios.get(url, {
+                    timeout: 10000,
+                });
+                if (!data.pairs) {
+                    log.warn(`⚠️ DexScrenner No pairs found in the response for chain ${chain}`);
+                    return [];
+                }
+                return data.pairs.map((pair) => ({
+                    rate: Number.parseFloat(pair.priceUsd),
+                    token: pair.baseToken.symbol,
+                }));
+            }
+            catch (error) {
+                log.error(`❌ DexScreener error fetching prices for chain ${chain}:`, error);
+                return [];
+            }
+        });
+        const results = await Promise.all(fetchPromises);
+        results.forEach(result => res.push(...result));
+        return res;
+    }
+}

package/dist/src/utils/prices/services/erc4626Service.js

@@ -0,0 +1,30 @@
+import { PriceSourceMethod } from "../../../../database/api/.generated";
+import { log } from "../../logger";
+import PriceService from "../priceService";
+import { getERC4626Price } from "./getERC4626";
+export default class ERC4626Service {
+    static instance = new ERC4626Service();
+    constructor() { }
+    async getPrice(tokens) {
+        const pricePromises = tokens
+            .filter(tokenPriceSource => tokenPriceSource.method === PriceSourceMethod.ERC4626)
+            .map(async (token) => {
+            const args = token.args;
+            if (!args?.chainId || !args.address || !args.vaultToken)
+                return log.warn(`❌ ERC4626Service ticker not found for ${token.symbol}`);
+            const rate = await getERC4626Price(args.chainId, args.address, args.decimals, args.vaultDecimals);
+            // 2 returned tokens as stUSD and STUSD (business requirement)
+            const price = this.priceCalculation(rate, args.vaultToken);
+            const res = [
+                { token: token.symbol, rate: price },
+                { token: token.symbol.toUpperCase(), rate: price },
+            ];
+            return res;
+        });
+        const resolvedPrices = await Promise.all(pricePromises);
+        return resolvedPrices.flat().filter(price => price !== undefined);
+    }
+    priceCalculation(rate, vaultToken) {
+        return rate * PriceService.instance.prices[vaultToken];
+    }
+}

package/dist/src/utils/prices/services/getERC4626.js

@@ -0,0 +1,11 @@
+import { BN2Number } from "@sdk";
+import { Contract, utils } from "ethers";
+import { log } from "../../logger";
+import { providers } from "../../providers";
+export async function getERC4626Price(chainId, contractAddress, assetDecimals = 18, vaultDecimals = 18) {
+    const contract = new Contract(contractAddress, ["function convertToAssets(uint256) external view returns(uint256)"], providers[chainId]);
+    const assetAmount = await contract.convertToAssets(utils.parseUnits("1", vaultDecimals));
+    if (!assetAmount || Number.isNaN(assetAmount))
+        log.error("❌ ERC4626Service convertToAssets failed for address:", contractAddress);
+    return BN2Number(assetAmount, assetDecimals);
+}

package/dist/src/utils/prices/services/indexCoopService.js

@@ -0,0 +1,55 @@
+import { PriceSourceMethod } from "../../../../database/api/.generated";
+import axios from "axios";
+import { log } from "../../logger";
+export default class IndexCoop {
+    static instance = new IndexCoop();
+    baseUrl = "https://api.indexcoop.com/";
+    constructor() { }
+    async getPrice(tokens) {
+        const filteredTokens = tokens.filter(tokenPriceSource => tokenPriceSource.method === PriceSourceMethod.INDEXCOOP);
+        if (filteredTokens.length === 0)
+            return [];
+        const tokensByChain = this.getTokenByChain(filteredTokens);
+        if (tokensByChain === undefined)
+            return [];
+        return this.fetchPrice(tokensByChain);
+    }
+    getTokenByChain(tokens) {
+        const tokensByChain = {};
+        for (const token of tokens) {
+            // Ensure `args` has the expected structure
+            const args = token.args;
+            if (args?.chainId !== undefined) {
+                // Initialize array if it doesn't exist for the chain
+                if (!tokensByChain[args.chainId])
+                    tokensByChain[args.chainId] = [];
+                tokensByChain[args.chainId].push(token.symbol);
+            }
+            else
+                log.warn(`⚠️ IndexCoop invalid token args: ${JSON.stringify(token.args)}`);
+        }
+        return tokensByChain;
+    }
+    async fetchPrice(tokensByChain) {
+        const res = [];
+        const fetchPromises = Object.entries(tokensByChain).flatMap(([chain, pairs]) => pairs.map(async (symbol) => {
+            const indexCoopUrl = this.buildUrl(chain, symbol);
+            try {
+                const { data } = await axios.get(indexCoopUrl, {
+                    timeout: 10000,
+                });
+                res.push({ rate: Number.parseFloat(data.nav), token: symbol });
+            }
+            catch (e) {
+                log.error(`❌ IndexCoop not responding for chain ${chain}`, e);
+            }
+        }));
+        await Promise.all(fetchPromises);
+        return res;
+    }
+    buildUrl(chainId, symbol) {
+        return chainId !== "0"
+            ? `${this.baseUrl}${chainId}/${symbol.toLowerCase()}/nav`
+            : `${this.baseUrl}${symbol.toLowerCase()}/nav`;
+    }
+}

package/dist/src/utils/prices/services/priceFetcher.js

@@ -0,0 +1 @@
+export {};