@merkl/api 0.9.15

package/dist/src/modules/v4/router.js

@@ -0,0 +1,76 @@
+import { AccountingController } from "@/modules/v4/accounting/accounting.controller";
+import { BlacklistController } from "@/modules/v4/blacklist/blacklist.controller";
+import { BoostController } from "@/modules/v4/boost/boost.controller";
+import { CampaignController } from "@/modules/v4/campaign/campaign.controller";
+import { ChainController } from "@/modules/v4/chain/chain.controller";
+import { ClaimController } from "@/modules/v4/claims/claims.controller";
+import { ComputedValueController } from "@/modules/v4/computedValue/computedValue.controller";
+import { CreatorController } from "@/modules/v4/creator/creator.controller";
+import { DynamicDataController } from "@/modules/v4/dynamicData/dynamicData.controller";
+import { ExplorerController } from "@/modules/v4/explorer/explorer.controller";
+import { InteractionController } from "@/modules/v4/interaction/interaction.controller";
+import { LiquidityController } from "@/modules/v4/liquidity/liquidity.controller";
+import { MerklRootController } from "@/modules/v4/merklRoot/merklRoot.controller";
+import { OpportunityController } from "@/modules/v4/opportunity";
+import { PriceController } from "@/modules/v4/price/price.controller";
+import { ProgramPayloadController } from "@/modules/v4/programPayload/programPayload.controller";
+import { ProtocolController } from "@/modules/v4/protocol/protocol.controller";
+import { RewardController } from "@/modules/v4/reward/reward.controller";
+import { StatusController } from "@/modules/v4/status/status.controller";
+import { TokenController } from "@/modules/v4/token/token.controller";
+import { UserController } from "@/modules/v4/user/user.controller";
+import { ErrorHandler } from "@/plugins/error-handling.plugin";
+import bigintToString from "@/utils/bigintToString";
+import { opentelemetry } from "@elysiajs/opentelemetry";
+import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-node";
+import { PrismaInstrumentation } from "@prisma/instrumentation";
+import Elysia from "elysia";
+import { ReferralController } from "./referral/referral.controller";
+// ─── V4 Router ───────────────────────────────────────────────────────────────
+export const v4 = new Elysia({ tags: ["v4"], prefix: "/v4" })
+    // ─── OpenTelemetry ───────────────────────────────────────────────────
+    .use(process.env.TRACE === "true"
+    ? opentelemetry({
+        spanProcessors: [
+            new BatchSpanProcessor(new OTLPTraceExporter({
+                url: process.env.OTEL_COLLECTOR,
+                headers: {
+                    "signoz-ingestion-key": String(process.env.SIGNOZ_INGESTION_KEY),
+                },
+            })),
+        ],
+        instrumentations: [new PrismaInstrumentation(), getNodeAutoInstrumentations()],
+    })
+    : new Elysia() // not optimal
+)
+    // ─── Error Handling ──────────────────────────────────────────────────
+    .use(ErrorHandler)
+    // ─── Logger ──────────────────────────────────────────────────────────
+    // .use(Logger)
+    // ─── Response Transformation ─────────────────────────────────────────
+    .onAfterHandle(({ response }) => bigintToString(response))
+    // ─── Route Controllers ───────────────────────────────────────────────
+    .use(OpportunityController)
+    .use(CampaignController)
+    .use(ProtocolController)
+    .use(ExplorerController)
+    .use(TokenController)
+    .use(RewardController)
+    .use(ChainController)
+    .use(PriceController)
+    .use(BlacklistController)
+    .use(UserController)
+    .use(MerklRootController)
+    .use(InteractionController)
+    .use(AccountingController)
+    .use(DynamicDataController)
+    .use(StatusController)
+    .use(LiquidityController)
+    .use(ClaimController)
+    .use(ProgramPayloadController)
+    .use(BoostController)
+    .use(ComputedValueController)
+    .use(CreatorController)
+    .use(ReferralController);

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

@@ -0,0 +1,239 @@
+import Elysia from "elysia";
+import { StatusService } from "./status.service";
+export declare const StatusController: Elysia<"/campaign-status", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    "campaign-status": {
+        engine: {
+            ":campaignId": {
+                put: {
+                    body: {
+                        value: "SUCCESS";
+                        computedUntil: number;
+                    } | {
+                        value: "PROCESSING";
+                    } | {
+                        error: string;
+                        details: string;
+                        value: "SKIPPED";
+                    } | {
+                        error: string;
+                        details: string;
+                        value: "FAILED";
+                    };
+                    params: {
+                        campaignId: string;
+                    };
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: void;
+                    };
+                };
+            };
+        };
+    } & {
+        engine: {
+            computedUntil: {
+                ":campaignId": {
+                    put: {
+                        body: {
+                            computedUntil: number;
+                        };
+                        params: {
+                            campaignId: string;
+                        };
+                        query: unknown;
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: void;
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        error: {
+            ":campaignId": {
+                put: {
+                    body: {
+                        error: string;
+                    };
+                    params: {
+                        campaignId: string;
+                    };
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: void;
+                    };
+                };
+            };
+        };
+    } & {
+        engine: {
+            overlaps: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: {
+                        campaignId: string;
+                        distributionChain: number;
+                    };
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: boolean;
+                    };
+                };
+            };
+        };
+    } & {
+        index: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    status?: "PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED" | ("PROCESSING" | "SUCCESS" | "FAILED" | "SKIPPED")[] | undefined;
+                    computeChainId?: number | undefined;
+                };
+                headers: unknown;
+                response: {
+                    200: {
+                        error: string;
+                        status: import("@db/api").$Enums.RunStatus;
+                        details: import("database/api/.generated/runtime/library").JsonValue;
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                    }[];
+                };
+            };
+        };
+    } & {
+        ":campaignId": {
+            get: {
+                body: unknown;
+                params: {
+                    campaignId: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: {
+                        error: string;
+                        status: import("@db/api").$Enums.RunStatus;
+                        details: import("database/api/.generated/runtime/library").JsonValue;
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                    }[] | {
+                        error: string;
+                        status: import("@db/api").$Enums.RunStatus;
+                        details: import("database/api/.generated/runtime/library").JsonValue;
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                    };
+                };
+            };
+        };
+    } & {
+        delay: {
+            index: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: {
+                        chainId?: number | undefined;
+                        endTimestampLowerBound?: number | undefined;
+                        delayLowerBound?: number | undefined;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: {
+                            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;
+                            }[];
+                        }[];
+                    };
+                };
+            };
+        };
+    } & {
+        delay: {
+            status: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: {
+                            [x: 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"]>>;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

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

@@ -0,0 +1,68 @@
+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, 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 ──────────────────────────────────────
+    .put("/engine/:campaignId", async ({ params, body }) => {
+    const [distributionChain, campaignId] = params.campaignId.split("-");
+    return await StatusService.update({ distributionChain: +distributionChain, campaignId }, body);
+}, {
+    beforeHandle: EngineGuard,
+    headers: AuthorizationHeadersDto,
+    body: UpdateCampaignStatusDto,
+})
+    // ─── Updates only the computed until field ───────────────────────────
+    .put("/engine/computedUntil/:campaignId", async ({ params, body }) => {
+    const [distributionChain, campaignId] = params.campaignId.split("-");
+    return await StatusService.updateComputedUntil({ distributionChain: +distributionChain, campaignId }, body.computedUntil);
+}, {
+    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), {
+    beforeHandle: EngineGuard,
+    headers: AuthorizationHeadersDto,
+    query: CampaignUniqueDto,
+})
+    // ─── Find Many Status ─────────────────────────────────────────────────
+    .get("/", async ({ query }) => await StatusService.findMany(query), { query: QueryCampaignStatusDto })
+    // ─── Get A Status By Id ───────────────────────────────────────────────
+    // campaignId will be either a rough campaignId in the engine sense, a campaignId in the api db way, or a distributionChain_campaignId
+    .get("/:campaignId", async ({ params }) => {
+    if (!params.campaignId.includes("-") && params.campaignId.startsWith("0x"))
+        return await StatusService.findManyByCampaignId(params.campaignId);
+    if (!params.campaignId.includes("-"))
+        return await StatusService.findUniqueOrThrow(params.campaignId);
+    const [distributionChain, campaignId] = params.campaignId.split("-");
+    return await StatusService.findUniqueOrThrow({ distributionChain: +distributionChain, campaignId });
+})
+    // ─── Fetch information about delays ────────────────────────────────────
+    .group("/delay", app => {
+    return app
+        .get("/", async ({ query }) => StatusService.findManyDelay(query), {
+        query: DelayDto,
+        beforeHandle: ({ query }) => {
+            if (!!query.chainId) {
+                throwOnUnsupportedChainId(query.chainId);
+            }
+        },
+        detail: { hide: true },
+    })
+        .get("/status", async () => StatusService.findUpdatesAndDelays(), {
+        detail: { hide: true },
+    });
+});

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

@@ -0,0 +1,63 @@
+import type { Campaign } from "../campaign";
+import type { Resource } from "../prisma";
+export type Status = Resource<"CampaignStatus", "campaignId", {
+    computedUntil: number;
+    processingStarted: number;
+}>;
+export type StatusWithCampaign = Status & {
+    campaign: Campaign["model"];
+};
+export declare const CampaignUniqueDto: import("@sinclair/typebox").TObject<{
+    distributionChain: import("@sinclair/typebox").TNumber;
+    campaignId: import("@sinclair/typebox").TString;
+}>;
+export declare const DelayDto: import("@sinclair/typebox").TObject<{
+    endTimestampLowerBound: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    delayLowerBound: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export declare const CampaignStatusResourceDto: import("@sinclair/typebox").TObject<{
+    campaignId: import("@sinclair/typebox").TString;
+    computedUntil: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNumber]>;
+    processingStarted: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNumber]>;
+    status: import("@sinclair/typebox").TString;
+    error: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    details: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;
+}>;
+export declare const UpdateCampaignStatusDto: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+    value: import("@sinclair/typebox").TLiteral<"SUCCESS">;
+    computedUntil: import("@sinclair/typebox").TNumber;
+}>, import("@sinclair/typebox").TObject<{
+    value: import("@sinclair/typebox").TLiteral<"PROCESSING">;
+}>, import("@sinclair/typebox").TObject<{
+    value: import("@sinclair/typebox").TLiteral<"SKIPPED">;
+    error: import("@sinclair/typebox").TString;
+    details: import("@sinclair/typebox").TString;
+}>, import("@sinclair/typebox").TObject<{
+    value: import("@sinclair/typebox").TLiteral<"FAILED">;
+    error: import("@sinclair/typebox").TString;
+    details: import("@sinclair/typebox").TString;
+}>]>;
+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<{
+        PROCESSING: "PROCESSING";
+        SUCCESS: "SUCCESS";
+        FAILED: "FAILED";
+        SKIPPED: "SKIPPED";
+    }>>, import("@sinclair/typebox").TEnum<{
+        PROCESSING: "PROCESSING";
+        SUCCESS: "SUCCESS";
+        FAILED: "FAILED";
+        SKIPPED: "SKIPPED";
+    }>]>>;
+}>;
+export type DelayModel = typeof DelayDto.static;
+export type UpdateStatusModel = typeof UpdateCampaignStatusDto.static;
+export type QueryCampaignStatus = typeof QueryCampaignStatusDto.static;

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

@@ -0,0 +1,34 @@
+import { RunStatus } from "@db/api";
+import { t } from "elysia";
+// ─── DTOs ────────────────────────────────────────────────────────────────────
+export const CampaignUniqueDto = t.Object({
+    distributionChain: t.Numeric(),
+    campaignId: t.String(),
+});
+export const DelayDto = t.Object({
+    endTimestampLowerBound: t.Optional(t.Numeric({
+        description: "Lower bound of end timestamps - by default it'll take all campaigns where endTimestamp is more than now - 1 week",
+    })),
+    delayLowerBound: t.Optional(t.Numeric({ description: "To filter small delays (in seconds)" })),
+    chainId: t.Optional(t.Numeric({ description: "To get delays for Campaigns on a given chain only" })),
+});
+export const CampaignStatusResourceDto = t.Object({
+    campaignId: t.String(),
+    computedUntil: t.Union([t.String(), t.Numeric()]),
+    processingStarted: t.Union([t.String(), t.Numeric()]),
+    status: t.String(),
+    error: t.Optional(t.String()),
+    details: t.Optional(t.Any()),
+});
+export const UpdateCampaignStatusDto = t.Union([
+    t.Object({ value: t.Literal(RunStatus.SUCCESS), computedUntil: t.Numeric() }),
+    t.Object({ value: t.Literal(RunStatus.PROCESSING) }),
+    t.Object({ value: t.Literal(RunStatus.SKIPPED), error: t.String(), details: t.String() }),
+    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

@@ -0,0 +1,104 @@
+import type { Prisma, RunStatus } from "@db/api";
+import { type CampaignUnique } from "../campaign";
+import type { DelayModel, QueryCampaignStatus } from "./status.model";
+export declare abstract class StatusRepository {
+    #private;
+    static findMany(query: QueryCampaignStatus): Promise<{
+        error: string;
+        status: import("@db/api").$Enums.RunStatus;
+        details: Prisma.JsonValue;
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+    }[]>;
+    static findManyByCampaignId(campaignId: string): Promise<{
+        error: string;
+        status: import("@db/api").$Enums.RunStatus;
+        details: Prisma.JsonValue;
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+    }[]>;
+    static findUniqueOrThrow(campaignId: string): Promise<{
+        error: string;
+        status: import("@db/api").$Enums.RunStatus;
+        details: Prisma.JsonValue;
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+    }>;
+    static findUnique(campaignUnique: CampaignUnique): Promise<{
+        error: string;
+        status: import("@db/api").$Enums.RunStatus;
+        details: Prisma.JsonValue;
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+    } | null>;
+    static create(campaign: CampaignUnique, startTimestamp: bigint): Promise<{
+        error: string;
+        status: import("@db/api").$Enums.RunStatus;
+        details: Prisma.JsonValue;
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+    }>;
+    static updateSuccess(campaignUnique: CampaignUnique, computedUntil: number): Promise<{
+        error: string;
+        status: import("@db/api").$Enums.RunStatus;
+        details: Prisma.JsonValue;
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+    }>;
+    static updateWithError(campaignUnique: CampaignUnique, status: Exclude<RunStatus, "SUCCESS" | "PROCESSING">, error: string, details: string): Promise<{
+        error: string;
+        status: import("@db/api").$Enums.RunStatus;
+        details: Prisma.JsonValue;
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+    }>;
+    static updateProcessing(campaignUnique: CampaignUnique): Promise<void>;
+    static updateComputedUntil(campaignUnique: CampaignUnique, computedUntil: number): Promise<{
+        error: string;
+        status: import("@db/api").$Enums.RunStatus;
+        details: Prisma.JsonValue;
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+    }>;
+    static updateErrorMessage(campaignUnique: CampaignUnique, error: string): Promise<{
+        error: string;
+        status: import("@db/api").$Enums.RunStatus;
+        details: Prisma.JsonValue;
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+    }>;
+    static findManyDelay(query: DelayModel): Promise<{
+        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: Prisma.JsonValue;
+            campaignId: string;
+            computedUntil: bigint;
+            processingStarted: bigint;
+        }[];
+    }[]>;
+}