@merkl/api 0.10.361 → 0.10.377

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

@@ -1,11 +1,12 @@
 import { NotFoundError } from "../../../errors";
-import { CampaignService, campaignTypeToEnumMap } from "../campaign";
+import { CampaignService, campaignTypeToEnumMap, } from "../campaign";
 import { log } from "../../../utils/logger";
 import { OpportunityAction, Prisma, Status } from "../../../../database/api/.generated";
 import { record } from "@elysiajs/opentelemetry";
 import moment from "moment";
 import { CacheService } from "../cache";
 import { TTLPresets } from "../cache/cache.model";
+import { CampaignRepository } from "../campaign/campaign.repository";
 import { TokenService } from "../token";
 import { UserService } from "../user";
 import { OpportunityRepository } from "./opportunity.repository";
@@ -95,6 +96,30 @@ export class OpportunityService {
                 throw "UNKNOWN CAMPAIGN TYPE";
         }
     }
+    static async fakeCreateFromCampaign(campaign) {
+        const campaignType = CampaignService.getTypeFromV3(campaign.type);
+        const metadata = await OpportunityService.#getMetadata(campaign);
+        metadata.tags = [...((await UserService.findUnique(campaign.creator))?.tags ?? []), ...(campaign?.tags ?? [])];
+        const opportunityId = OpportunityService.hashId({
+            chainId: campaign.computeChainId,
+            identifier: campaign.opportunityIdentifier,
+            type: campaignType,
+        });
+        const params = JSON.parse(campaign.params);
+        const opportunity = {
+            id: opportunityId,
+            chainId: campaign.computeChainId,
+            type: campaignType,
+            identifier: campaign.opportunityIdentifier, // mainParameter
+            name: metadata.name,
+            status: Status.SOON,
+            action: metadata.action,
+            mainProtocol: metadata.mainProtocol,
+            depositUrl: !!params.url ? params.url : undefined,
+            tags: metadata.tags,
+        };
+        return opportunity;
+    }
     static async createFromCampaign(campaign, upsert = false) {
         const campaignType = CampaignService.getTypeFromV3(campaign.type);
         const metadata = await OpportunityService.#getMetadata(campaign);
@@ -172,6 +197,21 @@ export class OpportunityService {
             throw err;
         }
     }
+    /**
+     * Finds opportunities based on filters of its campaigns
+     * @notice campaigns are filtered as well
+     * @param where
+     * @returns opportunities
+     */
+    static async getManyByCampaigns(where) {
+        const opportunities = await OpportunityRepository.findManyByCampaigns(CampaignRepository.transformQueryToPrismaFilters(where).where);
+        const formatted = opportunities.map(({ Campaigns, ...o }) => {
+            const opportunity = OpportunityService.formatResponse(o);
+            const campaigns = Campaigns.map(CampaignService.format);
+            return Object.assign(opportunity, { campaigns });
+        });
+        return formatted;
+    }
     static async getUniqueWithCampaignsOrThrow(opportunityId, withTest = false) {
         const id = typeof opportunityId === "string" ? opportunityId : OpportunityService.hashId(opportunityId);
         const { Campaigns, ...opportunity } = await OpportunityRepository.findUniqueOrThrowWithCampaigns(id, withTest);
@@ -257,7 +297,10 @@ export class OpportunityService {
         };
     }
     static formatResponseBase(opportunity) {
-        const { mainProtocolId, id, Tokens, Chain, Protocols, MainProtocol, ...opp } = opportunity;
+        let { mainProtocolId, id, Tokens, Chain, Protocols, MainProtocol, ...opp } = opportunity;
+        if (mainProtocolId === "unknown") {
+            MainProtocol = null;
+        }
         return {
             ...opp,
             id,

package/dist/src/modules/v4/opportunity/subservices/getHyperdriveMetadata.service.d.ts

@@ -1,3 +1,3 @@
 import type { ChainId, HyperDriveLogCampaign } from "@sdk";
 import type { OpportunityMetadata } from "../opportunity.model";
-export declare const getHyperdriveMetadata: (chainId: ChainId, campaignSubType: HyperDriveLogCampaign["campaignSubType"], params: HyperDriveLogCampaign["campaignParameters"]) => Promise<OpportunityMetadata>;
+export declare const getHyperdriveMetadata: (chainId: ChainId, campaignSubType: HyperDriveLogCampaign["campaignSubType"], params: HyperDriveLogCampaign["campaignParameters"]) => OpportunityMetadata;

package/dist/src/modules/v4/opportunity/subservices/getHyperdriveMetadata.service.js

@@ -1,7 +1,7 @@
 import { OpportunityAction } from "../../../../../database/api/.generated";
-export const getHyperdriveMetadata = async (chainId, campaignSubType, params) => {
+export const getHyperdriveMetadata = (chainId, campaignSubType, params) => {
     const subtypes = [
-        { name: "Add Liquidity on", action: OpportunityAction.LP },
+        { name: "Add Liquidity on", action: OpportunityAction.POOL },
         { name: "Open Long on", action: OpportunityAction.LONG },
         { name: "Open Short on", action: OpportunityAction.SHORT },
     ];

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

@@ -242,6 +242,36 @@ export declare const ProgramPayloadController: Elysia<"/program-payload", false,
             };
         };
     };
+} & {
+    "program-payload": {
+        parse: {
+            "from-campaign-data": {
+                post: {
+                    body: {
+                        chainId: number;
+                        startTimestamp: number;
+                        endTimestamp: number;
+                        computeChainId: number;
+                        amount: string;
+                        rewardToken: string;
+                        campaignType: number;
+                        campaignData: string;
+                        symbolRewardToken: string;
+                        decimalsRewardToken: number;
+                    };
+                    params: {};
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        [x: string]: any;
+                        200: any;
+                    };
+                };
+            };
+        };
+    };
 }, {
     derive: {};
     resolve: {};

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

@@ -1,7 +1,8 @@
+import { AuthorizationHeadersDto, BackOfficeGuard } from "../../../guards/BackOffice.guard";
 // import { AuthorizationHeadersDto, BackOfficeGuard } from "../../../guards/BackOffice.guard";
 import Elysia, { t } from "elysia";
 import { throwOnUnsupportedChainId } from "src/utils/throw";
-import { CampaignAmountsInputDto, CampaignPayloadInputDto, ProgramPayloadInputDto, SinglePayloadInputDto, } from "./programPayload.model";
+import { CampaignAmountsInputDto, CampaignDataDto, CampaignPayloadInputDto, ProgramPayloadInputDto, SinglePayloadInputDto, } from "./programPayload.model";
 import { ProgramPayloadService } from "./programPayload.service";
 // ─── ProgramPaylod Controller ───────────────────────────────────────────────────────
 export const ProgramPayloadController = new Elysia({ prefix: "/program-payload", detail: { tags: ["ProgramPayload"] } })
@@ -71,4 +72,14 @@ export const ProgramPayloadController = new Elysia({ prefix: "/program-payload",
     query: t.Object({ debug: t.Optional(t.Boolean({ description: "Debug mode" })) }),
     body: SinglePayloadInputDto,
     detail: { description: "BETA FEATURE : Generate the payload from a config file." },
+})
+    .post("/parse/from-campaign-data", async ({ body }) => {
+    return ProgramPayloadService.buildConfigFromCampaignData(body);
+}, {
+    headers: AuthorizationHeadersDto,
+    body: CampaignDataDto,
+    beforeHandle: ({ headers }) => {
+        BackOfficeGuard({ headers });
+    },
+    detail: { hide: true },
 });

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

@@ -9,6 +9,18 @@ export declare const CampaignPayloadInputDto: import("@sinclair/typebox").TObjec
     endTimestamp: import("@sinclair/typebox").TNumber;
     amount: import("@sinclair/typebox").TString;
 }>;
+export declare const CampaignDataDto: import("@sinclair/typebox").TObject<{
+    campaignType: import("@sinclair/typebox").TNumber;
+    campaignData: import("@sinclair/typebox").TString;
+    amount: import("@sinclair/typebox").TString;
+    chainId: import("@sinclair/typebox").TNumber;
+    computeChainId: import("@sinclair/typebox").TNumber;
+    endTimestamp: import("@sinclair/typebox").TNumber;
+    rewardToken: import("@sinclair/typebox").TString;
+    startTimestamp: import("@sinclair/typebox").TNumber;
+    symbolRewardToken: import("@sinclair/typebox").TString;
+    decimalsRewardToken: import("@sinclair/typebox").TNumber;
+}>;
 export declare const SinglePayloadInputDto: import("@sinclair/typebox").TObject<{
     distributionChainId: import("@sinclair/typebox").TNumber;
     rewardToken: import("@sinclair/typebox").TString;
@@ -58,6 +70,7 @@ export type CampaignPayloadInputModel = typeof CampaignPayloadInputDto.static;
 export type ProgramPayloadInputModel = typeof ProgramPayloadInputDto.static;
 export type CampaignAmountsInputModel = typeof CampaignAmountsInputDto.static;
 export type SinglePayloadInputDtoModel = typeof SinglePayloadInputDto.static;
+export type CampaignDataDtoModel = typeof CampaignDataDto.static;
 export type approvalTransaction = {
     to: string;
     value: string;
@@ -179,7 +192,14 @@ export type partialConfigIonic = {
     blacklist: string[];
     forwarders: string[];
 };
-export type partialConfig = partialConfigERC20 | partialConfigMorpho | partialConfigCLAMM | partialConfigIonic;
+export type partialConfigAirdrop = {
+    jsonUrl: string;
+    url?: string;
+    computeChainId?: MerklChainId;
+    hooks?: (HookParameters<HOOK> | string)[];
+    campaignType: Campaign;
+};
+export type partialConfig = partialConfigERC20 | partialConfigMorpho | partialConfigCLAMM | partialConfigIonic | partialConfigAirdrop;
 export declare const safeTemplate: {
     version: string;
     chainId: string;

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

@@ -10,6 +10,18 @@ export const CampaignPayloadInputDto = t.Object({
     endTimestamp: t.Numeric({ description: "End timestamp for the campaign" }),
     amount: t.String({ description: "Amount of the reward token to be distributed" }),
 });
+export const CampaignDataDto = t.Object({
+    campaignType: t.Numeric({ description: "Type of the campaign 1 : ERC20, 2: CLAMM , ..." }),
+    campaignData: t.String({ description: "Campaign data" }),
+    amount: t.String({ description: "Amount of the reward token to be distributed" }),
+    chainId: t.Numeric({ description: "Chain ID where the reward tokens will be distributed" }),
+    computeChainId: t.Numeric({ description: "Chain ID used for computation" }),
+    endTimestamp: t.Numeric({ description: "End timestamp for the campaign" }),
+    rewardToken: t.String({ description: "Address of the reward token to be distributed" }),
+    startTimestamp: t.Numeric({ description: "Start timestamp for the campaign" }),
+    symbolRewardToken: t.String({ description: "Symbol of the reward token" }),
+    decimalsRewardToken: t.Numeric({ description: "Decimals of the reward token" }),
+});
 export const SinglePayloadInputDto = t.Object({
     distributionChainId: t.Numeric({ description: "Chain ID where the reward tokens will be distributed" }),
     rewardToken: t.String({ description: "Address of the reward token to be distributed" }),

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

@@ -35,7 +35,7 @@ export declare enum pufferCampaigns {
     venus_pufeth = "0xE0ee5dDeBFe0abe0a4Af50299D68b74Cec31668e",
     unifiBTC = "0x170D847A8320F3B6A77eE15B0CAE430e3eC933a0",
     unifiUSD = "0x82c40e07277eBb92935f79cE92268F80dDc7caB4",
-    CARROT_USDC = "0xf00032d0f95e8f43e750c51d0188dca33cc5a8ea"
+    CARROT_USDC = "0xf00032d0F95e8f43E750C51d0188DCa33cC5a8eA"
 }
 export declare enum zkSyncCampaigns {
     Izumi_Finance_Zk_Weth = "Izumi Finance ZK/WETH 0xd62bc9f19bd94fde9c41df4b6eb6419ea6b8e25c",
@@ -112,7 +112,8 @@ export declare enum zkSyncCampaigns {
     ZKSwap_ETH_USDCe_20 = "ZKSwap Finance ETH/USDC v3 0.2pct 0x6480665e22d82b3b9079b44e421a62c185b9bd77",
     ZKSwap_wstETH_ETH_20 = "ZKSwap Finance wstETH/ETH v3 0.01pct 0xd587b615ac1acb6c1f95242a1bcac512d2cd8122",
     ZKSwap_wrsETH_ETH_20 = "ZKSwap Finance wrsETH/ETH v3 0.01pct 0xcd6d8b89f24b017dbbdc0c13a99d29edc13e2189",
-    ZKSwap_ZF_ETH = "ZKSwap Finance ZF/ETH v2 0.1pct ZKSwap Finance ZF/ETH v2 0xd33a17c883d5aa79470cd2522abb213dc4017e01"
+    ZKSwap_ZF_ETH = "ZKSwap Finance ZF/ETH v2 0.1pct ZKSwap Finance ZF/ETH v2 0xd33a17c883d5aa79470cd2522abb213dc4017e01",
+    raffle_jumper = "raffle jumper"
 }
 export declare enum modeCampaigns {
     Steer_EES_V2_Weth_USDC_Kim_Mode = "SteerEESV2 Kim WETH/USDC 0x468cc91df6f669cae6cdce766995bd7874052fbc",

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

@@ -1,4 +1,4 @@
-import { BalanceCallType, Campaign, ChainId, CompFork, CompoundSubCampaignType, Forwarder, MorphoSubCampaignType, StandardType, } from "@sdk";
+import { BalanceCallType, Campaign, ChainId, CompFork, CompoundSubCampaignType, Forwarder, HOOK, MorphoSubCampaignType, StandardType, selectionRaffleMethod, } from "@sdk";
 export var program;
 (function (program) {
     program["Puffer"] = "Puffer";
@@ -37,7 +37,7 @@ export var pufferCampaigns;
     pufferCampaigns["venus_pufeth"] = "0xE0ee5dDeBFe0abe0a4Af50299D68b74Cec31668e";
     pufferCampaigns["unifiBTC"] = "0x170D847A8320F3B6A77eE15B0CAE430e3eC933a0";
     pufferCampaigns["unifiUSD"] = "0x82c40e07277eBb92935f79cE92268F80dDc7caB4";
-    pufferCampaigns["CARROT_USDC"] = "0xf00032d0f95e8f43e750c51d0188dca33cc5a8ea";
+    pufferCampaigns["CARROT_USDC"] = "0xf00032d0F95e8f43E750C51d0188DCa33cC5a8eA";
 })(pufferCampaigns || (pufferCampaigns = {}));
 export var zkSyncCampaigns;
 (function (zkSyncCampaigns) {
@@ -116,6 +116,7 @@ export var zkSyncCampaigns;
     zkSyncCampaigns["ZKSwap_wstETH_ETH_20"] = "ZKSwap Finance wstETH/ETH v3 0.01pct 0xd587b615ac1acb6c1f95242a1bcac512d2cd8122";
     zkSyncCampaigns["ZKSwap_wrsETH_ETH_20"] = "ZKSwap Finance wrsETH/ETH v3 0.01pct 0xcd6d8b89f24b017dbbdc0c13a99d29edc13e2189";
     zkSyncCampaigns["ZKSwap_ZF_ETH"] = "ZKSwap Finance ZF/ETH v2 0.1pct ZKSwap Finance ZF/ETH v2 0xd33a17c883d5aa79470cd2522abb213dc4017e01";
+    zkSyncCampaigns["raffle_jumper"] = "raffle jumper";
 })(zkSyncCampaigns || (zkSyncCampaigns = {}));
 export var modeCampaigns;
 (function (modeCampaigns) {
@@ -1133,6 +1134,24 @@ const ModeInterfaceCampaigns = {
     },
 };
 const ZkSyncInterfaceCampaigns = {
+    [zkSyncCampaigns.raffle_jumper]: {
+        campaignType: Campaign.JSON_AIRDROP,
+        computeChainId: ChainId.ZKSYNC,
+        hooks: [
+            {
+                hookType: HOOK.RAFFLE,
+                resolutionIndex: 0,
+                selectionMethod: selectionRaffleMethod.RANDOM,
+                numberOfWinners: 5,
+                multipleWinningPossible: false,
+                weightIncreasesRewards: false,
+                weightedSelection: true,
+                blacklistWinnersFromRounds: [],
+                weightOfTotalRewards: 10000000,
+            },
+        ],
+        jsonUrl: "https://angle-blog.infura-ipfs.io/ipfs/QmRgF8gpSsJCTHXxmjY53f4tfMxWTaZFmPyw55xCRen6YN",
+    },
     [zkSyncCampaigns.Vest_USDC]: {
         campaignType: Campaign.VEST,
         computeChainId: ChainId.ZKSYNC,
@@ -2345,12 +2364,19 @@ const PufferInterfaceCampaigns = {
         targetToken: "0xD9A442856C234a39a81a089C06451EBAa4306a72",
         whitelist: [],
         blacklist: [
+            "0x1f2aa9680910aC5a4527FA72001dC249943f60b4",
             "0xF047ab4c75cebf0eB9ed34Ae2c186f3611aEAfa6",
             "0x68754d29f2e97B837Cb622ccfF325adAC27E9977",
             "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
             "0x18eeD20f71BEf84B605253C89A7576E3634134C0",
             "0x196ead472583Bc1e9aF7A05F860D9857e1Bd3dCc",
             "0x253008ba4aE2f3E6488DC998a5321D4EB1a0c905",
+            "0xEEda34A377dD0ca676b9511EE1324974fA8d980D",
+            "0x39F5b252dE249790fAEd0C2F05aBead56D2088e1",
+            "0xdD7Afc0f014A1E1716307Ff040704fA12E8D33A3",
+            "0x1a33B9be3Fe58C1Bde4325A68c09C1F7fA8aA1e5",
+            "0xBDB04e915B94FbFD6e8552ff7860E59Db7d4499a",
+            "0xE0ee5dDeBFe0abe0a4Af50299D68b74Cec31668e",
         ],
         url: "https://etherscan.io/token/0xd9a442856c234a39a81a089c06451ebaa4306a72",
         forwarders: [],

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

@@ -1,6 +1,6 @@
 import { type Campaign, ChainId, type campaignConfig } from "@sdk";
 import type { CampaignParametersStruct } from "libs/sdk/src/generated/CampaignCreator";
-import { type CampaignAmountsInputModel, type CampaignPayloadInputModel, type ProgramPayloadInputModel, type SinglePayloadInputDtoModel, type approvalTransaction, type createCampaignTransaction, type safePayload } from "./programPayload.model";
+import { type CampaignAmountsInputModel, type CampaignDataDtoModel, type CampaignPayloadInputModel, type ProgramPayloadInputModel, type SinglePayloadInputDtoModel, type approvalTransaction, type createCampaignTransaction, type safePayload } from "./programPayload.model";
 export declare class ProgramPayloadService {
     static buildConfigTemplate(params: {
         campaignType: number;
@@ -21,4 +21,5 @@ export declare class ProgramPayloadService {
     static buildPayload(query: CampaignPayloadInputModel, initialCampaignPayload?: safePayload | null, totalAmount?: string): safePayload;
     static buildProgramPayload(query: ProgramPayloadInputModel): safePayload | null;
     static buildProgramPayloadWithAmounts(query: ProgramPayloadInputModel, body: CampaignAmountsInputModel): safePayload | null;
+    static buildConfigFromCampaignData(body: CampaignDataDtoModel): Promise<any>;
 }

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

@@ -1,4 +1,4 @@
-import { CampaignTypeConfigResourceMapping, ChainId, NULL_ADDRESS, NULL_ROOT, buildCampaignPayload, encodeForwarderData, registry, } from "@sdk";
+import { CampaignTypeConfigResourceMapping, ChainId, NULL_ADDRESS, NULL_ROOT, ParserService, buildCampaignPayload, encodeForwarderData, registry, } from "@sdk";
 import _ from "lodash";
 import { safeTemplate, } from "./programPayload.model";
 import { MerklInterfaceCampaigns } from "./programPayload.repository";
@@ -102,7 +102,7 @@ export class ProgramPayloadService {
         }
         return [safePayload.transactions[2]];
     }
-    static initiateSafePayload(distributionChainId, distributionCreator, rewardToken, approvalAmount = "O") {
+    static initiateSafePayload(distributionChainId, distributionCreator, rewardToken, approvalAmount = "0") {
         const safePayload = _.cloneDeep(safeTemplate);
         safePayload.chainId = distributionChainId.toString();
         safePayload.createdAt = Math.floor(Date.now() / 1000);
@@ -117,6 +117,17 @@ export class ProgramPayloadService {
         }
         else
             safePayload.transactions = [safePayload.transactions[1]];
+        const wrapperContract = "0x8A5A5DE9db5770123Ff2145F59e9F20047f0A8EC";
+        if (rewardToken === wrapperContract && approvalAmount !== "0") {
+            const secondarySafePayload = _.cloneDeep(safeTemplate);
+            const underlying = "0x282A69142bac47855C3fbE1693FcC4bA3B4d5Ed6";
+            secondarySafePayload.transactions[0].to = underlying;
+            secondarySafePayload.transactions[0].contractInputsValues = {
+                amount: approvalAmount,
+                spender: wrapperContract,
+            };
+            safePayload.transactions.push(secondarySafePayload.transactions[0]);
+        }
         return safePayload;
     }
     static buildPayload(query, initialCampaignPayload = null, totalAmount = "0") {
@@ -164,4 +175,33 @@ export class ProgramPayloadService {
         }
         return campaignPayloads;
     }
+    static async buildConfigFromCampaignData(body) {
+        const parser = ParserService(body.campaignType);
+        const base = {
+            amount: body.amount,
+            campaignId: "0xdefaultId",
+            campaignSubType: 0,
+            campaignType: body.campaignType,
+            chainId: body.chainId,
+            computeChainId: body.computeChainId,
+            creator: "Oxcreator",
+            endTimestamp: body.endTimestamp,
+            index: 0,
+            mainParameter: " ".repeat(42),
+            rewardToken: body.rewardToken,
+            startTimestamp: body.startTimestamp,
+        };
+        try {
+            console.log("Parsing campaign data");
+            const res = await parser.parse(body.chainId, body.symbolRewardToken, body.decimalsRewardToken, base, body.campaignData);
+            if (res.success) {
+                return res;
+            }
+            throw res.message;
+        }
+        catch (e) {
+            console.error(e);
+            throw e;
+        }
+    }
 }

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

@@ -81,6 +81,7 @@ export declare const ProtocolController: Elysia<"/protocols", false, {
         ":id": {
             patch: {
                 body: {
+                    name?: string | undefined;
                     url?: string | undefined;
                     description?: string | undefined;
                     icon?: string | undefined;

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

@@ -30,6 +30,7 @@ export declare const UpdateProtocolDto: import("@sinclair/typebox").TObject<{
     icon: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     url: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
 }>;
 export declare const CreateProtocolDto: import("@sinclair/typebox").TObject<{
     icon: import("@sinclair/typebox").TString;

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

@@ -95,6 +95,7 @@ export const UpdateProtocolDto = t.Object({
     icon: t.Optional(t.String({ format: "uri" })),
     url: t.Optional(t.String({ format: "uri" })),
     description: t.Optional(t.String()),
+    name: t.Optional(t.String()),
     // iconFile: t.Optional(t.File()),
 });
 export const CreateProtocolDto = t.Object({

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

@@ -125,7 +125,8 @@ export declare abstract class RewardRepository {
         rewardCount: number;
         breakdownCount: number;
     }>;
-    static updateClaimed(recipient: string, rewardTokenId: string, campaignId: string, reason: string, amount: string): Promise<Prisma.BatchPayload>;
+    static updateRewardClaimed(recipient: string, rewardTokenId: string, amount: string): Promise<Prisma.BatchPayload>;
+    static updateBreakdownClaimed(recipient: string, rewardTokenId: string, campaignId: string, reason: string, amount: string): Promise<Prisma.BatchPayload>;
     static findManyBreakdownUniques(uniques: {
         rewardId: string;
         campaignId: string;

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

@@ -136,7 +136,18 @@ export class RewardRepository {
         });
         return { rewardCount, breakdownCount };
     }
-    static async updateClaimed(recipient, rewardTokenId, campaignId, reason, amount) {
+    static async updateRewardClaimed(recipient, rewardTokenId, amount) {
+        return await apiDbClient.reward.updateMany({
+            where: {
+                recipient,
+                rewardTokenId,
+            },
+            data: {
+                claimed: amount,
+            },
+        });
+    }
+    static async updateBreakdownClaimed(recipient, rewardTokenId, campaignId, reason, amount) {
         return await apiDbClient.rewardBreakdown.updateMany({
             where: {
                 campaignId,

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

@@ -41,8 +41,8 @@ export class RewardService {
     static format(rewards) {
         return rewards.map(reward => {
             const { Breakdown, RewardToken, id, rewardTokenId, ...rest } = reward;
-            const claimed = Breakdown.reduce((sum, { claimed }) => sum + BigInt(claimed), 0n);
             const pending = Breakdown.reduce((sum, { pending }) => sum + BigInt(pending), 0n);
+            const claimed = Breakdown.reduce((sum, { claimed }) => sum + BigInt(claimed), 0n);
             return {
                 ...rest,
                 token: RewardToken,
@@ -148,6 +148,7 @@ export class RewardService {
             const merklRootClaimedOn = claims[index].merkleRoot;
             // -> claim is on the current root (chainData.merklRoot) -> claimed === accumulated
             if (merklRootClaimedOn === roots.live) {
+                reward.claimed = reward.amount;
                 for (const breakdown of reward.Breakdown) {
                     if (BigInt(breakdown.claimed) === BigInt(breakdown.amount))
                         continue;
@@ -160,6 +161,7 @@ export class RewardService {
                 const lastTreeRewards = await RewardRepository.getByChainRecipientToken(user, merklRootClaimedOn, TokenService.hashId(reward.RewardToken));
                 if (!lastTreeRewards)
                     continue;
+                reward.claimed = lastTreeRewards.amount;
                 for (const breakdown of reward.Breakdown) {
                     const lastTreeRewardsBreakdown = lastTreeRewards.Breakdown.find(lastTreeBreakdown => lastTreeBreakdown.reason === breakdown.reason &&
                         lastTreeBreakdown.Campaign.campaignId === breakdown.Campaign.campaignId);
@@ -227,8 +229,9 @@ export class RewardService {
             const rewards = await RewardRepository.getByChainRecipientToken(claim.recipient, claim.root, tokenId);
             if (!rewards)
                 continue;
+            await RewardRepository.updateRewardClaimed(claim.recipient, tokenId, rewards.amount);
             for (const breakdown of rewards.Breakdown) {
-                await RewardRepository.updateClaimed(claim.recipient, tokenId, breakdown.campaignId, breakdown.reason, breakdown.amount);
+                await RewardRepository.updateBreakdownClaimed(claim.recipient, tokenId, breakdown.campaignId, breakdown.reason, breakdown.amount);
             }
         }
     }