@merkl/api 0.9.15

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

@@ -0,0 +1,146 @@
+import { apiDbClient } from "@db";
+import moment from "moment";
+import { CampaignService } from "../campaign";
+export class StatusRepository {
+    static #formatQuery(query) {
+        return {
+            where: {
+                status: Array.isArray(query.status) ? { in: query.status } : query.status,
+                Campaign: query.computeChainId ? { computeChainId: query.computeChainId } : undefined,
+            },
+            include: { Campaign: Boolean(query.status) },
+        };
+    }
+    static async findMany(query) {
+        return await apiDbClient.campaignStatus.findMany(StatusRepository.#formatQuery(query));
+    }
+    static async findManyByCampaignId(campaignId) {
+        return await apiDbClient.campaignStatus.findMany({
+            where: {
+                Campaign: {
+                    campaignId: campaignId,
+                },
+            },
+        });
+    }
+    static async findUniqueOrThrow(campaignId) {
+        return await apiDbClient.campaignStatus.findUniqueOrThrow({
+            where: {
+                campaignId,
+            },
+        });
+    }
+    static async findUnique(campaignUnique) {
+        return await apiDbClient.campaignStatus.findUnique({
+            where: {
+                campaignId: CampaignService.hashId(campaignUnique),
+            },
+        });
+    }
+    static async create(campaign, startTimestamp) {
+        return await apiDbClient.campaignStatus.create({
+            data: {
+                campaignId: CampaignService.hashId(campaign),
+                computedUntil: startTimestamp,
+                processingStarted: startTimestamp,
+            },
+        });
+    }
+    static async updateSuccess(campaignUnique, computedUntil) {
+        return await apiDbClient.campaignStatus.update({
+            where: {
+                campaignId: CampaignService.hashId(campaignUnique),
+            },
+            data: {
+                computedUntil,
+                status: "SUCCESS",
+                error: "",
+                details: "{}",
+            },
+        });
+    }
+    static async updateWithError(campaignUnique, status, error, details) {
+        return await apiDbClient.campaignStatus.update({
+            where: {
+                campaignId: CampaignService.hashId(campaignUnique),
+            },
+            data: {
+                status,
+                error: error?.length > 0 ? error : undefined,
+                details,
+            },
+        });
+    }
+    static async updateProcessing(campaignUnique) {
+        const campaignId = CampaignService.hashId(campaignUnique);
+        const now = moment().unix();
+        await apiDbClient.campaignStatus.update({
+            where: {
+                campaignId,
+                processingStarted: {
+                    lte: now - 60, // The job wasn't already updated in the last minute
+                },
+            },
+            data: {
+                status: "PROCESSING",
+                processingStarted: moment().unix(),
+                error: "",
+                details: "{}",
+            },
+        });
+    }
+    static async updateComputedUntil(campaignUnique, computedUntil) {
+        return await apiDbClient.campaignStatus.update({
+            where: {
+                campaignId: CampaignService.hashId(campaignUnique),
+            },
+            data: {
+                computedUntil,
+            },
+        });
+    }
+    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(2, "week").unix(),
+                },
+            },
+            select: {
+                campaignId: true,
+                computeChainId: true,
+                startTimestamp: true,
+                endTimestamp: true,
+                distributionChainId: true,
+                RewardToken: {
+                    select: {
+                        address: true,
+                        symbol: true,
+                        isTest: true,
+                    },
+                },
+                Opportunity: {
+                    select: {
+                        name: true,
+                        identifier: true,
+                        type: true,
+                    },
+                },
+                CampaignStatus: {
+                    take: 1,
+                },
+            },
+        });
+    }
+}

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

@@ -0,0 +1,88 @@
+import { CampaignService, type CampaignUnique } from "../campaign";
+import type { DelayModel, QueryCampaignStatus, UpdateStatusModel } from "./status.model";
+export declare abstract class StatusService {
+    static format(status: Awaited<ReturnType<(typeof CampaignService)["findUniqueOrThrow"]>>["CampaignStatus"][number]): {
+        computedUntil: number;
+        processingStarted: number;
+        error: string;
+        status: import("@db/api").$Enums.RunStatus;
+        details: import("database/api/.generated/runtime/library").JsonValue;
+        campaignId: string;
+    };
+    static findMany(query: QueryCampaignStatus): Promise<{
+        error: string;
+        status: import("@db/api").$Enums.RunStatus;
+        details: import("database/api/.generated/runtime/library").JsonValue;
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+    }[]>;
+    static findManyByCampaignId(campaignId: string): Promise<{
+        error: string;
+        status: import("@db/api").$Enums.RunStatus;
+        details: import("database/api/.generated/runtime/library").JsonValue;
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+    }[]>;
+    static findUniqueOrThrow(campaignUnique: CampaignUnique | string): Promise<{
+        error: string;
+        status: import("@db/api").$Enums.RunStatus;
+        details: import("database/api/.generated/runtime/library").JsonValue;
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+    }>;
+    static findUnique(campaignUnique: CampaignUnique): Promise<{
+        error: string;
+        status: import("@db/api").$Enums.RunStatus;
+        details: import("database/api/.generated/runtime/library").JsonValue;
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+    } | 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;
+        tree: string;
+        lastTree: string;
+        admin: string;
+        adminUrl?: string;
+        distributor: string;
+        distributionCreator: string;
+        endOfDisputePeriod: number;
+        disputer: string;
+        liveCampaigns: number;
+        delayed: Awaited<ReturnType<(typeof StatusService)["findManyDelay"]>>;
+    }>>;
+    static findManyDelay(query: DelayModel): Promise<{
+        delay: number;
+        computedUntil: number;
+        computeChainId: number;
+        distributionChainId: number;
+        campaignId: string;
+        startTimestamp: bigint;
+        endTimestamp: bigint;
+        RewardToken: {
+            symbol: string;
+            address: string;
+            isTest: boolean;
+        };
+        Opportunity: {
+            name: string;
+            type: string;
+            identifier: string;
+        };
+        CampaignStatus: {
+            error: string;
+            status: import("@db/api").$Enums.RunStatus;
+            details: import("database/api/.generated/runtime/library").JsonValue;
+            campaignId: string;
+            computedUntil: bigint;
+            processingStarted: bigint;
+        }[];
+    }[]>;
+}

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

@@ -0,0 +1,144 @@
+import { NotFoundError } from "@/errors";
+import { VoidString } from "@/errors/VoidString.error";
+import { log } from "@/utils/logger";
+import { RunStatus } from "@db/api";
+import { HOUR, MAX_COMPUTE_JOB_TIME, NETWORK_LABELS, getMultisigURL, registry } from "@sdk";
+import moment from "moment";
+import { CampaignService } from "../campaign";
+import { MerklRootService } from "../merklRoot";
+import { StatusRepository } from "./status.repository";
+export class StatusService {
+    static format(status) {
+        return {
+            ...status,
+            computedUntil: Number(status.computedUntil),
+            processingStarted: Number(status.processingStarted),
+        };
+    }
+    static async findMany(query) {
+        return await StatusRepository.findMany(query);
+    }
+    static async findManyByCampaignId(campaignId) {
+        return await StatusRepository.findManyByCampaignId(campaignId);
+    }
+    static async findUniqueOrThrow(campaignUnique) {
+        const campaignId = typeof campaignUnique === "string" ? campaignUnique : CampaignService.hashId(campaignUnique);
+        return await StatusRepository.findUniqueOrThrow(campaignId);
+    }
+    static async findUnique(campaignUnique) {
+        return await StatusRepository.findUnique(campaignUnique);
+    }
+    static async update(campaignUnique, status) {
+        // Check if the status exists already, otherwise create it
+        const campaignStatus = await StatusRepository.findUnique(campaignUnique);
+        if (!campaignStatus) {
+            let campaign = await CampaignService.findUnique(campaignUnique);
+            if (!campaign) {
+                await CampaignService.fill([campaignUnique]);
+                campaign = await CampaignService.findUniqueOrThrow(campaignUnique);
+            }
+            await StatusRepository.create(campaignUnique, campaign.startTimestamp);
+        }
+        // Update the run status
+        switch (status.value) {
+            case RunStatus.SUCCESS:
+                await StatusRepository.updateSuccess(campaignUnique, status.computedUntil);
+                return;
+            case RunStatus.PROCESSING:
+                await StatusRepository.updateProcessing(campaignUnique);
+                return;
+            case RunStatus.SKIPPED:
+                await StatusRepository.updateWithError(campaignUnique, status.value, status.error, status.details);
+                return;
+            case RunStatus.FAILED:
+                await StatusRepository.updateWithError(campaignUnique, status.value, status.error, status.details);
+                return;
+        }
+    }
+    static async updateComputedUntil(campaignUnique, computedUntil) {
+        // Check if the status exists already, otherwise create it
+        const campaignStatus = await StatusRepository.findUnique(campaignUnique);
+        if (!campaignStatus) {
+            let campaign = await CampaignService.findUnique(campaignUnique);
+            if (!campaign) {
+                await CampaignService.fill([campaignUnique]);
+                campaign = await CampaignService.findUniqueOrThrow(campaignUnique);
+            }
+            await StatusRepository.create(campaignUnique, campaign.startTimestamp);
+        }
+        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) {
+            return true;
+        }
+        if (status.status === RunStatus.PROCESSING) {
+            return status.processingStarted < moment().unix() - MAX_COMPUTE_JOB_TIME;
+        }
+        return true;
+    }
+    static async findUpdatesAndDelays() {
+        const merklRoots = await MerklRootService.fetchAll();
+        const delayedCampaignPromises = Promise.allSettled(Object.keys(merklRoots).map(chainId => StatusService.findManyDelay({ chainId: Number.parseInt(chainId), delayLowerBound: 9 * HOUR })));
+        const liveCampaignPromises = await Promise.allSettled(Object.keys(merklRoots).map(chainId => CampaignService.countLives({ distributionChainId: Number.parseInt(chainId) })));
+        const delayedCampaignArray = await delayedCampaignPromises;
+        const liveCampaignArray = await liveCampaignPromises;
+        const res = {};
+        for (const [index, chainIdString] of Object.keys(merklRoots).entries()) {
+            const chainId = Number.parseInt(chainIdString);
+            const delayedCampaignResult = delayedCampaignArray[index];
+            const liveCampaignResult = liveCampaignArray[index];
+            const delayedCampaigns = delayedCampaignResult.status === "rejected" ? [] : delayedCampaignResult.value;
+            const liveCampaigns = liveCampaignResult.status === "rejected" ? 0 : liveCampaignResult.value;
+            if (!registry(chainId)?.Merkl?.DistributionCreator || !registry(chainId)?.Merkl?.Distributor) {
+                log.warn(`Missing registry for ${NETWORK_LABELS[chainId]}`);
+                continue;
+            }
+            let adminUrl = undefined;
+            try {
+                adminUrl = getMultisigURL(chainId, registry(chainId)?.AngleLabs ?? "");
+            }
+            catch { }
+            res[chainId] = {
+                ...merklRoots[chainId],
+                admin: registry(chainId)?.AngleLabs ?? "0xb08AB4332AD871F89da24df4751968A61e58013c",
+                adminUrl,
+                distributor: registry(chainId)?.Merkl?.Distributor,
+                distributionCreator: registry(chainId)?.Merkl?.DistributionCreator,
+                liveCampaigns,
+                delayed: delayedCampaigns,
+            };
+        }
+        return res;
+    }
+    static async findManyDelay(query) {
+        const now = moment().unix();
+        return (await StatusRepository.findManyDelay(query))
+            .map(x => {
+            const endTimestamp = Number(x.endTimestamp);
+            const computedUntil = !!Number(x.CampaignStatus?.[0]?.computedUntil)
+                ? Number(x.CampaignStatus?.[0]?.computedUntil)
+                : Number(x.startTimestamp);
+            const delay = Math.min(now, endTimestamp) - Math.min(now, endTimestamp, computedUntil);
+            return {
+                ...x,
+                delay,
+                computedUntil,
+            };
+        })
+            .sort((a, b) => b.delay - a.delay)
+            .filter(x => x.delay > (query.delayLowerBound ?? 0));
+    }
+}