@merkl/api 0.10.306 → 0.10.308

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

@@ -1,6 +1,6 @@
 import type { Prisma } from "../../../../database/api/.generated";
 import type { ChainId } from "@sdk";
-import type { BreakdownForCampaignsRaw, CampaignIdModel, CampaignIdWithoutPageModel, CreateManyBreakdownModel, CreateManyRewardModel, PendingEntity, TokenIdModel } from "./reward.model";
+import type { BreakdownForCampaignsRaw, BreakdownForTokenRaw, CampaignIdModel, CampaignIdWithoutPageModel, CreateManyBreakdownModel, CreateManyRewardModel, PendingEntity, TokenIdModel } from "./reward.model";
 export declare abstract class RewardRepository {
     static createManyReward(rewards: CreateManyRewardModel): Promise<Prisma.BatchPayload>;
     static createManyBreakdown(data: CreateManyBreakdownModel): Promise<Prisma.BatchPayload>;
@@ -78,17 +78,20 @@ export declare abstract class RewardRepository {
             id: number;
             campaignId: string;
             amount: string;
-            protocolId: string | null;
             claimed: string;
+            protocolId: string | null;
             auxiliaryData1: string | null;
             auxiliaryData2: string | null;
             rewardId: string;
         })[];
     } & {
+        pending: string;
         id: string;
         recipient: string;
         rewardTokenId: string;
+        amount: string;
         root: string;
+        claimed: string;
         proofs: string[];
     })[]>;
     static getByChainRecipientToken(recipient: string, root: string, tokenId: string): Promise<({
@@ -102,17 +105,20 @@ export declare abstract class RewardRepository {
             id: number;
             campaignId: string;
             amount: string;
-            protocolId: string | null;
             claimed: string;
+            protocolId: string | null;
             auxiliaryData1: string | null;
             auxiliaryData2: string | null;
             rewardId: string;
         })[];
     } & {
+        pending: string;
         id: string;
         recipient: string;
         rewardTokenId: string;
+        amount: string;
         root: string;
+        claimed: string;
         proofs: string[];
     }) | null>;
     static countRewardPerRewardTokenIdAndRoot(): Promise<(Prisma.PickEnumerable<Prisma.RewardGroupByOutputType, ("rewardTokenId" | "root")[]> & {
@@ -131,49 +137,57 @@ export declare abstract class RewardRepository {
         campaignId: string;
         reason: string;
     }[]): Promise<({
-        reason: string;
         pending: string;
-        id: number;
-        campaignId: string;
+    } | null)[]>;
+    static findManyRewardUniques(rewardIds: string[]): Promise<({
+        pending: string;
+    } | null)[]>;
+    static updateRewardPendings(rewardTokenId: string, root: string, toUpdate: {
+        recipient: string;
+        pending: string;
+    }[]): Promise<{
+        pending: string;
+        id: string;
+        recipient: string;
+        rewardTokenId: string;
         amount: string;
-        protocolId: string | null;
+        root: string;
         claimed: string;
-        auxiliaryData1: string | null;
-        auxiliaryData2: string | null;
-        rewardId: string;
-    } | null)[]>;
-    static upsertPendings(rewardTokenId: string, root: string, campaignId: string, toUpdate: PendingEntity[]): Promise<{
+        proofs: string[];
+    }[]>;
+    static updateBreakdownPendings(rewardTokenId: string, root: string, campaignId: string, toUpdate: PendingEntity[]): Promise<{
         reason: string;
         pending: string;
         id: number;
         campaignId: string;
         amount: string;
-        protocolId: string | null;
         claimed: string;
+        protocolId: string | null;
         auxiliaryData1: string | null;
         auxiliaryData2: string | null;
         rewardId: string;
     }[]>;
-    static updatePendings(rewardTokenId: string, root: string, campaignId: string, toUpdate: PendingEntity[]): Promise<{
-        reason: string;
+    static createRewardPendings(rewardTokenId: string, root: string, toCreate: {
+        recipient: string;
         pending: string;
-        id: number;
-        campaignId: string;
+    }[]): Promise<{
+        pending: string;
+        id: string;
+        recipient: string;
+        rewardTokenId: string;
         amount: string;
-        protocolId: string | null;
+        root: string;
         claimed: string;
-        auxiliaryData1: string | null;
-        auxiliaryData2: string | null;
-        rewardId: string;
+        proofs: string[];
     }[]>;
-    static createPendings(rewardTokenId: string, root: string, campaignId: string, toCreate: PendingEntity[]): Promise<{
+    static createBreakdownPendings(rewardTokenId: string, root: string, campaignId: string, toCreate: PendingEntity[]): Promise<{
         reason: string;
         pending: string;
         id: number;
         campaignId: string;
         amount: string;
-        protocolId: string | null;
         claimed: string;
+        protocolId: string | null;
         auxiliaryData1: string | null;
         auxiliaryData2: string | null;
         rewardId: string;
@@ -187,7 +201,7 @@ export declare abstract class RewardRepository {
     static countForCampaign(campaignId: string, root: string): Promise<{
         count: number;
     }>;
-    static breakdownForToken(root: string, id: string, query: TokenIdModel): Promise<BreakdownForCampaignsRaw[]>;
+    static breakdownForToken(root: string, id: string, query: TokenIdModel): Promise<BreakdownForTokenRaw[]>;
     static totalForToken(tokenId: string, root: string): Promise<{
         tokenId: string;
         amount: bigint;

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

@@ -17,6 +17,9 @@ export class RewardRepository {
             return {
                 id: RewardService.hashId(reward.root, reward.recipient, rewardTokenId),
                 root: reward.root,
+                amount: reward.amount,
+                pending: reward.pending,
+                claimed: reward.claimed,
                 recipient: reward.recipient,
                 rewardTokenId,
                 proofs: reward.proofs,
@@ -141,6 +144,9 @@ export class RewardRepository {
     }
     static async findManyBreakdownUniques(uniques) {
         return await apiDbClient.$transaction(uniques.map(x => apiDbClient.rewardBreakdown.findUnique({
+            select: {
+                pending: true,
+            },
             where: {
                 rewardId_campaignId_reason: {
                     rewardId: x.rewardId,
@@ -150,47 +156,30 @@ export class RewardRepository {
             },
         })));
     }
-    static async upsertPendings(rewardTokenId, root, campaignId, toUpdate) {
-        const users = toUpdate.map(x => x.recipient);
-        await UserService.createMany(users.map(x => ({ address: x, tags: [] })));
+    static async findManyRewardUniques(rewardIds) {
+        return await apiDbClient.$transaction(rewardIds.map(x => apiDbClient.reward.findUnique({
+            select: {
+                pending: true,
+            },
+            where: {
+                id: x,
+            },
+        })));
+    }
+    static async updateRewardPendings(rewardTokenId, root, toUpdate) {
         return await apiDbClient.$transaction(toUpdate.map(x => {
             const rewardId = RewardService.hashId(root, x.recipient, rewardTokenId);
-            return apiDbClient.rewardBreakdown.upsert({
+            return apiDbClient.reward.update({
                 where: {
-                    rewardId_campaignId_reason: {
-                        rewardId: RewardService.hashId(root, x.recipient, rewardTokenId),
-                        campaignId: campaignId,
-                        reason: x.reason,
-                    },
+                    id: rewardId,
                 },
-                update: {
-                    pending: x.pending,
-                    auxiliaryData1: x.auxiliaryData1,
-                    auxiliaryData2: x.auxiliaryData2,
-                },
-                create: {
-                    reason: x.reason,
-                    amount: "0",
+                data: {
                     pending: x.pending,
-                    claimed: "0",
-                    Reward: {
-                        connectOrCreate: {
-                            where: { id: rewardId },
-                            create: {
-                                id: rewardId,
-                                MerklRoot: { connect: { root } },
-                                User: { connect: { address: x.recipient } },
-                                RewardToken: { connect: { id: rewardTokenId } },
-                                proofs: [],
-                            },
-                        },
-                    },
-                    Campaign: { connect: { id: campaignId } },
                 },
             });
         }));
     }
-    static async updatePendings(rewardTokenId, root, campaignId, toUpdate) {
+    static async updateBreakdownPendings(rewardTokenId, root, campaignId, toUpdate) {
         return await apiDbClient.$transaction(toUpdate.map(x => {
             return apiDbClient.rewardBreakdown.update({
                 where: {
@@ -208,7 +197,26 @@ export class RewardRepository {
             });
         }));
     }
-    static async createPendings(rewardTokenId, root, campaignId, toCreate) {
+    static async createRewardPendings(rewardTokenId, root, toCreate) {
+        const users = toCreate.map(x => x.recipient);
+        await UserService.createMany(users.map(x => ({ address: x, tags: [] })));
+        return await apiDbClient.$transaction(toCreate.map(x => {
+            const rewardId = RewardService.hashId(root, x.recipient, rewardTokenId);
+            return apiDbClient.reward.create({
+                data: {
+                    id: rewardId,
+                    MerklRoot: { connect: { root } },
+                    User: { connect: { address: x.recipient } },
+                    RewardToken: { connect: { id: rewardTokenId } },
+                    proofs: [],
+                    amount: "0",
+                    pending: x.pending,
+                    claimed: "0",
+                },
+            });
+        }));
+    }
+    static async createBreakdownPendings(rewardTokenId, root, campaignId, toCreate) {
         const users = toCreate.map(x => x.recipient);
         await UserService.createMany(users.map(x => ({ address: x, tags: [] })));
         return await apiDbClient.$transaction(toCreate.map(x => {
@@ -220,15 +228,8 @@ export class RewardRepository {
                     pending: x.pending,
                     claimed: "0",
                     Reward: {
-                        connectOrCreate: {
-                            where: { id: rewardId },
-                            create: {
-                                id: rewardId,
-                                MerklRoot: { connect: { root } },
-                                User: { connect: { address: x.recipient } },
-                                RewardToken: { connect: { id: rewardTokenId } },
-                                proofs: [],
-                            },
+                        connect: {
+                            id: rewardId,
                         },
                     },
                     Campaign: { connect: { id: campaignId } },
@@ -313,40 +314,30 @@ export class RewardRepository {
         const items = _items || 50;
         const result = await apiDbClient.$queryRawUnsafe(`
       SELECT 
-        rb."amount",
-        rb."reason",
-        rb."claimed",
-        rb."pending",
+        r."amount",
+        r."claimed",
+        r."pending",
         r."recipient",
-        r."campaignId",
-        t."address" as "rewardTokenAddress"
       FROM 
-        "RewardBreakdown" rb
-      INNER JOIN 
-        "Reward" r ON rb."rewardId" = r."id"
-      INNER JOIN 
-        "Token" t ON r."rewardTokenId" = t."id"
+        "Reward" r
       WHERE 
         r."root" = $1 AND r."rewardTokenId" = $2
       ORDER BY 
-        (rb."amount"::numeric + rb."pending"::numeric) DESC
+        (r."amount"::numeric + r."pending"::numeric) DESC
       LIMIT $3
       OFFSET $4
     `, root, id, items, items * page);
         return result;
     }
     static async totalForToken(tokenId, root) {
-        const totalAmount = await apiDbClient.rewardBreakdown.findMany({
+        const totalAmount = await apiDbClient.reward.findMany({
             where: {
-                Reward: {
-                    rewardTokenId: tokenId,
-                    root,
-                },
+                rewardTokenId: tokenId,
+                root,
             },
             select: {
                 amount: true,
                 pending: true,
-                campaignId: true,
             },
         });
         const reducedData = totalAmount.reduce((acc, { amount, pending }) => {
@@ -356,12 +347,10 @@ export class RewardRepository {
         return reducedData;
     }
     static async countForToken(tokenId, root) {
-        const count = await apiDbClient.rewardBreakdown.count({
+        const count = await apiDbClient.reward.count({
             where: {
-                Reward: {
-                    rewardTokenId: tokenId,
-                    root,
-                },
+                rewardTokenId: tokenId,
+                root,
             },
         });
         return { count };

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

@@ -232,17 +232,20 @@ export declare abstract class RewardService {
             id: number;
             campaignId: string;
             amount: string;
-            protocolId: string | null;
             claimed: string;
+            protocolId: string | null;
             auxiliaryData1: string | null;
             auxiliaryData2: string | null;
             rewardId: string;
         })[];
     } & {
+        pending: string;
         id: string;
         recipient: string;
         rewardTokenId: string;
+        amount: string;
         root: string;
+        claimed: string;
         proofs: string[];
     })[]>;
     /**
@@ -530,17 +533,20 @@ export declare abstract class RewardService {
             id: number;
             campaignId: string;
             amount: string;
-            protocolId: string | null;
             claimed: string;
+            protocolId: string | null;
             auxiliaryData1: string | null;
             auxiliaryData2: string | null;
             rewardId: string;
         })[];
     } & {
+        pending: string;
         id: string;
         recipient: string;
         rewardTokenId: string;
+        amount: string;
         root: string;
+        claimed: string;
         proofs: string[];
     })[]>;
     static getUserRewardsByChain(user: string, withToken: boolean, chainFilter?: ChainId[], connectedChainId?: MerklChainId | null, withTestTokens?: boolean): Promise<{
@@ -564,7 +570,7 @@ export declare abstract class RewardService {
         campaignId: string;
         amount: bigint;
     }>;
-    static breakdownForToken(query: TokenIdModel): Promise<import("./reward.model").BreakdownForCampaignsRaw[]>;
+    static breakdownForToken(query: TokenIdModel): Promise<import("./reward.model").BreakdownForTokenRaw[]>;
     static countForToken(query: TokenIdModel): Promise<{
         count: number;
     }>;

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

@@ -238,17 +238,29 @@ export class RewardService {
             distributionChain: data.distributionChainId,
             campaignId: data.campaignId,
         });
+        const rewardUniques = {};
+        // Adds a record to the Reward row where pendings need to be updated
+        const updateRewardUniques = (recipient, pending, previousPending) => {
+            const rewardId = RewardService.hashId(data.root, recipient, rewardTokenId);
+            if (!rewardUniques[rewardId]) {
+                rewardUniques[rewardId] = { pending: "0", recipient: recipient };
+            }
+            rewardUniques[rewardId].pending = (BigInt(rewardUniques[rewardId].pending) +
+                BigInt(pending) -
+                BigInt(previousPending ?? "0")).toString();
+        };
         let totalCreated = 0;
         let totalUpdated = 0;
-        const uniques = await data.data.map(({ recipient, reason }) => {
+        const breakdownUniques = await data.data.map(({ recipient, reason }) => {
             const rewardId = RewardService.hashId(data.root, recipient, rewardTokenId);
             return { rewardId, reason, campaignId };
         });
-        for (let i = 0; i < uniques.length; i += 1000) {
+        for (let i = 0; i < breakdownUniques.length; i += 1_000) {
             const toUpdate = [];
             const toCreate = [];
-            const exists = await RewardRepository.findManyBreakdownUniques(uniques.slice(i, Math.min(i + 1000, uniques.length)));
-            for (const [pointIndex, point] of data.data.slice(i, Math.min(i + 1000, uniques.length)).entries()) {
+            const exists = await RewardRepository.findManyBreakdownUniques(breakdownUniques.slice(i, Math.min(i + 1_000, breakdownUniques.length)));
+            for (const [pointIndex, point] of data.data.slice(i, Math.min(i + 1_000, breakdownUniques.length)).entries()) {
+                updateRewardUniques(point.recipient, point.pending, exists[pointIndex]?.pending);
                 if (!!exists[pointIndex]) {
                     toUpdate.push(point);
                 }
@@ -256,11 +268,36 @@ export class RewardService {
                     toCreate.push(point);
                 }
             }
-            await RewardRepository.updatePendings(rewardTokenId, data.root, campaignId, toUpdate);
-            await RewardRepository.createPendings(rewardTokenId, data.root, campaignId, toCreate);
+            await RewardRepository.updateBreakdownPendings(rewardTokenId, data.root, campaignId, toUpdate);
+            await RewardRepository.createBreakdownPendings(rewardTokenId, data.root, campaignId, toCreate);
             totalCreated += toCreate.length;
             totalUpdated += toUpdate.length;
         }
+        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);
+            }
+        }
+        catch (e) {
+            log.error("updatePendings - error updating reward pendings", e);
+        }
         return { created: totalCreated, updated: totalUpdated };
     }
     static async countAllchains() {

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

@@ -1190,18 +1190,20 @@ export declare const v4: Elysia<"/v4", false, {
             };
         } & {
             token: {
-                get: {
-                    body: unknown;
-                    params: {};
-                    query: {
-                        items?: number | undefined;
-                        page?: number | undefined;
-                        chainId: number;
-                        address: string;
-                    };
-                    headers: unknown;
-                    response: {
-                        200: import("./reward").BreakdownForCampaignsRaw[];
+                index: {
+                    get: {
+                        body: unknown;
+                        params: {};
+                        query: {
+                            items?: number | undefined;
+                            page?: number | undefined;
+                            chainId: number;
+                            address: string;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: import("./reward").BreakdownForTokenRaw[];
+                        };
                     };
                 };
             };
@@ -1250,22 +1252,27 @@ export declare const v4: Elysia<"/v4", false, {
             };
         } & {
             engine: {
-                post: {
-                    body: {
-                        recipient: string;
-                        distributionChainId: number;
-                        root: string;
-                        proofs: string[];
-                        rewardToken: string;
-                    }[];
-                    params: {};
-                    query: unknown;
-                    headers: {
-                        authorization: string;
-                    };
-                    response: {
-                        200: {
-                            count: number;
+                index: {
+                    post: {
+                        body: {
+                            pending: string;
+                            recipient: string;
+                            distributionChainId: number;
+                            amount: string;
+                            root: string;
+                            claimed: string;
+                            proofs: string[];
+                            rewardToken: string;
+                        }[];
+                        params: {};
+                        query: unknown;
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: {
+                                count: number;
+                            };
                         };
                     };
                 };