@merkl/api 0.10.129 → 0.10.131

package/dist/src/backgroundJobs/jobs/opportunityUpdater.js

@@ -0,0 +1,63 @@
+import { Redis } from "../../cache";
+import { ANGLE_NETWORKS } from "@sdk";
+import { extractIds, getCampaignsFor, splitCampaigns } from "../../entities/campaign";
+import { extractOpportunities } from "../../entities/opportunity";
+import { log } from "../../utils/logger";
+import { Pricer } from "../../utils/pricer";
+export const OPPORTUNITY_CACHE = "Opportunities_All";
+export const OPPORTUNITY_CACHE_TEST = "Opportunities_Test";
+const reduceOpportunities = async (showTest = false) => {
+    const campaigns = await getCampaignsFor(ANGLE_NETWORKS.merkl.map(c => c));
+    const pricer = await Pricer.load();
+    const opportunityIds = extractIds(campaigns);
+    const opportunityCampaigns = splitCampaigns(campaigns, opportunityIds, showTest);
+    const opportunities = {};
+    for (const { id, ...opportunity } of opportunityCampaigns) {
+        const [_, type, mainParameter] = id.split("_");
+        if (!extractOpportunities[type])
+            continue;
+        const { campaigns: oppCampaigns, ...extracted } = extractOpportunities[type](opportunity?.all?.[0], {
+            all: opportunity?.all ?? [],
+            active: opportunity.active ?? [],
+            inactive: opportunity.inactive ?? [],
+        }, pricer?.prices);
+        opportunities[`${type}_${mainParameter}`] = {
+            ...extracted,
+            campaigns: {
+                type: Number.parseInt(type),
+                ids: opportunity?.all?.map(({ campaignId }) => campaignId).filter(c => c),
+            },
+        };
+    }
+    return opportunities;
+};
+const getUpdateBreakdown = (opportunities) => {
+    const total = Object.keys(opportunities)?.length;
+    const totalByChain = Object.entries(opportunities).reduce((prev, [_, { chainId }]) => {
+        prev[chainId] += 1;
+        return prev;
+    }, ANGLE_NETWORKS.merkl.reduce((allChains, chain) => Object.assign(allChains, { [chain]: 0 }), {}));
+    const breakdown = Object.entries(totalByChain).reduce((prev, [chain, count]) => {
+        if (count === 0)
+            return prev;
+        prev[chain] = count;
+        return prev;
+    }, {});
+    return { total, breakdown };
+};
+export const opportunityUpdater = (app) => {
+    return app.get("/v3/updateOpportunities", async () => {
+        const opportunities = await reduceOpportunities(false);
+        const opportunitiesWithTest = await reduceOpportunities(true);
+        await Redis.safeSet("Opportunities", opportunities);
+        await Redis.safeSet("OpportunitiesWithTest", opportunitiesWithTest);
+        log.info("✅ opportunity cache updated successfully");
+        return new Response(JSON.stringify({
+            status: "success",
+            all: getUpdateBreakdown(opportunities),
+            test: getUpdateBreakdown(opportunitiesWithTest),
+        }), {
+            status: 200,
+        });
+    });
+};

package/dist/src/backgroundJobs/jobs/priceUpdater.js

@@ -0,0 +1,16 @@
+import { TokenService } from "../../modules/v4";
+import { log } from "../../utils/logger";
+import { Pricer } from "../../utils/pricer";
+export const priceUpdater = (app) => {
+    return app.get("/v3/updatePrices", async () => {
+        const pricer = await Pricer.load();
+        await pricer.update();
+        log.info("✅ price cache updated successfully");
+        await TokenService.updatePrices(pricer);
+        return new Response(JSON.stringify({
+            status: "success",
+        }), {
+            status: 200,
+        });
+    });
+};

package/dist/src/backgroundJobs/jobs/sync.js

@@ -0,0 +1,33 @@
+import { AuthorizationHeadersDto, EngineGuard } from "../../guards/Engine.guard";
+import { CampaignService } from "../../modules/v4/campaign";
+import { ChainService } from "../../modules/v4/chain";
+import { log } from "../../utils/logger";
+import Elysia from "elysia";
+export const sync = new Elysia({ prefix: "/jobs" }).get("/api/sync-with-engine", async () => {
+    const chains = await ChainService.getMany({});
+    for (const chain of chains) {
+        log.info(`fetching campaigns on ${chain.name} (chainId: ${chain.id})`);
+        const campaignsV3 = await CampaignService.getFromEngineDb(chain.id, 0);
+        const campaigns = campaignsV3.map(campaignV3 => {
+            return {
+                amount: campaignV3.amount,
+                campaignId: campaignV3.campaignId,
+                chainId: campaignV3.chainId,
+                computeChainId: campaignV3.computeChainId,
+                creator: campaignV3.creator,
+                endTimestamp: campaignV3.endTimestamp.toString(),
+                opportunityIdentifier: campaignV3.mainParameter,
+                params: JSON.stringify(campaignV3.campaignParameters),
+                rewardTokenAddress: campaignV3.rewardToken,
+                startTimestamp: campaignV3.startTimestamp.toString(),
+                type: campaignV3.campaignType,
+                subType: campaignV3.campaignSubType,
+            };
+        });
+        log.info(`syncing ${campaigns.length} campaigns to sync on ${chain.name}...`);
+        const { success, fail } = await CampaignService.createMany(campaigns);
+        log.info(`${success} campaigns synced successfully on ${chain.name}`);
+        log.info(`${fail} campaigns failed to sync on ${chain.name}`);
+    }
+    return;
+}, { headers: AuthorizationHeadersDto, beforeHandle: EngineGuard });

package/dist/src/cache/declaration.js

@@ -0,0 +1,146 @@
+import { TTLType } from "./redis";
+export const CacheDeclaration = {
+    Updates: { compressed: false, redisTTL: TTLType.Minutes2, localCache: false },
+    Delays: { compressed: false, redisTTL: TTLType.Minutes2, localCache: false },
+    TwtParticipants: { compressed: false, redisTTL: TTLType.Minutes5, localCache: false },
+    CampaignRewards: {
+        compressed: true,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    RewardsMainParameter: {
+        compressed: true,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    RewardsMainParameterDelta: {
+        compressed: true,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    CampaignRewardsDelta: {
+        compressed: true,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    LastBlockBefore: {
+        compressed: false,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    LostYield: {
+        compressed: false,
+        redisTTL: TTLType.Hours3,
+        localCache: false,
+    },
+    DolomiteMarkets: {
+        compressed: false,
+        redisTTL: TTLType.Minutes30,
+        localCache: false,
+    },
+    EulerV2Vaults: {
+        compressed: false,
+        redisTTL: TTLType.Minutes30,
+        localCache: false,
+    },
+    CompoundV2ForksVaults: {
+        compressed: false,
+        redisTTL: TTLType.Week,
+        localCache: false,
+    },
+    RadiantMarkets: {
+        compressed: false,
+        redisTTL: TTLType.Minutes30,
+        localCache: false,
+    },
+    SiloMarkets: {
+        compressed: false,
+        redisTTL: TTLType.Minutes30,
+        localCache: false,
+    },
+    MorphoMarkets: {
+        compressed: false,
+        redisTTL: TTLType.Minutes30,
+        localCache: false,
+    },
+    FarmedPositions: {
+        compressed: false,
+        redisTTL: TTLType.Minutes2,
+        localCache: false,
+    },
+    JsonByTimestamp: {
+        compressed: false,
+        redisTTL: TTLType.Minutes10,
+        localCache: false,
+    },
+    Prices: {
+        compressed: true,
+        redisTTL: TTLType.Minutes30,
+        localCache: false,
+    },
+    MerklChainData: {
+        compressed: false,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    Opportunities: {
+        compressed: true,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    OpportunitiesWithTest: {
+        compressed: true,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    Campaigns: {
+        compressed: true,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    LiveCampaigns: {
+        compressed: true,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    CampaignsOldFormat: {
+        compressed: true,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    LiveCampaignsOldFormat: {
+        compressed: true,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    StaticCampaigns: {
+        compressed: true,
+        redisTTL: TTLType.Hours12,
+        localCache: false,
+    },
+    Blacklist: {
+        compressed: true,
+        redisTTL: TTLType.Minutes10,
+        localCache: false,
+    },
+    TokenList: {
+        compressed: false,
+        redisTTL: TTLType.Minutes30,
+        localCache: false,
+    },
+    CurrentRoot: {
+        compressed: false,
+        redisTTL: TTLType.Seconds30,
+        localCache: true,
+    },
+    Chains: {
+        compressed: false,
+        redisTTL: TTLType.Hours3,
+        localCache: true,
+    },
+    RootsWithRewardOnChain: {
+        compressed: false,
+        redisTTL: TTLType.Minutes2,
+        localCache: true,
+    },
+};

package/dist/src/cache/index.js

@@ -0,0 +1,152 @@
+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
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
+    isLocallyCached(key) {
+        return false;
+        // return this.localCache.has(key);
+    }
+    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);
+    }
+    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 getMany(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.getMany(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

@@ -0,0 +1,49 @@
+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 },
+    password: REDISPASSWORD,
+};
+export const redisClient = createClient(redisConfig);
+redisClient.on("error", error => {
+    log.error("Redis", error);
+});
+redisClient.connect();
+redisClient.on("end", () => log.info("Redis: disconnected"));
+redisClient.on("ready", () => {
+    log.debug("Redis: connected!");
+});

package/dist/src/constants.js

@@ -0,0 +1,119 @@
+import Big from "big.js";
+export const zeroBN = new Big(0);
+export const baseTestAnalyticsGraphUrl = "https://api.thegraph.com/subgraphs/name/angleprotocol/test-analytics-";
+export const baseAnalyticsGraphUrl = "https://api.thegraph.com/subgraphs/name/angleprotocol/test-analytics-";
+export const EXPORTER_URL = "https://exporter.angle.money";
+export const DEFAULT_LOCAL_TTL = 120;
+export const subgraphSuffixMapping = {
+    [ChainId.ARBITRUM]: "arb",
+    [ChainId.MAINNET]: "eth",
+    [ChainId.OPTIMISM]: "opt",
+    [ChainId.POLYGON]: "pol",
+    [ChainId.BASE]: "bas",
+    [ChainId.POLYGONZKEVM]: "zke",
+};
+export const MAX_NUM_SUBCALLS = 100;
+export const MERKL_TREE_OPTIONS = { hashLeaves: true, sortLeaves: true, sortPairs: true };
+export const MERKL_USER_POSITION_FETCHING_TIMEOUT = 8000;
+export const MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT = 10000;
+export const MERKL_USER_CLAIMED_TOKENS_TIMEOUT = 10000;
+export const MERKL_ALM_FETCHING_TIMEOUT = 10000;
+export const MERKL_ALM_POSITION_FETCHING_TIMEOUT = 100000;
+export const MERKL_USER_REWARDS_FETCHING_TIMEOUT = 10000;
+export const GITHUB_MERKL_REWARDS_URL = "https://raw.githubusercontent.com/AngleProtocol/merkl-rewards/main/";
+export const GCLOUD_STORAGE_MERKL_PUBLIC_URL = "https://storage.googleapis.com/merkl-production-rewards/";
+export const MERKL_BLACKLIST = [
+    "0xa6161c3e1bc3c743819f0be91322e108946c1a0e7666ae2885ce03c2068cbef7", // ETH - stETH fucked up by gauntlet
+];
+export const EBTC_ADDRESS = "0x661c70333AA1850CcDBAe82776Bb436A0fCfeEfB";
+export const CDPMANAGER_ADDRESS = "0xc4cbaE499bb4Ca41E78f52F07f5d98c375711774";
+export const SORTEDCDPS_ADDRESS = "0x591AcB5AE192c147948c12651a0a5f24f0529BE3";
+export const RFX_DATASTORE = "0x895124783008C6c68eFcccac24c482Fdf30439B2";
+export const DOPEX_OPTION_MARKET = {
+    // UniswapV3 pools
+    ["0xC6962004f452bE9203591991D15f6b388e09E8D0".toLowerCase()]: "0x501B03BdB431154b8Df17BF1c00756E3a8F21744",
+    ["0x0E4831319A50228B9e450861297aB92dee15B44F".toLowerCase()]: "0x550e7E236912DaA302F7d5D0d6e5D7b6EF191f04", // wBTC / USDC
+    ["0xb0f6cA40411360c03d41C5fFc5F179b8403CdcF8".toLowerCase()]: "0x4eed3A2b797Bf5630517EcCe2e31C1438A76bb92",
+    ["0xC31E54c7a869B9FcBEcc14363CF510d1c41fa443".toLowerCase()]: "0x764fA09d0B3de61EeD242099BD9352C1C61D3d27",
+    ["0xac70bD92F89e6739B3a08Db9B6081a923912f73D".toLowerCase()]: "0x3808E8C983023a125fFE2714E2A703A3BF02bE0d",
+    ["0xcDa53B1F66614552F834cEeF361A8D12a0B8DaD8".toLowerCase()]: "0x77b6f45a3Dcf0493f1B9Ac9874e5982AB526AA9e",
+    // PCS pools
+    ["0x843aC8dc6D34AEB07a56812b8b36429eE46BDd07".toLowerCase()]: "0x550e7E236912DaA302F7d5D0d6e5D7b6EF191f04", // wBTC / USDC
+    ["0xd9e2a1a61b6e61b275cec326465d417e52c1b95c".toLowerCase()]: "0x501B03BdB431154b8Df17BF1c00756E3a8F21744", // wETH / USDC
+    ["0x9fFCA51D23Ac7F7df82da414865Ef1055E5aFCc3".toLowerCase()]: "0x4eed3A2b797Bf5630517EcCe2e31C1438A76bb92", // ARB / USDC
+};
+import { ChainId } from "@sdk";
+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",
+    },
+};