@merkl/api 0.21.46 → 1.0.0

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

@@ -1,136 +0,0 @@
-import { Redis } from "@/cache";
-import { CampaignService } from "@/modules/v4/campaign/campaign.service";
-import { OpportunityConvertorService } from "@/modules/v4/opportunity/opportunity.converter";
-import { UnsupportedNetwork } from "@/utils/error";
-import { ANGLE_NETWORKS, Campaign as CampaignType, ChainId, isSupportedChain, registry, } from "@sdk";
-import { t } from "elysia";
-export const query = t.Object({
-    chainIds: t.Optional(t.Union([t.String(), t.Array(t.String())])),
-    types: t.Optional(t.Union([t.Numeric(), t.Array(t.Numeric()), t.String(), t.Array(t.String())])),
-    live: t.Optional(t.BooleanString()),
-    creatorTag: t.Optional(t.String()),
-    hideTestTokens: t.Optional(t.String()),
-});
-export const response = t.Record(t.Union(ANGLE_NETWORKS.merkl.map(chain => t.Literal(`${chain}`))), t.Optional(t.Record(t.String({ title: "id" }), t.Record(t.String({ title: "CampaignId" }), t.Object({
-    chainId: t.Numeric(),
-    campaignId: t.String(),
-    tags: t.Optional(t.Array(t.String())),
-    creator: t.String(),
-    rewardToken: t.String(),
-    mainParameter: t.String(),
-    campaignParameters: t.Object({}),
-    campaignType: t.String(),
-})))));
-/**
- * @deprecated - conversion to v4 done
- *
- * @dev there was a significant loss of information with the v4 conversion
- * So some issues are expected
- *
- * v3 was returning a whole bunch of dynamic data when the v4 only has tvl and apr
- */
-export default (app) => app.get("/campaigns", async ({ query }) => {
-    let hideTestTokens = false;
-    if (typeof query.hideTestTokens === "string" && query.hideTestTokens === "true") {
-        hideTestTokens = true;
-    }
-    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));
-    }
-    const rawTypes = query.types;
-    let types = [];
-    if (!rawTypes) {
-    }
-    else if (Number.parseInt(rawTypes.toString()).toString() === rawTypes.toString()) {
-        types = [Number.parseInt(rawTypes.toString())];
-    }
-    else {
-        types = rawTypes.map(type => Number.parseInt(type.toString()));
-    }
-    for (const chainId of chainIds) {
-        if (!!chainId &&
-            (!isSupportedChain(chainId, "merkl") ||
-                !registry(chainId)?.Merkl?.DistributionCreator ||
-                !registry(chainId)?.Merkl?.Distributor ||
-                !registry(chainId)?.Merkl?.CoreMerkl)) {
-            throw new UnsupportedNetwork(chainId);
-        }
-    }
-    if (process.env.FF_OPPORTUNITY === "true") {
-        const campaigns = await CampaignService.findMany({
-            distributionChainIds: chainIds,
-            types: !types.length ? undefined : types.map(type => CampaignType[type]),
-            status: query.live ? "LIVE" : undefined,
-            creatorTag: query.creatorTag,
-            test: !hideTestTokens,
-            withOpportunity: true,
-        });
-        const res = {};
-        for (const campaign of campaigns) {
-            if (!res[campaign.distributionChainId]) {
-                res[campaign.distributionChainId] = {};
-            }
-            const opportunityIdentifier = campaign.Opportunity.identifier;
-            const campaignType = CampaignType[campaign.type];
-            if (!res[campaign.distributionChainId][`${campaignType}_${opportunityIdentifier}`]) {
-                res[campaign.distributionChainId][`${campaignType}_${opportunityIdentifier}`] = {
-                    ...OpportunityConvertorService.convertV4CampaignToV3(campaignType, campaign, opportunityIdentifier),
-                    apr: campaign.Opportunity.apr,
-                    tvl: campaign.Opportunity.tvl,
-                };
-            }
-        }
-        return res;
-    }
-    const campaignCachePrefix = query.live === true ? "LiveCampaigns" : "Campaigns";
-    const dynamicData = (await Redis.getManyWithArgs(campaignCachePrefix, chainIds)).reduce((prev, allData, index) => {
-        if (!!allData) {
-            prev[chainIds[index]] = Object.keys(allData).reduce((acc, curr) => {
-                if ((types.length === 0 || types.includes(Number.parseInt(curr.split("_")[0]))) &&
-                    (!hideTestTokens ||
-                        !["aglamerkl", "test"].includes(allData[curr].campaignParameters.symbolRewardToken?.toLowerCase()))) {
-                    acc[curr] = allData[curr];
-                }
-                return acc;
-            }, {});
-        }
-        return prev;
-    }, {});
-    // Remove everything that doesn't contain the creator tag
-    if (!!query.creatorTag) {
-        for (const c of Object.keys(dynamicData)) {
-            for (const type_mainParam of Object.keys(dynamicData[c])) {
-                for (const campaignId of Object.keys(dynamicData[c][type_mainParam])) {
-                    if (!dynamicData[c][type_mainParam][campaignId]?.tags?.includes(query.creatorTag)) {
-                        delete dynamicData[c][type_mainParam][campaignId];
-                    }
-                }
-                // Delete the type_mainParam if it's empty
-                if (Object.keys(dynamicData[c][type_mainParam]).length === 0) {
-                    delete dynamicData[c][type_mainParam];
-                }
-            }
-            // Delete the c if it's empty
-            if (Object.keys(dynamicData[c]).length === 0) {
-                delete dynamicData[c];
-            }
-        }
-    }
-    return dynamicData;
-}, {
-    query,
-    tags: ["Campaigns"],
-});

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

@@ -1,33 +0,0 @@
-import { NotFoundError } from "@/errors";
-import { OpportunityService } from "@/modules/v4/opportunity/opportunity.service";
-import { BN2Number, Campaign as CampaignType } from "@sdk";
-import { t } from "elysia";
-import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
-export const query = t.Object({
-    chainId: t.Numeric(),
-    mainParameter: t.String(),
-});
-export default (app) => app.use(checkQueryChainIdValidity()).get("/campaignsForMainParameter", async ({ query }) => {
-    const chainId = query.chainId;
-    const opportunityId = (await OpportunityService.findMany({
-        chainId: chainId.toString(),
-        identifier: query.mainParameter,
-    }))?.[0]?.id;
-    if (!opportunityId) {
-        throw new NotFoundError(`Opportunity not found for identifier: ${query.mainParameter} and chainId: ${chainId}`);
-    }
-    return (await OpportunityService.getUniqueWithCampaignsOrThrow(opportunityId))?.campaigns
-        ?.map(c => ({
-        campaignId: c.campaignId,
-        campaignType: CampaignType[c.type],
-        rewardToken: c.rewardToken.address,
-        rewardTokenSymbol: c.rewardToken.symbol,
-        amountDecimal: BN2Number(c.amount, c.rewardToken.decimals),
-        startTimestamp: Number(c.startTimestamp),
-        endTimestamp: Number(c.endTimestamp),
-    }))
-        .sort((a, b) => b.endTimestamp - a.endTimestamp);
-}, {
-    query,
-    tags: ["Campaigns"],
-});

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

@@ -1,48 +0,0 @@
-import { RewardService } from "@/modules/v4/reward/reward.service";
-import { t } from "elysia";
-/**
- * @deprecated - conversion to v4 done
- */
-export const query = t.Object({
-    chain_campaignIds: t.Array(t.String(), {
-        style: "pipeDelimited",
-        examples: {
-            "Shuffle on Ethereum": {
-                value: "1_0xf69d17aa75d36c4a9c6402fd9abc012b66a7947acaa2b20b267fe3ef10733421|1_0x817b90779d8b6789b832c9bafe9aaa22bc907f072dedb31ef0bfb280bf6a037e",
-            },
-        },
-    }),
-    from: t.Optional(t.Numeric()),
-    to: t.Optional(t.Numeric()),
-});
-export default (app) => app.get("/campaignsRewardsReport", async ({ query: { chain_campaignIds } }) => {
-    const rewards = [];
-    const campaigns = chain_campaignIds.map(c_c => {
-        const [chain, campaignId] = c_c.split("_");
-        return [Number.parseInt(chain), campaignId];
-    });
-    for (const [chainId, campaignId] of campaigns) {
-        rewards.push(...(await RewardService.breakdownForCampaign({
-            campaignId,
-            chainId,
-            items: 10_000,
-            page: 0,
-        })).map(x => {
-            return {
-                recipient: x.recipient,
-                reason: x.reason,
-                rewardToken: x.rewardTokenAddress,
-                amount: x.amount,
-            };
-        }));
-    }
-    return rewards;
-}, {
-    transform({ query }) {
-        query.chain_campaignIds =
-            query.chain_campaignIds?.split?.("|") ??
-                query.chain_campaignIds;
-    },
-    query,
-    tags: ["Rewards"],
-});

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

@@ -1,16 +0,0 @@
-import { t } from "elysia";
-import checkQueryAddressValidity from "../../hooks/checkQueryAddressValidity";
-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("/claims", async () => {
-    return {
-        message: "This route is now deprecated removed for performance improvement, please reach out to the team for more information.",
-    };
-}, {
-    query,
-    tags: ["Rewards"],
-});

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

@@ -1,9 +0,0 @@
-import { getCompoundV2ForksVaultsWithCache } from "@/engine/deprecated/dynamicData/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("/compoundV2", async () => {
-    return await getCompoundV2ForksVaultsWithCache();
-}, {
-    query: t.Object({}),
-    tags: ["Protocols"],
-});

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

@@ -1,66 +0,0 @@
-import { executeSimple } from "@/utils/execute";
-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";
-export const query = t.Object({
-    chainId: t.Numeric(),
-    user: t.String(),
-});
-export default (app) => app
-    .use(checkQueryChainIdValidity())
-    .use(checkQueryAddressValidity())
-    .get("/createCampaign", 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

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

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

@@ -1,52 +0,0 @@
-import { getEulerV2Vaults, updateEulerVaultsCollatInDatabase, } from "@/engine/deprecated/dynamicData/utils/getEulerV2Vaults";
-import { AuthorizationHeadersDto, BackOfficeGuard } from "@/guards/BackOffice.guard";
-import { TTLPresets } from "@/modules/v4/cache/cache.model";
-import { CacheService } from "@/modules/v4/cache/cache.service";
-import { ChainUniqueDto } from "@/modules/v4/chain/chain.model";
-import { UnsupportedNetwork } from "@/utils/error";
-import { eulerChainIds } from "@sdk";
-import { t } from "elysia";
-export default (app) => app.group("/euler", router => router
-    .get("/", async () => {
-    return await CacheService.get(getEulerV2Vaults, []);
-}, {
-    tags: ["euler"],
-})
-    .get("/:chainId", async ({ params, query }) => {
-    return (await CacheService.get(getEulerV2Vaults, []))
-        ?.filter(v => v.chainId === params.chainId)
-        .filter(v => (!!query.vaultAddress ? v.address === query.vaultAddress : true));
-}, {
-    params: ChainUniqueDto,
-    query: t.Object({
-        vaultAddress: t.Optional(t.String()),
-    }),
-    beforeHandle: ({ params }) => {
-        if (!eulerChainIds.includes(params.chainId))
-            throw new UnsupportedNetwork(params.chainId);
-    },
-    tags: ["euler"],
-})
-    .post("/update", async () => {
-    await updateEulerVaultsCollatInDatabase();
-    await CacheService.set(TTLPresets.DAY_1, getEulerV2Vaults);
-}, {
-    headers: AuthorizationHeadersDto,
-    beforeHandle: BackOfficeGuard,
-    tags: ["euler"],
-})
-    .post("/update/:chainId", async ({ params }) => {
-    await updateEulerVaultsCollatInDatabase(params.chainId);
-    await CacheService.set(TTLPresets.DAY_1, getEulerV2Vaults);
-    // // DEBUG ONLY
-    // return await getEulerV2Vaults(params.chainId);
-}, {
-    params: ChainUniqueDto,
-    headers: AuthorizationHeadersDto,
-    beforeHandle: async ({ params, headers }) => {
-        if (!eulerChainIds.includes(params.chainId))
-            throw new UnsupportedNetwork(params.chainId);
-        await BackOfficeGuard({ headers });
-    },
-    tags: ["euler"],
-}));

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

@@ -1,27 +0,0 @@
-import { providers } from "@/utils/providers";
-import { DistributionCreator__factory, parseCampaign, registry } from "@sdk";
-import { t } from "elysia";
-import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
-export const query = t.Object({
-    chainId: t.Numeric(),
-    index: t.Numeric(),
-});
-/** Fetch params  */
-export default (app) => app.use(checkQueryChainIdValidity()).get("/fetch", 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, amount: campaignStruct.amount.toString() }, 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

@@ -1,13 +0,0 @@
-import { Redis } from "@/cache";
-import { t } from "elysia";
-export const response = t.Object({ success: t.Boolean() });
-export default (app) => app.get("/health", 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

@@ -1,101 +0,0 @@
-import { Redis } from "@/cache";
-import { TokenService } from "@/modules/v4/token/token.service";
-import { batchMulticallCallWithRetry } from "@/utils/generic";
-import { getLastBlockBeforeWithCache } from "@/utils/lastBlockBefore";
-import { log } from "@/utils/logger";
-import { providers } from "@/utils/providers";
-import { BN2Number, ChainId, DAY, ERC20Interface } from "@sdk";
-import { t } from "elysia";
-import { utils } from "ethers";
-import moment from "moment";
-import checkQueryAddressValidity from "../../hooks/checkQueryAddressValidity";
-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 result = {};
-    const now = moment().unix();
-    const LOOKBACK = 30 * DAY;
-    const AVERAGING_PERIOD = 2 * DAY;
-    const promises = Object.keys(CONSTANTS).map(chainId => (async () => {
-        try {
-            const tokenList = await TokenService.findManyObjectPerAddress({
-                chainId: Number.parseInt(chainId),
-                verified: true,
-            });
-            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[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("/lostyield", 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

@@ -1,119 +0,0 @@
-import { getClamsInfo } from "@/libs/deprecated-merklv3";
-import { InvalidParameter } from "@/utils/error";
-import { throwOnUnsupportedChainId } from "@/utils/throw";
-import { AMM, ChainId, isSupportedChain } from "@sdk";
-import { t } from "elysia";
-import checkQueryAddressValidity from "../../hooks/checkQueryAddressValidity";
-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("/merkl", merklRoute, {
-    // query,
-    tags: ["Merkl"],
-});

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

@@ -1,27 +0,0 @@
-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("/morphoMarkets", async (request) => {
-    const chainId = request.query.chainId;
-    if (request.query.repository !== MorphoSubCampaignType.META.toString())
-        return await getMorphoMarketsWithCache(chainId, request.query.repository);
-}, {
-    query,
-    tags: ["Protocols"],
-});