@merkl/api 0.9.15

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

@@ -0,0 +1,136 @@
+import { Redis } from "@/cache";
+import { removeTestTokens } from "@/entities/campaign";
+import { CampaignService } from "@/modules/v4/campaign";
+import { OpportunityConvertorService } from "@/modules/v4/opportunity/opportunity.converter";
+import { ANGLE_NETWORKS, Campaign as CampaignEnum, ChainId, isSupportedChain, registry, } from "@sdk";
+import { t } from "elysia";
+import { UnsupportedNetwork } from "../../utils/error";
+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 => CampaignEnum[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 = CampaignEnum[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 || removeTestTokens(allData[curr]))) {
+                    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.d.ts

@@ -0,0 +1,54 @@
+import { type Elysia } from "elysia";
+/**
+ * @deprecated - conversion to v4 done
+ */
+type CampaignsForMainParameterReturnType = {
+    campaignId: string;
+    campaignType: number;
+    rewardToken: string;
+    rewardTokenSymbol: string;
+    amountDecimal: number;
+    startTimestamp: number;
+    endTimestamp: number;
+}[];
+export declare const query: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    mainParameter: import("@sinclair/typebox").TString;
+}>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    campaignsForMainParameter: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                chainId: number;
+                mainParameter: string;
+            };
+            headers: unknown;
+            response: {
+                200: CampaignsForMainParameterReturnType;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;

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

@@ -0,0 +1,33 @@
+import { NotFoundError } from "@/errors";
+import { OpportunityService } from "@/modules/v4/opportunity";
+import { BN2Number, Campaign as CampaignEnum } 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: CampaignEnum[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.d.ts

@@ -0,0 +1,47 @@
+import { type Elysia } from "elysia";
+/**
+ * @deprecated - conversion to v4 done
+ */
+export declare const query: import("@sinclair/typebox").TObject<{
+    chain_campaignIds: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    from: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    to: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    campaignsRewardsReport: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                from?: number | undefined;
+                to?: number | undefined;
+                chain_campaignIds: string[];
+            };
+            headers: unknown;
+            response: {
+                200: any[];
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;

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

@@ -0,0 +1,48 @@
+import { RewardService } from "@/modules/v4/reward";
+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.d.ts

@@ -0,0 +1,48 @@
+import { type Elysia } from "elysia";
+export declare const query: import("@sinclair/typebox").TObject<{
+    creatorTag: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    chainIds: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>]>>;
+    byReason: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    user: import("@sinclair/typebox").TString;
+}>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    claims: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                chainIds?: string | string[] | undefined;
+                creatorTag?: string | undefined;
+                byReason?: boolean | undefined;
+                user: string;
+            };
+            headers: unknown;
+            response: {
+                200: {
+                    message: string;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;

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

@@ -0,0 +1,16 @@
+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.d.ts

@@ -0,0 +1,42 @@
+import { type Elysia } from "elysia";
+export declare const response: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+    address: import("@sinclair/typebox").TString;
+    asset: import("@sinclair/typebox").TString;
+    chaind: import("@sinclair/typebox").TNumber;
+    debtTokenAddress: import("@sinclair/typebox").TString;
+}>>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    compoundV2: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {};
+            headers: unknown;
+            response: {
+                [x: string]: any;
+                200: any;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;

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

@@ -0,0 +1,9 @@
+import { getCompoundV2ForksVaultsWithCache } from "@/engine/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.d.ts

@@ -0,0 +1,47 @@
+import type Elysia from "elysia";
+export declare const query: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    user: import("@sinclair/typebox").TString;
+}>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    createCampaign: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                chainId: number;
+                user: string;
+            };
+            headers: unknown;
+            response: {
+                200: {
+                    feeRebate: number | undefined;
+                    message: any;
+                    signed: boolean | undefined;
+                    validRewardTokens: any;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;

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("/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.d.ts

@@ -0,0 +1,46 @@
+import type Elysia from "elysia";
+export declare const query: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+}>;
+export declare const response: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+    index: import("@sinclair/typebox").TNumber;
+    token: import("@sinclair/typebox").TString;
+    symbol: import("@sinclair/typebox").TString;
+}>>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    dolomite: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                chainId: number;
+            };
+            headers: unknown;
+            response: {
+                [x: string]: any;
+                200: any;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;

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

@@ -0,0 +1,12 @@
+import { getDolomiteMarketWithCache } from "@/engine/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.d.ts

@@ -0,0 +1,53 @@
+import { type Elysia } from "elysia";
+export declare const response: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+    address: import("@sinclair/typebox").TString;
+    asset: import("@sinclair/typebox").TString;
+    chaind: import("@sinclair/typebox").TNumber;
+    debtTokenAddress: import("@sinclair/typebox").TString;
+}>>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    euler: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {};
+            headers: unknown;
+            response: {
+                200: EulerVaultType[];
+            };
+        };
+    };
+} & {
+    "euler-update-collat": {
+        get: {
+            body: unknown;
+            params: {};
+            query: {};
+            headers: unknown;
+            response: {
+                200: void;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;

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

@@ -0,0 +1,17 @@
+import { getEulerV2VaultsWithCache, updateEulerVaultsCollatInDatabase, } from "@/engine/dynamicData/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("/euler", async () => {
+    return await getEulerV2VaultsWithCache();
+}, {
+    query: t.Object({}),
+    tags: ["euler"],
+})
+    // DO NOT MODIFY THIS LINE, USED FOR DEBUGGING PURPOSES
+    .get("/euler-update-collat", async () => {
+    return await updateEulerVaultsCollatInDatabase();
+}, {
+    query: t.Object({}),
+    tags: ["euler"],
+});