@merkl/api 0.10.81 → 0.10.83

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/SturdySiloProcessor.d.ts

@@ -0,0 +1,39 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { tokenType } from "../helpers/tokenType";
+import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawSturdySilo;
+    call: string;
+    target: keyof callKeysSturdySilo;
+    metaData?: any;
+};
+type callKeysSturdySilo = callKeys & {
+    underlying: string;
+    sharePrice: string;
+    collateralContract: string;
+    collateral: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+    symbolCollateral: string;
+};
+type dataRawSturdySilo = callKeysSturdySilo & {};
+type dataTypeSturdySilo = dataType & {
+    underlying: string;
+    sharePrice: number;
+    collateral: string;
+    collateralContract: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+    symbolCollateral: string;
+};
+export declare class SturdySiloProcessor extends GenericProcessor<callKeysSturdySilo, dataRawSturdySilo, dataTypeSturdySilo> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawSturdySilo, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeSturdySilo>;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/TorosProcessor.d.ts

@@ -0,0 +1,29 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { tokenType } from "../helpers/tokenType";
+import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawToros;
+    call: string;
+    target: keyof callKeysToros;
+    metaData?: any;
+};
+type callKeysToros = callKeys & {
+    tokenPrice: string;
+};
+type dataRawToros = callKeysToros & {};
+type dataTypeToros = dataType & {
+    tokenPrice: string;
+    priceTargetToken: number;
+    symbolUnderlyingToken: string;
+};
+export declare class TorosProcessor extends GenericProcessor<callKeysToros, dataRawToros, dataTypeToros> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawToros, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeToros>;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/curveProcessor.d.ts

@@ -0,0 +1,47 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import { tokenType } from "../helpers/tokenType";
+import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawCurve;
+    call: string;
+    target: keyof callKeysCurve;
+    metaData?: any;
+    optional?: boolean;
+};
+type callKeysCurve = callKeys & {
+    lp_price: string;
+    token0: string;
+    token1: string;
+    token2: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    symbolToken2: string;
+};
+type dataRawCurve = callKeysCurve & {
+    poolTokens: {
+        [key: string]: string;
+    };
+};
+type dataTypeCurve = dataType & {
+    lp_price: number;
+    token0: string;
+    token1: string;
+    token2: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    symbolToken2: string;
+    poolTokens: {
+        [key: string]: string;
+    };
+};
+export declare class CurveProcessor extends GenericProcessor<callKeysCurve, dataRawCurve, dataTypeCurve> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawCurve, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeCurve>;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/genericProcessor.d.ts

@@ -0,0 +1,61 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
+import { type tokenType, type tokenTypeStruct } from "../helpers/tokenType";
+export declare enum roundType {
+    one = "round1",
+    two = "round2",
+    three = "round3",
+    four = "round4"
+}
+export type callType = {
+    key: any;
+    call: any;
+    target: any;
+    metaData?: any;
+    optional?: boolean;
+};
+export type callKeys = {
+    [key: string]: string;
+    tokenAddress: string;
+    blacklistedSupply: string;
+    totalSupply: string;
+};
+export type dataRaw = {
+    tokenAddress: string;
+    blacklistedSupply: string;
+    totalSupply: string;
+};
+export type dataType = {
+    tokenAddress: string;
+    totalSupply: number;
+    blacklistedSupply: number;
+    tvl: number;
+    cardName: string;
+    priceTargetToken: number;
+};
+export declare class GenericProcessor<Input extends callKeys, DataRaw extends dataRaw, Output extends dataType> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    debug: boolean;
+    processingRound1(typeInfo: DataRaw): void;
+    processingRound2(typeInfo: DataRaw): void;
+    processingRound3(typeInfo: DataRaw): void;
+    processingRound4(typeInfo: DataRaw): void;
+    processingRound5(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<Output>;
+    computeRound1(type: tokenType, typeInfo: DataRaw): tokenTypeStruct;
+    computeRound2(index: number, type: tokenType, typeInfo: DataRaw, calls: string[]): tokenTypeStruct;
+    computeRound3(index: number, type: tokenType, typeInfo: DataRaw, calls: string[]): tokenTypeStruct;
+    computeRound4(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
+    computeRound5(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<tokenTypeStruct>;
+    generateBlackListCall(type: tokenType, typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20>): Multicall3.Call3Struct[];
+    decodeBlackListedSupply(index: number, decimals: number, blacklist: string[], calls: string[]): string;
+    decodeRound(round: callType[], index: number, calls: string[], type: tokenType, data: DataRaw): void;
+    decodePreviousRound(round: roundType, calls: string[], data: DataRaw, type: tokenType, index: number): void;
+    encodeRound(round: callType[], callInfo: Input, type: tokenType): Multicall3.Call3Struct[];
+    encodeNextRound(round: roundType, type: tokenType, data: DataRaw): Multicall3.Call3Struct[];
+}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/processorMapping.d.ts

@@ -0,0 +1,6 @@
+import { tokenType } from "../helpers/tokenType";
+import { GenericProcessor } from "./GenericProcessor";
+import type { callKeys, dataRaw, dataType } from "./GenericProcessor";
+export declare const processorMapping: {
+    [key in tokenType]: typeof GenericProcessor<callKeys, dataRaw, dataType>;
+};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/templateProcessor.d.ts

@@ -0,0 +1,32 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import type { Campaign, CampaignParameters } from "@sdk";
+import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
+import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawTemplate;
+    call: string;
+    target: keyof callKeysTemplate;
+    metaData?: any;
+};
+type callKeysTemplate = callKeys & {};
+type dataRawTemplate = callKeysTemplate & {};
+type dataTypeTemplate = dataType & {};
+export declare class TemplateProcessor extends GenericProcessor<callKeysTemplate, dataRawTemplate, dataTypeTemplate> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound1(typeInfo: dataRawTemplate): void;
+    processingRound2(typeInfo: dataRawTemplate): void;
+    processingRound3(typeInfo: dataRawTemplate): void;
+    processingRound4(typeInfo: dataRawTemplate): void;
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawTemplate, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeTemplate>;
+    computeRound1(type: tokenType, typeInfo: dataRawTemplate): tokenTypeStruct;
+    computeRound2(index: number, type: tokenType, typeInfo: dataRawTemplate, calls: string[]): tokenTypeStruct;
+    computeRound3(index: number, type: tokenType, typeInfo: dataRawTemplate, calls: string[]): tokenTypeStruct;
+    computeRound4(index: number, type: tokenType, typeInfo: dataRawTemplate, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
+    computeRound5(index: number, type: tokenType, typeInfo: dataRawTemplate, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<tokenTypeStruct>;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/uniswapProcessor.d.ts

@@ -0,0 +1,42 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { tokenType } from "../helpers/tokenType";
+import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawUni;
+    call: string;
+    target: keyof callKeysUni;
+    metaData?: any;
+};
+type callKeysUni = callKeys & {
+    token0: string;
+    token1: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    decimalsToken0: string;
+    decimalsToken1: string;
+    balanceToken0: string;
+    balanceToken1: string;
+};
+type dataRawUni = callKeysUni & {};
+type dataTypeUni = dataType & {
+    token0: string;
+    token1: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    decimalsToken0: number;
+    decimalsToken1: number;
+    balanceToken0: number;
+    balanceToken1: number;
+    priceTargetToken: number;
+};
+export declare class UniswapProcessor extends GenericProcessor<callKeysUni, dataRawUni, dataTypeUni> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawUni, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeUni>;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesPricesRefactoFinal.d.ts

@@ -0,0 +1,4 @@
+import type { Pricer } from "../../../../utils/pricer";
+import type { Campaign, CampaignParameters } from "@sdk";
+import type { tokenType, tokenTypeStruct } from "./helpers/tokenType";
+export declare function getTokenPricesInfo(index: number, type: tokenType, typeInfo: any, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<tokenTypeStruct>;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound1RefactoFinal.d.ts

@@ -0,0 +1,3 @@
+import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
+import { type tokenTypeStruct } from "./helpers/tokenType";
+export declare function getTokenTypeRound1(calls: Multicall3.ResultStructOutput[], targetToken: string, index: number): tokenTypeStruct;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound2RefactoFinal.d.ts

@@ -0,0 +1,3 @@
+import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
+import type { tokenType, tokenTypeStruct } from "./helpers/tokenType";
+export declare function getTokenTypeRound2(index: number, type: tokenType, typeInfo: any, calls: Multicall3.ResultStructOutput[]): tokenTypeStruct;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound3RefactoFinal.d.ts

@@ -0,0 +1,3 @@
+import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
+import type { tokenType, tokenTypeStruct } from "./helpers/tokenType";
+export declare function getTokenTypeRound3(index: number, type: tokenType, typeInfo: any, calls: Multicall3.ResultStructOutput[]): tokenTypeStruct;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound4RefactoFinal.d.ts

@@ -0,0 +1,4 @@
+import type { Campaign, CampaignParameters } from "@sdk";
+import type { Multicall3 } from "libs/sdk/src/generated/Multicall";
+import type { tokenType, tokenTypeStruct } from "./helpers/tokenType";
+export declare function getTokenTypeRound4(index: number, type: tokenType, typeInfo: any, calls: Multicall3.ResultStructOutput[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;

package/dist/src/libs/campaigns/campaignsDynamicDataRefacto.d.ts

@@ -0,0 +1,3 @@
+import { Campaign, type CampaignDynamicData, type CampaignParameters, type MerklChainId } from "@sdk";
+import type { UncachedResult } from "../../utils/execute";
+export declare function campaignsDynamicDataRefacto<T extends Campaign>(chainId: MerklChainId, campaigns: CampaignParameters<T>[], type: T, nextVersion?: boolean): Promise<UncachedResult<Partial<CampaignDynamicData<T>[]>>>;

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

@@ -122,18 +122,6 @@ export declare abstract class OpportunityRepository {
                 verified: boolean;
                 price: number | null;
             };
-            RewardBreakdown: {
-                id: number;
-                protocolId: string | null;
-                reason: string;
-                amount: string;
-                claimed: string;
-                pending: string;
-                auxiliaryData1: string | null;
-                auxiliaryData2: string | null;
-                rewardId: string;
-                campaignId: string;
-            }[];
         } & {
             id: string;
             computeChainId: number;

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

@@ -145,6 +145,7 @@ export declare abstract class RewardRepository {
         rewardId: string;
         campaignId: string;
     }[]>;
+    static findManyRootsWithRewardOnChain(chainId: number): Promise<string[]>;
     static breakdownForCampaigns(root: string, campaignIds: string[], query: CampaignIdListModel): Promise<{
         Campaign: {
             identifier: string;

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

@@ -74,7 +74,7 @@ export declare abstract class RewardService {
      * @param reward straight from db
      * @returns a Reward model
      */
-    static format(reward: Awaited<ReturnType<typeof RewardRepository.getByRecipient>>[number]): {
+    static format(rewards: Awaited<ReturnType<typeof RewardRepository.getByRecipient>>): {
         token: {
             id: string;
             name: string | null;
@@ -148,10 +148,10 @@ export declare abstract class RewardService {
         root: string;
         recipient: string;
         proofs: string[];
-    };
+    }[];
     static createManyBreakdown(data: CreateManyBreakdownModel): Promise<import("../../../../database/api/.generated").Prisma.BatchPayload>;
-    static getByRecipient(recipient: string, roots: string[], withToken?: boolean): Promise<{
-        token: {
+    static getByRecipient(recipient: string, roots: string[], withToken?: boolean): Promise<({
+        RewardToken: {
             id: string;
             name: string | null;
             chainId: number;
@@ -162,69 +162,77 @@ export declare abstract class RewardService {
             verified: boolean;
             price: number | null;
         };
-        breakdowns: {
-            campaignId: string;
-            opportunity: {
-                Chain: {
-                    id: number;
-                    name: string;
-                    icon: string;
-                };
-                Tokens: {
+        Breakdown: ({
+            Campaign: {
+                identifier: string;
+                campaignId: string;
+                Opportunity: {
+                    Chain: {
+                        id: number;
+                        name: string;
+                        icon: string;
+                    };
+                    Tokens: {
+                        id: string;
+                        name: string | null;
+                        chainId: number;
+                        address: string;
+                        decimals: number;
+                        symbol: string;
+                        icon: string;
+                        verified: boolean;
+                        price: number | null;
+                    }[];
+                    Protocols: {
+                        id: string;
+                        tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
+                        name: string;
+                        description: string;
+                        url: string;
+                        icon: string;
+                    }[];
+                    MainProtocol: {
+                        id: string;
+                        tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
+                        name: string;
+                        description: string;
+                        url: string;
+                        icon: string;
+                    } | null;
+                } & {
                     id: string;
-                    name: string | null;
                     chainId: number;
-                    address: string;
-                    decimals: number;
-                    symbol: string;
-                    icon: string;
-                    verified: boolean;
-                    price: number | null;
-                }[];
-                Protocols: {
-                    id: string;
-                    tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
-                    name: string;
-                    description: string;
-                    url: string;
-                    icon: string;
-                }[];
-                MainProtocol: {
-                    id: string;
-                    tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
+                    type: import("../../../../database/api/.generated").$Enums.CampaignType;
+                    identifier: string;
                     name: string;
-                    description: string;
-                    url: string;
-                    icon: string;
-                } | null;
-            } & {
-                id: string;
-                chainId: number;
-                type: import("../../../../database/api/.generated").$Enums.CampaignType;
-                identifier: string;
-                name: string;
-                status: import("../../../../database/api/.generated").$Enums.Status;
-                action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
-                mainProtocolId: string | null;
-                tvl: number;
-                apr: number;
-                dailyRewards: number;
-                tags: string[];
+                    status: import("../../../../database/api/.generated").$Enums.Status;
+                    action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
+                    mainProtocolId: string | null;
+                    tvl: number;
+                    apr: number;
+                    dailyRewards: number;
+                    tags: string[];
+                };
             };
+        } & {
+            id: number;
+            protocolId: string | null;
             reason: string;
             amount: string;
             claimed: string;
             pending: string;
             auxiliaryData1: string | null;
             auxiliaryData2: string | null;
-        }[];
-        claimed: bigint;
-        amount: bigint;
-        pending: bigint;
+            rewardId: string;
+            campaignId: string;
+        })[];
+    } & {
+        id: string;
         root: string;
         recipient: string;
+        rewardTokenId: string;
         proofs: string[];
-    }[]>;
+    })[]>;
     /**
      * Groups a breakdown array by their corresponding opportunities
      * @param breakdowns with campaignIds
@@ -247,7 +255,7 @@ export declare abstract class RewardService {
      */
     static splitRewardsBreakdownByOpportunity(rewards: Awaited<ReturnType<typeof RewardService.getUserRewardsByChain>>): (Omit<{
         chain: Chain;
-        rewards: Awaited<ReturnType<(typeof RewardService)["getByRecipient"]>>;
+        rewards: Awaited<ReturnType<(typeof RewardService)["format"]>>;
     }, "rewards"> & {
         rewards: (Omit<{
             token: {
@@ -337,7 +345,7 @@ export declare abstract class RewardService {
     })[];
     static removeOpportunityFromRewardBreakdown(rewards: Awaited<ReturnType<typeof RewardService.getUserRewardsByChain>>): (Omit<{
         chain: Chain;
-        rewards: Awaited<ReturnType<(typeof RewardService)["getByRecipient"]>>;
+        rewards: Awaited<ReturnType<(typeof RewardService)["format"]>>;
     }, "rewards"> & {
         rewards: (Omit<{
             token: {
@@ -425,8 +433,9 @@ export declare abstract class RewardService {
             }[];
         })[];
     })[];
-    static checkLastClaim(chainId: number, user: string, roots: CacheKeys["CurrentRoot"]["returns"], rewards: Awaited<ReturnType<typeof RewardService.getByRecipient>>): Promise<{
-        token: {
+    static findManyRootsOnChain(chainId: ChainId): Promise<any>;
+    static checkLastClaim(chainId: number, user: string, roots: CacheKeys["CurrentRoot"]["returns"], rewards: Awaited<ReturnType<typeof RewardService.getByRecipient>>): Promise<({
+        RewardToken: {
             id: string;
             name: string | null;
             chainId: number;
@@ -437,72 +446,80 @@ export declare abstract class RewardService {
             verified: boolean;
             price: number | null;
         };
-        breakdowns: {
-            campaignId: string;
-            opportunity: {
-                Chain: {
-                    id: number;
-                    name: string;
-                    icon: string;
-                };
-                Tokens: {
+        Breakdown: ({
+            Campaign: {
+                identifier: string;
+                campaignId: string;
+                Opportunity: {
+                    Chain: {
+                        id: number;
+                        name: string;
+                        icon: string;
+                    };
+                    Tokens: {
+                        id: string;
+                        name: string | null;
+                        chainId: number;
+                        address: string;
+                        decimals: number;
+                        symbol: string;
+                        icon: string;
+                        verified: boolean;
+                        price: number | null;
+                    }[];
+                    Protocols: {
+                        id: string;
+                        tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
+                        name: string;
+                        description: string;
+                        url: string;
+                        icon: string;
+                    }[];
+                    MainProtocol: {
+                        id: string;
+                        tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
+                        name: string;
+                        description: string;
+                        url: string;
+                        icon: string;
+                    } | null;
+                } & {
                     id: string;
-                    name: string | null;
                     chainId: number;
-                    address: string;
-                    decimals: number;
-                    symbol: string;
-                    icon: string;
-                    verified: boolean;
-                    price: number | null;
-                }[];
-                Protocols: {
-                    id: string;
-                    tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
-                    name: string;
-                    description: string;
-                    url: string;
-                    icon: string;
-                }[];
-                MainProtocol: {
-                    id: string;
-                    tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
+                    type: import("../../../../database/api/.generated").$Enums.CampaignType;
+                    identifier: string;
                     name: string;
-                    description: string;
-                    url: string;
-                    icon: string;
-                } | null;
-            } & {
-                id: string;
-                chainId: number;
-                type: import("../../../../database/api/.generated").$Enums.CampaignType;
-                identifier: string;
-                name: string;
-                status: import("../../../../database/api/.generated").$Enums.Status;
-                action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
-                mainProtocolId: string | null;
-                tvl: number;
-                apr: number;
-                dailyRewards: number;
-                tags: string[];
+                    status: import("../../../../database/api/.generated").$Enums.Status;
+                    action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
+                    mainProtocolId: string | null;
+                    tvl: number;
+                    apr: number;
+                    dailyRewards: number;
+                    tags: string[];
+                };
             };
+        } & {
+            id: number;
+            protocolId: string | null;
             reason: string;
             amount: string;
             claimed: string;
             pending: string;
             auxiliaryData1: string | null;
             auxiliaryData2: string | null;
-        }[];
-        claimed: bigint;
-        amount: bigint;
-        pending: bigint;
+            rewardId: string;
+            campaignId: string;
+        })[];
+    } & {
+        id: string;
         root: string;
         recipient: string;
+        rewardTokenId: string;
         proofs: string[];
-    }[]>;
+    })[]>;
     static getUserRewardsByChain(user: string, withToken: boolean, chainFilter?: ChainId[]): Promise<{
         chain: Chain;
-        rewards: Awaited<ReturnType<(typeof RewardService)["getByRecipient"]>>;
+        rewards: Awaited<ReturnType<(typeof RewardService)["format"]>>;
     }[]>;
     static updatePendings(data: UpdatePendingModel): Promise<boolean>;
     static count(): Promise<Record<string, {