@merkl/api 0.10.352 → 0.10.353

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

@@ -1,6 +1,53 @@
+import { CampaignType } from "../../../../database/api/.generated";
 import { t } from "elysia";
 // ─── DTOs ────────────────────────────────────────────────────────────────────
 export const DynamicDataSourceIdentifier = t.Object({
     chainId: t.Numeric(),
     tokenAddress: t.String(),
 });
+export const DynamicDataExtendedDto = t.Object({
+    targetTokenSymbol: t.Optional(t.String()),
+});
+export const SimplifiedCampaignDto = t.Object({
+    id: t.Optional(t.String()),
+    distributionChainId: t.Optional(t.Number()),
+    rewardTokenId: t.Optional(t.String()),
+    opportunityId: t.Optional(t.String()),
+    computeChainId: t.Number(),
+    chainId: t.Optional(t.Number()),
+    campaignId: t.Optional(t.String()),
+    identifier: t.Optional(t.String()),
+    creatorAddress: t.Optional(t.String()),
+    type: t.Enum(CampaignType),
+    subType: t.Optional(t.Number()),
+    rewardTokenAddress: t.Optional(t.String()),
+    amount: t.Optional(t.String()),
+    opportunityIdentifier: t.Optional(t.String()),
+    startTimestamp: t.Optional(t.String()),
+    endTimestamp: t.Optional(t.String()),
+    params: t.Object({}),
+    tags: t.Optional(t.Array(t.String())),
+    chain: t.Optional(t.Object({})),
+    rewardToken: t.Optional(t.Object({})),
+    distributionChain: t.Optional(t.Object({})),
+    campaignStatus: t.Optional(t.Object({})),
+});
+export const FilledCampaignDto = t.Object({
+    id: t.String(),
+    distributionChainId: t.Number(),
+    rewardTokenId: t.String(),
+    opportunityId: t.String(),
+    computeChainId: t.Number(),
+    chainId: t.Number(),
+    campaignId: t.String(),
+    identifier: t.String(),
+    creatorAddress: t.String(),
+    type: t.Enum(CampaignType),
+    subType: t.Optional(t.Number()),
+    rewardTokenAddress: t.String(),
+    amount: t.String(),
+    opportunityIdentifier: t.String(),
+    startTimestamp: t.String(),
+    endTimestamp: t.String(),
+    campaignParameters: t.Object({}),
+});

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

@@ -1,4 +1,7 @@
-import { type ChainId } from "@sdk";
+import { CampaignType } from "../../../../database/api/.generated";
+import { Campaign, type ChainId } from "@sdk";
+import { type GetCampaignQueryModel } from "../campaign";
+import type { SimplifiedCampaignDtoModel } from "./dynamicData.model";
 type output = {
     tvl: number;
     totalSupply: number;
@@ -8,7 +11,16 @@ type output = {
     type: string;
 };
 export declare class DynamicDataService {
+    #private;
     /** Fetches a single price */
     static queryERC20DynamicData(chainId: ChainId, tokenAddress: string): Promise<output>;
+    static queryDynamicData(campaign: SimplifiedCampaignDtoModel): Promise<any>;
+    static queryDynamicDataFromCampaignId(query: GetCampaignQueryModel): Promise<any>;
+    /**
+     * Returns the campaign type index from the CampaignType enum
+     * @param type CampaignType as db-related enum for v4
+     * @returns index of Campaign enum from sdk
+     */
+    static getV3FromType(type: CampaignType): Campaign;
 }
 export {};

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

@@ -1,7 +1,10 @@
 import { campaignsDynamicData } from "../../../libs/campaigns/campaignsDynamicData";
 import { executeSimple } from "../../../utils/execute";
 import { log } from "../../../utils/logger";
+import { CampaignType } from "../../../../database/api/.generated";
 import { Campaign, NETWORK_LABELS } from "@sdk";
+import { CampaignService, campaignTypeToEnumMap } from "../campaign";
+import { CampaignRepository } from "../campaign/campaign.repository";
 export class DynamicDataService {
     // ─── DynamicDatas ──────────────────────────────────────────────────────────
     /** Fetches a single price */
@@ -25,13 +28,13 @@ export class DynamicDataService {
                     decimalsRewardToken: 18,
                     decimalsTargetToken: 18,
                     duration: 30,
+                    whitelist: [],
                     forwarders: [],
                     hooks: [],
                     shouldIgnore: false,
                     symbolRewardToken: "EXR",
                     symbolTargetToken: "EXT",
                     targetToken: tokenAddress,
-                    whitelist: [],
                 },
                 campaignType: Campaign.ERC20,
             },
@@ -47,4 +50,52 @@ export class DynamicDataService {
             type: result[0]?.type ?? "defaultType",
         };
     }
+    static async queryDynamicData(campaign) {
+        const campaignParameters = {
+            type: campaign.type,
+            computeChainId: campaign.computeChainId,
+            chainId: campaign.chainId ? campaign.chainId : campaign.computeChainId,
+            subType: campaign.subType,
+            rewardTokenAddress: campaign.rewardTokenAddress ? campaign.rewardTokenAddress : "0xdefault",
+            amount: campaign.amount ? campaign.amount : "1000000000000000000", // 1 EXR in wei
+            startTimestamp: campaign.startTimestamp ? campaign.startTimestamp : Math.floor(Date.now() / 1000).toString(), // current timestamp
+            endTimestamp: campaign.endTimestamp
+                ? campaign.endTimestamp
+                : (Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60).toString(), // 30 days from now
+            creatorAddress: campaign.creatorAddress ? campaign.creatorAddress : "0xdefaultcreatoraddress",
+            campaignParameters: campaign.params,
+            campaignId: "0xdefaultid",
+            opportunityIdentifier: "0xdefaultopportunityid",
+            id: "0xdefaultid",
+            distributionChainId: campaign.distributionChainId ? campaign.distributionChainId : 1,
+            rewardTokenId: campaign.rewardTokenId ? campaign.rewardTokenId : "0xdefaultrewardtokenid",
+            opportunityId: campaign.opportunityId ? campaign.opportunityId : "0xdefaultopportunityid",
+            identifier: campaign.identifier ? campaign.identifier : "defaultidentifier",
+        };
+        return await DynamicDataService.#getDynamicData(campaignParameters);
+    }
+    static async queryDynamicDataFromCampaignId(query) {
+        const campaigns = await CampaignRepository.findMany(query);
+        const campaign = campaigns[0];
+        return DynamicDataService.queryDynamicData(CampaignService.format(campaign));
+    }
+    /**
+     * Returns the campaign type index from the CampaignType enum
+     * @param type CampaignType as db-related enum for v4
+     * @returns index of Campaign enum from sdk
+     */
+    static getV3FromType(type) {
+        return Object.entries(campaignTypeToEnumMap).find(([v4]) => v4 === type)?.[1];
+    }
+    /**
+     * build/fetch metadata of a campaign's opportunity
+     * @param campaign
+     * @returns {OpportunityMetadata}
+     */
+    static async #getDynamicData(campaign) {
+        // const campaignType = DynamicDataService.getV3FromType(campaign.type);
+        if (campaign.type !== CampaignType.INVALID) {
+            return await CampaignService.fetchDynamicData(campaign.computeChainId, campaign.type, [campaign]);
+        }
+    }
 }

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

@@ -219,10 +219,21 @@ export declare const ProgramPayloadController: Elysia<"/program-payload", false,
                         campaignType: number;
                     };
                     params: {};
-                    query: unknown;
+                    query: {
+                        debug?: boolean | undefined;
+                    };
                     headers: unknown;
                     response: {
                         200: {
+                            version: string;
+                            chainId: string;
+                            createdAt: number;
+                            meta: {
+                                name: string;
+                                txBuilderVersion: string;
+                            };
+                            transactions: import("./programPayload.model").transaction[];
+                        } | {
                             safePayload: import("./programPayload.model").safePayload;
                             nonEncodedConfig: any;
                         };

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

@@ -65,9 +65,10 @@ export const ProgramPayloadController = new Elysia({ prefix: "/program-payload",
     },
     detail: { description: "Generate the payload with the campaigns and amounts provided" },
 })
-    .post("/payload/from-config", async ({ body }) => {
-    return ProgramPayloadService.buildPayloadFromConfig(body);
+    .post("/payload/from-config", async ({ query, body }) => {
+    return ProgramPayloadService.buildPayloadFromConfig(body, query.debug);
 }, {
+    query: t.Object({ debug: t.Optional(t.Boolean({ description: "Debug mode" })) }),
     body: SinglePayloadInputDto,
     detail: { description: "BETA FEATURE : Generate the payload from a config file." },
 });

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

@@ -12,7 +12,7 @@ export declare class ProgramPayloadService {
     static buildCampaignData(query: CampaignPayloadInputModel): {
         args: any;
     };
-    static buildPayloadFromConfig(config: SinglePayloadInputDtoModel): Promise<{
+    static buildPayloadFromConfig(config: SinglePayloadInputDtoModel, debug?: boolean): Promise<safePayload | {
         safePayload: safePayload;
         nonEncodedConfig: any;
     }>;

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

@@ -46,7 +46,7 @@ export class ProgramPayloadService {
         const args = buildCampaignPayload(ProgramPayloadService.buildConfig(query), distributionChainId).args;
         return { args };
     }
-    static async buildPayloadFromConfig(config) {
+    static async buildPayloadFromConfig(config, debug = false) {
         const campaignType = config.campaignType;
         const rewardToken = config.rewardToken;
         class CampaignConfig extends CampaignTypeConfigResourceMapping[campaignType] {
@@ -70,7 +70,10 @@ export class ProgramPayloadService {
         const safePayload = ProgramPayloadService.initiateSafePayload(distributionChainId, distributionCreator);
         const transactions = ProgramPayloadService.createSafePayloadForCampaign(args, distributionChainId, rewardToken, distributionCreator ?? NULL_ADDRESS);
         safePayload.transactions.push(...transactions);
-        return { safePayload, nonEncodedConfig };
+        if (debug) {
+            return { safePayload, nonEncodedConfig };
+        }
+        return safePayload;
     }
     static createSafePayloadForCampaign(args, distributionChainId, rewardToken, distributionCreator) {
         const safePayload = _.cloneDeep(safeTemplate);

package/dist/src/modules/v4/router.d.ts

@@ -2675,6 +2675,78 @@ export declare const v4: Elysia<"/v4", false, {
                 };
             };
         };
+    } & {
+        "dynamic-data": {
+            "from-config": {
+                post: {
+                    body: {
+                        id?: string | undefined;
+                        tags?: string[] | undefined;
+                        identifier?: string | undefined;
+                        subType?: number | undefined;
+                        chain?: {} | undefined;
+                        chainId?: number | undefined;
+                        startTimestamp?: string | undefined;
+                        endTimestamp?: string | undefined;
+                        distributionChainId?: number | undefined;
+                        campaignId?: string | undefined;
+                        rewardTokenId?: string | undefined;
+                        amount?: string | undefined;
+                        opportunityId?: string | undefined;
+                        creatorAddress?: string | undefined;
+                        campaignStatus?: {} | undefined;
+                        rewardToken?: {} | undefined;
+                        rewardTokenAddress?: string | undefined;
+                        distributionChain?: {} | undefined;
+                        opportunityIdentifier?: string | undefined;
+                        type: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4" | "ION" | "EIGENLAYER" | "ERC20TRANSFERS" | "ERC20LOGPROCESSOR" | "ERC20REBASELOGPROCESSOR" | "VEST";
+                        params: {};
+                        computeChainId: number;
+                    };
+                    params: {};
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        [x: string]: any;
+                        200: any;
+                    };
+                };
+            };
+        };
+    } & {
+        "dynamic-data": {
+            "from-existing": {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: {
+                        type?: "INVALID" | "ERC20" | "CLAMM" | "ERC20_SNAPSHOT" | "JSON_AIRDROP" | "SILO" | "RADIANT" | "MORPHO" | "DOLOMITE" | "BADGER" | "COMPOUND" | "AJNA" | "EULER" | "UNISWAP_V4" | "ION" | "EIGENLAYER" | "ERC20TRANSFERS" | "ERC20LOGPROCESSOR" | "ERC20REBASELOGPROCESSOR" | "VEST" | undefined;
+                        items?: number | undefined;
+                        subType?: number | undefined;
+                        page?: number | undefined;
+                        chainId?: number | undefined;
+                        startTimestamp?: string | undefined;
+                        endTimestamp?: string | undefined;
+                        tokenAddress?: string | undefined;
+                        mainParameter?: string | undefined;
+                        campaignId?: string | undefined;
+                        opportunityId?: string | undefined;
+                        test?: boolean | undefined;
+                        creatorTag?: string | undefined;
+                        tokenSymbol?: string | undefined;
+                    };
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        [x: string]: any;
+                        200: any;
+                    };
+                };
+            };
+        };
     };
 } & {
     v4: {
@@ -3067,10 +3139,21 @@ export declare const v4: Elysia<"/v4", false, {
                             campaignType: number;
                         };
                         params: {};
-                        query: unknown;
+                        query: {
+                            debug?: boolean | undefined;
+                        };
                         headers: unknown;
                         response: {
                             200: {
+                                version: string;
+                                chainId: string;
+                                createdAt: number;
+                                meta: {
+                                    name: string;
+                                    txBuilderVersion: string;
+                                };
+                                transactions: import("./programPayload").transaction[];
+                            } | {
                                 safePayload: import("./programPayload").safePayload;
                                 nonEncodedConfig: any;
                             };