@merkl/api 0.21.47 → 1.0.0

package/dist/src/cache/index.js

@@ -1,161 +0,0 @@
-import { InvalidCacheCall } from "@/utils/error";
-import { log } from "@/utils/logger";
-import { withRetry, withTimeout } from "@sdk";
-import NodeCache from "node-cache";
-import { CacheDeclaration } from "./declaration";
-import { REDIS_CRON_WRITE_TIMEOUT, REDIS_READ_TIMEOUT, REDIS_RETRIES, redisClient } from "./redis";
-export class Cache {
-    static decoder = new TextDecoder();
-    static encoder = new TextEncoder();
-    localCache = new NodeCache();
-    /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-                                                         UTILS
-    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
-    static baseKey(key) {
-        return key.split("_")[0];
-    }
-    /** @notice Uncompress (if enabled), parsed and typed data from the cache */
-    static uncompress(key, value) {
-        const { compressed } = CacheDeclaration[Cache.baseKey(key)];
-        if (!compressed)
-            return JSON.parse(value);
-        if (!value)
-            return {};
-        const encoded = Buffer.from(value, "base64");
-        const uncompressed = Bun.gunzipSync(encoded);
-        const decoded = Cache.decoder.decode(uncompressed);
-        return JSON.parse(decoded);
-    }
-    /** @notice Compress (if enabled), stringify and encoded data to be stored in the cache */
-    static compress(key, value) {
-        const { compressed } = CacheDeclaration[Cache.baseKey(key)];
-        if (!compressed)
-            return JSON.stringify(value);
-        const encoded = Cache.encoder.encode(JSON.stringify(value));
-        const compressedValue = Bun.gzipSync(encoded);
-        return Buffer.from(compressedValue).toString("base64");
-    }
-    /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-                                                      REDIS CACHE
-    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
-    async getRaw(key) {
-        if (!key || key === "")
-            throw new InvalidCacheCall("Trying to access cache with no key");
-        return await withRetry(withTimeout, [redisClient.get(key), REDIS_READ_TIMEOUT], REDIS_RETRIES);
-    }
-    async getManyRaw(keys) {
-        if (keys?.length === 0)
-            throw new InvalidCacheCall("Trying to access cache with no keys");
-        const strippedKeys = Array.from(keys.map(a => a.split("_")[0]).reduce((unique, key) => unique.add(key), new Set()));
-        const multipleCached = await withRetry(withTimeout, [redisClient.mGet(keys), REDIS_READ_TIMEOUT], REDIS_RETRIES);
-        log.local(`Redis: ${keys.length} data fetched with mGet`);
-        return multipleCached;
-    }
-    async setRaw(key, value) {
-        const { redisTTL } = CacheDeclaration[Cache.baseKey(key)];
-        await redisClient.set(key, value, { EX: redisTTL });
-    }
-    /** @notice Set value for a given key for both local and raw cache */
-    async set(key, value) {
-        this.setLocally(key, value);
-        this.setRaw(key, Cache.compress(key, value));
-    }
-    /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-                                                      LOCAL CACHE
-    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
-    /**
-     * @deprecated Local cache is not used anymore
-     */
-    isLocallyCached(_key) {
-        return false;
-        // return this.localCache.has(key);
-    }
-    /**
-     * @deprecated Local cache is not used anymore
-     */
-    setLocally(_key, _value) {
-        return true;
-        // const { localCacheTtl } = CacheDeclaration[Cache.baseKey<T, Key>(key)] as { localCacheTtl?: number };
-        // return this.localCache.set(key, value, localCacheTtl ?? DEFAULT_LOCAL_TTL);
-    }
-    /**
-     * @deprecated Local cache is not used anymore
-     */
-    getLocally(_key) {
-        return undefined;
-        // return this.localCache.get(key);
-    }
-    /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-                                                   PUBLIC OPERATIONS
-    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
-    /**
-     * @returns the uncompressed (if enabled), parsed and typed data from the cache
-     */
-    async get(key, args) {
-        const actualKey = (args ? `${key}_${args}` : key);
-        if (this.isLocallyCached(actualKey))
-            return this.getLocally(actualKey);
-        const rawCache = await this.getRaw(actualKey);
-        if (rawCache === null)
-            return null;
-        const value = Cache.uncompress(actualKey, rawCache);
-        this.setLocally(actualKey, value);
-        return value;
-    }
-    /**
-     * Get many data from cache
-     * @param key cache key
-     * @returns the uncompressed (if enabled), parsed and typed data from the cache for all keys
-     */
-    async findMany(keys) {
-        const nonLocalKeys = keys.filter(key => !this.isLocallyCached(key)); // Keys not stored locally
-        const cached = !!nonLocalKeys.length ? await this.getManyRaw(nonLocalKeys) : [];
-        const res = keys.map(key => {
-            if (!nonLocalKeys.includes(key))
-                return this.localCache.get(key);
-            const cachedValue = cached[nonLocalKeys.indexOf(key)];
-            if (cachedValue !== null) {
-                const value = Cache.uncompress(key, cachedValue);
-                this.setLocally(key, value);
-                return value;
-            }
-            return null;
-        });
-        return res;
-    }
-    /**
-     * Get many data from cache with argument
-     * @param key cache key
-     * @param args arguments to append to cache keys
-     * @returns the uncompressed (if enabled), parsed and typed data from the cache for all keys
-     */
-    async getManyWithArgs(key, args) {
-        const actualKeys = args.map(arg => `${key}_${arg}`);
-        return this.findMany(actualKeys);
-    }
-    /**
-     * Get data from cache or set it using the callback
-     * @param key cache key
-     * @returns the uncompressed (if enabled), parsed and typed data from the cache
-     */
-    async getOrSet(key, callback, ...args) {
-        if (this.isLocallyCached(key))
-            return this.localCache.get(key);
-        let value;
-        const cachedValue = await this.getRaw(key);
-        if (cachedValue !== null) {
-            value = Cache.uncompress(key, cachedValue);
-        }
-        else {
-            value = await callback(...args);
-            await this.setRaw(key, Cache.compress(key, value));
-        }
-        this.setLocally(key, value);
-        return value;
-    }
-    /** @notice Set with retrials */
-    async safeSet(key, value) {
-        return await withRetry(withTimeout, [this.set(key, value), REDIS_CRON_WRITE_TIMEOUT], REDIS_RETRIES);
-    }
-}
-export const Redis = new Cache();

package/dist/src/cache/redis.js

@@ -1,57 +0,0 @@
-import { log } from "@/utils/logger";
-import { createClient, } from "redis";
-const REDISHOST = process.env.REDISHOST || "redis";
-const REDISPORT = !!process.env.REDISPORT ? Number(process.env.REDISPORT) : 6379;
-const REDISPASSWORD = process.env.REDISPASSWORD || "";
-export const REDIS_RETRIES = 0;
-export const REDIS_READ_TIMEOUT = !!process.env.REDIS_READ_TIMEOUT
-    ? Number.parseInt(process.env.REDIS_READ_TIMEOUT)
-    : Bun.env.NODE_ENV === "production"
-        ? 4_000
-        : 10 * 2_000;
-export const REDIS_WRITE_TIMEOUT = 4000;
-export const REDIS_CRON_READ_TIMEOUT = 5000;
-export const REDIS_CRON_WRITE_TIMEOUT = 10000;
-export var TTLType;
-(function (TTLType) {
-    TTLType[TTLType["HalfBlock"] = 4] = "HalfBlock";
-    TTLType[TTLType["Block"] = 11] = "Block";
-    TTLType[TTLType["Seconds30"] = 30] = "Seconds30";
-    TTLType[TTLType["Minutes2"] = 120] = "Minutes2";
-    TTLType[TTLType["Minutes3"] = 180] = "Minutes3";
-    TTLType[TTLType["Minutes5"] = 300] = "Minutes5";
-    TTLType[TTLType["Minutes10"] = 600] = "Minutes10";
-    TTLType[TTLType["Minutes25"] = 1500] = "Minutes25";
-    TTLType[TTLType["Minutes30"] = 1800] = "Minutes30";
-    TTLType[TTLType["Minutes35"] = 2100] = "Minutes35";
-    TTLType[TTLType["Hours3"] = 10800] = "Hours3";
-    TTLType[TTLType["Hours12"] = 43200] = "Hours12";
-    TTLType[TTLType["Day"] = 86400] = "Day";
-    TTLType[TTLType["Week"] = 604800] = "Week";
-})(TTLType || (TTLType = {}));
-/** Redis client
- * @dev About how handling client connections -> https://stackoverflow.com/questions/22387187/node-js-express-redis-when-to-close-connection
- * @dev Also -> https://github.com/redis/node-redis/issues/568
- */
-const redisConfig = {
-    url: `redis://${REDISHOST}:${REDISPORT}`,
-    socket: REDISHOST === "redis"
-        ? undefined
-        : {
-            tls: true,
-            reconnectStrategy: retries => Math.min(retries * 100, 5000),
-            keepAlive: 5_000,
-        },
-    password: REDISPASSWORD,
-    pingInterval: 10_000,
-};
-export const redisClient = createClient(redisConfig);
-redisClient.on("error", error => {
-    log.error("[REDIS]", error);
-    redisClient.connect().catch(() => { }); // Auto-reconnect
-});
-redisClient.connect();
-redisClient.on("end", () => log.debug("[REDIS]: disconnected"));
-redisClient.on("ready", () => {
-    log.debug("[REDIS]: connected");
-});

package/dist/src/constants.js

@@ -1,93 +0,0 @@
-import { ChainId } from "@sdk";
-export const DEFAULT_LOCAL_TTL = 120;
-export const MAX_NUM_SUBCALLS = 100;
-export const MERKL_USER_POSITION_FETCHING_TIMEOUT = 8000;
-export const MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT = 10000;
-export const MERKL_ALM_POSITION_FETCHING_TIMEOUT = 100000;
-export const EBTC_ADDRESS = "0x661c70333AA1850CcDBAe82776Bb436A0fCfeEfB";
-export const CDPMANAGER_ADDRESS = "0xc4cbaE499bb4Ca41E78f52F07f5d98c375711774";
-export const SORTEDCDPS_ADDRESS = "0x591AcB5AE192c147948c12651a0a5f24f0529BE3";
-export const RFX_DATASTORE = "0x895124783008C6c68eFcccac24c482Fdf30439B2";
-const COMMON_PREFIX_STAKE = "https://lockers.stakedao.org/api/strategies/cache/curve";
-const COMMON_PREFIX_CONVEX = "https://www.convexfinance.com/api/curve-apys";
-export const constantChain = {
-    [ChainId.MAINNET]: {
-        apw: "0x4104b135dbc9609fc1a9490e61369036497660c8",
-        convexEndpoint: COMMON_PREFIX_CONVEX,
-        crv: "0xD533a949740bb3306d119CC777fa900bA034cd52",
-        crv3: "0x6c3F90f043a72FA612cbac8115EE7e52BDe6E490",
-        crvANGLESDANGLE: "0x96AAE323E111A19b1E0e26F55e8De21F1dD01f26",
-        crvEURAEUROC: "0xBa3436Fd341F2C8A928452Db3C5A3670d1d5Cc73",
-        crvEURAEURe: "0x413928a25D6ea1A26F2625d633207755f67Bf97c",
-        crvEuropool: "0xe7A3b38c39F97E977723bd1239C3470702568e7B",
-        crvFRAX: "0x3175Df0976dFA876431C2E9eE6Bc45b65d3473CC",
-        crvFRAXEURA: "0x22e859Ee894c2068920858A60b51DC03ac5581c1",
-        crvLUSD3CRV: "0xEd279fDD11cA84bEef15AF5D39BB4d4bEE23F0cA",
-        cvx: "0x4e3FBD56CD56c3e72c1403e103b45Db9da5B9D2B",
-        dai: "0x6B175474E89094C44Da98b954EedeAC495271d0F",
-        frax: "0x853d955aCEf822Db058eb8505911ED77F175b99e",
-        fxs: "0x3432B6A60D23Ca0dFCa7761B7ab56459D9C964D0",
-        morpho: "0x9994E35Db50125E0DF82e4c2dde62496CE330999",
-        rKP3R: "0x1ceb5cb57c4d4e2b2433641b95dd330a33185a44",
-        sdt: "0x73968b9a57c6e53d41345fd57a6e6ae27d6cdb2f",
-        stakeEndpoint: COMMON_PREFIX_STAKE,
-        sushi: "0x6b3595068778dd592e39a122f4f5a5cf09c90fe2",
-        usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-        weth: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
-        wstETH: "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0",
-    },
-    [ChainId.ARBITRUM]: {
-        arb: "0x912ce59144191c1204e64559fe8253a0e49e6548",
-        chr: "0x15b2fb8f08E4Ac1Ce019EADAe02eE92AeDF06851",
-        convexProxy: "0x989AEb4d175e16225E39E87d0D97A3360524AD80",
-        crv: "0x11cdb42b0eb46d95f990bedd4695a6e3fa034978",
-        crv2Pool: "0x7f90122BF0700F9E7e1F688fe926940E8839F353",
-        cvx: "0xb952A807345991BD529FDded05009F5e80Fe8F45",
-        frax: "0x17FC002b466eEc40DaE837Fc4bE5c67993ddBd6F",
-        jeur: "0xAD435674417520aeeED6b504bBe654d4f556182F",
-        ram: "0xAAA6C1E32C55A7Bfa8066A6FAE9b42650F262418",
-        sdt: "0x7ba4a00d54a07461d9db2aef539e91409943adc9",
-        sliz: "0x463913D3a3D3D291667D53B8325c598Eb88D3B0e",
-        stakeEndpoint: `${COMMON_PREFIX_STAKE}-arbitrum`,
-        usdc: "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8",
-    },
-    [ChainId.OPTIMISM]: {
-        jeur: "0x79AF5dd14e855823FA3E9ECAcdF001D99647d043",
-        mai: "0xdFA46478F9e5EA86d57387849598dbFB2e964b02",
-        op: "0x4200000000000000000000000000000000000042",
-        usdc: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
-        usdce: "0x7F5c764cBc14f9669B88837ca1490cCa17c31607",
-        velo: "0x3c8b650257cfb5f272f799f5e2b4e65093a11a05",
-        veloV2: "0x9560e827aF36c94D2Ac33a39bCE1Fe78631088Db",
-    },
-    [ChainId.BASE]: {
-        aero: "0x940181a94A35A4569E4529A3CDfB74e38FD98631",
-        usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-    },
-    [ChainId.POLYGON]: {
-        am3CRV: "0xE7a24EF0C5e95Ffb0f6684b813A78F2a3AD7D171",
-        amDAI: "0x27F8D03b3a2196956ED754baDc28D73be8830A6e",
-        amUSDC: "0x1a13F4Ca1d028320A707D99520AbFefca3998b7F",
-        amUSDT: "0x60D55F02A771d515e077c9C2403a1ef324885CeC",
-        jeur: "0x4e3Decbb3645551B8A19f0eA1678079FCB33fB4c",
-        jrt: "0x596ebe76e2db4470966ea395b0d063ac6197a8c5",
-        oretro: "0x3A29CAb2E124919d14a6F735b6033a3AaD2B260F",
-        usdc: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
-    },
-    [ChainId.AVALANCHE]: {
-        glcr: "0x3712871408a829C5cd4e86DA1f4CE727eFCD28F6",
-        usdc: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
-    },
-    [ChainId.BSC]: {
-        cake: "0x0E09FaBB73Bd3Ade0a17ECC321fD13a19e81cE82",
-    },
-};
-export const MAVERICK_ZKSYNC_BP_LENS_ADDRESS = "0xd32CE31CaC98CAC0631764B8286358c0606D87F9";
-export const SPECTRA_NETWORK_SLUGS = {
-    [ChainId.MAINNET]: "mainnet",
-    [ChainId.ARBITRUM]: "arbitrum",
-    [ChainId.OPTIMISM]: "optimism",
-    [ChainId.BASE]: "base",
-    [ChainId.POLYGON]: "polygon",
-    [ChainId.SONIC]: "sonic",
-};

package/dist/src/engine/deprecated/dynamicData/implementations/Ajna.js

@@ -1,107 +0,0 @@
-import { TokenService } from "@/modules/v4/token/token.service";
-import { log } from "@/utils/logger";
-import { providers } from "@/utils/providers";
-import { AjnaSubCampaignType, BN2Number, ChainInteractionService, ERC20Pool__factory, NETWORK_LABELS, PoolInfoUtilsInterface, YEAR, } from "@sdk";
-import { POOL_INFO_UTILS } from "@sdk";
-import axios from "axios";
-export class AjnaDynamicData {
-    async build(chainId, campaigns) {
-        const calls = [];
-        for (const campaign of campaigns) {
-            if (campaign.campaignParameters.subCampaignType === AjnaSubCampaignType.lend) {
-                calls.push({
-                    allowFailure: true,
-                    callData: PoolInfoUtilsInterface.encodeFunctionData("poolPricesInfo", [campaign.campaignParameters.poolId]),
-                    target: POOL_INFO_UTILS[campaign.computeChainId],
-                });
-            }
-        }
-        const result = await ChainInteractionService(chainId).fetchState(calls);
-        const dynamicData = [];
-        let index = 0;
-        for (const campaign of campaigns) {
-            const res = await axios.get(`https://ajna-api.blockanalitica.com/v4/${NETWORK_LABELS[chainId].toLowerCase()}/pools/${campaign.campaignParameters.poolId.toLowerCase()}`);
-            try {
-                let totalSupplyTargetToken = 0;
-                let totalComputedTargetToken = 0;
-                let blacklistedSupply = 0;
-                let blacklistedPosition;
-                if (campaign.campaignParameters.subCampaignType === AjnaSubCampaignType.lend) {
-                    totalSupplyTargetToken = res?.data.results?.quote_token_balance;
-                    const htpIndex = PoolInfoUtilsInterface.decodeFunctionResult("poolPricesInfo", result[index].returnData)[3];
-                    const lupIndex = PoolInfoUtilsInterface.decodeFunctionResult("poolPricesInfo", result[index].returnData)[5];
-                    const threshold = BN2Number(lupIndex, 0) === 0 ? lupIndex : lupIndex.gt(htpIndex) ? lupIndex.add(22) : htpIndex.add(22);
-                    const InterestEarningSupplyRes = await ERC20Pool__factory.connect(campaign.campaignParameters.poolId, providers[campaign.computeChainId]).depositUpToIndex(threshold);
-                    totalComputedTargetToken = BN2Number(InterestEarningSupplyRes, 18);
-                    index++;
-                }
-                else {
-                    totalSupplyTargetToken = res?.data.results?.debt;
-                }
-                totalComputedTargetToken =
-                    campaign.campaignSubType === AjnaSubCampaignType.lend ? totalComputedTargetToken : totalSupplyTargetToken;
-                if (campaign.campaignParameters.blacklist.length !== 0 && totalComputedTargetToken !== 0) {
-                    for (const blacklisted of campaign.campaignParameters.blacklist) {
-                        const res = await axios.get(`https://ajna-api.blockanalitica.com/v4/${NETWORK_LABELS[chainId].toLowerCase()}/wallets/${blacklisted}/pools/?days_ago=1&order=-debt&p_size=50`);
-                        let nextRoute = null;
-                        if (!!res.data.next) {
-                            nextRoute = `https://${res.data.next.slice(res.data.next.indexOf(":") + 1)}`;
-                        }
-                        blacklistedPosition = res.data.results.find((position) => position.pool_address === campaign.campaignParameters.poolId);
-                        blacklistedSupply = !blacklistedPosition
-                            ? 0
-                            : campaign.campaignSubType === AjnaSubCampaignType.lend
-                                ? Number(blacklistedPosition.supply)
-                                : Number(blacklistedPosition.debt);
-                        while (nextRoute !== null && blacklistedSupply !== 0) {
-                            const res = await axios.get(nextRoute);
-                            blacklistedPosition = res.data.results.find((position) => position.pool_address === campaign.campaignParameters.poolId);
-                            blacklistedSupply = !blacklistedPosition
-                                ? 0
-                                : campaign.campaignSubType === AjnaSubCampaignType.lend
-                                    ? Number(blacklistedPosition.supply)
-                                    : Number(blacklistedPosition.debt);
-                            if (!!res.data.next) {
-                                nextRoute = `https://${res.data.next.slice(res.data.next.indexOf(":") + 1)}`;
-                            }
-                            else {
-                                nextRoute = null;
-                            }
-                        }
-                    }
-                }
-                totalComputedTargetToken -= blacklistedSupply;
-                const priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
-                // (await pricer.get({
-                //   address: campaign.rewardToken,
-                //   chainId,
-                //   symbol: campaign.campaignParameters.symbolRewardToken,
-                // })) ?? 0;
-                let apr = (priceRewardToken *
-                    BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) *
-                    YEAR *
-                    100) /
-                    campaign.campaignParameters.duration /
-                    (totalComputedTargetToken * res?.data.results?.quote_token_underlying_price);
-                const rewardTokens = await TokenService.findManyOrCreate([
-                    { chainId: campaign.chainId, address: campaign.rewardToken },
-                ]);
-                const rewardToken = rewardTokens[0];
-                apr = rewardToken.isPoint ? apr / 365 / 100 : apr;
-                dynamicData.push({
-                    ...campaign,
-                    apr,
-                    totalSupplyTargetToken,
-                    tvl: res?.data.results?.tvl,
-                    computedtotalSupply: totalComputedTargetToken,
-                });
-            }
-            catch (e) {
-                log.error("Failed to fetch Ajna data", e);
-                // In this case we return just the staticData
-                dynamicData.push({ ...campaign });
-            }
-        }
-        return dynamicData;
-    }
-}

package/dist/src/engine/deprecated/dynamicData/implementations/Badger.js

@@ -1,90 +0,0 @@
-import { CDPMANAGER_ADDRESS, EBTC_ADDRESS, SORTEDCDPS_ADDRESS } from "@/constants";
-import { TokenService } from "@/modules/v4/token/token.service";
-import { log } from "@/utils/logger";
-import { Pricer } from "@/utils/pricer";
-import { BN2Number, CdpManagerInterface, ChainInteractionService, SortedCdpsInterface, YEAR, } from "@sdk";
-export class BadgerDynamicData {
-    async build(chainId, campaigns) {
-        const pricer = await Pricer.load();
-        const calls = [];
-        calls.push({
-            allowFailure: false,
-            callData: CdpManagerInterface.encodeFunctionData("getSystemDebt"),
-            target: CDPMANAGER_ADDRESS,
-        });
-        const dynamicData = [];
-        const result = await ChainInteractionService(chainId).fetchState(calls);
-        for (const campaign of campaigns) {
-            try {
-                // Blacklist management
-                let blacklistSupply = 0;
-                let calls = [];
-                for (const blacklisted of [
-                    "0xFBC472DdbE6DaE23fc0771518d1791D06a52cf4D",
-                    "0x690C74AF48BE029e763E61b4aDeB10E06119D3ba",
-                    "0xD0A7A8B98957b9CD3cFB9c0425AbE44551158e9e",
-                    "0x68682e8857D24A5Bb71fCd5C6Dc5867731226B62",
-                ]) {
-                    calls.push({
-                        allowFailure: false,
-                        callData: SortedCdpsInterface.encodeFunctionData("getCdpsOf", [blacklisted]),
-                        target: SORTEDCDPS_ADDRESS,
-                    });
-                }
-                const resCdps = await ChainInteractionService(chainId).fetchState(calls);
-                calls = [];
-                for (const res of resCdps) {
-                    const cdp = SortedCdpsInterface.decodeFunctionResult("getCdpsOf", res.returnData)[0];
-                    if (cdp.length !== 0) {
-                        calls.push({
-                            allowFailure: false,
-                            callData: CdpManagerInterface.encodeFunctionData("Cdps", cdp),
-                            target: CDPMANAGER_ADDRESS,
-                        });
-                    }
-                }
-                const resBlacklist = await ChainInteractionService(chainId).fetchState(calls);
-                for (const res of resBlacklist) {
-                    const cdpBlacklistedSupply = CdpManagerInterface.decodeFunctionResult("Cdps", res.returnData)[0];
-                    blacklistSupply += BN2Number(cdpBlacklistedSupply, campaign.campaignParameters.decimalsTargetToken);
-                }
-                const totalSupplyTargetToken = BN2Number(CdpManagerInterface.decodeFunctionResult("getSystemDebt", result[0].returnData)[0], campaign.campaignParameters.decimalsTargetToken) - blacklistSupply;
-                // const priceRewardToken =
-                //   (await pricer.get({
-                //     address: campaign.rewardToken,
-                //     chainId,
-                //     symbol: campaign.campaignParameters.symbolRewardToken,
-                //   })) ?? 0;
-                const priceRewardToken = await TokenService.getRewardTokenPrice(campaign);
-                const priceTargetToken = (await pricer.get({
-                    address: EBTC_ADDRESS,
-                    chainId,
-                    symbol: campaign.campaignParameters.symbolTargetToken,
-                })) ?? 0;
-                let apr = (priceRewardToken *
-                    BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) *
-                    YEAR *
-                    100) /
-                    campaign.campaignParameters.duration /
-                    (totalSupplyTargetToken * priceTargetToken);
-                const rewardTokens = await TokenService.findManyOrCreate([
-                    { chainId: campaign.chainId, address: campaign.rewardToken },
-                ]);
-                const rewardToken = rewardTokens[0];
-                apr = rewardToken.isPoint ? apr / 365 / 100 : apr;
-                dynamicData.push({
-                    ...campaign,
-                    apr,
-                    totalSupplyTargetToken,
-                    tvl: totalSupplyTargetToken * priceTargetToken,
-                });
-            }
-            catch (e) {
-                log.error("Failed to fetch Dolomite data", e);
-                // In this case we return just the staticData
-                dynamicData.push({ ...campaign });
-            }
-        }
-        return dynamicData;
-    }
-}