@merkl/api 0.18.0 → 0.18.1

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

@@ -2942,6 +2942,21 @@ declare const eden: {
                     }>>;
                 };
             };
+            error: ((params: {
+                campaignId: string | number;
+            }) => {
+                put: (body: {
+                    error: string;
+                }, 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;
@@ -3019,7 +3034,7 @@ declare const eden: {
                                 endOfDisputePeriod: number;
                                 disputer: string;
                                 liveCampaigns: number;
-                                delayed: Awaited<ReturnType<typeof import("../modules/v4/status").StatusService["findManyDelay"]>>;
+                                delayed: Awaited<ReturnType<typeof import("../modules/v4/status/status.service").StatusService["findManyDelay"]>>;
                             };
                         };
                     }>>;
@@ -6366,6 +6381,21 @@ declare const eden: {
                     }>>;
                 };
             };
+            error: ((params: {
+                campaignId: string | number;
+            }) => {
+                put: (body: {
+                    error: string;
+                }, 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;
@@ -6443,7 +6473,7 @@ declare const eden: {
                                 endOfDisputePeriod: number;
                                 disputer: string;
                                 liveCampaigns: number;
-                                delayed: Awaited<ReturnType<typeof import("../modules/v4/status").StatusService["findManyDelay"]>>;
+                                delayed: Awaited<ReturnType<typeof import("../modules/v4/status/status.service").StatusService["findManyDelay"]>>;
                             };
                         };
                     }>>;
@@ -11039,6 +11069,26 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     };
                 };
             };
+        } & {
+            error: {
+                ":campaignId": {
+                    put: {
+                        body: {
+                            error: string;
+                        };
+                        params: {
+                            campaignId: string;
+                        };
+                        query: unknown;
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: void;
+                        };
+                    };
+                };
+            };
         } & {
             engine: {
                 overlaps: {
@@ -11173,7 +11223,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                                     endOfDisputePeriod: number;
                                     disputer: string;
                                     liveCampaigns: number;
-                                    delayed: Awaited<ReturnType<typeof import("../modules/v4/status").StatusService["findManyDelay"]>>;
+                                    delayed: Awaited<ReturnType<typeof import("../modules/v4/status/status.service").StatusService["findManyDelay"]>>;
                                 };
                             };
                         };
@@ -15497,6 +15547,21 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     }>>;
                 };
             };
+            error: ((params: {
+                campaignId: string | number;
+            }) => {
+                put: (body: {
+                    error: string;
+                }, 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;
@@ -15574,7 +15639,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                                 endOfDisputePeriod: number;
                                 disputer: string;
                                 liveCampaigns: number;
-                                delayed: Awaited<ReturnType<typeof import("../modules/v4/status").StatusService["findManyDelay"]>>;
+                                delayed: Awaited<ReturnType<typeof import("../modules/v4/status/status.service").StatusService["findManyDelay"]>>;
                             };
                         };
                     }>>;
@@ -18921,6 +18986,21 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     }>>;
                 };
             };
+            error: ((params: {
+                campaignId: string | number;
+            }) => {
+                put: (body: {
+                    error: string;
+                }, 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;
@@ -18998,7 +19078,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                                 endOfDisputePeriod: number;
                                 disputer: string;
                                 liveCampaigns: number;
-                                delayed: Awaited<ReturnType<typeof import("../modules/v4/status").StatusService["findManyDelay"]>>;
+                                delayed: Awaited<ReturnType<typeof import("../modules/v4/status/status.service").StatusService["findManyDelay"]>>;
                             };
                         };
                     }>>;

package/dist/src/errors/VoidString.error.d.ts

@@ -0,0 +1,4 @@
+import { HttpError } from "./HttpError";
+export declare class VoidString extends HttpError {
+    constructor(message?: string);
+}

package/dist/src/errors/VoidString.error.js

@@ -0,0 +1,7 @@
+import { HttpError } from "./HttpError";
+export class VoidString extends HttpError {
+    constructor(message = "Void String is invalid") {
+        super(message, 409);
+        this.name = "VoidString";
+    }
+}

package/dist/src/factories/metadataFactory/implementations/UniswapV4.js

@@ -16,7 +16,7 @@ export class UniswapV4Metadata {
         //     }
         //   }
         return {
-            name: `Provide liquidity to ${whitelistNameString} UniswapV4 ${params.symbolCurrency0}-${params.symbolCurrency1}${params.lpFee ? ` ${params.lpFee}%` : ""}`,
+            name: `Provide liquidity to ${whitelistNameString} UniswapV4 ${params.symbolCurrency0}-${params.symbolCurrency1}${params.lpFee ? ` ${params.lpFee / 10_000}%` : ""}`,
             action: OpportunityAction.POOL,
             tokens: [
                 { chainId: computeChainId, address: params.currency0 },

package/dist/src/index.d.ts

@@ -3522,6 +3522,26 @@ declare const app: Elysia<"", false, {
                     };
                 };
             };
+        } & {
+            error: {
+                ":campaignId": {
+                    put: {
+                        body: {
+                            error: string;
+                        };
+                        params: {
+                            campaignId: string;
+                        };
+                        query: unknown;
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: void;
+                        };
+                    };
+                };
+            };
         } & {
             engine: {
                 overlaps: {
@@ -3656,7 +3676,7 @@ declare const app: Elysia<"", false, {
                                     endOfDisputePeriod: number;
                                     disputer: string;
                                     liveCampaigns: number;
-                                    delayed: Awaited<ReturnType<typeof import("./modules/v4/status").StatusService["findManyDelay"]>>;
+                                    delayed: Awaited<ReturnType<typeof import("./modules/v4/status/status.service").StatusService["findManyDelay"]>>;
                                 };
                             };
                         };

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

@@ -3392,6 +3392,26 @@ export declare const v4: Elysia<"/v4", false, {
                     };
                 };
             };
+        } & {
+            error: {
+                ":campaignId": {
+                    put: {
+                        body: {
+                            error: string;
+                        };
+                        params: {
+                            campaignId: string;
+                        };
+                        query: unknown;
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: void;
+                        };
+                    };
+                };
+            };
         } & {
             engine: {
                 overlaps: {
@@ -3526,7 +3546,7 @@ export declare const v4: Elysia<"/v4", false, {
                                     endOfDisputePeriod: number;
                                     disputer: string;
                                     liveCampaigns: number;
-                                    delayed: Awaited<ReturnType<typeof import("./status").StatusService["findManyDelay"]>>;
+                                    delayed: Awaited<ReturnType<typeof import("./status/status.service").StatusService["findManyDelay"]>>;
                                 };
                             };
                         };

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

@@ -66,6 +66,26 @@ export declare const StatusController: Elysia<"/campaign-status", false, {
                 };
             };
         };
+    } & {
+        error: {
+            ":campaignId": {
+                put: {
+                    body: {
+                        error: string;
+                    };
+                    params: {
+                        campaignId: string;
+                    };
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: void;
+                    };
+                };
+            };
+        };
     } & {
         engine: {
             overlaps: {

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

@@ -1,7 +1,8 @@
+import { BackOfficeGuard } from "../../../guards/BackOffice.guard";
 import { AuthorizationHeadersDto, EngineGuard } from "../../../guards/Engine.guard";
 import { throwOnUnsupportedChainId } from "../../../utils/throw";
 import Elysia from "elysia";
-import { CampaignUniqueDto, ComputedUntilDto, DelayDto, QueryCampaignStatusDto, UpdateCampaignStatusDto, } from "./status.model";
+import { CampaignUniqueDto, ComputedUntilDto, DelayDto, QueryCampaignStatusDto, StatusErrorDto, UpdateCampaignStatusDto, } from "./status.model";
 import { StatusService } from "./status.service";
 export const StatusController = new Elysia({ prefix: "/campaign-status", detail: { tags: ["Status"], hide: true } })
     // ─── Update a Campaign Status ──────────────────────────────────────
@@ -21,6 +22,15 @@ export const StatusController = new Elysia({ prefix: "/campaign-status", detail:
     beforeHandle: EngineGuard,
     headers: AuthorizationHeadersDto,
     body: ComputedUntilDto,
+})
+    // ─── Updates only the computed until field ───────────────────────────
+    .put("/error/:campaignId", async ({ params, body }) => {
+    const [distributionChain, campaignId] = params.campaignId.split("-");
+    return await StatusService.updateErrorMessage({ distributionChain: +distributionChain, campaignId }, body.error);
+}, {
+    beforeHandle: BackOfficeGuard,
+    headers: AuthorizationHeadersDto,
+    body: StatusErrorDto,
 })
     // ─── Is Safe For Overlaps ───────────────────────────────────────────
     .get("/engine/overlaps", async ({ query }) => await StatusService.isSafeForOverlaps(query), {

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

@@ -41,6 +41,9 @@ export declare const UpdateCampaignStatusDto: import("@sinclair/typebox").TUnion
 export declare const ComputedUntilDto: import("@sinclair/typebox").TObject<{
     computedUntil: import("@sinclair/typebox").TNumber;
 }>;
+export declare const StatusErrorDto: import("@sinclair/typebox").TObject<{
+    error: import("@sinclair/typebox").TString;
+}>;
 export declare const QueryCampaignStatusDto: import("@sinclair/typebox").TObject<{
     computeChainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
     status: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TArray<import("@sinclair/typebox").TEnum<{

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

@@ -27,6 +27,7 @@ export const UpdateCampaignStatusDto = t.Union([
     t.Object({ value: t.Literal(RunStatus.FAILED), error: t.String(), details: t.String() }),
 ]);
 export const ComputedUntilDto = t.Object({ computedUntil: t.Numeric() });
+export const StatusErrorDto = t.Object({ error: t.String() });
 export const QueryCampaignStatusDto = t.Object({
     computeChainId: t.Optional(t.Numeric()),
     status: t.Optional(t.Union([t.Array(t.Enum(RunStatus)), t.Enum(RunStatus)])),

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

@@ -68,6 +68,14 @@ export declare abstract class StatusRepository {
         computedUntil: bigint;
         processingStarted: bigint;
     }>;
+    static updateErrorMessage(campaignUnique: CampaignUnique, error: string): Promise<{
+        error: string;
+        details: Prisma.JsonValue;
+        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+    }>;
     static findManyDelay(query: DelayModel): Promise<{
         startTimestamp: bigint;
         endTimestamp: bigint;

package/dist/src/modules/v4/status/status.repository.js

@@ -65,7 +65,7 @@ export class StatusRepository {
             },
             data: {
                 status,
-                error,
+                error: error?.length > 0 ? error : undefined,
                 details,
             },
         });
@@ -98,12 +98,22 @@ export class StatusRepository {
             },
         });
     }
+    static async updateErrorMessage(campaignUnique, error) {
+        return await apiDbClient.campaignStatus.update({
+            where: {
+                campaignId: CampaignService.hashId(campaignUnique),
+            },
+            data: {
+                error,
+            },
+        });
+    }
     static async findManyDelay(query) {
         return await apiDbClient.campaign.findMany({
             where: {
                 distributionChainId: !!query.chainId ? query.chainId : undefined,
                 endTimestamp: {
-                    gte: !!query.endTimestampLowerBound ? query.endTimestampLowerBound : moment().subtract(1, "week").unix(),
+                    gte: !!query.endTimestampLowerBound ? query.endTimestampLowerBound : moment().subtract(2, "week").unix(),
                 },
             },
             select: {

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

@@ -43,6 +43,7 @@ export declare abstract class StatusService {
     } | null>;
     static update(campaignUnique: CampaignUnique, status: UpdateStatusModel): Promise<void>;
     static updateComputedUntil(campaignUnique: CampaignUnique, computedUntil: number): Promise<void>;
+    static updateErrorMessage(campaignUnique: CampaignUnique, error: string): Promise<void>;
     static isSafeForOverlaps(campaignUnique: CampaignUnique): Promise<boolean>;
     static findUpdatesAndDelays(): Promise<Record<number, {
         live: string;

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

@@ -1,3 +1,5 @@
+import { NotFoundError } from "../../../errors";
+import { VoidString } from "../../../errors/VoidString.error";
 import { log } from "../../../utils/logger";
 import { RunStatus } from "../../../../database/api/.generated";
 import { HOUR, MAX_COMPUTE_JOB_TIME, NETWORK_LABELS, getMultisigURL, registry } from "@sdk";
@@ -66,6 +68,17 @@ export class StatusService {
         }
         await StatusRepository.updateComputedUntil(campaignUnique, computedUntil);
     }
+    static async updateErrorMessage(campaignUnique, error) {
+        // Check if the status exists already, otherwise thros
+        const campaignStatus = await StatusRepository.findUnique(campaignUnique);
+        if (!(error?.length > 0)) {
+            throw new VoidString("Error message is empty");
+        }
+        if (!campaignStatus) {
+            throw new NotFoundError("CampaignStatus not found");
+        }
+        await StatusRepository.updateErrorMessage(campaignUnique, error);
+    }
     static async isSafeForOverlaps(campaignUnique) {
         const status = await StatusRepository.findUnique(campaignUnique);
         if (!status) {
@@ -106,7 +119,6 @@ export class StatusService {
                 delayed: delayedCampaigns,
             };
         }
-        console.log(res[146]);
         return res;
     }
     static async findManyDelay(query) {