@merkl/api 0.10.316 → 0.10.318

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

@@ -1,23 +1,58 @@
 import { t } from "elysia";
 // ─── DTOs ────────────────────────────────────────────────────────────────────
 export const CampaignPayloadInputDto = t.Object({
-    campaign: t.String(),
-    program: t.String(),
-    creator: t.String(),
-    rewardToken: t.String(),
-    distributionChainId: t.Numeric(),
-    startTimestamp: t.Numeric(),
-    endTimestamp: t.Numeric(),
-    amount: t.String(),
+    campaign: t.String({ description: "Campaign identifier, these are shared by the merkl team" }),
+    program: t.String({ description: "Program identifier, these are shared by the merkl team" }),
+    creator: t.String({ description: "Address of the campaign creator" }),
+    rewardToken: t.String({ description: "Address of the reward token to be distributed" }),
+    distributionChainId: t.Numeric({ description: "Chain ID where the reward tokens will be distributed" }),
+    startTimestamp: t.Numeric({ description: "Start timestamp for the campaign" }),
+    endTimestamp: t.Numeric({ description: "End timestamp for the campaign" }),
+    amount: t.String({ description: "Amount of the reward token to be distributed" }),
+});
+export const SinglePayloadInputDto = t.Object({
+    distributionChainId: t.Numeric({ description: "Chain ID where the reward tokens will be distributed" }),
+    rewardToken: t.String({ description: "Address of the reward token to be distributed" }),
+    amount: t.String({ description: "Amount of the reward token to be distributed" }),
+    startTimestamp: t.Numeric({ description: "Start timestamp for the campaign" }),
+    computeChainId: t.Numeric({ description: "Chain ID used for computation" }),
+    creator: t.String({ description: "Address of the campaign creator" }),
+    hooks: t.Array(t.Object({})),
+    whitelist: t.Array(t.String({ description: "List of addresses allowed to participate" })),
+    blacklist: t.Array(t.String({ description: "List of addresses not allowed to participate" })),
+    campaignType: t.Numeric({ description: "Type of the campaign 1 : ERC20, 2: CLAMM , ..." }),
+    endTimestamp: t.Optional(t.Numeric({ description: "End timestamp for the campaign" })),
+    targetToken: t.Optional(t.String({ description: "Address of the target token that is incentivized" })),
+    url: t.Optional(t.String({ description: "URL for more information" })),
+    forwarders: t.Optional(t.Array(t.Object({}))),
+    poolAddress: t.Optional(t.String({ description: "Address of the pool that is incentivized" })),
+    isOutOfRangeIncentivized: t.Optional(t.Boolean({ description: "Whether out-of-range is incentivized" })),
+    weightFees: t.Optional(t.Number({ description: "Weight of the fees" })),
+    weightToken0: t.Optional(t.Number({ description: "Weight of token 0" })),
+    weightToken1: t.Optional(t.Number({ description: "Weight of token 1" })),
+    usesBlockNumber: t.Optional(t.Boolean({ description: "Whether block number is used" })),
+    snapshotTimestamp: t.Optional(t.Numeric({ description: "Snapshot timestamp" })),
+    snapshotBlockNumber: t.Optional(t.Numeric({ description: "Snapshot block number" })),
+    jsonUrl: t.Optional(t.String({ description: "URL for JSON data for Airdrops" })),
+    subCampaignType: t.Optional(t.Numeric({ description: "Type of the sub-campaign" })),
+    repository: t.Optional(t.String({ description: "Repository URL" })),
+    capInUSD: t.Optional(t.String({ description: "Cap in USD" })),
+    marketId: t.Optional(t.String({ description: "Market ID" })),
+    compFork: t.Optional(t.Numeric({ description: "Compound fork ID" })),
+    poolId: t.Optional(t.String({ description: "Pool ID that is incentivized" })),
+    evkAddress: t.Optional(t.String({ description: "EVK address" })),
+    collateralAddress: t.Optional(t.String({ description: "Collateral address" })),
+    strategy: t.Optional(t.String({ description: "Strategy that is incentivized" })),
+    contract: t.Optional(t.String({ description: "Contract address" })),
 });
 export const ProgramPayloadInputDto = t.Object({
-    program: t.String(),
-    creator: t.String(),
-    rewardToken: t.String(),
-    distributionChainId: t.Numeric(),
-    startTimestamp: t.Numeric(),
-    endTimestamp: t.Numeric(),
-    amount: t.Optional(t.String()),
+    program: t.String({ description: "Program identifier, these are shared by the merkl team" }),
+    creator: t.String({ description: "Address of the campaign creator" }),
+    rewardToken: t.String({ description: "Address of the reward token to be distributed" }),
+    distributionChainId: t.Numeric({ description: "Chain ID where the reward tokens will be distributed" }),
+    startTimestamp: t.Numeric({ description: "Start timestamp for the campaign" }),
+    endTimestamp: t.Numeric({ description: "End timestamp for the campaign" }),
+    amount: t.Optional(t.String({ description: "Amount of the reward token to be distributed" })),
 });
 export const CampaignAmountsInputDto = t.Record(t.String(), t.String());
 // ---- Template below ----

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

@@ -1,12 +1,19 @@
-import { type Campaign, type campaignConfig } from "@sdk";
-import { type CampaignAmountsInputModel, type CampaignPayloadInputModel, type ProgramPayloadInputModel } from "./programPayload.model";
+import { type Campaign, ChainId, type campaignConfig } from "@sdk";
+import type { CampaignParametersStruct } from "libs/sdk/src/generated/CampaignCreator";
+import { type CampaignAmountsInputModel, type CampaignPayloadInputModel, type ProgramPayloadInputModel, type SinglePayloadInputDtoModel, type approvalTransaction, type createCampaignTransaction, type safePayload } from "./programPayload.model";
 export declare class ProgramPayloadService {
     static buildConfig(query: CampaignPayloadInputModel): campaignConfig<Campaign>;
     /** building payload for a single campaign */
     static buildCampaignData(query: CampaignPayloadInputModel): {
         args: any;
     };
-    static buildPayload(query: CampaignPayloadInputModel, initialCampaignPayload?: null): any;
-    static buildProgramPayload(query: ProgramPayloadInputModel): any;
-    static buildProgramPayloadWithAmounts(query: ProgramPayloadInputModel, body: CampaignAmountsInputModel): any;
+    static buildPayloadFromConfig(config: SinglePayloadInputDtoModel): Promise<{
+        safePayload: safePayload;
+        nonEncodedConfig: any;
+    }>;
+    static createSafePayloadForCampaign(args: CampaignParametersStruct, distributionChainId: ChainId, rewardToken: string, distributionCreator: string): [approvalTransaction, createCampaignTransaction];
+    static initiateSafePayload(distributionChainId: ChainId, distributionCreator: string): safePayload;
+    static buildPayload(query: CampaignPayloadInputModel, initialCampaignPayload?: safePayload | null): safePayload;
+    static buildProgramPayload(query: ProgramPayloadInputModel): safePayload | null;
+    static buildProgramPayloadWithAmounts(query: ProgramPayloadInputModel, body: CampaignAmountsInputModel): safePayload | null;
 }

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

@@ -1,4 +1,4 @@
-import { ChainId, NULL_ADDRESS, NULL_ROOT, buildCampaignPayload, encodeForwarderData, registry, } from "@sdk";
+import { CampaignTypeConfigResourceMapping, ChainId, NULL_ADDRESS, NULL_ROOT, buildCampaignPayload, encodeForwarderData, registry, } from "@sdk";
 import _ from "lodash";
 import { safeTemplate, } from "./programPayload.model";
 import { MerklInterfaceCampaigns, zkSyncCampaignAmounts } from "./programPayload.repository";
@@ -36,52 +36,77 @@ export class ProgramPayloadService {
         const args = buildCampaignPayload(ProgramPayloadService.buildConfig(query), distributionChainId).args;
         return { args };
     }
+    static async buildPayloadFromConfig(config) {
+        const campaignType = config.campaignType;
+        const rewardToken = config.rewardToken;
+        class CampaignConfig extends CampaignTypeConfigResourceMapping[campaignType] {
+        }
+        const parsedConfig = CampaignConfig.hydrate(config, {
+            strategy: "exposeAll",
+            excludeExtraneousValues: true,
+        });
+        parsedConfig.hooks = config.hooks.map(hook => hook);
+        const nonEncodedConfig = { ...parsedConfig };
+        if ("forwarders" in parsedConfig) {
+            parsedConfig.forwarders = config?.forwarders
+                ? config.forwarders.map(forwarder => encodeForwarderData(forwarder))
+                : [];
+        }
+        const distributionChainId = config.distributionChainId ? config.distributionChainId : ChainId.MAINNET;
+        const registryInitialized = registry(distributionChainId);
+        const distributionCreator = registryInitialized?.Merkl?.DistributionCreator ?? NULL_ADDRESS;
+        // Small hack to avoid the need to parse the config again
+        const args = buildCampaignPayload(parsedConfig, distributionChainId).args;
+        const safePayload = ProgramPayloadService.initiateSafePayload(distributionChainId, distributionCreator);
+        const transactions = ProgramPayloadService.createSafePayloadForCampaign(args, distributionChainId, rewardToken, distributionCreator ?? NULL_ADDRESS);
+        safePayload.transactions.push(...transactions);
+        return { safePayload, nonEncodedConfig };
+    }
+    static createSafePayloadForCampaign(args, distributionChainId, rewardToken, distributionCreator) {
+        const safePayload = _.cloneDeep(safeTemplate);
+        safePayload.chainId = distributionChainId.toString();
+        safePayload.createdAt = Math.floor(Date.now() / 1000);
+        safePayload.transactions[0].to = rewardToken;
+        safePayload.transactions[0].contractInputsValues = {
+            amount: args?.amount.toString(),
+            spender: distributionCreator ? distributionCreator : NULL_ADDRESS,
+        };
+        safePayload.transactions[2].to = distributionCreator ? distributionCreator : NULL_ADDRESS;
+        safePayload.transactions[2].contractInputsValues = {
+            newCampaign: JSON.stringify([
+                NULL_ROOT,
+                NULL_ADDRESS,
+                args?.rewardToken,
+                args?.amount,
+                args?.campaignType,
+                args?.startTimestamp,
+                args?.duration,
+                args?.campaignData,
+            ]),
+        };
+        return [safePayload.transactions[0], safePayload.transactions[2]];
+    }
+    static initiateSafePayload(distributionChainId, distributionCreator) {
+        const safePayload = _.cloneDeep(safeTemplate);
+        safePayload.chainId = distributionChainId.toString();
+        safePayload.createdAt = Math.floor(Date.now() / 1000);
+        safePayload.transactions[1].to = distributionCreator;
+        safePayload.transactions = [safePayload.transactions[1]];
+        return safePayload;
+    }
     static buildPayload(query, initialCampaignPayload = null) {
         const rewardToken = query.rewardToken;
         const distributionChainId = query.distributionChainId ? query.distributionChainId : ChainId.MAINNET;
         const registryInitialized = registry(distributionChainId);
-        const distributionCreator = registryInitialized?.Merkl?.DistributionCreator;
-        function aggregateConfig(query) {
-            return ProgramPayloadService.buildConfig(query);
-        }
-        function createSafePayloadForCampaign(args) {
-            const safePayload = _.cloneDeep(safeTemplate);
-            safePayload.chainId = distributionChainId.toString();
-            safePayload.createdAt = Math.floor(Date.now() / 1000);
-            safePayload.transactions[0].to = rewardToken;
-            safePayload.transactions[0].contractInputsValues = {
-                amount: args?.amount.toString(),
-                spender: distributionCreator ? distributionCreator : NULL_ADDRESS,
-            };
-            safePayload.transactions[2].to = distributionCreator ? distributionCreator : NULL_ADDRESS;
-            safePayload.transactions[2].contractInputsValues = {
-                newCampaign: JSON.stringify([
-                    NULL_ROOT,
-                    NULL_ADDRESS,
-                    args?.rewardToken,
-                    args?.amount,
-                    args?.campaignType,
-                    args?.startTimestamp,
-                    args?.duration,
-                    args?.campaignData,
-                ]),
-            };
-            return [safePayload.transactions[0], safePayload.transactions[2]];
-        }
-        function initiateSafePayload() {
-            const safePayload = JSON.parse(JSON.stringify(safeTemplate));
-            safePayload.chainId = distributionChainId.toString();
-            safePayload.createdAt = Math.floor(Date.now() / 1000);
-            safePayload.transactions[1].to = distributionCreator;
-            safePayload.transactions = [safePayload.transactions[1]];
-            return safePayload;
-        }
+        const distributionCreator = registryInitialized?.Merkl?.DistributionCreator ?? NULL_ADDRESS;
         function generatePayloadFile(query) {
-            const args = buildCampaignPayload(aggregateConfig(query), distributionChainId).args;
-            const safePayload = createSafePayloadForCampaign(args);
+            const args = buildCampaignPayload(ProgramPayloadService.buildConfig(query), distributionChainId).args;
+            const safePayload = ProgramPayloadService.createSafePayloadForCampaign(args, distributionChainId, rewardToken, distributionCreator);
             return safePayload;
         }
-        const campaignPayloads = initialCampaignPayload === null ? initiateSafePayload() : initialCampaignPayload;
+        const campaignPayloads = initialCampaignPayload === null
+            ? ProgramPayloadService.initiateSafePayload(distributionChainId, distributionCreator)
+            : initialCampaignPayload;
         const transactions = generatePayloadFile(query);
         campaignPayloads.transactions.push(...transactions);
         return campaignPayloads;

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

@@ -556,6 +556,80 @@ export declare const v4: Elysia<"/v4", false, {
                 };
             };
         };
+    } & {
+        opportunities: {
+            aggregate: {
+                max: {
+                    ":field": {
+                        get: {
+                            body: unknown;
+                            params: {
+                                field: never;
+                            };
+                            query: {
+                                sort?: string | undefined;
+                                name?: string | undefined;
+                                tokens?: string | undefined;
+                                status?: string | undefined;
+                                items?: number | undefined;
+                                tags?: string | undefined;
+                                page?: number | undefined;
+                                chainId?: string | undefined;
+                                action?: string | undefined;
+                                creatorAddress?: string | undefined;
+                                mainProtocolId?: string | undefined;
+                                order?: string | undefined;
+                                test?: boolean | undefined;
+                                minimumTvl?: number | undefined;
+                            };
+                            headers: unknown;
+                            response: {
+                                200: {
+                                    max: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        opportunities: {
+            aggregate: {
+                min: {
+                    ":field": {
+                        get: {
+                            body: unknown;
+                            params: {
+                                field: never;
+                            };
+                            query: {
+                                sort?: string | undefined;
+                                name?: string | undefined;
+                                tokens?: string | undefined;
+                                status?: string | undefined;
+                                items?: number | undefined;
+                                tags?: string | undefined;
+                                page?: number | undefined;
+                                chainId?: string | undefined;
+                                action?: string | undefined;
+                                creatorAddress?: string | undefined;
+                                mainProtocolId?: string | undefined;
+                                order?: string | undefined;
+                                test?: boolean | undefined;
+                                minimumTvl?: number | undefined;
+                            };
+                            headers: unknown;
+                            response: {
+                                200: {
+                                    min: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
     } & {
         opportunities: {
             ":id": {
@@ -2685,8 +2759,16 @@ export declare const v4: Elysia<"/v4", false, {
                     };
                     headers: unknown;
                     response: {
-                        [x: string]: any;
-                        200: any;
+                        200: {
+                            version: string;
+                            chainId: string;
+                            createdAt: number;
+                            meta: {
+                                name: string;
+                                txBuilderVersion: string;
+                            };
+                            transactions: import("./programPayload").transaction[];
+                        };
                     };
                 };
             };
@@ -2757,8 +2839,16 @@ export declare const v4: Elysia<"/v4", false, {
                     };
                     headers: unknown;
                     response: {
-                        [x: string]: any;
-                        200: any;
+                        200: {
+                            version: string;
+                            chainId: string;
+                            createdAt: number;
+                            meta: {
+                                name: string;
+                                txBuilderVersion: string;
+                            };
+                            transactions: import("./programPayload").transaction[];
+                        } | null;
                     };
                 };
             };
@@ -2783,8 +2873,69 @@ export declare const v4: Elysia<"/v4", false, {
                         };
                         headers: unknown;
                         response: {
-                            [x: string]: any;
-                            200: any;
+                            200: {
+                                version: string;
+                                chainId: string;
+                                createdAt: number;
+                                meta: {
+                                    name: string;
+                                    txBuilderVersion: string;
+                                };
+                                transactions: import("./programPayload").transaction[];
+                            } | null;
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        "program-payload": {
+            payload: {
+                "from-config": {
+                    post: {
+                        body: {
+                            url?: string | undefined;
+                            endTimestamp?: number | undefined;
+                            poolAddress?: string | undefined;
+                            marketId?: string | undefined;
+                            strategy?: string | undefined;
+                            poolId?: string | undefined;
+                            contract?: string | undefined;
+                            forwarders?: {}[] | undefined;
+                            targetToken?: string | undefined;
+                            isOutOfRangeIncentivized?: boolean | undefined;
+                            weightFees?: number | undefined;
+                            weightToken0?: number | undefined;
+                            weightToken1?: number | undefined;
+                            usesBlockNumber?: boolean | undefined;
+                            snapshotTimestamp?: number | undefined;
+                            snapshotBlockNumber?: number | undefined;
+                            jsonUrl?: string | undefined;
+                            subCampaignType?: number | undefined;
+                            repository?: string | undefined;
+                            capInUSD?: string | undefined;
+                            compFork?: number | undefined;
+                            evkAddress?: string | undefined;
+                            collateralAddress?: string | undefined;
+                            hooks: {}[];
+                            creator: string;
+                            startTimestamp: number;
+                            computeChainId: number;
+                            distributionChainId: number;
+                            amount: string;
+                            blacklist: string[];
+                            rewardToken: string;
+                            campaignType: number;
+                            whitelist: string[];
+                        };
+                        params: {};
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: {
+                                safePayload: import("./programPayload").safePayload;
+                                nonEncodedConfig: any;
+                            };
                         };
                     };
                 };