@merkl/api 0.10.89 → 0.10.91

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

@@ -1421,6 +1421,103 @@ declare const eden: {
                 }) & {};
             }) & {};
         };
+        campaignStatus: {
+            engine: {
+                post: (body: {
+                    status: {
+                        value: "SUCCESS";
+                        computedUntil: number;
+                    } | {
+                        value: "PROCESSING";
+                    } | {
+                        error: string;
+                        details: string;
+                        value: "SKIPPED";
+                    } | {
+                        error: string;
+                        details: string;
+                        value: "FAILED";
+                    };
+                    campaignId: string;
+                    distributionChain: number;
+                }, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: void;
+                }>>;
+            };
+            index: {
+                get: (options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        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;
+                    query: {
+                        campaignId: string;
+                        distributionChain: number;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                        status: import("../../database/api/.generated").$Enums.RunStatus;
+                        error: string;
+                        details: import("../../database/api/.generated").Prisma.JsonValue;
+                    };
+                }>>;
+            };
+            computeChain: ((params: {
+                chainId: 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: {
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                        status: import("../../database/api/.generated").$Enums.RunStatus;
+                        error: string;
+                        details: import("../../database/api/.generated").Prisma.JsonValue;
+                    }[];
+                }>>;
+            }) & {};
+            overlaps: {
+                get: (options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query: {
+                        campaignId: string;
+                        distributionChain: number;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: boolean;
+                }>>;
+            };
+        };
     };
 };
 type Api = typeof eden;
@@ -3218,6 +3315,130 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
             };
         };
     };
+} & {
+    v4: {
+        campaignStatus: {
+            engine: {
+                post: {
+                    body: {
+                        status: {
+                            value: "SUCCESS";
+                            computedUntil: number;
+                        } | {
+                            value: "PROCESSING";
+                        } | {
+                            error: string;
+                            details: string;
+                            value: "SKIPPED";
+                        } | {
+                            error: string;
+                            details: string;
+                            value: "FAILED";
+                        };
+                        campaignId: string;
+                        distributionChain: number;
+                    };
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: void;
+                    };
+                };
+            };
+        };
+    } & {
+        campaignStatus: {
+            index: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: {
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
+                            status: import("../../database/api/.generated").$Enums.RunStatus;
+                            error: string;
+                            details: import("../../database/api/.generated").Prisma.JsonValue;
+                        }[];
+                    };
+                };
+            };
+        };
+    } & {
+        campaignStatus: {
+            unique: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        campaignId: string;
+                        distributionChain: number;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: {
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
+                            status: import("../../database/api/.generated").$Enums.RunStatus;
+                            error: string;
+                            details: import("../../database/api/.generated").Prisma.JsonValue;
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        campaignStatus: {
+            computeChain: {
+                ":chainId": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            chainId: number;
+                        };
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: {
+                                campaignId: string;
+                                computedUntil: bigint;
+                                processingStarted: bigint;
+                                status: import("../../database/api/.generated").$Enums.RunStatus;
+                                error: string;
+                                details: import("../../database/api/.generated").Prisma.JsonValue;
+                            }[];
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        campaignStatus: {
+            overlaps: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        campaignId: string;
+                        distributionChain: number;
+                    };
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: boolean;
+                    };
+                };
+            };
+        };
+    };
 }, {
     derive: {};
     resolve: {};
@@ -4651,6 +4872,103 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 }) & {};
             }) & {};
         };
+        campaignStatus: {
+            engine: {
+                post: (body: {
+                    status: {
+                        value: "SUCCESS";
+                        computedUntil: number;
+                    } | {
+                        value: "PROCESSING";
+                    } | {
+                        error: string;
+                        details: string;
+                        value: "SKIPPED";
+                    } | {
+                        error: string;
+                        details: string;
+                        value: "FAILED";
+                    };
+                    campaignId: string;
+                    distributionChain: number;
+                }, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: void;
+                }>>;
+            };
+            index: {
+                get: (options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        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;
+                    query: {
+                        campaignId: string;
+                        distributionChain: number;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                        status: import("../../database/api/.generated").$Enums.RunStatus;
+                        error: string;
+                        details: import("../../database/api/.generated").Prisma.JsonValue;
+                    };
+                }>>;
+            };
+            computeChain: ((params: {
+                chainId: 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: {
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                        status: import("../../database/api/.generated").$Enums.RunStatus;
+                        error: string;
+                        details: import("../../database/api/.generated").Prisma.JsonValue;
+                    }[];
+                }>>;
+            }) & {};
+            overlaps: {
+                get: (options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query: {
+                        campaignId: string;
+                        distributionChain: number;
+                    };
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: boolean;
+                }>>;
+            };
+        };
     };
 };
 export type Opportunity = FromPromise<Api["v4"]["opportunities"]["index"]["get"]>;

package/dist/src/index.d.ts

@@ -1786,6 +1786,130 @@ declare const app: Elysia<"", false, {
             };
         };
     };
+} & {
+    v4: {
+        campaignStatus: {
+            engine: {
+                post: {
+                    body: {
+                        status: {
+                            value: "SUCCESS";
+                            computedUntil: number;
+                        } | {
+                            value: "PROCESSING";
+                        } | {
+                            error: string;
+                            details: string;
+                            value: "SKIPPED";
+                        } | {
+                            error: string;
+                            details: string;
+                            value: "FAILED";
+                        };
+                        campaignId: string;
+                        distributionChain: number;
+                    };
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: void;
+                    };
+                };
+            };
+        };
+    } & {
+        campaignStatus: {
+            index: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: {
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
+                            status: import("../database/api/.generated").$Enums.RunStatus;
+                            error: string;
+                            details: import("../database/api/.generated").Prisma.JsonValue;
+                        }[];
+                    };
+                };
+            };
+        };
+    } & {
+        campaignStatus: {
+            unique: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        campaignId: string;
+                        distributionChain: number;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: {
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
+                            status: import("../database/api/.generated").$Enums.RunStatus;
+                            error: string;
+                            details: import("../database/api/.generated").Prisma.JsonValue;
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        campaignStatus: {
+            computeChain: {
+                ":chainId": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            chainId: number;
+                        };
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: {
+                                campaignId: string;
+                                computedUntil: bigint;
+                                processingStarted: bigint;
+                                status: import("../database/api/.generated").$Enums.RunStatus;
+                                error: string;
+                                details: import("../database/api/.generated").Prisma.JsonValue;
+                            }[];
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        campaignStatus: {
+            overlaps: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        campaignId: string;
+                        distributionChain: number;
+                    };
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: boolean;
+                    };
+                };
+            };
+        };
+    };
 }, {
     derive: {};
     resolve: {};

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

@@ -1768,6 +1768,130 @@ export declare const v4: Elysia<"/v4", false, {
             };
         };
     };
+} & {
+    v4: {
+        campaignStatus: {
+            engine: {
+                post: {
+                    body: {
+                        status: {
+                            value: "SUCCESS";
+                            computedUntil: number;
+                        } | {
+                            value: "PROCESSING";
+                        } | {
+                            error: string;
+                            details: string;
+                            value: "SKIPPED";
+                        } | {
+                            error: string;
+                            details: string;
+                            value: "FAILED";
+                        };
+                        campaignId: string;
+                        distributionChain: number;
+                    };
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: void;
+                    };
+                };
+            };
+        };
+    } & {
+        campaignStatus: {
+            index: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: {
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
+                            status: import("../../../database/api/.generated").$Enums.RunStatus;
+                            error: string;
+                            details: import("../../../database/api/.generated").Prisma.JsonValue;
+                        }[];
+                    };
+                };
+            };
+        };
+    } & {
+        campaignStatus: {
+            unique: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        campaignId: string;
+                        distributionChain: number;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: {
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
+                            status: import("../../../database/api/.generated").$Enums.RunStatus;
+                            error: string;
+                            details: import("../../../database/api/.generated").Prisma.JsonValue;
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        campaignStatus: {
+            computeChain: {
+                ":chainId": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            chainId: number;
+                        };
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: {
+                                campaignId: string;
+                                computedUntil: bigint;
+                                processingStarted: bigint;
+                                status: import("../../../database/api/.generated").$Enums.RunStatus;
+                                error: string;
+                                details: import("../../../database/api/.generated").Prisma.JsonValue;
+                            }[];
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        campaignStatus: {
+            overlaps: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: {
+                        campaignId: string;
+                        distributionChain: number;
+                    };
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: boolean;
+                    };
+                };
+            };
+        };
+    };
 }, {
     derive: {};
     resolve: {};