@merkl/api 0.10.128 → 0.10.130

package/dist/src/routes/v3/campaignsRewardsReport.js

@@ -0,0 +1,47 @@
+import { t } from "elysia";
+import { merklChainDataWithCache } from "../../libs/merklChainData";
+import { getCampaignRewardsDeltaWithCache, getCampaignRewardsWithCache } from "../../libs/reports/campaignReport";
+import { ChainCampaignId } from "../../types/parameters/ChainCampaignId";
+import { Timestamp } from "../../types/parameters/Timestamp";
+export const query = t.Object({
+    chain_campaignIds: t.Array(ChainCampaignId.type, {
+        style: "pipeDelimited",
+        examples: {
+            "Shuffle on Ethereum": {
+                value: "1_0xf69d17aa75d36c4a9c6402fd9abc012b66a7947acaa2b20b267fe3ef10733421|1_0x817b90779d8b6789b832c9bafe9aaa22bc907f072dedb31ef0bfb280bf6a037e",
+            },
+        },
+    }),
+    from: t.Optional(Timestamp.type),
+    to: t.Optional(Timestamp.type),
+});
+export default (app) => app.get("", async ({ query: { chain_campaignIds, from, to }, set }) => {
+    const rewards = [];
+    const campaigns = chain_campaignIds.map(c_c => {
+        const [chain, campaignId] = c_c.split("_");
+        return [Number.parseInt(chain), campaignId];
+    });
+    const hasValidTimeframe = !!to && !!from;
+    if (!hasValidTimeframe) {
+        const uniqueChains = Array.from(campaigns.reduce((set, [chain]) => set.add(chain), new Set()));
+        const roots = {};
+        for (const chain of uniqueChains)
+            roots[chain] = (await merklChainDataWithCache(chain)).merkleRoot;
+        for (const [chain, campaignId] of campaigns)
+            rewards.push(...(await getCampaignRewardsWithCache(chain, roots[chain] ?? "", campaignId?.toLowerCase())));
+    }
+    else {
+        for (const [chain, campaignId] of campaigns) {
+            rewards.push(...(await getCampaignRewardsDeltaWithCache(chain, from, to, campaignId?.toLowerCase())));
+        }
+    }
+    return rewards;
+}, {
+    transform({ query }) {
+        query.chain_campaignIds =
+            query.chain_campaignIds?.split?.("|") ??
+                query.chain_campaignIds;
+    },
+    query,
+    tags: ["Rewards"],
+});

package/dist/src/routes/v3/claims.js

@@ -0,0 +1,45 @@
+import { engineDbClient } from "../../utils/prisma";
+import { ChainId, isSupportedChain } from "@sdk";
+import { t } from "elysia";
+import checkQueryAddressValidity from "../../hooks/checkQueryAddressValidity";
+import { CLAIMS_FOR_CREATOR_TAG, CLAIMS_FOR_CREATOR_TAG_GROUPED, CLAIMS_FOR_USER, CLAIMS_FOR_USER_GROUPED, } from "../../utils/queries/claimsOverTime";
+export const query = t.Object({
+    creatorTag: t.Optional(t.String()),
+    chainIds: t.Optional(t.Union([t.String(), t.Array(t.String())])),
+    byReason: t.Optional(t.BooleanString()),
+    user: t.String(),
+});
+export default (app) => app.use(checkQueryAddressValidity()).get("", async ({ query, path, set }) => {
+    const creatorTag = query.creatorTag;
+    const rawChainIds = query.chainIds;
+    const user = query.user;
+    let chainIds;
+    if (!rawChainIds) {
+        chainIds = Object.keys(ChainId)
+            .map(k => Number.parseInt(k))
+            .filter(k => isSupportedChain(k, "merkl"));
+    }
+    else if (typeof rawChainIds === "string") {
+        chainIds = [Number.parseInt(rawChainIds)];
+    }
+    else {
+        chainIds = rawChainIds.map(chainId => Number.parseInt(chainId));
+    }
+    let byReason = true;
+    if (query.byReason !== undefined) {
+        byReason = query.byReason;
+    }
+    if (!byReason) {
+        if (!!creatorTag) {
+            return await engineDbClient.$queryRaw(CLAIMS_FOR_CREATOR_TAG_GROUPED(chainIds, user, creatorTag));
+        }
+        return await engineDbClient.$queryRaw(CLAIMS_FOR_USER_GROUPED(chainIds, user));
+    }
+    if (!!creatorTag) {
+        return await engineDbClient.$queryRaw(CLAIMS_FOR_CREATOR_TAG(chainIds, user, creatorTag));
+    }
+    return await engineDbClient.$queryRaw(CLAIMS_FOR_USER(chainIds, user));
+}, {
+    query,
+    tags: ["Rewards"],
+});

package/dist/src/routes/v3/compoundV2.js

@@ -0,0 +1,9 @@
+import { getCompoundV2ForksVaultsWithCache } from "../../libs/campaigns/utils/getCompV2ForksVaults";
+import { t } from "elysia";
+export const response = t.Array(t.Object({ address: t.String(), asset: t.String(), chaind: t.Number(), debtTokenAddress: t.String() }));
+export default (app) => app.get("", async () => {
+    return await getCompoundV2ForksVaultsWithCache();
+}, {
+    query: t.Object({}),
+    tags: ["Protocols"],
+});

package/dist/src/routes/v3/createCampaign.js

@@ -0,0 +1,66 @@
+import { BN2Number, DistributionCreatorInterface, registry } from "@sdk";
+import { t } from "elysia";
+import checkQueryAddressValidity from "../../hooks/checkQueryAddressValidity";
+import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
+import { merklChainDataWithCache } from "../../libs/merklChainData";
+import { executeSimple } from "../../utils/execute";
+export const query = t.Object({
+    chainId: t.Numeric(),
+    user: t.String(),
+});
+export default (app) => app
+    .use(checkQueryChainIdValidity())
+    .use(checkQueryAddressValidity())
+    .get("", async (request) => {
+    const chainId = request.query.chainId;
+    const user = request.query.user;
+    const { feeRebate, signed } = await executeSimple(chainId, campaignCreationUserInfo(user, chainId));
+    // Need to get the message and valid tokens from cache
+    const { message, validRewardTokens } = await merklChainDataWithCache(chainId);
+    return {
+        feeRebate,
+        message,
+        signed,
+        validRewardTokens,
+    };
+}, {
+    query,
+    tags: ["Campaigns"],
+});
+async function campaignCreationUserInfo(user, chainId) {
+    const creatorAddress = registry(chainId)?.Merkl?.DistributionCreator;
+    const calls = [
+        {
+            callData: DistributionCreatorInterface.encodeFunctionData("feeRebate", [user]),
+            target: creatorAddress,
+        },
+        {
+            callData: DistributionCreatorInterface.encodeFunctionData("userSignatures", [user]),
+            target: creatorAddress,
+        },
+        {
+            callData: DistributionCreatorInterface.encodeFunctionData("userSignatureWhitelist", [user]),
+            target: creatorAddress,
+        },
+        {
+            callData: DistributionCreatorInterface.encodeFunctionData("messageHash"),
+            target: creatorAddress,
+        },
+    ];
+    return {
+        cached: false,
+        call: {
+            callData: calls,
+            handler: () => { },
+            reducer: async (result) => {
+                let i = 0;
+                const feeRebate = BN2Number(DistributionCreatorInterface.decodeFunctionResult("feeRebate", result[i++])[0]?.toString());
+                const signature = DistributionCreatorInterface.decodeFunctionResult("userSignatures", result[i++])[0]?.toString();
+                const signatureWhitelist = DistributionCreatorInterface.decodeFunctionResult("userSignatureWhitelist", result[i++])[0]?.toString();
+                const messageHash = DistributionCreatorInterface.decodeFunctionResult("messageHash", result[i++])[0]?.toString();
+                const signed = signature === messageHash || signatureWhitelist === messageHash;
+                return { feeRebate, signed };
+            },
+        },
+    };
+}

package/dist/src/routes/v3/dolomite.js

@@ -0,0 +1,9 @@
+import { t } from "elysia";
+import { getDolomiteMarketWithCache } from "../../libs/campaigns/utils/getDolomiteMarkets";
+export const response = t.Array(t.Object({ index: t.Number(), token: t.String(), symbol: t.String() }));
+export default (app) => app.get("", async () => {
+    return await getDolomiteMarketWithCache();
+}, {
+    query: t.Object({}),
+    tags: ["Protocols"],
+});

package/dist/src/routes/v3/euler.js

@@ -0,0 +1,9 @@
+import { getEulerV2VaultsWithCache } from "../../libs/campaigns/utils/getEulerV2Vaults";
+import { t } from "elysia";
+export const response = t.Array(t.Object({ address: t.String(), asset: t.String(), chaind: t.Number(), debtTokenAddress: t.String() }));
+export default (app) => app.get("", async () => {
+    return await getEulerV2VaultsWithCache();
+}, {
+    query: t.Object({}),
+    tags: ["Protocols"],
+});

package/dist/src/routes/v3/exports/campaigns.js

@@ -0,0 +1,28 @@
+import checkQueryChainIdValidity from "../../../hooks/checkQueryChainIdValidity";
+import { staticCampaignWithCache } from "../../../libs/staticCampaigns";
+import { engineDbClient } from "../../../utils/prisma";
+import { t } from "elysia";
+export const query = t.Object({
+    chainId: t.Numeric(),
+    minIndex: t.Optional(t.Numeric()),
+});
+export default (app) => app.use(checkQueryChainIdValidity()).get("", async ({ query }) => {
+    const chainId = query.chainId;
+    const minIndex = query.minIndex;
+    if (!!minIndex || minIndex === 0) {
+        // Query from minIndex
+        return await engineDbClient.campaigns.findMany({
+            where: {
+                chainId: chainId,
+                index: {
+                    gte: minIndex,
+                },
+            },
+        });
+    }
+    // Query all campaigns
+    return await staticCampaignWithCache(chainId);
+}, {
+    query,
+    tags: ["Campaigns"],
+});

package/dist/src/routes/v3/fetch.js

@@ -0,0 +1,27 @@
+import { DistributionCreator__factory, parseCampaign, registry } from "@sdk";
+import { t } from "elysia";
+import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
+import { providers } from "../../utils/providers";
+export const query = t.Object({
+    chainId: t.Numeric(),
+    index: t.Numeric(),
+});
+/** Fetch params  */
+export default (app) => app.use(checkQueryChainIdValidity()).get("", async (request) => {
+    const chainId = request.query.chainId;
+    /** Merkl reward manager contract */
+    const distributionCreator = DistributionCreator__factory.connect(registry(chainId)?.Merkl?.DistributionCreator, providers[chainId]);
+    const campaignStruct = await distributionCreator.campaignList(request.query.index);
+    try {
+        const parsingResult = await parseCampaign(chainId, campaignStruct, request.query.index ?? 0);
+        if (parsingResult.success)
+            return JSON.stringify(parsingResult.parsedCampaign);
+        throw parsingResult.message;
+    }
+    catch (e) {
+        return { message: `Error parsing campaign: ${e}`, name: "Error" };
+    }
+}, {
+    query,
+    tags: ["Campaigns"],
+});

package/dist/src/routes/v3/health.js

@@ -0,0 +1,13 @@
+import { Redis } from "../../cache";
+import { t } from "elysia";
+export const response = t.Object({ success: t.Boolean() });
+export default (app) => app.get("", async () => {
+    // Check if the cache is working
+    await Redis.get("Prices");
+    return {
+        success: true,
+    };
+}, {
+    query: t.Object({}),
+    tags: ["Onchain"],
+});

package/dist/src/routes/v3/lostyield.js

@@ -0,0 +1,98 @@
+import { Redis } from "../../cache";
+import { getLastBlockBeforeWithCache } from "../../utils/lastBlockBefore";
+import { BN2Number, ChainId, DAY, ERC20Interface } from "@sdk";
+import { t } from "elysia";
+import { utils } from "ethers";
+import moment from "moment";
+import checkQueryAddressValidity from "../../hooks/checkQueryAddressValidity";
+import { getTokensListWithCache } from "../../libs/getTokensList";
+import { batchMulticallCallWithRetry } from "../../utils/generic";
+import { log } from "../../utils/logger";
+import { providers } from "../../utils/providers";
+const CONSTANTS = {
+    [ChainId.MAINNET]: [
+        utils.getAddress("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"),
+        utils.getAddress("0xdac17f958d2ee523a2206206994597c13d831ec7"),
+    ],
+    [ChainId.BASE]: [
+        utils.getAddress("0x833589fcd6edb6e08f4c7c32d4f71b54bda02913"),
+        utils.getAddress("0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2"),
+    ],
+    [ChainId.ARBITRUM]: [
+        utils.getAddress("0xaf88d065e77c8cc2239327c5edb3a432268e5831"),
+        utils.getAddress("0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9"),
+    ],
+    [ChainId.OPTIMISM]: [
+        utils.getAddress("0x0b2c639c533813f4aa9d7837caf62653d097ff85"),
+        utils.getAddress("0x94b008aa00579c1307b0ef2c499ad98a8ce58e58"),
+    ],
+    [ChainId.POLYGON]: [
+        utils.getAddress("0x3c499c542cef5e3811e1192ce70d8cc03d5c3359"),
+        utils.getAddress("0xc2132d05d31c914a87c6611c10748aeb04b58e8f"),
+    ],
+};
+const getLostYield = async (user) => {
+    const tokenList = await getTokensListWithCache();
+    const result = {};
+    const now = moment().unix();
+    const LOOKBACK = 30 * DAY;
+    const AVERAGING_PERIOD = 2 * DAY;
+    const promises = Object.keys(CONSTANTS).map(chainId => (async () => {
+        try {
+            result[chainId] = {};
+            for (const token of CONSTANTS[Number.parseInt(chainId)]) {
+                result[chainId][token] = { total: 0, yield: 0 };
+            }
+            const currentBlockNumber = await providers[Number.parseInt(chainId)].getBlockNumber();
+            const startBlockNumber = await getLastBlockBeforeWithCache(Math.floor((now - LOOKBACK) / AVERAGING_PERIOD) * AVERAGING_PERIOD, Number.parseInt(chainId));
+            const AVERAGING_PERIOD_IN_BLOCKS = Math.floor((currentBlockNumber - startBlockNumber) / (LOOKBACK / AVERAGING_PERIOD));
+            let blockNumber = startBlockNumber;
+            const averagingPromises = [];
+            let blocksByChain = 0;
+            while (blockNumber < currentBlockNumber) {
+                blocksByChain++;
+                averagingPromises.push((async () => {
+                    const calls = [];
+                    for (const token of CONSTANTS[Number.parseInt(chainId)]) {
+                        calls.push({
+                            target: token,
+                            callData: ERC20Interface.encodeFunctionData("balanceOf", [user]),
+                            allowFailure: true,
+                        });
+                    }
+                    // console.log(`Calling multicall with ${calls.length} calls for block ${blockNumber} on chain ${chainId}`);
+                    const results = await batchMulticallCallWithRetry(Number.parseInt(chainId), { calls, blockNumber });
+                    let i = 0;
+                    for (const token of CONSTANTS[Number.parseInt(chainId)]) {
+                        const tokenDetails = tokenList[Number.parseInt(chainId)][utils.getAddress(token)];
+                        const balance = ERC20Interface.decodeFunctionResult("balanceOf", results[i++].returnData)[0];
+                        result[chainId][token].total += BN2Number(balance, tokenDetails.decimals);
+                    }
+                })());
+                blockNumber += AVERAGING_PERIOD_IN_BLOCKS;
+            }
+            await Promise.all(averagingPromises);
+            for (const token of CONSTANTS[Number.parseInt(chainId)]) {
+                result[chainId][token].total = result[chainId][token].total / blocksByChain;
+                result[chainId][token].yield = result[chainId][token].total * 0.04;
+            }
+        }
+        catch (e) {
+            log.error(`Failed to get yield data for ${user} on chain ${chainId}`, e);
+        }
+    })());
+    await Promise.all(promises);
+    return result;
+};
+export const query = t.Object({
+    user: t.String(),
+});
+export const response = t.Record(t.String({ title: "ChainId" }), t.Record(t.String({ title: "TokenAddress" }), t.Object({ total: t.Number(), yield: t.Number() })));
+export default (app) => app.use(checkQueryAddressValidity()).get("", async ({ query }) => {
+    return await Redis.getOrSet(`LostYield_${query.user}`, getLostYield, query.user);
+}, {
+    query: t.Object({
+        user: t.String(),
+    }),
+    tags: ["Protocols"],
+});

package/dist/src/routes/v3/merkl.js

@@ -0,0 +1,119 @@
+import { getClamsInfo } from "../../libs/deprecated-merklv3";
+import { AMM, ChainId, isSupportedChain } from "@sdk";
+import { t } from "elysia";
+import checkQueryAddressValidity from "../../hooks/checkQueryAddressValidity";
+import { InvalidParameter } from "../../utils/error";
+import { throwOnUnsupportedChainId } from "../../utils/throw";
+export const query = t.Object({
+    AMMs: t.Optional(t.Union([t.String(), t.Array(t.String())])),
+    chainIds: t.Optional(t.Union([t.Numeric(), t.Array(t.Numeric())])),
+    user: t.Optional(t.String()),
+    onlyLive: t.Optional(t.String()),
+});
+export const response = t.Record(t.String({ title: "Merkl" }), t.Object({
+    merkleRoot: t.Optional(t.String()),
+    message: t.Optional(t.String()),
+    validRewardTokens: t.Optional(t.Array(t.Object({
+        decimals: t.Number(),
+        minimumAmountPerEpoch: t.Number(),
+        symbol: t.String(),
+        token: t.String(),
+    }))),
+    pools: t.Record(t.String(), t.Object({
+        alm: t.Object({}),
+        amm: t.Number(),
+        ammAlgo: t.Number(),
+        ammAlgoName: t.String(),
+        ammName: t.String(),
+        aprs: t.Object({}),
+        chainId: t.Number(),
+        decimalsToken0: t.Number(),
+        decimalsToken1: t.Number(),
+        disputeLive: t.Boolean(),
+        distributionData: t.Array(t.Unknown()),
+        endOfDisputePeriod: t.Number(),
+        meanAPR: t.Number(),
+        pool: t.String(),
+        poolBalanceToken0: t.Number(),
+        poolBalanceToken1: t.Number(),
+        poolFee: t.Number(),
+        poolTotalLiquidity: t.Number(),
+        rewardsPerToken: t.Object({}),
+        symbolToken0: t.String(),
+        symbolToken1: t.String(),
+        tick: t.Number(),
+        token0: t.String(),
+        token1: t.String(),
+        tvl: t.Union([t.Number(), t.Null()]),
+    })),
+}));
+export const merklRoute = async ({ query, set }) => {
+    const user = query.user;
+    let AMMs;
+    let rawAMMs = query.AMMs;
+    if (!rawAMMs) {
+        rawAMMs = query["AMMs[]"];
+    }
+    if (!rawAMMs) {
+        rawAMMs = query["AMMs[0]"];
+    }
+    if (!rawAMMs) {
+        AMMs = undefined;
+    }
+    else if (typeof rawAMMs === "string") {
+        if (rawAMMs.includes(",")) {
+            AMMs = rawAMMs.split(",");
+        }
+        else {
+            AMMs = [rawAMMs];
+        }
+    }
+    if (!!AMMs) {
+        AMMs = AMMs.map(amm => {
+            return amm.toLowerCase();
+        });
+        for (const filterAMM of AMMs) {
+            if (Object.keys(AMM)
+                .filter(amm => Number.isNaN(Number(amm)))
+                .map(amm => {
+                return amm.toLowerCase();
+            })
+                .indexOf(filterAMM.toLowerCase()) === -1) {
+                throw new InvalidParameter(`API for Merkl products by Angle Labs does not support this type of AMM: ${filterAMM}`);
+            }
+        }
+    }
+    let rawChainIds = query.chainIds;
+    if (!rawChainIds) {
+        rawChainIds = query["chainIds[]"];
+    }
+    if (!rawChainIds) {
+        rawChainIds = query["chainIds[0]"];
+    }
+    let chainIds;
+    if (!rawChainIds) {
+        chainIds = Object.keys(ChainId)
+            .map(k => Number.parseInt(k))
+            .filter(k => isSupportedChain(k, "merkl"));
+    }
+    else if (typeof rawChainIds === "number") {
+        chainIds = [rawChainIds];
+    }
+    else if (typeof rawChainIds === "string") {
+        chainIds = [Number.parseInt(rawChainIds)];
+    }
+    else {
+        chainIds = rawChainIds;
+    }
+    for (const chainId of chainIds)
+        throwOnUnsupportedChainId(chainId);
+    let onlyLive = false;
+    if (query.onlyLive === "true") {
+        onlyLive = true;
+    }
+    return getClamsInfo(chainIds, AMMs, user, onlyLive);
+};
+export default (app) => app.use(checkQueryAddressValidity()).get("", merklRoute, {
+    // query,
+    tags: ["Merkl"],
+});

package/dist/src/routes/v3/morphoMarkets.js

@@ -0,0 +1,27 @@
+import { getMorphoMarketsWithCache } from "../../libs/parse/marketsWithCache";
+import { MorphoSubCampaignType } from "@sdk";
+import { t } from "elysia";
+export const query = t.Object({
+    repository: t.String(),
+    chainId: t.Numeric(),
+});
+const asset = t.Object({
+    address: t.String(),
+    chain: t.Object({ network: t.String() }),
+    symbol: t.String(),
+});
+export const response = t.Array(t.Object({
+    uniqueKey: t.String(),
+    whitelisted: t.Boolean(),
+    lltv: t.Numeric(),
+    loanAsset: asset,
+    collateralAsset: asset,
+}));
+export default (app) => app.get("", async (request) => {
+    const chainId = request.query.chainId;
+    if (request.query.repository !== MorphoSubCampaignType.META.toString())
+        return await getMorphoMarketsWithCache(chainId, request.query.repository);
+}, {
+    query,
+    tags: ["Protocols"],
+});

package/dist/src/routes/v3/morphoVaults.js

@@ -0,0 +1,22 @@
+import { getMorphoMarketsWithCache } from "../../libs/parse/marketsWithCache";
+import { MorphoSubCampaignType } from "@sdk";
+import { t } from "elysia";
+export const query = t.Object({
+    repository: t.String(),
+    chainId: t.Numeric(),
+});
+export const response = t.Array(t.Object({
+    address: t.String(),
+    name: t.String(),
+    whitelisted: t.Boolean(),
+    symbol: t.String(),
+    chain: t.Object({ network: t.String() }),
+}));
+export default (app) => app.get("", async (request) => {
+    const chainId = request.query.chainId;
+    if (request.query.repository === MorphoSubCampaignType.META.toString())
+        return await getMorphoMarketsWithCache(chainId, request.query.repository);
+}, {
+    query,
+    tags: ["Protocols"],
+});

package/dist/src/routes/v3/multiChainPositions.js

@@ -0,0 +1,69 @@
+import { Redis } from "../../cache";
+import { ChainId, isSupportedChain } from "@sdk";
+import { t } from "elysia";
+import checkQueryAddressValidity from "../../hooks/checkQueryAddressValidity";
+import { getUserPositionsV2 } from "../../libs/positions";
+import { prepareFetch } from "../../libs/positions/prepareFetch";
+import { throwOnUnsupportedChainId } from "../../utils/throw";
+export const query = t.Object({
+    chainIds: t.Optional(t.Union([t.String(), t.Array(t.String())])),
+    user: t.String(),
+    creatorTag: t.String(),
+});
+export default (app) => app.use(checkQueryAddressValidity()).get("", async ({ query, set }) => {
+    let rawChainIds = query.chainIds;
+    if (typeof rawChainIds === "string" && rawChainIds.includes(",")) {
+        rawChainIds = rawChainIds.split(",");
+    }
+    let chainIds;
+    if (!rawChainIds) {
+        chainIds = Object.keys(ChainId)
+            .map(k => Number.parseInt(k))
+            .filter(k => isSupportedChain(k, "merkl"));
+    }
+    else if (typeof rawChainIds === "string") {
+        chainIds = [Number.parseInt(rawChainIds)];
+    }
+    else {
+        chainIds = rawChainIds.map(chainId => Number.parseInt(chainId));
+    }
+    for (const chainId of chainIds)
+        throwOnUnsupportedChainId(chainId);
+    const user = query.user;
+    for (const chainId of chainIds)
+        throwOnUnsupportedChainId(chainId);
+    const cacheKeys = chainIds.map(chainId => `LiveCampaigns_${chainId}`);
+    const cacheData = await Redis.getMany(cacheKeys);
+    const promises = [];
+    let i = 0;
+    for (const chainId of chainIds) {
+        if (!cacheData[i]) {
+            promises.push(getUserPositionsV2({}, chainId, user));
+            i++;
+            continue;
+        }
+        const allOpportunities = cacheData[i];
+        const positionsToCheck = {};
+        for (const campaigns of Object.values(allOpportunities)) {
+            for (const campaign of Object.values(campaigns)) {
+                if (campaign.tags.includes(query.creatorTag)) {
+                    const type = campaign.campaignType;
+                    positionsToCheck[type] = prepareFetch(type, positionsToCheck[type] ? positionsToCheck[type] : {}, campaign);
+                }
+            }
+        }
+        promises.push(getUserPositionsV2(positionsToCheck, chainId, user));
+        i++;
+    }
+    const result = await Promise.all(promises);
+    i = 0;
+    const finalResult = {};
+    for (const chainId of chainIds) {
+        finalResult[chainId] = result[i];
+        i++;
+    }
+    return finalResult;
+}, {
+    query,
+    tags: ["Protocols"],
+});

package/dist/src/routes/v3/opportunity.js

@@ -0,0 +1,63 @@
+import { Redis } from "../../cache";
+import { t } from "elysia";
+import { fillCampaigns } from "../../entities/opportunity";
+import param from "../../types/parameters";
+export const query = t.Object({
+    campaigns: t.Optional(t.Boolean()),
+    testTokens: t.Optional(t.Boolean()),
+    mainParameter: t.Optional(param.MainParameter.type),
+    chainId: t.Optional(param.Chain.type),
+    type: t.Optional(param.Type.type),
+    action: t.Optional(param.Action.type),
+    tag: t.Optional(t.String()),
+});
+export const response = t.Record(t.TemplateLiteral([param.Type.type, t.Literal("_"), param.MainParameter.type]), t.Object({
+    id: t.TemplateLiteral([param.Type.type, t.Literal("_"), param.MainParameter.type]),
+    name: t.String(),
+    chainId: param.Chain.type,
+    action: t.String(),
+    status: t.String(),
+    tags: t.Optional(t.Array(t.String())),
+    tokenIcons: t.Array(t.String()),
+    rewardTokenIcons: t.Array(t.String()),
+    dailyRewardTokens: t.Unknown(),
+    campaigns: t.Object({ type: t.Number() }, { additionalProperties: true }),
+}));
+export default (app) => {
+    return app.get("", async ({ query: { campaigns: showCampaigns, ...filters } }) => {
+        const opportunities = await Redis.get(filters?.testTokens ? "OpportunitiesWithTest" : "Opportunities");
+        const returnedOpportunities = {};
+        const corresponds = (opp) => {
+            if (filters.type !== undefined && filters.type !== opp.campaigns.type)
+                return false;
+            if (filters.action !== undefined && filters.action !== opp.action)
+                return false;
+            if (filters.chainId !== undefined && filters.chainId !== opp.chainId)
+                return false;
+            if (filters.mainParameter !== undefined &&
+                filters.mainParameter?.toLowerCase() !== opp.id.split("_")?.[1]?.toLowerCase())
+                return false;
+            if (filters.tag !== undefined && !opp.tags?.includes(filters.tag))
+                return false;
+            return true;
+        };
+        for (const [id, opportunity] of Object.entries(opportunities)) {
+            if (!corresponds(opportunity))
+                continue;
+            returnedOpportunities[id] = opportunity;
+        }
+        if (!showCampaigns)
+            return returnedOpportunities;
+        return await fillCampaigns(returnedOpportunities, !showCampaigns, filters.testTokens);
+    }, {
+        transform({ query }) {
+            query.chainId = !query.chainId ? undefined : Number.parseInt(query.chainId);
+            query.type = !query.type ? undefined : Number.parseInt(query.type);
+            query.campaigns = query.campaigns === "false" ? false : !!query.campaigns;
+            query.testTokens = query.testTokens === "false" ? false : !!query.testTokens;
+        },
+        query,
+        response: { 200: response },
+        tags: ["Opportunity"],
+    });
+};