@merkl/api 0.19.13 → 0.19.15

package/dist/src/engine/opportunityMetadata/implementations/JsonAirdrop.d.ts

@@ -10,6 +10,14 @@ export declare class JsonAirdropMetadata implements MetadataBuilder<campaignType
             address: string;
         }[];
         mainProtocol: string | undefined;
+        depositUrl?: undefined;
+    } | {
+        action: "DROP";
+        name: string;
+        tokens: never[];
+        mainProtocol: string | undefined;
+        depositUrl: any;
     }>;
+    static generateUrl(_computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): any;
 }
 export {};

package/dist/src/engine/opportunityMetadata/implementations/JsonAirdrop.js

@@ -32,7 +32,11 @@ export class JsonAirdropMetadata {
                 name: `${prefix} ${params.symbolRewardToken}`,
                 tokens: [],
                 mainProtocol: aavePrefix || aciPrefix ? "aave" : undefined,
+                depositUrl: JsonAirdropMetadata.generateUrl(computeChainId, params),
             };
         }
     }
+    static generateUrl(_computeChainId, params) {
+        return params.jsonUrl;
+    }
 }

package/dist/src/engine/opportunityMetadata/implementations/Morpho.d.ts

@@ -10,6 +10,8 @@ export declare class MorphoMetadata implements MetadataBuilder<campaignType> {
         }[];
         name: string;
         mainProtocol: string;
+        depositUrl: string | undefined;
     }>;
+    static generateUrl(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"], subType: CampaignParameters<campaignType>["campaignSubType"]): string | undefined;
 }
 export {};

package/dist/src/engine/opportunityMetadata/implementations/Morpho.js

@@ -1,5 +1,5 @@
 import { OpportunityAction } from "@db/api";
-import { BN2Number } from "@sdk";
+import { BN2Number, MorphoSubCampaignType, NETWORK_LABELS, } from "@sdk";
 export class MorphoMetadata {
     async build(computeChainId, params, subType) {
         const morphoParams = params;
@@ -16,6 +16,22 @@ export class MorphoMetadata {
             tokens: [{ chainId: computeChainId, address: params.targetToken }],
             name: subtype.name,
             mainProtocol: "morpho",
+            depositUrl: MorphoMetadata.generateUrl(computeChainId, params, subType),
         };
     }
+    static generateUrl(computeChainId, params, subType) {
+        switch (subType) {
+            case MorphoSubCampaignType.META: {
+                return `https://app.morpho.org/vault?vault=${params.targetToken}&network=${NETWORK_LABELS[computeChainId]?.toLowerCase()}`;
+            }
+            case MorphoSubCampaignType.SUPPLY_BLUE: {
+                return `https://app.morpho.org/?network=${NETWORK_LABELS[computeChainId]?.toLowerCase()}`;
+            }
+            case MorphoSubCampaignType.BORROWING_BLUE:
+            case MorphoSubCampaignType.COLLATERAL_BLUE: {
+                const typedParams = params;
+                return `https://app.morpho.org/market?id=${typedParams.marketId}&network=${NETWORK_LABELS[computeChainId]?.toLowerCase()}`;
+            }
+        }
+    }
 }

package/dist/src/index.d.ts

@@ -1246,6 +1246,175 @@ declare const app: Elysia<"", false, {
                     };
                 };
             };
+        } & {
+            "dry-run": {
+                ":campaignId": {
+                    "dynamic-data": {
+                        get: {
+                            body: unknown;
+                            params: {
+                                campaignId: string;
+                            };
+                            query: unknown;
+                            headers: {
+                                authorization: string;
+                            };
+                            response: {
+                                200: unknown[];
+                            };
+                        };
+                    };
+                };
+            };
+        } & {
+            "dry-run": {
+                ":campaignId": {
+                    "meta-data": {
+                        get: {
+                            body: unknown;
+                            params: {
+                                campaignId: string;
+                            };
+                            query: unknown;
+                            headers: {
+                                authorization: string;
+                            };
+                            response: {
+                                200: {
+                                    id: string;
+                                    chainId: number;
+                                    type: string;
+                                    identifier: string;
+                                    name: string;
+                                    status: "PAST" | "LIVE" | "SOON";
+                                    action: any;
+                                    tokens: ({
+                                        symbol: string;
+                                        id: string;
+                                        name: string | null;
+                                        icon: string;
+                                        address: string;
+                                        chainId: number;
+                                        decimals: number;
+                                        verified: boolean;
+                                        isTest: boolean;
+                                        isPoint: boolean;
+                                        isNative: boolean;
+                                    } & {
+                                        price?: number | null | undefined;
+                                    })[][];
+                                    mainProtocol: string | undefined;
+                                    depositUrl: any;
+                                    tags: string[];
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        } & {
+            index: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: {
+                        type?: string | undefined;
+                        status?: "NONE" | "PAST" | "LIVE" | "SOON" | undefined;
+                        items?: number | undefined;
+                        subType?: number | undefined;
+                        page?: number | undefined;
+                        types?: string[] | undefined;
+                        campaignId?: string | undefined;
+                        opportunityId?: string | undefined;
+                        startTimestamp?: string | undefined;
+                        endTimestamp?: string | undefined;
+                        creatorAddress?: string | undefined;
+                        chainId?: number | undefined;
+                        creatorId?: string | undefined;
+                        mainParameter?: string | undefined;
+                        point?: boolean | undefined;
+                        tokenAddress?: string | undefined;
+                        test?: boolean | undefined;
+                        creatorTag?: string | undefined;
+                        distributionChainIds?: number[] | undefined;
+                        tokenSymbol?: string | undefined;
+                        withOpportunity?: boolean | undefined;
+                        createdAfter?: Date | null | undefined;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: {
+                            params: any;
+                            chain: {
+                                id: number;
+                                name: string;
+                                icon: string;
+                            };
+                            endTimestamp: number;
+                            startTimestamp: number;
+                            rewardToken: {
+                                symbol: string;
+                                id: string;
+                                name: string | null;
+                                icon: string;
+                                address: string;
+                                chainId: number;
+                                decimals: number;
+                                verified: boolean;
+                                isTest: boolean;
+                                isPoint: boolean;
+                                isNative: boolean;
+                            } & {
+                                price?: number | null | undefined;
+                            };
+                            distributionChain: {
+                                id: number;
+                                name: string;
+                                icon: string;
+                            } | undefined;
+                            campaignStatus: {
+                                computedUntil: number;
+                                processingStarted: number;
+                                error: string;
+                                status: import("@db/api").$Enums.RunStatus;
+                                details: import("database/api/.generated/runtime/library").JsonValue;
+                                campaignId: string;
+                            } | undefined;
+                            creatorAddress: string;
+                            creator: {
+                                tags: string[];
+                                address: string;
+                                creatorId: string | null;
+                            };
+                            createdAt: string;
+                            Opportunity: {
+                                id: string;
+                                name: string;
+                                type: string;
+                                status: import("@db/api").$Enums.Status;
+                                tags: string[];
+                                identifier: string;
+                                action: import("@db/api").$Enums.OpportunityAction;
+                                chainId: number;
+                                depositUrl: string | null;
+                                mainProtocolId: string | null;
+                                tvl: number;
+                                apr: number;
+                                dailyRewards: number;
+                            };
+                            id: string;
+                            type: string;
+                            subType: number | null;
+                            computeChainId: number;
+                            distributionChainId: number;
+                            campaignId: string;
+                            rewardTokenId: string;
+                            amount: string;
+                            opportunityId: string;
+                        }[];
+                    };
+                };
+            };
         } & {
             ":id": {
                 get: {

package/dist/src/modules/v4/campaign/campaign.controller.d.ts

@@ -163,6 +163,175 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                 };
             };
         };
+    } & {
+        "dry-run": {
+            ":campaignId": {
+                "dynamic-data": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            campaignId: string;
+                        };
+                        query: unknown;
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: unknown[];
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        "dry-run": {
+            ":campaignId": {
+                "meta-data": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            campaignId: string;
+                        };
+                        query: unknown;
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: {
+                                id: string;
+                                chainId: number;
+                                type: string;
+                                identifier: string;
+                                name: string;
+                                status: "PAST" | "LIVE" | "SOON";
+                                action: any;
+                                tokens: ({
+                                    symbol: string;
+                                    id: string;
+                                    name: string | null;
+                                    icon: string;
+                                    address: string;
+                                    chainId: number;
+                                    decimals: number;
+                                    verified: boolean;
+                                    isTest: boolean;
+                                    isPoint: boolean;
+                                    isNative: boolean;
+                                } & {
+                                    price?: number | null | undefined;
+                                })[][];
+                                mainProtocol: string | undefined;
+                                depositUrl: any;
+                                tags: string[];
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        index: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    type?: string | undefined;
+                    status?: "NONE" | "PAST" | "LIVE" | "SOON" | undefined;
+                    items?: number | undefined;
+                    subType?: number | undefined;
+                    page?: number | undefined;
+                    types?: string[] | undefined;
+                    campaignId?: string | undefined;
+                    opportunityId?: string | undefined;
+                    startTimestamp?: string | undefined;
+                    endTimestamp?: string | undefined;
+                    creatorAddress?: string | undefined;
+                    chainId?: number | undefined;
+                    creatorId?: string | undefined;
+                    mainParameter?: string | undefined;
+                    point?: boolean | undefined;
+                    tokenAddress?: string | undefined;
+                    test?: boolean | undefined;
+                    creatorTag?: string | undefined;
+                    distributionChainIds?: number[] | undefined;
+                    tokenSymbol?: string | undefined;
+                    withOpportunity?: boolean | undefined;
+                    createdAfter?: Date | null | undefined;
+                };
+                headers: unknown;
+                response: {
+                    200: {
+                        params: any;
+                        chain: {
+                            id: number;
+                            name: string;
+                            icon: string;
+                        };
+                        endTimestamp: number;
+                        startTimestamp: number;
+                        rewardToken: {
+                            symbol: string;
+                            id: string;
+                            name: string | null;
+                            icon: string;
+                            address: string;
+                            chainId: number;
+                            decimals: number;
+                            verified: boolean;
+                            isTest: boolean;
+                            isPoint: boolean;
+                            isNative: boolean;
+                        } & {
+                            price?: number | null | undefined;
+                        };
+                        distributionChain: {
+                            id: number;
+                            name: string;
+                            icon: string;
+                        } | undefined;
+                        campaignStatus: {
+                            computedUntil: number;
+                            processingStarted: number;
+                            error: string;
+                            status: import("@db/api").$Enums.RunStatus;
+                            details: import("database/api/.generated/runtime/library").JsonValue;
+                            campaignId: string;
+                        } | undefined;
+                        creatorAddress: string;
+                        creator: {
+                            tags: string[];
+                            address: string;
+                            creatorId: string | null;
+                        };
+                        createdAt: string;
+                        Opportunity: {
+                            id: string;
+                            name: string;
+                            type: string;
+                            status: import("@db/api").$Enums.Status;
+                            tags: string[];
+                            identifier: string;
+                            action: import("@db/api").$Enums.OpportunityAction;
+                            chainId: number;
+                            depositUrl: string | null;
+                            mainProtocolId: string | null;
+                            tvl: number;
+                            apr: number;
+                            dailyRewards: number;
+                        };
+                        id: string;
+                        type: string;
+                        subType: number | null;
+                        computeChainId: number;
+                        distributionChainId: number;
+                        campaignId: string;
+                        rewardTokenId: string;
+                        amount: string;
+                        opportunityId: string;
+                    }[];
+                };
+            };
+        };
     } & {
         ":id": {
             get: {

package/dist/src/modules/v4/campaign/campaign.controller.js

@@ -6,6 +6,7 @@ import { Campaign } from "@sdk";
 import Elysia, { t } from "elysia";
 import { throwOnUnsupportedChainId } from "src/utils/throw";
 import { DynamicDataService } from "../dynamicData/dynamicData.service";
+import { OpportunityService } from "../opportunity";
 import { CampaignResourceDto, CreateCampaignDto, GetCampaignQueryDto, RemoveManualOverrideDto, UpdateCampaignCreatorDto, UpdateCampaignDto, UpdateMetaDataCampaignDto, } from "./campaign.model";
 import { CampaignService } from "./campaign.service";
 // ─── Campaigns Controller ────────────────────────────────────────────────────
@@ -66,6 +67,67 @@ export const CampaignController = new Elysia({ prefix: "/campaigns", detail: { t
     };
     return await DynamicDataService.updateForCampaigns([campaignV3]);
 }, { beforeHandle: BackOfficeGuard, headers: AuthorizationHeadersDto, detail: { hide: true } })
+    // ─── Test Dynamic and MetaData ──────────────────────────────────────────────
+    .get("/dry-run/:campaignId/dynamic-data", async ({ params }) => {
+    const id = (await CampaignService.findMany({ campaignId: params.campaignId, test: true }))[0].id;
+    if (!id)
+        throw new NotFoundError();
+    const campaign = await CampaignService.findUniqueOrThrow(id, true);
+    const campaignV3 = {
+        amount: campaign.amount,
+        campaignId: campaign.campaignId,
+        mainParameter: campaign.Opportunity.identifier,
+        campaignParameters: campaign.params,
+        campaignSubType: campaign.subType,
+        campaignType: Campaign[campaign.type],
+        chainId: campaign.distributionChainId,
+        computeChainId: campaign.computeChainId,
+        creator: campaign.creatorAddress,
+        endTimestamp: Number(campaign.endTimestamp),
+        rewardToken: campaign.RewardToken.address,
+        startTimestamp: Number(campaign.startTimestamp),
+        index: 0,
+    };
+    return await DynamicDataService.updateForCampaigns([campaignV3], true);
+}, { beforeHandle: BackOfficeGuard, headers: AuthorizationHeadersDto, detail: { hide: true } })
+    .get("/dry-run/:campaignId/meta-data", async ({ params }) => {
+    const id = (await CampaignService.findMany({ campaignId: params.campaignId, test: true }))[0].id;
+    if (!id)
+        throw new NotFoundError();
+    const campaign = await CampaignService.findUniqueOrThrow(id, true);
+    const campaignV3 = {
+        amount: campaign.amount,
+        campaignId: campaign.campaignId,
+        mainParameter: campaign.Opportunity.identifier,
+        campaignParameters: campaign.params,
+        campaignSubType: campaign.subType,
+        chainId: campaign.distributionChainId,
+        computeChainId: campaign.computeChainId,
+        creator: campaign.creatorAddress,
+        endTimestamp: campaign.endTimestamp.toString(),
+        rewardToken: campaign.RewardToken.address,
+        startTimestamp: campaign.startTimestamp.toString(),
+        index: 0,
+        type: Campaign[campaign.type],
+        params: JSON.stringify(campaign.params),
+        rewardTokenAddress: campaign.RewardToken.address,
+        opportunityIdentifier: campaign.Opportunity.identifier,
+    };
+    return await OpportunityService.fakeCreateFromCampaign(campaignV3);
+}, { beforeHandle: BackOfficeGuard, headers: AuthorizationHeadersDto, detail: { hide: true } })
+    // ─── Get Many Campaigns ──────────────────────────────────────────────
+    .get("/", async ({ query }) => {
+    if (query.items === 0)
+        throw new HttpError("Bad Request: Cannot retrieve 0 items", 400);
+    return await CampaignService.findMany(query);
+}, {
+    query: GetCampaignQueryDto,
+    response: t.Array(CampaignResourceDto),
+    detail: {
+        description: `**Retrieve Multiple Campaigns**
+      <p>This endpoint enables you to search for campaigns by providing specific criteria through query parameters.</p>`,
+    },
+})
     // ─── Get One Campaign ────────────────────────────────────────────────
     .get("/:id", async ({ params }) => {
     try {

package/dist/src/modules/v4/dynamicData/dynamicData.service.d.ts

@@ -9,6 +9,6 @@ export declare class DynamicDataService {
         priceTargetToken: number;
         type: string;
     }>;
-    static updateForCampaignType(campaigns: CampaignParameters<CampaignEnum>[], type: Campaign): Promise<unknown[]>;
-    static updateForCampaigns(campaigns: CampaignParameters<CampaignEnum>[]): Promise<unknown[]>;
+    static updateForCampaignType(campaigns: CampaignParameters<CampaignEnum>[], type: Campaign, dryRun?: boolean): Promise<unknown[]>;
+    static updateForCampaigns(campaigns: CampaignParameters<CampaignEnum>[], dryRun?: boolean): Promise<unknown[]>;
 }

package/dist/src/modules/v4/dynamicData/dynamicData.service.js

@@ -52,7 +52,7 @@ export class DynamicDataService {
             type: result[0]?.type ?? "defaultType",
         };
     }
-    static async updateForCampaignType(campaigns, type) {
+    static async updateForCampaignType(campaigns, type, dryRun = false) {
         const chainId = campaigns[0].computeChainId;
         const dynamicDataArray = [];
         const dynamicData = await dynamicDataBuilderFactory(typeof type === "number" ? type : Campaign[type]).build(chainId, campaigns);
@@ -78,7 +78,8 @@ export class DynamicDataService {
                 type: Campaign[+type],
             });
             try {
-                await OpportunityRepository.updateRecords(opportunityId, apr, tvl, dailyRewards);
+                if (!dryRun)
+                    await OpportunityRepository.updateRecords(opportunityId, apr, tvl, dailyRewards);
             }
             catch (err) {
                 throw new HttpError("Failed to update dynamic data", 500, {
@@ -97,7 +98,7 @@ export class DynamicDataService {
         }
         return dynamicDataArray;
     }
-    static async updateForCampaigns(campaigns) {
+    static async updateForCampaigns(campaigns, dryRun = false) {
         const campaignTypeToCampaigns = new Map();
         for (const campaign of campaigns) {
             const type = campaign.campaignType;
@@ -113,7 +114,7 @@ export class DynamicDataService {
             try {
                 log.info(`updating dynamic data for ${campaigns.length} campaigns of type ${CampaignEnum[campaignType]}`);
                 try {
-                    dynamicDataArray.push(await DynamicDataService.updateForCampaignType(campaigns, campaignType));
+                    dynamicDataArray.push(await DynamicDataService.updateForCampaignType(campaigns, campaignType, dryRun));
                 }
                 catch (err) {
                     console.error(`Failed to update dynamic data for campaign type ${CampaignEnum[campaignType]}`, err);

package/dist/src/modules/v4/opportunity/opportunity.service.d.ts

@@ -32,8 +32,23 @@ export declare abstract class OpportunityService {
         type: string;
         identifier: string;
         name: string;
-        status: "SOON";
+        status: "PAST" | "LIVE" | "SOON";
         action: OpportunityAction;
+        tokens: ({
+            symbol: string;
+            id: string;
+            name: string | null;
+            icon: string;
+            address: string;
+            chainId: number;
+            decimals: number;
+            verified: boolean;
+            isTest: boolean;
+            isPoint: boolean;
+            isNative: boolean;
+        } & {
+            price?: number | null | undefined;
+        })[][];
         mainProtocol: string | undefined;
         depositUrl: any;
         tags: string[];

package/dist/src/modules/v4/opportunity/opportunity.service.js

@@ -10,6 +10,7 @@ import { Prisma, Status } from "@db/api";
 import { Campaign as CampaignEnum } from "@sdk";
 import moment from "moment";
 import { metadataBuilderFactory } from "../../../engine/opportunityMetadata/factory";
+import { ProtocolService } from "../protocol/protocol.service";
 import { OpportunityRepository } from "./opportunity.repository";
 export class OpportunityService {
     static hashId(opportunity) {
@@ -44,17 +45,36 @@ export class OpportunityService {
             identifier: campaign.opportunityIdentifier,
             type: campaignType,
         });
+        const protocol = (await ProtocolService.findMany({ id: metadata.mainProtocol }))?.[0];
+        const tokens = await Promise.all(metadata.tokens.map(async (t) => {
+            return await TokenService.findMany(t);
+        }));
         const params = JSON.parse(campaign.params);
+        const now = moment().unix();
         const opportunity = {
             id: opportunityId,
             chainId: campaign.computeChainId,
             type: campaignType,
             identifier: campaign.opportunityIdentifier, // mainParameter
             name: metadata.name,
-            status: Status.SOON,
+            status: now >= +campaign.startTimestamp && now < +campaign.endTimestamp
+                ? Status.LIVE
+                : now > +campaign.endTimestamp
+                    ? Status.PAST
+                    : Status.SOON,
             action: metadata.action,
+            tokens,
             mainProtocol: metadata.mainProtocol,
-            depositUrl: !!params.url ? params.url : undefined,
+            // If creator has specified a deposit URL, use it
+            // Else if we have the specific logic to handle the deposit URL, use it
+            // Else if the protocol has a deposit URL, use it
+            depositUrl: !!params.url
+                ? params.url
+                : !!metadata.depositUrl
+                    ? metadata.depositUrl
+                    : !!metadata.mainProtocol && !!protocol.url
+                        ? protocol.url
+                        : undefined,
             tags,
         };
         return opportunity;
@@ -69,8 +89,9 @@ export class OpportunityService {
             type: campaignType,
         });
         const tokens = (await TokenService.findManyOrCreate(metadata.tokens)).filter(t => t !== undefined);
-        const params = JSON.parse(campaign.params);
         const now = moment().unix();
+        const protocol = (await ProtocolService.findMany({ id: metadata.mainProtocol }))?.[0];
+        const params = JSON.parse(campaign.params);
         const opportunity = {
             id: opportunityId,
             chainId: campaign.computeChainId,
@@ -85,7 +106,16 @@ export class OpportunityService {
             action: metadata.action,
             tokens,
             mainProtocol: metadata.mainProtocol,
-            depositUrl: !!params.url ? params.url : undefined,
+            // If creator has specified a deposit URL, use it
+            // Else if we have the specific logic to handle the deposit URL, use it
+            // Else if the protocol has a deposit URL, use it
+            depositUrl: !!params.url
+                ? params.url
+                : !!metadata.depositUrl
+                    ? metadata.depositUrl
+                    : !!metadata.mainProtocol && !!protocol.url
+                        ? protocol.url
+                        : undefined,
             tags,
         };
         await OpportunityRepository.create(opportunity, upsert);