@merkl/api 0.10.408 → 0.10.409

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

@@ -1631,10 +1631,8 @@ declare const eden: {
                         query?: Record<string, unknown> | undefined;
                         fetch?: RequestInit | undefined;
                     }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                        200: {
-                            created: number;
-                            updated: number;
-                        };
+                        [x: string]: any;
+                        200: any;
                     }>>;
                 };
             };
@@ -4634,10 +4632,8 @@ declare const eden: {
                         query?: Record<string, unknown> | undefined;
                         fetch?: RequestInit | undefined;
                     }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                        200: {
-                            created: number;
-                            updated: number;
-                        };
+                        [x: string]: any;
+                        200: any;
                     }>>;
                 };
             };
@@ -8625,10 +8621,8 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                             authorization: string;
                         };
                         response: {
-                            200: {
-                                created: number;
-                                updated: number;
-                            };
+                            [x: string]: any;
+                            200: any;
                         };
                     };
                 };
@@ -12944,10 +12938,8 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         query?: Record<string, unknown> | undefined;
                         fetch?: RequestInit | undefined;
                     }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                        200: {
-                            created: number;
-                            updated: number;
-                        };
+                        [x: string]: any;
+                        200: any;
                     }>>;
                 };
             };
@@ -15947,10 +15939,8 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         query?: Record<string, unknown> | undefined;
                         fetch?: RequestInit | undefined;
                     }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                        200: {
-                            created: number;
-                            updated: number;
-                        };
+                        [x: string]: any;
+                        200: any;
                     }>>;
                 };
             };

package/dist/src/index.d.ts

@@ -1930,10 +1930,8 @@ declare const app: Elysia<"", false, {
                             authorization: string;
                         };
                         response: {
-                            200: {
-                                created: number;
-                                updated: number;
-                            };
+                            [x: string]: any;
+                            200: any;
                         };
                     };
                 };

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

@@ -305,10 +305,8 @@ export declare const RewardController: Elysia<"/rewards", false, {
                         authorization: string;
                     };
                     response: {
-                        200: {
-                            created: number;
-                            updated: number;
-                        };
+                        [x: string]: any;
+                        200: any;
                     };
                 };
             };

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

@@ -1,5 +1,5 @@
 import type { ChainId } from "@sdk";
-import type { BreakdownForCampaignsRaw, CampaignIdModel, CampaignIdWithoutPageModel, CreateManyBreakdownModel, CreateManyRewardModel, PendingEntity, TokenIdModel } from "./reward.model";
+import type { BreakdownForCampaignsRaw, CampaignIdModel, CampaignIdWithoutPageModel, CreateManyBreakdownModel, CreateManyRewardModel, TokenIdModel } from "./reward.model";
 export declare abstract class RewardRepository {
     static createManyReward(rewards: CreateManyRewardModel): Promise<import("database/api/.generated/runtime/library").GetBatchResult>;
     static createManyBreakdown(data: CreateManyBreakdownModel): Promise<import("database/api/.generated/runtime/library").GetBatchResult>;
@@ -122,62 +122,6 @@ export declare abstract class RewardRepository {
     }>;
     static updateRewardClaimed(recipient: string, rewardTokenId: string, amount: string): Promise<import("database/api/.generated/runtime/library").GetBatchResult>;
     static updateBreakdownClaimed(recipient: string, rewardTokenId: string, campaignId: string, reason: string, amount: string): Promise<import("database/api/.generated/runtime/library").GetBatchResult>;
-    static findManyBreakdownUniques(uniques: {
-        rewardId: string;
-        campaignId: string;
-        reason: string;
-    }[]): Promise<({
-        pending: 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;
-        root: string;
-        claimed: string;
-        proofs: string[];
-    }[]>;
-    static updateBreakdownPendings(rewardTokenId: string, root: string, campaignId: string, toUpdate: PendingEntity[]): Promise<{
-        reason: string;
-        pending: string;
-        id: number;
-        campaignId: string;
-        amount: string;
-        claimed: string;
-        protocolId: string | null;
-        rewardId: string;
-    }[]>;
-    static createRewardPendings(rewardTokenId: string, root: string, toCreate: {
-        recipient: string;
-        pending: string;
-    }[]): Promise<{
-        pending: string;
-        id: string;
-        recipient: string;
-        rewardTokenId: string;
-        amount: string;
-        root: string;
-        claimed: string;
-        proofs: string[];
-    }[]>;
-    static createBreakdownPendings(rewardTokenId: string, root: string, campaignId: string, toCreate: PendingEntity[]): Promise<{
-        reason: string;
-        pending: string;
-        id: number;
-        campaignId: string;
-        amount: string;
-        claimed: string;
-        protocolId: string | null;
-        rewardId: string;
-    }[]>;
     static findManyRootsWithRewardOnChain(chainId: number): Promise<string[]>;
     static breakdownForCampaign(root: string, id: string, query: CampaignIdModel): Promise<BreakdownForCampaignsRaw[]>;
     static totalForCampaign(campaignId: string, root: string): Promise<{

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

@@ -162,99 +162,6 @@ 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,
-                    campaignId: x.campaignId,
-                    reason: x.reason,
-                },
-            },
-        })));
-    }
-    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.reward.update({
-                where: {
-                    id: rewardId,
-                },
-                data: {
-                    pending: x.pending,
-                },
-            });
-        }));
-    }
-    static async updateBreakdownPendings(rewardTokenId, root, campaignId, toUpdate) {
-        return await apiDbClient.$transaction(toUpdate.map(x => {
-            return apiDbClient.rewardBreakdown.update({
-                where: {
-                    rewardId_campaignId_reason: {
-                        rewardId: RewardService.hashId(root, x.recipient, rewardTokenId),
-                        campaignId: campaignId,
-                        reason: x.reason,
-                    },
-                },
-                data: {
-                    pending: x.pending,
-                },
-            });
-        }));
-    }
-    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 => {
-            const rewardId = RewardService.hashId(root, x.recipient, rewardTokenId);
-            return apiDbClient.rewardBreakdown.create({
-                data: {
-                    reason: x.reason,
-                    amount: "0",
-                    pending: x.pending,
-                    claimed: "0",
-                    Reward: {
-                        connect: {
-                            id: rewardId,
-                        },
-                    },
-                    Campaign: { connect: { id: campaignId } },
-                },
-            });
-        }));
-    }
     static async findManyRootsWithRewardOnChain(chainId) {
         return (await apiDbClient.merklRoot.findMany({
             where: {

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

@@ -2,7 +2,7 @@ import type { CacheKeys } from "../../../cache/keys";
 import type { Chain } from "../../../../database/api/.generated";
 import { Campaign, type CampaignDynamicData, type ChainId, type MerklChainId } from "@sdk";
 import { type LightOpportunityFromDB, type Opportunity } from "../opportunity";
-import type { CampaignIdModel, CampaignIdWithoutPageModel, CreateManyBreakdownModel, CreateManyRewardModel, DailyRewardsRecord, RegisterClaimsModel, RewardBreakdown, TokenIdModel, UpdatePendingModel } from "./reward.model";
+import type { CampaignIdModel, CampaignIdWithoutPageModel, CreateManyBreakdownModel, CreateManyRewardModel, DailyRewardsRecord, RegisterClaimsModel, RewardBreakdown, TokenIdModel } from "./reward.model";
 import { RewardRepository } from "./reward.repository";
 export declare abstract class RewardService {
     static hashId(root: string, recipient: string, rewardTokenId: string): string;
@@ -536,10 +536,6 @@ export declare abstract class RewardService {
         rewards: Awaited<ReturnType<(typeof RewardService)["format"]>>;
     }[]>;
     static registerClaims(claims: RegisterClaimsModel): Promise<void>;
-    static updatePendings(data: UpdatePendingModel): Promise<{
-        created: number;
-        updated: number;
-    }>;
     static countOnChain(chainId: number): Promise<{
         [x: string]: {
             rewardCount: number;

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

@@ -143,15 +143,17 @@ export class RewardService {
         const claims = await DistributorService(chainId).claimedMultiple(user, rewards.map(reward => reward.RewardToken.address));
         const rootsWithRewardOnChain = await RewardService.findManyRootsOnChain(chainId);
         for (const [index, reward] of rewards.entries()) {
+            const tokenId = TokenService.hashId(reward.RewardToken);
             const merklRootClaimedOn = claims[index].merkleRoot;
             // -> claim is on the current root (chainData.merklRoot) -> claimed === accumulated
             if (merklRootClaimedOn === roots.live) {
                 reward.claimed = reward.amount;
+                await RewardRepository.updateRewardClaimed(user, tokenId, reward.amount);
                 for (const breakdown of reward.Breakdown) {
                     if (BigInt(breakdown.claimed) === BigInt(breakdown.amount))
                         continue;
                     breakdown.claimed = breakdown.amount; // Set unclaim to 0
-                    await RewardRepository.updateClaimed(user, TokenService.hashId(reward.RewardToken), reward.Breakdown[0].campaignId, reward.Breakdown[0].reason, reward.Breakdown[0].amount);
+                    await RewardRepository.updateBreakdownClaimed(user, tokenId, reward.Breakdown[0].campaignId, reward.Breakdown[0].reason, reward.Breakdown[0].amount);
                 }
             }
             // -> claim is on a tree we have in db -> claimed === accumulated of the rewards of lastTree
@@ -160,13 +162,14 @@ export class RewardService {
                 if (!lastTreeRewards)
                     continue;
                 reward.claimed = lastTreeRewards.amount;
+                await RewardRepository.updateRewardClaimed(user, tokenId, lastTreeRewards.amount);
                 for (const breakdown of reward.Breakdown) {
                     const lastTreeRewardsBreakdown = lastTreeRewards.Breakdown.find(lastTreeBreakdown => lastTreeBreakdown.reason === breakdown.reason &&
                         lastTreeBreakdown.Campaign.campaignId === breakdown.Campaign.campaignId);
                     if (!lastTreeRewardsBreakdown)
                         continue;
                     breakdown.claimed = lastTreeRewardsBreakdown.amount;
-                    await RewardRepository.updateClaimed(user, TokenService.hashId(reward.RewardToken), breakdown.campaignId, breakdown.reason, breakdown.amount);
+                    await RewardRepository.updateBreakdownClaimed(user, tokenId, breakdown.campaignId, breakdown.reason, breakdown.amount);
                 }
             }
         }
@@ -233,60 +236,6 @@ export class RewardService {
             }
         }
     }
-    static async updatePendings(data) {
-        const rewardTokenId = await TokenService.hashId({ address: data.rewardToken, chainId: data.distributionChainId });
-        const campaignId = await CampaignService.hashId({
-            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")) // Store the delta
-                .toString();
-        };
-        const breakdownUniques = await data.data.map(({ recipient, reason }) => {
-            const rewardId = RewardService.hashId(data.root, recipient, rewardTokenId);
-            return { rewardId, reason, campaignId };
-        });
-        const breakdownToUpdate = [];
-        const breakdownToCreate = [];
-        const breakdownExists = await RewardRepository.findManyBreakdownUniques(breakdownUniques);
-        for (const [pointIndex, point] of data.data.entries()) {
-            updateRewardUniques(point.recipient, point.pending, breakdownExists[pointIndex]?.pending);
-            if (!!breakdownExists[pointIndex]) {
-                breakdownToUpdate.push(point);
-            }
-            else {
-                breakdownToCreate.push(point);
-            }
-        }
-        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);
-            }
-        }
-        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 countOnChain(chainId) {
         const roots = await MerklRootService.fetch(chainId);
         const promises = [

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

@@ -1800,10 +1800,8 @@ export declare const v4: Elysia<"/v4", false, {
                             authorization: string;
                         };
                         response: {
-                            200: {
-                                created: number;
-                                updated: number;
-                            };
+                            [x: string]: any;
+                            200: any;
                         };
                     };
                 };