@merkl/api 0.10.310 → 0.10.312

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

@@ -31,6 +31,11 @@ export class ProgramPayloadService {
         };
     }
     /** building payload for a single campaign */
+    static buildCampaignData(query) {
+        const distributionChainId = query.distributionChainId ? query.distributionChainId : ChainId.MAINNET;
+        const args = buildCampaignPayload(ProgramPayloadService.buildConfig(query), distributionChainId).args;
+        return { args };
+    }
     static buildPayload(query, initialCampaignPayload = null) {
         const rewardToken = query.rewardToken;
         const distributionChainId = query.distributionChainId ? query.distributionChainId : ChainId.MAINNET;
@@ -93,4 +98,14 @@ export class ProgramPayloadService {
         }
         return campaignPayloads;
     }
+    static buildProgramPayloadWithAmounts(query, body) {
+        let campaignPayloads = null;
+        for (const [campaign, amount] of Object.entries(body)) {
+            if (Object.keys(MerklInterfaceCampaigns[query.program]).includes(campaign)) {
+                const queryCampaign = { ...query, campaign, amount: amount };
+                campaignPayloads = ProgramPayloadService.buildPayload(queryCampaign, campaignPayloads);
+            }
+        }
+        return campaignPayloads;
+    }
 }

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

@@ -167,6 +167,7 @@ export class RewardService {
                     if (!lastTreeRewardsBreakdown)
                         continue;
                     breakdown.claimed = lastTreeRewardsBreakdown.amount;
+                    await RewardRepository.updateClaimed(user, TokenService.hashId(reward.RewardToken), breakdown.campaignId, breakdown.reason, breakdown.amount);
                 }
             }
         }
@@ -247,7 +248,8 @@ export class RewardService {
             }
             rewardUniques[rewardId].pending = (BigInt(rewardUniques[rewardId].pending) +
                 BigInt(pending) -
-                BigInt(previousPending ?? "0")).toString();
+                BigInt(previousPending ?? "0")) // Store the delta
+                .toString();
         };
         const breakdownUniques = await data.data.map(({ recipient, reason }) => {
             const rewardId = RewardService.hashId(data.root, recipient, rewardTokenId);
@@ -255,72 +257,47 @@ export class RewardService {
         });
         const breakdownToUpdate = [];
         const breakdownToCreate = [];
-        // for (let i = 0; i < breakdownUniques.length; i += 1_000) {
-        const exists = await RewardRepository.findManyBreakdownUniques(breakdownUniques);
-        console.log(exists);
+        const breakdownExists = await RewardRepository.findManyBreakdownUniques(breakdownUniques);
         for (const [pointIndex, point] of data.data.entries()) {
-            updateRewardUniques(point.recipient, point.pending, exists[pointIndex]?.pending);
-            console.log(pointIndex, !!exists[pointIndex]);
-            if (!!exists[pointIndex]) {
+            updateRewardUniques(point.recipient, point.pending, breakdownExists[pointIndex]?.pending);
+            if (!!breakdownExists[pointIndex]) {
                 breakdownToUpdate.push(point);
             }
             else {
                 breakdownToCreate.push(point);
             }
         }
-        // }
-        try {
-            for (let i = 0; i < Object.keys(rewardUniques).length; i += 1_000) {
-                const toUpdate = [];
-                const toCreate = [];
-                const exists = await RewardRepository.findManyRewardUniques(Object.keys(rewardUniques).slice(i, Math.min(i + 1_000, Object.keys(rewardUniques).length)));
-                for (const [pointIndex, point] of Object.values(rewardUniques)
-                    .slice(i, Math.min(i + 1_000, Object.keys(rewardUniques).length))
-                    .entries()) {
-                    if (!!exists[pointIndex]) {
-                        toUpdate.push({
-                            ...point,
-                            pending: (BigInt(exists[pointIndex].pending) + BigInt(point.pending)).toString(),
-                        });
-                    }
-                    else {
-                        toCreate.push(point);
-                    }
-                }
-                await RewardRepository.updateRewardPendings(rewardTokenId, data.root, toUpdate);
-                await RewardRepository.createRewardPendings(rewardTokenId, data.root, toCreate);
+        const toUpdate = [];
+        const toCreate = [];
+        const exists = await RewardRepository.findManyRewardUniques(Object.keys(rewardUniques));
+        for (const [pointIndex, point] of Object.values(rewardUniques).entries()) {
+            if (!!exists[pointIndex]) {
+                toUpdate.push({
+                    ...point,
+                    pending: (BigInt(exists[pointIndex].pending) + BigInt(point.pending)).toString(), // Store the delta
+                });
+            }
+            else {
+                toCreate.push(point);
             }
         }
-        catch (e) {
-            log.error("updatePendings - error updating reward pendings", e);
-        }
+        await RewardRepository.updateRewardPendings(rewardTokenId, data.root, toUpdate);
+        await RewardRepository.createRewardPendings(rewardTokenId, data.root, toCreate);
         await RewardRepository.updateBreakdownPendings(rewardTokenId, data.root, campaignId, breakdownToUpdate);
         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);
@@ -337,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;
                                 };
                             };
                         };
@@ -2682,6 +2684,31 @@ export declare const v4: Elysia<"/v4", false, {
                 };
             };
         };
+    } & {
+        "program-payload": {
+            campaignData: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: {
+                        creator: string;
+                        startTimestamp: number;
+                        endTimestamp: number;
+                        campaign: string;
+                        distributionChainId: number;
+                        amount: string;
+                        rewardToken: string;
+                        program: string;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: {
+                            args: any;
+                        };
+                    };
+                };
+            };
+        };
     } & {
         "program-payload": {
             program: {
@@ -2705,6 +2732,33 @@ export declare const v4: Elysia<"/v4", false, {
                 };
             };
         };
+    } & {
+        "program-payload": {
+            program: {
+                withAmounts: {
+                    post: {
+                        body: {
+                            [x: string]: string;
+                        };
+                        params: {};
+                        query: {
+                            amount?: string | undefined;
+                            creator: string;
+                            startTimestamp: number;
+                            endTimestamp: number;
+                            distributionChainId: number;
+                            rewardToken: string;
+                            program: string;
+                        };
+                        headers: unknown;
+                        response: {
+                            [x: string]: any;
+                            200: any;
+                        };
+                    };
+                };
+            };
+        };
     };
 } & {
     v4: {