@merkl/api 0.16.9 → 0.16.10

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

@@ -1048,6 +1048,7 @@ declare const eden: {
                             campaignId: string;
                             CampaignStatus: {
                                 computedUntil: bigint;
+                                processingStarted: bigint;
                             }[];
                         }[];
                     }>>;
@@ -4160,6 +4161,7 @@ declare const eden: {
                             campaignId: string;
                             CampaignStatus: {
                                 computedUntil: bigint;
+                                processingStarted: bigint;
                             }[];
                         }[];
                     }>>;
@@ -8126,6 +8128,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                                 campaignId: string;
                                 CampaignStatus: {
                                     computedUntil: bigint;
+                                    processingStarted: bigint;
                                 }[];
                             }[];
                         };
@@ -12735,6 +12738,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                             campaignId: string;
                             CampaignStatus: {
                                 computedUntil: bigint;
+                                processingStarted: bigint;
                             }[];
                         }[];
                     }>>;
@@ -15847,6 +15851,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                             campaignId: string;
                             CampaignStatus: {
                                 computedUntil: bigint;
+                                processingStarted: bigint;
                             }[];
                         }[];
                     }>>;

package/dist/src/index.d.ts

@@ -1204,6 +1204,7 @@ declare const app: Elysia<"", false, {
                                 campaignId: string;
                                 CampaignStatus: {
                                     computedUntil: bigint;
+                                    processingStarted: bigint;
                                 }[];
                             }[];
                         };

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

@@ -230,6 +230,7 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                             campaignId: string;
                             CampaignStatus: {
                                 computedUntil: bigint;
+                                processingStarted: bigint;
                             }[];
                         }[];
                     };

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

@@ -107,9 +107,8 @@ export declare abstract class CampaignRepository {
         mainParameter: string;
         campaignParameters: import("database/engine/.generated/runtime/library").JsonValue;
     }[]>;
-    static checkIfExist(campaign: CampaignUnique): Promise<boolean>;
-    static checkIfIdExist(id: string): Promise<boolean>;
-    static findUnique(campaign: CampaignUnique): Promise<{
+    static checkIfExist(id: string): Promise<boolean>;
+    static findUnique(id: string): Promise<{
         type: string;
         id: string;
         params: Prisma.JsonValue;
@@ -144,6 +143,7 @@ export declare abstract class CampaignRepository {
         campaignId: string;
         CampaignStatus: {
             computedUntil: bigint;
+            processingStarted: bigint;
         }[];
     }[]>;
     static findMany(query: GetCampaignQueryModel): Promise<({

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

@@ -195,17 +195,7 @@ export class CampaignRepository {
             },
         });
     }
-    static async checkIfExist(campaign) {
-        return !!(await apiDbClient.campaign.findFirst({
-            select: {
-                id: true,
-            },
-            where: {
-                id: CampaignService.hashId(campaign),
-            },
-        }));
-    }
-    static async checkIfIdExist(id) {
+    static async checkIfExist(id) {
         return !!(await apiDbClient.campaign.findFirst({
             select: {
                 id: true,
@@ -215,10 +205,10 @@ export class CampaignRepository {
             },
         }));
     }
-    static async findUnique(campaign) {
+    static async findUnique(id) {
         return await apiDbClient.campaign.findUnique({
             where: {
-                id: CampaignService.hashId(campaign),
+                id,
             },
         });
     }
@@ -247,6 +237,7 @@ export class CampaignRepository {
                                 status: {
                                     not: RunStatus.PROCESSING,
                                 },
+                                computedUntil: { lt: currentTime }, // more than 10 min ago
                             },
                             {
                                 status: RunStatus.PROCESSING,
@@ -266,6 +257,7 @@ export class CampaignRepository {
                     take: 1,
                     select: {
                         computedUntil: true,
+                        processingStarted: true,
                     },
                 },
             },

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

@@ -19,6 +19,14 @@ export declare abstract class CampaignService {
         opportunityId: string;
         creatorAddress: string;
     } | undefined>;
+    static createMany(campaigns: Omit<CreateCampaignModel, "id">[], upsert?: boolean): Promise<{
+        success: number;
+        fail: number;
+    }>;
+    /**
+     * @dev back-office function
+     * @dev deprecated should be replaced with a manual override
+     */
     static updateMetaData(campaign: Omit<UpdateMetaDataCampaignModel, "id">): Promise<{
         type: string;
         id: string;
@@ -34,11 +42,10 @@ export declare abstract class CampaignService {
         opportunityId: string;
         creatorAddress: string;
     }>;
+    /**
+     * @dev back-office function
+     */
     static moveToOpportunity(campaign: Omit<UpdateCampaignModel, "id">, upsert?: boolean): Promise<string>;
-    static createMany(campaigns: Omit<CreateCampaignModel, "id">[], upsert?: boolean): Promise<{
-        success: number;
-        fail: number;
-    }>;
     /**
      * Get the list of campaigns satisfying the query
      * @param query
@@ -103,9 +110,8 @@ export declare abstract class CampaignService {
      */
     static countMany(query: GetCampaignQueryModel): Promise<number>;
     static countLives(chainId: number): Promise<number>;
-    static checkIfExist(campaign: CampaignUnique): Promise<boolean>;
-    static checkIfIdExist(id: string): Promise<boolean>;
-    static findUnique(campaign: CampaignUnique): Promise<{
+    static checkIfExist(campaign: CampaignUnique | string): Promise<boolean>;
+    static findUnique(campaign: CampaignUnique | string): Promise<{
         type: string;
         id: string;
         params: import("database/api/.generated/runtime/library").JsonValue;
@@ -140,6 +146,7 @@ export declare abstract class CampaignService {
         campaignId: string;
         CampaignStatus: {
             computedUntil: bigint;
+            processingStarted: bigint;
         }[];
     }[]>;
     static findNextCampaignToProcess(chainId: ChainId): Promise<{

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

@@ -26,6 +26,31 @@ export class CampaignService {
         await OpportunityService.createFromCampaign(campaign);
         return await CampaignRepository.upsert({ id, ...campaign });
     }
+    static async createMany(campaigns, upsert = false) {
+        const failedToFetchMetadata = [];
+        const campaignsToInsert = [];
+        await Promise.all(campaigns.map(async (campaign) => {
+            const id = CampaignService.hashId({ distributionChain: campaign.chainId, campaignId: campaign.campaignId });
+            campaign.computeChainId = campaign.computeChainId === 0 ? campaign.chainId : campaign.computeChainId;
+            try {
+                if (upsert || !(await CampaignService.checkIfExist(id))) {
+                    await OpportunityService.createFromCampaign(campaign);
+                    campaignsToInsert.push({ id, ...campaign });
+                }
+            }
+            catch (err) {
+                log.error(`Cannot get Opportunity metadata for campaign ${campaign.campaignId} of type ${campaign.type}`, err);
+                failedToFetchMetadata.push(campaign);
+            }
+        }));
+        let { success, fail } = await CampaignRepository.upsertMany(campaignsToInsert);
+        fail += failedToFetchMetadata.length;
+        return { success, fail };
+    }
+    /**
+     * @dev back-office function
+     * @dev deprecated should be replaced with a manual override
+     */
     static async updateMetaData(campaign) {
         const id = CampaignService.hashId({
             distributionChain: campaign.distributionChain,
@@ -39,6 +64,9 @@ export class CampaignService {
         const updatedParams = JSON.stringify(params);
         return await CampaignRepository.updateMetaData(id, updatedParams);
     }
+    /**
+     * @dev back-office function
+     */
     static async moveToOpportunity(campaign, upsert = false) {
         const id = CampaignService.hashId({
             distributionChain: campaign.distributionChain,
@@ -87,31 +115,6 @@ export class CampaignService {
         // Return new opportunityId
         return (await CampaignService.findUniqueOrThrow(campaign)).opportunityId;
     }
-    static async createMany(campaigns, upsert = false) {
-        const failedToFetchMetadata = [];
-        const campaignsToInsert = [];
-        await Promise.all(campaigns.map(async (campaign) => {
-            const id = CampaignService.hashId({ distributionChain: campaign.chainId, campaignId: campaign.campaignId });
-            campaign.computeChainId = campaign.computeChainId === 0 ? campaign.chainId : campaign.computeChainId;
-            try {
-                if (upsert || !(await CampaignService.checkIfIdExist(id))) {
-                    await OpportunityService.createFromCampaign(campaign);
-                    campaignsToInsert.push({ id, ...campaign });
-                }
-                // } else {
-                //   console.log("Updating status from campaign");
-                //   await OpportunityService.updateStatusFromCampaign(campaign);
-                // }
-            }
-            catch (err) {
-                log.error(`Cannot get Opportunity metadata for campaign ${campaign.campaignId} of type ${campaign.type}`, err);
-                failedToFetchMetadata.push(campaign);
-            }
-        }));
-        let { success, fail } = await CampaignRepository.upsertMany(campaignsToInsert);
-        fail += failedToFetchMetadata.length;
-        return { success, fail };
-    }
     /**
      * Get the list of campaigns satisfying the query
      * @param query
@@ -140,24 +143,27 @@ export class CampaignService {
         return await CampaignRepository.countLives(chainId);
     }
     static async checkIfExist(campaign) {
-        return await CampaignRepository.checkIfExist(campaign);
-    }
-    static async checkIfIdExist(id) {
-        return await CampaignRepository.checkIfIdExist(id);
+        const id = typeof campaign === "string" ? campaign : CampaignService.hashId(campaign);
+        return await CampaignRepository.checkIfExist(id);
     }
     static async findUnique(campaign) {
-        return await CampaignRepository.findUnique(campaign);
+        const id = typeof campaign === "string" ? campaign : CampaignService.hashId(campaign);
+        return await CampaignRepository.findUnique(id);
     }
     static async findUniqueOrThrow(campaign) {
         const id = typeof campaign === "string" ? campaign : CampaignService.hashId(campaign);
         return await CampaignRepository.findUniqueOrThrow(id);
     }
     static async findCampaignsToProcess(distributionChainId) {
-        return (await CampaignRepository.findCampaignsToProcess(distributionChainId)).filter(campaign => campaign.endTimestamp > campaign?.CampaignStatus?.[0]?.computedUntil);
+        return (await CampaignRepository.findCampaignsToProcess(distributionChainId))
+            .filter(campaign => campaign.endTimestamp > campaign?.CampaignStatus?.[0]?.computedUntil)
+            ?.sort((a, b) => Number(a.CampaignStatus?.[0]?.processingStarted - b.CampaignStatus?.[0]?.processingStarted));
     }
     static async findNextCampaignToProcess(chainId) {
         const campaigns = await CampaignService.findCampaignsToProcess(chainId);
-        return { campaignId: campaigns?.[0]?.campaignId };
+        return {
+            campaignId: campaigns?.[0]?.campaignId,
+        };
     }
     static async pickCampaignToProcess(chainId) {
         const campaigns = await CampaignService.findCampaignsToProcess(chainId);

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

@@ -1,5 +1,5 @@
 import { type ChainId } from "@sdk";
-import { type GetCampaignQueryModel } from "../campaign";
+import type { GetCampaignQueryModel } from "../campaign";
 import type { FilledCampaignDtoModel, SimplifiedCampaignDtoModel } from "./dynamicData.model";
 export declare class DynamicDataService {
     #private;

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

@@ -1,11 +1,11 @@
 import { campaignsDynamicData } from "../../../libs/campaigns/campaignsDynamicData";
+import { CampaignRepository } from "../campaign/campaign.repository";
+import { CampaignService } from "../campaign/campaign.service";
+import { OpportunityService } from "../opportunity/opportunity.service";
 import { executeSimple } from "../../../utils/execute";
 import { log } from "../../../utils/logger";
 import { Campaign, NETWORK_LABELS } from "@sdk";
 import { utils } from "ethers";
-import { CampaignService } from "../campaign";
-import { CampaignRepository } from "../campaign/campaign.repository";
-import { OpportunityService } from "../opportunity";
 export class DynamicDataService {
     static async queryERC20DynamicData(chainId, tokenAddress, decimals = 18) {
         const campaigns = [

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

@@ -1074,6 +1074,7 @@ export declare const v4: Elysia<"/v4", false, {
                                 campaignId: string;
                                 CampaignStatus: {
                                     computedUntil: bigint;
+                                    processingStarted: bigint;
                                 }[];
                             }[];
                         };

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

@@ -59,14 +59,21 @@ export declare class StatusRepository {
         computedUntil: bigint;
         processingStarted: bigint;
     }>;
-    static updateProcessing(campaignUnique: CampaignUnique): Promise<{
+    static updateProcessing(campaignUnique: CampaignUnique): Promise<[{
         error: string;
         details: Prisma.JsonValue;
         status: import("../../../../database/api/.generated").$Enums.RunStatus;
         campaignId: string;
         computedUntil: bigint;
         processingStarted: bigint;
-    }>;
+    }, {
+        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

@@ -71,17 +71,28 @@ export class StatusRepository {
         });
     }
     static async updateProcessing(campaignUnique) {
-        return await apiDbClient.campaignStatus.update({
-            where: {
-                campaignId: CampaignService.hashId(campaignUnique),
-            },
-            data: {
-                status: "PROCESSING",
-                processingStarted: moment().unix(),
-                error: "",
-                details: "{}",
-            },
-        });
+        const campaignId = CampaignService.hashId(campaignUnique);
+        return await apiDbClient.$transaction([
+            apiDbClient.campaignStatus.findUniqueOrThrow({
+                where: {
+                    campaignId,
+                    status: {
+                        not: "PROCESSING",
+                    },
+                },
+            }),
+            apiDbClient.campaignStatus.update({
+                where: {
+                    campaignId,
+                },
+                data: {
+                    status: "PROCESSING",
+                    processingStarted: moment().unix(),
+                    error: "",
+                    details: "{}",
+                },
+            }),
+        ]);
     }
     static async findManyDelay(query) {
         return await apiDbClient.campaign.findMany({