@merkl/api 0.10.311 → 0.10.313

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

@@ -1097,18 +1097,20 @@ declare const eden: {
                         count: number;
                     };
                 }>>;
-                chains: {
+                chain: {
                     get: (options: {
                         headers: {
                             authorization: string;
                         };
-                        query?: Record<string, unknown> | undefined;
+                        query: {
+                            chainId: number;
+                        };
                         fetch?: RequestInit | undefined;
                     }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                         200: {
                             [x: string]: {
-                                breakdown: number;
-                                rewards: Record<string, number>;
+                                rewardCount: number;
+                                breakdownCount: number;
                             };
                         };
                     }>>;
@@ -2181,6 +2183,40 @@ declare const eden: {
                     }[];
                 }>>;
             };
+            delay: {
+                index: {
+                    get: (options: {
+                        headers?: Record<string, unknown> | undefined;
+                        query: {
+                            chainId?: number | undefined;
+                            endTimestampLowerBound?: number | undefined;
+                            delayLowerBound?: number | undefined;
+                        };
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            delay: number;
+                            delayFormatted: string;
+                            startTimestamp: bigint;
+                            endTimestamp: bigint;
+                            computeChainId: number;
+                            distributionChainId: number;
+                            campaignId: string;
+                            Opportunity: {
+                                name: string;
+                            };
+                            CampaignStatus: {
+                                error: string;
+                                details: import("database/api/.generated/runtime/library").JsonValue;
+                                status: import("../../database/api/.generated").$Enums.RunStatus;
+                                campaignId: string;
+                                computedUntil: bigint;
+                                processingStarted: bigint;
+                            }[];
+                        }[];
+                    }>>;
+                };
+            };
         };
         liquidity: {
             index: {
@@ -4399,19 +4435,21 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
             };
         } & {
             count: {
-                chains: {
+                chain: {
                     get: {
                         body: unknown;
                         params: {};
-                        query: unknown;
+                        query: {
+                            chainId: number;
+                        };
                         headers: {
                             authorization: string;
                         };
                         response: {
                             200: {
                                 [x: string]: {
-                                    breakdown: number;
-                                    rewards: Record<string, number>;
+                                    rewardCount: number;
+                                    breakdownCount: number;
                                 };
                             };
                         };
@@ -5550,9 +5588,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     };
                 };
             };
-        };
-    } & {
-        "campaign-status": {
+        } & {
             engine: {
                 overlaps: {
                     get: {
@@ -5571,9 +5607,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     };
                 };
             };
-        };
-    } & {
-        "campaign-status": {
+        } & {
             index: {
                 get: {
                     body: unknown;
@@ -5595,9 +5629,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     };
                 };
             };
-        };
-    } & {
-        "campaign-status": {
+        } & {
             ":campaignId": {
                 get: {
                     body: unknown;
@@ -5625,6 +5657,43 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     };
                 };
             };
+        } & {
+            delay: {
+                index: {
+                    get: {
+                        body: unknown;
+                        params: {};
+                        query: {
+                            chainId?: number | undefined;
+                            endTimestampLowerBound?: number | undefined;
+                            delayLowerBound?: number | undefined;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                delay: number;
+                                delayFormatted: string;
+                                startTimestamp: bigint;
+                                endTimestamp: bigint;
+                                computeChainId: number;
+                                distributionChainId: number;
+                                campaignId: string;
+                                Opportunity: {
+                                    name: string;
+                                };
+                                CampaignStatus: {
+                                    error: string;
+                                    details: import("database/api/.generated/runtime/library").JsonValue;
+                                    status: import("../../database/api/.generated").$Enums.RunStatus;
+                                    campaignId: string;
+                                    computedUntil: bigint;
+                                    processingStarted: bigint;
+                                }[];
+                            }[];
+                        };
+                    };
+                };
+            };
         };
     };
 } & {
@@ -7674,18 +7743,20 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         count: number;
                     };
                 }>>;
-                chains: {
+                chain: {
                     get: (options: {
                         headers: {
                             authorization: string;
                         };
-                        query?: Record<string, unknown> | undefined;
+                        query: {
+                            chainId: number;
+                        };
                         fetch?: RequestInit | undefined;
                     }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                         200: {
                             [x: string]: {
-                                breakdown: number;
-                                rewards: Record<string, number>;
+                                rewardCount: number;
+                                breakdownCount: number;
                             };
                         };
                     }>>;
@@ -8758,6 +8829,40 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     }[];
                 }>>;
             };
+            delay: {
+                index: {
+                    get: (options: {
+                        headers?: Record<string, unknown> | undefined;
+                        query: {
+                            chainId?: number | undefined;
+                            endTimestampLowerBound?: number | undefined;
+                            delayLowerBound?: number | undefined;
+                        };
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            delay: number;
+                            delayFormatted: string;
+                            startTimestamp: bigint;
+                            endTimestamp: bigint;
+                            computeChainId: number;
+                            distributionChainId: number;
+                            campaignId: string;
+                            Opportunity: {
+                                name: string;
+                            };
+                            CampaignStatus: {
+                                error: string;
+                                details: import("database/api/.generated/runtime/library").JsonValue;
+                                status: import("../../database/api/.generated").$Enums.RunStatus;
+                                campaignId: string;
+                                computedUntil: bigint;
+                                processingStarted: bigint;
+                            }[];
+                        }[];
+                    }>>;
+                };
+            };
         };
         liquidity: {
             index: {

package/dist/src/index.d.ts

@@ -1486,19 +1486,21 @@ declare const app: Elysia<"", false, {
             };
         } & {
             count: {
-                chains: {
+                chain: {
                     get: {
                         body: unknown;
                         params: {};
-                        query: unknown;
+                        query: {
+                            chainId: number;
+                        };
                         headers: {
                             authorization: string;
                         };
                         response: {
                             200: {
                                 [x: string]: {
-                                    breakdown: number;
-                                    rewards: Record<string, number>;
+                                    rewardCount: number;
+                                    breakdownCount: number;
                                 };
                             };
                         };
@@ -2637,9 +2639,7 @@ declare const app: Elysia<"", false, {
                     };
                 };
             };
-        };
-    } & {
-        "campaign-status": {
+        } & {
             engine: {
                 overlaps: {
                     get: {
@@ -2658,9 +2658,7 @@ declare const app: Elysia<"", false, {
                     };
                 };
             };
-        };
-    } & {
-        "campaign-status": {
+        } & {
             index: {
                 get: {
                     body: unknown;
@@ -2682,9 +2680,7 @@ declare const app: Elysia<"", false, {
                     };
                 };
             };
-        };
-    } & {
-        "campaign-status": {
+        } & {
             ":campaignId": {
                 get: {
                     body: unknown;
@@ -2712,6 +2708,43 @@ declare const app: Elysia<"", false, {
                     };
                 };
             };
+        } & {
+            delay: {
+                index: {
+                    get: {
+                        body: unknown;
+                        params: {};
+                        query: {
+                            chainId?: number | undefined;
+                            endTimestampLowerBound?: number | undefined;
+                            delayLowerBound?: number | undefined;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                delay: number;
+                                delayFormatted: string;
+                                startTimestamp: bigint;
+                                endTimestamp: bigint;
+                                computeChainId: number;
+                                distributionChainId: number;
+                                campaignId: string;
+                                Opportunity: {
+                                    name: string;
+                                };
+                                CampaignStatus: {
+                                    error: string;
+                                    details: import("database/api/.generated/runtime/library").JsonValue;
+                                    status: import("../database/api/.generated").$Enums.RunStatus;
+                                    campaignId: string;
+                                    computedUntil: bigint;
+                                    processingStarted: bigint;
+                                }[];
+                            }[];
+                        };
+                    };
+                };
+            };
         };
     };
 } & {

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

@@ -4,7 +4,7 @@ import { ExplorerService } from ".";
 import { CreateExplorerDto } from "./explorer.model";
 // ─── Explorer Controller ───────────────────────────────────────────────────────
 export const ExplorerController = new Elysia({ prefix: "/explorers", detail: { tags: ["Explorers"] } })
-    // ─── Create An Explorer ──────────────────────────────────────
+    // ─── Create An Explorer ──────────────────────────────────────────────────────
     .post("", async ({ body }) => await ExplorerService.create(body), {
     beforeHandle: BackOfficeGuard,
     headers: AuthorizationHeadersDto,

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

@@ -244,19 +244,21 @@ export declare const RewardController: Elysia<"/rewards", false, {
         };
     } & {
         count: {
-            chains: {
+            chain: {
                 get: {
                     body: unknown;
                     params: {};
-                    query: unknown;
+                    query: {
+                        chainId: number;
+                    };
                     headers: {
                         authorization: string;
                     };
                     response: {
                         200: {
                             [x: string]: {
-                                breakdown: number;
-                                rewards: Record<string, number>;
+                                rewardCount: number;
+                                breakdownCount: number;
                             };
                         };
                     };

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

@@ -2,6 +2,7 @@ import { BackOfficeGuard } from "../../../guards/BackOffice.guard";
 import { AuthorizationHeadersDto, EngineGuard } from "../../../guards/Engine.guard";
 import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "../../../utils/throw";
 import Elysia from "elysia";
+import { ChainDto } from "../accounting";
 import { CampaignIdDto, CampaignIdWithoutPageDto, CreateManyBreakdownDto, CreateManyRewardDto, RegisterClaimsDto, TokenIdDto, UpdatePendingDto, } from "./reward.model";
 import { RewardService } from "./reward.service";
 // ─── Rewards Controller ──────────────────────────────────────────────────────
@@ -101,9 +102,13 @@ export const RewardController = new Elysia({ prefix: "/rewards", detail: { tags:
     }));
 })
     // ─── Get Reward Count By Chain And Root ──────────────────────────────
-    .get("/count/chains", async () => await RewardService.countAllchains(), {
+    .get("/count/chain", async ({ query }) => await RewardService.countOnChain(query.chainId), {
+    query: ChainDto,
     headers: AuthorizationHeadersDto,
-    beforeHandle: BackOfficeGuard,
+    beforeHandle: ({ headers, query }) => {
+        BackOfficeGuard({ headers });
+        throwOnUnsupportedChainId(query.chainId);
+    },
     detail: { hide: true },
 })
     // ─── Unclaimed Data routes ───────────────────────────────────────────

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

@@ -121,16 +121,10 @@ export declare abstract class RewardRepository {
         claimed: string;
         proofs: string[];
     }) | null>;
-    static countRewardPerRewardTokenIdAndRoot(): Promise<(Prisma.PickEnumerable<Prisma.RewardGroupByOutputType, ("rewardTokenId" | "root")[]> & {
-        _count: {
-            _all: number;
-        };
-    })[]>;
-    static countRewardBreakdownPerCampaignId(): Promise<(Prisma.PickEnumerable<Prisma.RewardBreakdownGroupByOutputType, "campaignId"[]> & {
-        _count: {
-            _all: number;
-        };
-    })[]>;
+    static countRewardAndBreakdownOnChain(chainId: number, root: string): Promise<{
+        rewardCount: number;
+        breakdownCount: number;
+    }>;
     static updateClaimed(recipient: string, rewardTokenId: string, campaignId: string, reason: string, amount: string): Promise<Prisma.BatchPayload>;
     static findManyBreakdownUniques(uniques: {
         rewardId: string;

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

@@ -115,17 +115,26 @@ export class RewardRepository {
             },
         });
     }
-    static async countRewardPerRewardTokenIdAndRoot() {
-        return await apiDbClient.reward.groupBy({
-            by: ["root", "rewardTokenId"],
-            _count: { _all: true },
+    static async countRewardAndBreakdownOnChain(chainId, root) {
+        const rewardCount = await apiDbClient.reward.count({
+            where: {
+                root,
+                RewardToken: {
+                    chainId,
+                },
+            },
         });
-    }
-    static async countRewardBreakdownPerCampaignId() {
-        return await apiDbClient.rewardBreakdown.groupBy({
-            by: ["campaignId"],
-            _count: { _all: true },
+        const breakdownCount = await apiDbClient.rewardBreakdown.count({
+            where: {
+                Reward: {
+                    root,
+                    RewardToken: {
+                        chainId,
+                    },
+                },
+            },
         });
+        return { rewardCount, breakdownCount };
     }
     static async updateClaimed(recipient, rewardTokenId, campaignId, reason, amount) {
         return await apiDbClient.rewardBreakdown.updateMany({

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

@@ -558,10 +558,12 @@ export declare abstract class RewardService {
         created: number;
         updated: number;
     }>;
-    static countAllchains(): Promise<Record<string, {
-        breakdown: number;
-        rewards: Record<string, number>;
-    }>>;
+    static countOnChain(chainId: number): Promise<{
+        [x: string]: {
+            rewardCount: number;
+            breakdownCount: number;
+        };
+    }>;
     static breakdownForCampaign(query: CampaignIdModel): Promise<import("./reward.model").BreakdownForCampaignsRaw[]>;
     static countForCampaign(query: CampaignIdModel): Promise<{
         count: number;

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

@@ -287,29 +287,17 @@ export class RewardService {
         await RewardRepository.createBreakdownPendings(rewardTokenId, data.root, campaignId, breakdownToCreate);
         return { created: breakdownToCreate.length, updated: breakdownToUpdate.length };
     }
-    static async countAllchains() {
-        const rewardPerRewardTokenId = await RewardRepository.countRewardPerRewardTokenIdAndRoot();
-        const rewardBreakdownPerCampaignId = await RewardRepository.countRewardBreakdownPerCampaignId();
-        const tokenIdToChain = await TokenService.findChains();
-        const campaignIdToChain = await CampaignService.findChains();
-        const res = {};
-        for (const { _count, rewardTokenId, root } of rewardPerRewardTokenId) {
-            const chainId = tokenIdToChain[rewardTokenId];
-            if (!chainId)
-                continue;
-            if (!res[NETWORK_LABELS[chainId]])
-                res[NETWORK_LABELS[chainId]] = { rewards: {}, breakdown: 0 };
-            if (!res[NETWORK_LABELS[chainId]].rewards[root])
-                res[NETWORK_LABELS[chainId]].rewards[root] = 0;
-            res[NETWORK_LABELS[chainId]].rewards[root] += _count._all;
-        }
-        for (const { _count, campaignId } of rewardBreakdownPerCampaignId) {
-            const chainId = campaignIdToChain[campaignId];
-            if (!chainId)
-                continue;
-            res[NETWORK_LABELS[chainId]].breakdown += _count._all;
-        }
-        return res;
+    static async countOnChain(chainId) {
+        const roots = await MerklRootService.fetch(chainId);
+        const promises = [
+            RewardRepository.countRewardAndBreakdownOnChain(chainId, roots.tree),
+            RewardRepository.countRewardAndBreakdownOnChain(chainId, roots.lastTree),
+        ];
+        await Promise.all(promises);
+        return {
+            [roots.tree]: await promises[0],
+            [roots.lastTree]: await promises[1],
+        };
     }
     static async breakdownForCampaign(query) {
         const root = await MerklRootService.fetch(query.chainId);
@@ -326,19 +314,25 @@ export class RewardService {
         return RewardRepository.totalForCampaign(CampaignService.hashId({ distributionChain: query.chainId, campaignId: query.campaignId }), root.live);
     }
     static async breakdownForToken(query) {
-        const root = await MerklRootService.fetch(query.chainId);
-        const id = TokenService.hashId({ chainId: query.chainId, address: query.address });
-        return RewardRepository.breakdownForToken(root.live, id, query);
+        return CacheService.wrap(TTLPresets.MIN_10, async (query) => {
+            const root = await MerklRootService.fetch(query.chainId);
+            const id = TokenService.hashId({ chainId: query.chainId, address: query.address });
+            return RewardRepository.breakdownForToken(root.live, id, query);
+        }, query);
     }
     static async countForToken(query) {
-        const root = await MerklRootService.fetch(query.chainId);
-        const id = TokenService.hashId({ chainId: query.chainId, address: query.address });
-        return RewardRepository.countForToken(id, root.live);
+        return CacheService.wrap(TTLPresets.MIN_10, async (query) => {
+            const root = await MerklRootService.fetch(query.chainId);
+            const id = TokenService.hashId({ chainId: query.chainId, address: query.address });
+            return RewardRepository.countForToken(id, root.live);
+        }, query);
     }
     static async totalForToken(query) {
-        const root = await MerklRootService.fetch(query.chainId);
-        const id = TokenService.hashId({ chainId: query.chainId, address: query.address });
-        return RewardRepository.totalForToken(id, root.live);
+        return CacheService.wrap(TTLPresets.MIN_10, async (query) => {
+            const root = await MerklRootService.fetch(query.chainId);
+            const id = TokenService.hashId({ chainId: query.chainId, address: query.address });
+            return RewardRepository.totalForToken(id, root.live);
+        }, query);
     }
     static async getAmountAndClaimedForCampaigns(x) {
         const currentRoot = await MerklRootService.fetch(x.chainId);

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

@@ -1364,19 +1364,21 @@ export declare const v4: Elysia<"/v4", false, {
             };
         } & {
             count: {
-                chains: {
+                chain: {
                     get: {
                         body: unknown;
                         params: {};
-                        query: unknown;
+                        query: {
+                            chainId: number;
+                        };
                         headers: {
                             authorization: string;
                         };
                         response: {
                             200: {
                                 [x: string]: {
-                                    breakdown: number;
-                                    rewards: Record<string, number>;
+                                    rewardCount: number;
+                                    breakdownCount: number;
                                 };
                             };
                         };
@@ -2515,9 +2517,7 @@ export declare const v4: Elysia<"/v4", false, {
                     };
                 };
             };
-        };
-    } & {
-        "campaign-status": {
+        } & {
             engine: {
                 overlaps: {
                     get: {
@@ -2536,9 +2536,7 @@ export declare const v4: Elysia<"/v4", false, {
                     };
                 };
             };
-        };
-    } & {
-        "campaign-status": {
+        } & {
             index: {
                 get: {
                     body: unknown;
@@ -2560,9 +2558,7 @@ export declare const v4: Elysia<"/v4", false, {
                     };
                 };
             };
-        };
-    } & {
-        "campaign-status": {
+        } & {
             ":campaignId": {
                 get: {
                     body: unknown;
@@ -2590,6 +2586,43 @@ export declare const v4: Elysia<"/v4", false, {
                     };
                 };
             };
+        } & {
+            delay: {
+                index: {
+                    get: {
+                        body: unknown;
+                        params: {};
+                        query: {
+                            chainId?: number | undefined;
+                            endTimestampLowerBound?: number | undefined;
+                            delayLowerBound?: number | undefined;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                delay: number;
+                                delayFormatted: string;
+                                startTimestamp: bigint;
+                                endTimestamp: bigint;
+                                computeChainId: number;
+                                distributionChainId: number;
+                                campaignId: string;
+                                Opportunity: {
+                                    name: string;
+                                };
+                                CampaignStatus: {
+                                    error: string;
+                                    details: import("database/api/.generated/runtime/library").JsonValue;
+                                    status: import("../../../database/api/.generated").$Enums.RunStatus;
+                                    campaignId: string;
+                                    computedUntil: bigint;
+                                    processingStarted: bigint;
+                                }[];
+                            }[];
+                        };
+                    };
+                };
+            };
         };
     };
 } & {