@merkl/api 0.10.90 → 0.10.92

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

@@ -1466,6 +1466,40 @@ declare const eden: {
                     }[];
                 }>>;
             };
+            status: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        status: "PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED" | ("PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED")[];
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: ({
+                        Campaign: {
+                            id: string;
+                            computeChainId: number;
+                            distributionChainId: number;
+                            campaignId: string;
+                            type: import("../../database/api/.generated").$Enums.CampaignType;
+                            subType: number | null;
+                            rewardTokenId: string;
+                            amount: string;
+                            opportunityId: string;
+                            startTimestamp: bigint;
+                            endTimestamp: bigint;
+                            params: import("../../database/api/.generated").Prisma.JsonValue;
+                            creatorAddress: string;
+                        };
+                    } & {
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                        status: import("../../database/api/.generated").$Enums.RunStatus;
+                        error: string;
+                        details: import("../../database/api/.generated").Prisma.JsonValue;
+                    })[];
+                }>>;
+            };
             unique: {
                 get: (options: {
                     headers?: Record<string, unknown> | undefined;
@@ -3370,6 +3404,45 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 };
             };
         };
+    } & {
+        campaignStatus: {
+            status: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        status: "PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED" | ("PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED")[];
+                    };
+                    headers: unknown;
+                    response: {
+                        200: ({
+                            Campaign: {
+                                id: string;
+                                computeChainId: number;
+                                distributionChainId: number;
+                                campaignId: string;
+                                type: import("../../database/api/.generated").$Enums.CampaignType;
+                                subType: number | null;
+                                rewardTokenId: string;
+                                amount: string;
+                                opportunityId: string;
+                                startTimestamp: bigint;
+                                endTimestamp: bigint;
+                                params: import("../../database/api/.generated").Prisma.JsonValue;
+                                creatorAddress: string;
+                            };
+                        } & {
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
+                            status: import("../../database/api/.generated").$Enums.RunStatus;
+                            error: string;
+                            details: import("../../database/api/.generated").Prisma.JsonValue;
+                        })[];
+                    };
+                };
+            };
+        };
     } & {
         campaignStatus: {
             unique: {
@@ -4917,6 +4990,40 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     }[];
                 }>>;
             };
+            status: {
+                get: (options: {
+                    headers?: Record<string, unknown> | undefined;
+                    query: {
+                        status: "PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED" | ("PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED")[];
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: ({
+                        Campaign: {
+                            id: string;
+                            computeChainId: number;
+                            distributionChainId: number;
+                            campaignId: string;
+                            type: import("../../database/api/.generated").$Enums.CampaignType;
+                            subType: number | null;
+                            rewardTokenId: string;
+                            amount: string;
+                            opportunityId: string;
+                            startTimestamp: bigint;
+                            endTimestamp: bigint;
+                            params: import("../../database/api/.generated").Prisma.JsonValue;
+                            creatorAddress: string;
+                        };
+                    } & {
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                        status: import("../../database/api/.generated").$Enums.RunStatus;
+                        error: string;
+                        details: import("../../database/api/.generated").Prisma.JsonValue;
+                    })[];
+                }>>;
+            };
             unique: {
                 get: (options: {
                     headers?: Record<string, unknown> | undefined;

package/dist/src/index.d.ts

@@ -1841,6 +1841,45 @@ declare const app: Elysia<"", false, {
                 };
             };
         };
+    } & {
+        campaignStatus: {
+            status: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        status: "PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED" | ("PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED")[];
+                    };
+                    headers: unknown;
+                    response: {
+                        200: ({
+                            Campaign: {
+                                id: string;
+                                computeChainId: number;
+                                distributionChainId: number;
+                                campaignId: string;
+                                type: import("../database/api/.generated").$Enums.CampaignType;
+                                subType: number | null;
+                                rewardTokenId: string;
+                                amount: string;
+                                opportunityId: string;
+                                startTimestamp: bigint;
+                                endTimestamp: bigint;
+                                params: import("../database/api/.generated").Prisma.JsonValue;
+                                creatorAddress: string;
+                            };
+                        } & {
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
+                            status: import("../database/api/.generated").$Enums.RunStatus;
+                            error: string;
+                            details: import("../database/api/.generated").Prisma.JsonValue;
+                        })[];
+                    };
+                };
+            };
+        };
     } & {
         campaignStatus: {
             unique: {

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType.d.ts

@@ -46,7 +46,8 @@ export declare enum tokenType {
     zerolend_lending = "zerolend_lending",
     ironclad_lending = "ironclad_lending",
     ironclad_borrowing = "ironclad_borrowing",
-    pendle = "pendle"
+    pendle = "pendle",
+    ironcladStaking = "ironcladStaking"
 }
 export declare const tokenTypeToProtocol: {
     [key in tokenType]: {

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesPricesRefactoFinal.d.ts

@@ -1,4 +1,4 @@
 import type { Pricer } from "../../../../utils/pricer";
 import type { Campaign, CampaignParameters } from "@sdk";
-import type { tokenType, tokenTypeStruct } from "./helpers/tokenType";
+import { tokenType, type tokenTypeStruct } from "./helpers/tokenType";
 export declare function getTokenPricesInfo(index: number, type: tokenType, typeInfo: any, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<tokenTypeStruct>;

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

@@ -1823,6 +1823,45 @@ export declare const v4: Elysia<"/v4", false, {
                 };
             };
         };
+    } & {
+        campaignStatus: {
+            status: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        status: "PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED" | ("PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED")[];
+                    };
+                    headers: unknown;
+                    response: {
+                        200: ({
+                            Campaign: {
+                                id: string;
+                                computeChainId: number;
+                                distributionChainId: number;
+                                campaignId: string;
+                                type: import("../../../database/api/.generated").$Enums.CampaignType;
+                                subType: number | null;
+                                rewardTokenId: string;
+                                amount: string;
+                                opportunityId: string;
+                                startTimestamp: bigint;
+                                endTimestamp: bigint;
+                                params: import("../../../database/api/.generated").Prisma.JsonValue;
+                                creatorAddress: string;
+                            };
+                        } & {
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
+                            status: import("../../../database/api/.generated").$Enums.RunStatus;
+                            error: string;
+                            details: import("../../../database/api/.generated").Prisma.JsonValue;
+                        })[];
+                    };
+                };
+            };
+        };
     } & {
         campaignStatus: {
             unique: {

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

@@ -64,6 +64,45 @@ export declare const StatusController: Elysia<"/campaignStatus", false, {
             };
         };
     };
+} & {
+    campaignStatus: {
+        status: {
+            get: {
+                body: unknown;
+                params: Record<never, string>;
+                query: {
+                    status: "PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED" | ("PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED")[];
+                };
+                headers: unknown;
+                response: {
+                    200: ({
+                        Campaign: {
+                            id: string;
+                            computeChainId: number;
+                            distributionChainId: number;
+                            campaignId: string;
+                            type: import("../../../../database/api/.generated").$Enums.CampaignType;
+                            subType: number | null;
+                            rewardTokenId: string;
+                            amount: string;
+                            opportunityId: string;
+                            startTimestamp: bigint;
+                            endTimestamp: bigint;
+                            params: import("../../../../database/api/.generated").Prisma.JsonValue;
+                            creatorAddress: string;
+                        };
+                    } & {
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+                        error: string;
+                        details: import("../../../../database/api/.generated").Prisma.JsonValue;
+                    })[];
+                };
+            };
+        };
+    };
 } & {
     campaignStatus: {
         unique: {

package/dist/src/modules/v4/status/status.model.d.ts

@@ -19,5 +19,10 @@ export declare const UpdateStatusDto: import("@sinclair/typebox").TObject<{
         details: import("@sinclair/typebox").TString;
     }>]>;
 }>;
-export declare const ChainModel: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+export declare const RunStatusDto: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"SUCCESS">, import("@sinclair/typebox").TLiteral<"FAILED">, import("@sinclair/typebox").TLiteral<"PROCESSING">, import("@sinclair/typebox").TLiteral<"SKIPPED">]>;
+export declare const RunStatusListDto: import("@sinclair/typebox").TObject<{
+    status: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"SUCCESS">, import("@sinclair/typebox").TLiteral<"FAILED">, import("@sinclair/typebox").TLiteral<"PROCESSING">, import("@sinclair/typebox").TLiteral<"SKIPPED">]>>, import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"SUCCESS">, import("@sinclair/typebox").TLiteral<"FAILED">, import("@sinclair/typebox").TLiteral<"PROCESSING">, import("@sinclair/typebox").TLiteral<"SKIPPED">]>]>;
+}>;
+export type ChainModel = typeof ChainDto.static;
+export type RunStatusListModel = typeof RunStatusListDto.static;
 export type UpdateStatusModel = typeof UpdateStatusDto.static;

package/dist/src/modules/v4/status/status.repository.d.ts

@@ -9,6 +9,30 @@ export declare class StatusRepository {
         error: string;
         details: import("../../../../database/api/.generated").Prisma.JsonValue;
     }[]>;
+    static findManyByRunStatus(statuses: RunStatus[]): Promise<({
+        Campaign: {
+            id: string;
+            computeChainId: number;
+            distributionChainId: number;
+            campaignId: string;
+            type: import("../../../../database/api/.generated").$Enums.CampaignType;
+            subType: number | null;
+            rewardTokenId: string;
+            amount: string;
+            opportunityId: string;
+            startTimestamp: bigint;
+            endTimestamp: bigint;
+            params: import("../../../../database/api/.generated").Prisma.JsonValue;
+            creatorAddress: string;
+        };
+    } & {
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+        error: string;
+        details: import("../../../../database/api/.generated").Prisma.JsonValue;
+    })[]>;
     static findManyPerChain(chainId: number): Promise<{
         campaignId: string;
         computedUntil: bigint;

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

@@ -1,5 +1,5 @@
 import { type CampaignUnique } from "../campaign";
-import type { UpdateStatusModel } from "./status.model";
+import type { RunStatusListModel, UpdateStatusModel } from "./status.model";
 export declare class StatusService {
     static findMany(): Promise<{
         campaignId: string;
@@ -9,6 +9,30 @@ export declare class StatusService {
         error: string;
         details: import("../../../../database/api/.generated").Prisma.JsonValue;
     }[]>;
+    static findManyByRunStatus(x: RunStatusListModel): Promise<({
+        Campaign: {
+            id: string;
+            computeChainId: number;
+            distributionChainId: number;
+            campaignId: string;
+            type: import("../../../../database/api/.generated").$Enums.CampaignType;
+            subType: number | null;
+            rewardTokenId: string;
+            amount: string;
+            opportunityId: string;
+            startTimestamp: bigint;
+            endTimestamp: bigint;
+            params: import("../../../../database/api/.generated").Prisma.JsonValue;
+            creatorAddress: string;
+        };
+    } & {
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+        error: string;
+        details: import("../../../../database/api/.generated").Prisma.JsonValue;
+    })[]>;
     static findManyPerChain(chainId: number): Promise<{
         campaignId: string;
         computedUntil: bigint;

package/dist/src/routes/v3/ERC20Campaigns.d.ts

@@ -1849,6 +1849,45 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                 };
             };
         };
+    } & {
+        campaignStatus: {
+            status: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        status: "PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED" | ("PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED")[];
+                    };
+                    headers: unknown;
+                    response: {
+                        200: ({
+                            Campaign: {
+                                id: string;
+                                computeChainId: number;
+                                distributionChainId: number;
+                                campaignId: string;
+                                type: import("../../../database/api/.generated").$Enums.CampaignType;
+                                subType: number | null;
+                                rewardTokenId: string;
+                                amount: string;
+                                opportunityId: string;
+                                startTimestamp: bigint;
+                                endTimestamp: bigint;
+                                params: import("../../../database/api/.generated").Prisma.JsonValue;
+                                creatorAddress: string;
+                            };
+                        } & {
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
+                            status: import("../../../database/api/.generated").$Enums.RunStatus;
+                            error: string;
+                            details: import("../../../database/api/.generated").Prisma.JsonValue;
+                        })[];
+                    };
+                };
+            };
+        };
     } & {
         campaignStatus: {
             unique: {

package/dist/src/routes/v3/blacklist.d.ts

@@ -1847,6 +1847,45 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                 };
             };
         };
+    } & {
+        campaignStatus: {
+            status: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        status: "PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED" | ("PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED")[];
+                    };
+                    headers: unknown;
+                    response: {
+                        200: ({
+                            Campaign: {
+                                id: string;
+                                computeChainId: number;
+                                distributionChainId: number;
+                                campaignId: string;
+                                type: import("../../../database/api/.generated").$Enums.CampaignType;
+                                subType: number | null;
+                                rewardTokenId: string;
+                                amount: string;
+                                opportunityId: string;
+                                startTimestamp: bigint;
+                                endTimestamp: bigint;
+                                params: import("../../../database/api/.generated").Prisma.JsonValue;
+                                creatorAddress: string;
+                            };
+                        } & {
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
+                            status: import("../../../database/api/.generated").$Enums.RunStatus;
+                            error: string;
+                            details: import("../../../database/api/.generated").Prisma.JsonValue;
+                        })[];
+                    };
+                };
+            };
+        };
     } & {
         campaignStatus: {
             unique: {

package/dist/src/routes/v3/campaigns.d.ts

@@ -1850,6 +1850,45 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                 };
             };
         };
+    } & {
+        campaignStatus: {
+            status: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        status: "PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED" | ("PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED")[];
+                    };
+                    headers: unknown;
+                    response: {
+                        200: ({
+                            Campaign: {
+                                id: string;
+                                computeChainId: number;
+                                distributionChainId: number;
+                                campaignId: string;
+                                type: import("../../../database/api/.generated").$Enums.CampaignType;
+                                subType: number | null;
+                                rewardTokenId: string;
+                                amount: string;
+                                opportunityId: string;
+                                startTimestamp: bigint;
+                                endTimestamp: bigint;
+                                params: import("../../../database/api/.generated").Prisma.JsonValue;
+                                creatorAddress: string;
+                            };
+                        } & {
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
+                            status: import("../../../database/api/.generated").$Enums.RunStatus;
+                            error: string;
+                            details: import("../../../database/api/.generated").Prisma.JsonValue;
+                        })[];
+                    };
+                };
+            };
+        };
     } & {
         campaignStatus: {
             unique: {

package/dist/src/routes/v3/campaignsInfo.d.ts

@@ -1841,6 +1841,45 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                 };
             };
         };
+    } & {
+        campaignStatus: {
+            status: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        status: "PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED" | ("PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED")[];
+                    };
+                    headers: unknown;
+                    response: {
+                        200: ({
+                            Campaign: {
+                                id: string;
+                                computeChainId: number;
+                                distributionChainId: number;
+                                campaignId: string;
+                                type: import("../../../database/api/.generated").$Enums.CampaignType;
+                                subType: number | null;
+                                rewardTokenId: string;
+                                amount: string;
+                                opportunityId: string;
+                                startTimestamp: bigint;
+                                endTimestamp: bigint;
+                                params: import("../../../database/api/.generated").Prisma.JsonValue;
+                                creatorAddress: string;
+                            };
+                        } & {
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
+                            status: import("../../../database/api/.generated").$Enums.RunStatus;
+                            error: string;
+                            details: import("../../../database/api/.generated").Prisma.JsonValue;
+                        })[];
+                    };
+                };
+            };
+        };
     } & {
         campaignStatus: {
             unique: {

package/dist/src/routes/v3/multiChainPositions.d.ts

@@ -1846,6 +1846,45 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                 };
             };
         };
+    } & {
+        campaignStatus: {
+            status: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        status: "PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED" | ("PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED")[];
+                    };
+                    headers: unknown;
+                    response: {
+                        200: ({
+                            Campaign: {
+                                id: string;
+                                computeChainId: number;
+                                distributionChainId: number;
+                                campaignId: string;
+                                type: import("../../../database/api/.generated").$Enums.CampaignType;
+                                subType: number | null;
+                                rewardTokenId: string;
+                                amount: string;
+                                opportunityId: string;
+                                startTimestamp: bigint;
+                                endTimestamp: bigint;
+                                params: import("../../../database/api/.generated").Prisma.JsonValue;
+                                creatorAddress: string;
+                            };
+                        } & {
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
+                            status: import("../../../database/api/.generated").$Enums.RunStatus;
+                            error: string;
+                            details: import("../../../database/api/.generated").Prisma.JsonValue;
+                        })[];
+                    };
+                };
+            };
+        };
     } & {
         campaignStatus: {
             unique: {

package/dist/src/routes/v3/opportunity.d.ts

@@ -1864,6 +1864,45 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                 };
             };
         };
+    } & {
+        campaignStatus: {
+            status: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        status: "PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED" | ("PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED")[];
+                    };
+                    headers: unknown;
+                    response: {
+                        200: ({
+                            Campaign: {
+                                id: string;
+                                computeChainId: number;
+                                distributionChainId: number;
+                                campaignId: string;
+                                type: import("../../../database/api/.generated").$Enums.CampaignType;
+                                subType: number | null;
+                                rewardTokenId: string;
+                                amount: string;
+                                opportunityId: string;
+                                startTimestamp: bigint;
+                                endTimestamp: bigint;
+                                params: import("../../../database/api/.generated").Prisma.JsonValue;
+                                creatorAddress: string;
+                            };
+                        } & {
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
+                            status: import("../../../database/api/.generated").$Enums.RunStatus;
+                            error: string;
+                            details: import("../../../database/api/.generated").Prisma.JsonValue;
+                        })[];
+                    };
+                };
+            };
+        };
     } & {
         campaignStatus: {
             unique: {