npm - @merkl/api - Versions diffs - 0.10.317 → 0.10.319 - Mend

@merkl/api 0.10.317 → 0.10.319

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/dist/src/eden/index.d.ts CHANGED Viewed

@@ -608,7 +608,64 @@ declare const eden: {
                         sum: string;
                     };
                 }>>;
-            }) & {};
+            }) & {
+                max: ((params: {
+                    field: string | number;
+                }) => {
+                    get: (options: {
+                        headers?: Record<string, unknown> | undefined;
+                        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;
+                        };
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            max: string;
+                        };
+                    }>>;
+                }) & {};
+                min: ((params: {
+                    field: string | number;
+                }) => {
+                    get: (options: {
+                        headers?: Record<string, unknown> | undefined;
+                        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;
+                        };
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            min: string;
+                        };
+                    }>>;
+                }) & {};
+            };
         };
         campaigns: {
             engine: {
@@ -2294,6 +2351,19 @@ declare const eden: {
                     200: any;
                 }>>;
             };
+            "template-config": ((params: {
+                campaignType: string | number;
+            }) => {
+                get: (options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        [x: string]: string;
+                    };
+                }>>;
+            }) & {};
             campaignData: {
                 get: (options: {
                     headers?: Record<string, unknown> | undefined;
@@ -3699,6 +3769,80 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 };
             };
         };
+    } & {
+        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": {
@@ -5866,6 +6010,26 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 };
             };
         };
+    } & {
+        "program-payload": {
+            "template-config": {
+                ":campaignType": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            campaignType: number;
+                        };
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: {
+                                [x: string]: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
     } & {
         "program-payload": {
             campaignData: {
@@ -7403,7 +7567,64 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         sum: string;
                     };
                 }>>;
-            }) & {};
+            }) & {
+                max: ((params: {
+                    field: string | number;
+                }) => {
+                    get: (options: {
+                        headers?: Record<string, unknown> | undefined;
+                        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;
+                        };
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            max: string;
+                        };
+                    }>>;
+                }) & {};
+                min: ((params: {
+                    field: string | number;
+                }) => {
+                    get: (options: {
+                        headers?: Record<string, unknown> | undefined;
+                        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;
+                        };
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            min: string;
+                        };
+                    }>>;
+                }) & {};
+            };
         };
         campaigns: {
             engine: {
@@ -9089,6 +9310,19 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     200: any;
                 }>>;
             };
+            "template-config": ((params: {
+                campaignType: string | number;
+            }) => {
+                get: (options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        [x: string]: string;
+                    };
+                }>>;
+            }) & {};
             campaignData: {
                 get: (options: {
                     headers?: Record<string, unknown> | undefined;

package/dist/src/index.d.ts CHANGED Viewed

@@ -678,6 +678,80 @@ declare const app: Elysia<"", 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": {
@@ -2845,6 +2919,26 @@ declare const app: Elysia<"", false, {
                 };
             };
         };
+    } & {
+        "program-payload": {
+            "template-config": {
+                ":campaignType": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            campaignType: number;
+                        };
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: {
+                                [x: string]: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
     } & {
         "program-payload": {
             campaignData: {

package/dist/src/modules/v4/opportunity/opportunity.controller.d.ts CHANGED Viewed

@@ -547,6 +547,80 @@ export declare const OpportunityController: Elysia<"/opportunities", 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": {

package/dist/src/modules/v4/opportunity/opportunity.controller.js CHANGED Viewed

@@ -131,6 +131,16 @@ export const OpportunityController = new Elysia({
     .get("/aggregate/:field", async ({ query, params }) => await OpportunityService.aggregate(query, params.field), {
     params: OpportunityAggregateFieldDto,
     query: GetOpportunitiesQueryDto,
+})
+    // ─── Get Aggregate Fields ────────────────────────────────────────────
+    .get("/aggregate/max/:field", async ({ query, params }) => await OpportunityService.aggregateMax(query, params.field), {
+    params: OpportunityAggregateFieldDto,
+    query: GetOpportunitiesQueryDto,
+})
+    // ─── Get Aggregate Fields ────────────────────────────────────────────
+    .get("/aggregate/min/:field", async ({ query, params }) => await OpportunityService.aggregateMin(query, params.field), {
+    params: OpportunityAggregateFieldDto,
+    query: GetOpportunitiesQueryDto,
 })
     // ─── Update An Opportunity ───────────────────────────────────────────
     .patch("/:id", async ({ params, body }) => await OpportunityService.update(params.id, body), {

package/dist/src/modules/v4/opportunity/opportunity.model.d.ts CHANGED Viewed

@@ -344,7 +344,7 @@ export declare const CreateOpportunityDto: import("@sinclair/typebox").TObject<{
     tags: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
 }>;
 export declare const OpportunityAggregateFieldDto: import("@sinclair/typebox").TObject<{
-    field: import("@sinclair/typebox").TUnion<import("@sinclair/typebox").TLiteral<"dailyRewards">[]>;
+    field: import("@sinclair/typebox").TUnion<import("@sinclair/typebox").TLiteral<"tvl" | "apr" | "dailyRewards">[]>;
 }>;
 export declare const OpportunityIdDto: import("@sinclair/typebox").TObject<{
     id: import("@sinclair/typebox").TString;

package/dist/src/modules/v4/opportunity/opportunity.model.js CHANGED Viewed

@@ -87,7 +87,7 @@ export const CreateOpportunityDto = t.Object({
     tags: t.Optional(t.Array(t.String())),
 });
 export const OpportunityAggregateFieldDto = t.Object({
-    field: t.Union(["dailyRewards"].map(v => t.Literal(v))),
+    field: t.Union(["dailyRewards", "tvl", "apr"].map(v => t.Literal(v))),
 });
 export const OpportunityIdDto = t.Object({ id: t.String() });
 export const UpdateOpportunityDto = t.Object({

package/dist/src/modules/v4/opportunity/opportunity.repository.d.ts CHANGED Viewed

@@ -902,6 +902,12 @@ export declare abstract class OpportunityRepository {
     static aggregateSum(field: keyof Prisma.OpportunitySumAggregateInputType, query: GetOpportunitiesQueryModel): Promise<{
         sum: string;
     }>;
+    static aggregateMin(field: keyof Prisma.OpportunityMinAggregateInputType, query: GetOpportunitiesQueryModel): Promise<{
+        min: string;
+    }>;
+    static aggregateMax(field: keyof Prisma.OpportunityMaxAggregateInputType, query: GetOpportunitiesQueryModel): Promise<{
+        max: string;
+    }>;
     static update(id: string, data: UpdateOpportunityModel): Promise<{
         name: string;
         type: import("../../../../database/api/.generated").$Enums.CampaignType;

package/dist/src/modules/v4/opportunity/opportunity.repository.js CHANGED Viewed

@@ -382,6 +382,26 @@ export class OpportunityRepository {
         });
         return { sum: result._sum[field] ?? null };
     }
+    static async aggregateMin(field, query) {
+        const args = OpportunityRepository.#transformQueryToPrismaFilters(query);
+        const result = await apiDbClient.opportunity.aggregate({
+            _min: {
+                [field]: true,
+            },
+            ...args,
+        });
+        return { min: result._min[field] ?? null };
+    }
+    static async aggregateMax(field, query) {
+        const args = OpportunityRepository.#transformQueryToPrismaFilters(query);
+        const result = await apiDbClient.opportunity.aggregate({
+            _max: {
+                [field]: true,
+            },
+            ...args,
+        });
+        return { max: result._max[field] ?? null };
+    }
     static async update(id, data) {
         return await apiDbClient.opportunity.update({ where: { id }, data });
     }

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

@@ -451,6 +451,12 @@ export declare abstract class OpportunityService {
     static aggregate(query: GetOpportunitiesQueryModel, field: keyof Prisma.OpportunitySumAggregateInputType): Promise<{
         sum: string;
     }>;
+    static aggregateMin(query: GetOpportunitiesQueryModel, field: keyof Prisma.OpportunityMinAggregateInputType): Promise<{
+        min: string;
+    }>;
+    static aggregateMax(query: GetOpportunitiesQueryModel, field: keyof Prisma.OpportunityMaxAggregateInputType): Promise<{
+        max: string;
+    }>;
     static update(id: string, data: UpdateOpportunityModel): Promise<{
         name: string;
         type: import("../../../../database/api/.generated").$Enums.CampaignType;

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

@@ -266,6 +266,12 @@ export class OpportunityService {
     static aggregate(query, field) {
         return OpportunityRepository.aggregateSum(field, query);
     }
+    static aggregateMin(query, field) {
+        return OpportunityRepository.aggregateMin(field, query);
+    }
+    static aggregateMax(query, field) {
+        return OpportunityRepository.aggregateMax(field, query);
+    }
     static async update(id, data) {
         return await OpportunityRepository.update(id, data);
     }

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

@@ -67,6 +67,26 @@ export declare const ProgramPayloadController: Elysia<"/program-payload", false,
             };
         };
     };
+} & {
+    "program-payload": {
+        "template-config": {
+            ":campaignType": {
+                get: {
+                    body: unknown;
+                    params: {
+                        campaignType: number;
+                    };
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: {
+                            [x: string]: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
 } & {
     "program-payload": {
         campaignData: {

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

@@ -1,5 +1,5 @@
 // import { AuthorizationHeadersDto, BackOfficeGuard } from "../../../guards/BackOffice.guard";
-import Elysia from "elysia";
+import Elysia, { t } from "elysia";
 import { throwOnUnsupportedChainId } from "src/utils/throw";
 import { CampaignAmountsInputDto, CampaignPayloadInputDto, ProgramPayloadInputDto, SinglePayloadInputDto, } from "./programPayload.model";
 import { ProgramPayloadService } from "./programPayload.service";
@@ -26,6 +26,12 @@ export const ProgramPayloadController = new Elysia({ prefix: "/program-payload",
         throwOnUnsupportedChainId(query.distributionChainId);
     },
     detail: { description: "Generate the configuration for a specific hardcoded campaign from a program" },
+})
+    .get("/template-config/:campaignType", async ({ params }) => {
+    return ProgramPayloadService.buildConfigTemplate(params);
+}, {
+    params: t.Object({ campaignType: t.Number() }),
+    detail: { description: "Generate the template configuration with expected types for a specific campaign" },
 })
     .get("/campaignData", async ({ query }) => {
     return ProgramPayloadService.buildCampaignData(query);

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

@@ -2,6 +2,11 @@ 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 buildConfigTemplate(params: {
+        campaignType: number;
+    }): {
+        [key: string]: string;
+    };
     static buildConfig(query: CampaignPayloadInputModel): campaignConfig<Campaign>;
     /** building payload for a single campaign */
     static buildCampaignData(query: CampaignPayloadInputModel): {

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

@@ -4,6 +4,16 @@ import { safeTemplate, } from "./programPayload.model";
 import { MerklInterfaceCampaigns, zkSyncCampaignAmounts } from "./programPayload.repository";
 export class ProgramPayloadService {
     // ─── ProgramPayload ──────────────────────────────────────────────────────────
+    static buildConfigTemplate(params) {
+        class CampaignConfig extends CampaignTypeConfigResourceMapping[params.campaignType] {
+        }
+        const parsedConfig = new CampaignConfig();
+        const configTemplate = {};
+        for (const [key, value] of Object.entries(parsedConfig)) {
+            configTemplate[key] = typeof value;
+        }
+        return configTemplate;
+    }
     static buildConfig(query) {
         const campaign = query.campaign;
         const startTimestamp = query.startTimestamp;