@merkl/api 0.10.180 → 0.10.182

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

@@ -788,7 +788,7 @@ declare const eden: {
                     };
                     fetch?: RequestInit | undefined;
                 }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                    200: {
+                    200: ({
                         symbol: string;
                         name: string | null;
                         id: string;
@@ -796,11 +796,11 @@ declare const eden: {
                         address: string;
                         icon: string;
                         decimals: number;
-                        displaySymbol: string;
                         verified: boolean;
                         isTest: boolean;
-                        price: number | null;
-                    }[];
+                    } & {
+                        price?: number | null | undefined;
+                    })[];
                 }>>;
             };
             count: {
@@ -1914,6 +1914,19 @@ declare const eden: {
                 }>>;
             };
         };
+        claims: ((params: {
+            address: string | number;
+        }) => {
+            get: (options?: {
+                headers?: Record<string, unknown> | undefined;
+                query?: Record<string, unknown> | undefined;
+                fetch?: RequestInit | undefined;
+            } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                200: (import("../modules/v4/claims").ClaimModel & {
+                    token: import("../modules/v4").Token["model"];
+                })[];
+            }>>;
+        }) & {};
     };
 };
 type Api = typeof eden;
@@ -2826,7 +2839,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     };
                     headers: unknown;
                     response: {
-                        200: {
+                        200: ({
                             symbol: string;
                             name: string | null;
                             id: string;
@@ -2834,11 +2847,11 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                             address: string;
                             icon: string;
                             decimals: number;
-                            displaySymbol: string;
                             verified: boolean;
                             isTest: boolean;
-                            price: number | null;
-                        }[];
+                        } & {
+                            price?: number | null | undefined;
+                        })[];
                     };
                 };
             };
@@ -4309,6 +4322,26 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
             };
         };
     };
+} & {
+    v4: {
+        claims: {
+            ":address": {
+                get: {
+                    body: unknown;
+                    params: {
+                        address: string;
+                    };
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: (import("../modules/v4/claims").ClaimModel & {
+                            token: import("../modules/v4").Token["model"];
+                        })[];
+                    };
+                };
+            };
+        };
+    };
 }, {
     derive: {};
     resolve: {};
@@ -5105,7 +5138,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     };
                     fetch?: RequestInit | undefined;
                 }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                    200: {
+                    200: ({
                         symbol: string;
                         name: string | null;
                         id: string;
@@ -5113,11 +5146,11 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                         address: string;
                         icon: string;
                         decimals: number;
-                        displaySymbol: string;
                         verified: boolean;
                         isTest: boolean;
-                        price: number | null;
-                    }[];
+                    } & {
+                        price?: number | null | undefined;
+                    })[];
                 }>>;
             };
             count: {
@@ -6231,6 +6264,19 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 }>>;
             };
         };
+        claims: ((params: {
+            address: string | number;
+        }) => {
+            get: (options?: {
+                headers?: Record<string, unknown> | undefined;
+                query?: Record<string, unknown> | undefined;
+                fetch?: RequestInit | undefined;
+            } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                200: (import("../modules/v4/claims").ClaimModel & {
+                    token: import("../modules/v4").Token["model"];
+                })[];
+            }>>;
+        }) & {};
     };
 };
 export type Opportunity = FromPromise<Api["v4"]["opportunities"]["index"]["get"]>;

package/dist/src/index.d.ts

@@ -901,7 +901,7 @@ declare const app: Elysia<"", false, {
                     };
                     headers: unknown;
                     response: {
-                        200: {
+                        200: ({
                             symbol: string;
                             name: string | null;
                             id: string;
@@ -909,11 +909,11 @@ declare const app: Elysia<"", false, {
                             address: string;
                             icon: string;
                             decimals: number;
-                            displaySymbol: string;
                             verified: boolean;
                             isTest: boolean;
-                            price: number | null;
-                        }[];
+                        } & {
+                            price?: number | null | undefined;
+                        })[];
                     };
                 };
             };
@@ -2384,6 +2384,26 @@ declare const app: Elysia<"", false, {
             };
         };
     };
+} & {
+    v4: {
+        claims: {
+            ":address": {
+                get: {
+                    body: unknown;
+                    params: {
+                        address: string;
+                    };
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: (import("./modules/v4/claims").ClaimModel & {
+                            token: import("./modules/v4").Token["model"];
+                        })[];
+                    };
+                };
+            };
+        };
+    };
 }, {
     derive: {};
     resolve: {};

package/dist/src/libs/campaigns/campaignTypes/ERC20DynamicDataRefacto.js

@@ -64,7 +64,7 @@ export async function ERC20DynamicDataRefacto(chainId, campaigns) {
             calls: [],
             typeInfo: {},
         };
-        typeStruct = getTokenTypeRound1(resultRound1, campaign.campaignParameters.targetToken, i);
+        typeStruct = getTokenTypeRound1(resultRound1, campaign.campaignParameters.targetToken, i, campaign);
         i += 5;
         tokenTypesByCampaign[campaign.campaignId] = typeStruct;
         callsRounds2.push(...typeStruct.calls);
@@ -124,8 +124,8 @@ export async function ERC20DynamicDataRefacto(chainId, campaigns) {
                     const callsForCampaign = tokenTypesByCampaign[campaign.campaignId].calls.length;
                     tokenTypesByCampaign[campaign.campaignId] = await getTokenPricesInfo(i, tokenTypesByCampaign[campaign.campaignId].type, tokenTypesByCampaign[campaign.campaignId].typeInfo, result, campaign, pricer);
                     i += callsForCampaign;
-                    const totalSupplyTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.totalSupply;
                     const whitelistedSupplyTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.whitelistedSupplyTargetToken;
+                    const totalSupplyTargetToken = whitelistedSupplyTargetToken;
                     const priceTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.priceTargetToken;
                     let lastEligibilityRatio = 1;
                     if (!!campaign.campaignParameters.hooks?.length) {
@@ -141,7 +141,7 @@ export async function ERC20DynamicDataRefacto(chainId, campaigns) {
                             campaign.campaignParameters.duration /
                             (whitelistedSupplyTargetToken * priceTargetToken),
                         totalSupplyTargetToken,
-                        tvl: totalSupplyTargetToken * priceTargetToken,
+                        tvl: whitelistedSupplyTargetToken * priceTargetToken,
                         type: tokenTypesByCampaign[campaign.campaignId].type,
                         typeInfo: tokenTypesByCampaign[campaign.campaignId].typeInfo,
                         priceRewardToken: priceRewardToken,

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType.d.ts

@@ -57,7 +57,8 @@ export declare enum tokenType {
     pendleYT = "pendleYT",
     pancakeswap = "pancakeswap",
     tempestStaking = "tempestStaking",
-    holdstation = "holdstation"
+    holdstation = "holdstation",
+    staking = "staking"
 }
 export declare const tokenTypeToProtocol: {
     [key in tokenType]: {

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType.js

@@ -59,6 +59,7 @@ export var tokenType;
     tokenType["pancakeswap"] = "pancakeswap";
     tokenType["tempestStaking"] = "tempestStaking";
     tokenType["holdstation"] = "holdstation";
+    tokenType["staking"] = "staking";
 })(tokenType || (tokenType = {}));
 export const tokenTypeToProtocol = {
     [tokenType.aave_borrowing]: { protocol: "Aave" },
@@ -139,4 +140,7 @@ export const tokenTypeToProtocol = {
     [tokenType.holdstation]: {
         protocol: "HoldStation",
     },
+    [tokenType.staking]: {
+        protocol: "Staking",
+    },
 };

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

@@ -21,6 +21,7 @@ type callKeysAura = mandatoryCallKeys & {
     pid: string;
     gaugeBalance: string;
     auraBalance: string;
+    vaultBalance: string;
 };
 type dataRawAura = callKeysAura & {
     poolTokensRaw: Array<string[] | BigNumber[]>;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/AuraProcessor.js

@@ -2,6 +2,7 @@ import { decodeCall } from "../../../../../utils/decodeCalls";
 import { createCall } from "../../../../../utils/encodeCalls";
 import { generateCardName } from "../../../../../utils/generateCardName";
 import { BN2Number } from "@sdk";
+import { utils } from "ethers";
 import { GenericProcessor, roundType } from "./GenericProcessor";
 export class AuraProcessor extends GenericProcessor {
     rounds = {
@@ -21,6 +22,7 @@ export class AuraProcessor extends GenericProcessor {
             { key: "poolTokensRaw", call: "getPoolTokens", target: "vault", metaData: "poolId" },
             { key: "gaugeBalance", call: "balanceOf", target: "balancerPool", metaData: "gaugeContract" },
             { key: "auraBalance", call: "balanceOf", target: "gaugeContract", metaData: "auraStaker" },
+            { key: "vaultBalance", call: "balanceOf", target: "balancerPool", metaData: "vault" },
             { key: "totalSupplyGauge", call: "totalSupply", target: "gaugeContract" },
         ],
         round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
@@ -43,8 +45,15 @@ export class AuraProcessor extends GenericProcessor {
         }
     }
     async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
-        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
-        const totalSupplyBalancerPool = BN2Number(typeInfo.totalSupplyBalancerPool, 18);
+        let { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        const vaultBalance = BN2Number(typeInfo.vaultBalance, 18);
+        const vaultIndex = campaign.campaignParameters.blacklist
+            ?.map(b => utils.getAddress(b))
+            ?.indexOf(utils.getAddress(typeInfo.vault));
+        if (vaultIndex !== -1) {
+            blacklistedSupply -= BN2Number(decodeCall(calls, index + vaultIndex, "balanceOf"), campaign.campaignParameters.decimalsTargetToken); // The vault balance was already removed from the total supply
+        }
+        const totalSupplyBalancerPool = BN2Number(typeInfo.totalSupplyBalancerPool, 18) - vaultBalance;
         const gaugeBalance = BN2Number(typeInfo.gaugeBalance, 18);
         const auraBalance = BN2Number(typeInfo.auraBalance, 18);
         const totalSupplyGauge = BN2Number(typeInfo.totalSupplyGauge, 18);
@@ -66,7 +75,7 @@ export class AuraProcessor extends GenericProcessor {
         }
         const percentageOfSupplyInAura = (auraBalance / totalSupplyGauge) * (gaugeBalance / totalSupplyBalancerPool);
         const tvl = poolTvl * percentageOfSupplyInAura;
-        const priceTargetToken = tvl / totalSupply;
+        const priceTargetToken = tvl / totalSupplyBalancerPool;
         return {
             ...typeInfo,
             totalSupplyBalancerPool,

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

@@ -1,5 +1,5 @@
 import type { Pricer } from "../../../../../utils/pricer";
-import { type Campaign, type CampaignParameters } from "@sdk";
+import type { Campaign, CampaignParameters } from "@sdk";
 import type { tokenType } from "../helpers/tokenType";
 import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
 type callType = {

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/PendleProcessor.js

@@ -1,5 +1,4 @@
 import { generateCardName } from "../../../../../utils/generateCardName";
-import { ChainId } from "@sdk";
 import { GenericProcessor } from "./GenericProcessor";
 export class PendleProcessor extends GenericProcessor {
     rounds = {
@@ -14,8 +13,7 @@ export class PendleProcessor extends GenericProcessor {
     async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
         const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
         const priceTargetToken = (await pricer.get({
-            address: typeInfo.tokenAddress,
-            chainId: ChainId.MAINNET,
+            symbol: typeInfo.tokenAddress,
         })) ?? 0;
         const tvl = priceTargetToken * totalSupply;
         return {

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

@@ -0,0 +1,39 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import type { Campaign, CampaignParameters } from "@sdk";
+import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawStaking;
+    call: string;
+    target: keyof callKeysStaking;
+    metaData?: keyof callKeysStaking;
+    optional?: boolean;
+};
+type callKeysStaking = mandatoryCallKeys & {
+    stakingContract: string;
+    lockNFT: string;
+    stakingSymbol: string;
+};
+type dataRawStaking = callKeysStaking & {
+    eip712DomainName: string;
+};
+type dataTypeStaking = dataType & {};
+export declare class StakingProcessor extends GenericProcessor<callKeysStaking, dataRawStaking, dataTypeStaking> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound1(typeInfo: dataRawStaking): void;
+    processingRound2(typeInfo: dataRawStaking): void;
+    processingRound3(typeInfo: dataRawStaking): void;
+    processingRound4(typeInfo: dataRawStaking): void;
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawStaking, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeStaking>;
+    computeRound1(type: tokenType, typeInfo: dataRawStaking): tokenTypeStruct;
+    computeRound2(index: number, type: tokenType, typeInfo: dataRawStaking, calls: string[]): tokenTypeStruct;
+    computeRound3(index: number, type: tokenType, typeInfo: dataRawStaking, calls: string[]): tokenTypeStruct;
+    computeRound4(index: number, type: tokenType, typeInfo: dataRawStaking, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
+    computeRound5(index: number, type: tokenType, typeInfo: dataRawStaking, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<tokenTypeStruct>;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/StakingProcessor.js

@@ -0,0 +1,45 @@
+import { GenericProcessor } from "./GenericProcessor";
+export class StakingProcessor extends GenericProcessor {
+    rounds = {
+        round1: [
+            { key: "lockNFT", call: "lockNFT", target: "stakingContract", optional: true },
+            { key: "eip712DomainName", call: "eip712DomainName", target: "stakingContract", optional: true },
+        ],
+        round2: [{ key: "stakingSymbol", call: "symbol", target: "lockNFT", optional: true }],
+        round3: [],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    // override computeRound1(): void {}
+    processingRound1(typeInfo) {
+        if (typeInfo.stakingContract === "0x18eeD20f71BEf84B605253C89A7576E3634134C0") {
+            typeInfo.stakingSymbol = "CyberStaking";
+        }
+    }
+    processingRound2(typeInfo) {
+        typeInfo.stakingSymbol = typeInfo.eip712DomainName;
+    }
+    processingRound3(typeInfo) {
+        super.processingRound3(typeInfo);
+    }
+    processingRound4(typeInfo) {
+        super.processingRound4(typeInfo);
+    }
+    async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
+        return super.processingRound5(index, type, typeInfo, calls, campaign, pricer);
+    }
+    computeRound1(type, typeInfo) {
+        return super.computeRound1(type, typeInfo);
+    }
+    computeRound2(index, type, typeInfo, calls) {
+        return super.computeRound2(index, type, typeInfo, calls);
+    }
+    computeRound3(index, type, typeInfo, calls) {
+        return super.computeRound3(index, type, typeInfo, calls);
+    }
+    computeRound4(index, type, typeInfo, calls, campaign) {
+        return super.computeRound4(index, type, typeInfo, calls, campaign);
+    }
+    async computeRound5(index, type, typeInfo, calls, campaign, pricer) {
+        return super.computeRound5(index, type, typeInfo, calls, campaign, pricer);
+    }
+}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/processorMapping.js

@@ -21,6 +21,7 @@ import { PendleYTProcessor } from "./PendleYTProcessor";
 import { RadiantProcessor } from "./RadiantProcessor";
 import { RfxProcessor } from "./RfxProcessor";
 import { SpliceProcessor } from "./SpliceProcessor";
+import { StakingProcessor } from "./StakingProcessor";
 import { SturdySiloProcessor } from "./SturdySiloProcessor";
 import { TempestVaultProcessor } from "./TempestVaultProcessor";
 import { TorosProcessor } from "./TorosProcessor";
@@ -88,4 +89,5 @@ export const processorMapping = {
     [tokenType.pancakeswap]: UniswapProcessor,
     [tokenType.tempestStaking]: TempestVaultProcessor,
     [tokenType.holdstation]: HoldStationProcessor,
+    [tokenType.staking]: StakingProcessor,
 };

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

@@ -1,3 +1,4 @@
+import type { Campaign, CampaignParameters } from "@sdk";
 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;
+export declare function getTokenTypeRound1(calls: Multicall3.ResultStructOutput[], targetToken: string, index: number, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>): tokenTypeStruct;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/subtypesRound1RefactoFinal.js

@@ -179,7 +179,27 @@ function parseForBalancer(calls, index, targetToken, name) {
         // Not a balancer pool
     }
 }
-export function getTokenTypeRound1(calls, targetToken, index) {
+function parseForStaking(campaign, calls, index, targetToken) {
+    try {
+        const whitelist = campaign.campaignParameters.whitelist;
+        console.log("whitelist", whitelist, whitelist.length);
+        if (whitelist.length === 1) {
+            const forwarders = campaign.campaignParameters.forwarders;
+            console.log("forwarders", forwarders);
+            if (forwarders.length === 1) {
+                if (forwarders[0].sender === whitelist[0]) {
+                    const name = decodeCall(calls, index + 2, "name");
+                    return generateResult(tokenType.staking, name, targetToken, { stakingContract: whitelist[0] });
+                }
+            }
+        }
+    }
+    catch (e) {
+        // No factory on this token
+        // console.log(e);
+    }
+}
+export function getTokenTypeRound1(calls, targetToken, index, campaign) {
     const returnValueOfCalls = calls.map(call => call.returnData);
     let result = parseForFactory(returnValueOfCalls, index, targetToken);
     if (result)
@@ -188,6 +208,10 @@ export function getTokenTypeRound1(calls, targetToken, index) {
     if (result)
         return result;
     result = parseForMetamorpho(returnValueOfCalls, index, targetToken);
+    if (result)
+        return result;
+    console.log("parsing for staking");
+    result = parseForStaking(campaign, returnValueOfCalls, index, targetToken);
     if (result)
         return result;
     let name;

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

@@ -0,0 +1,40 @@
+import Elysia from "elysia";
+export declare const ClaimController: Elysia<"/claims", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    claims: {
+        ":address": {
+            get: {
+                body: unknown;
+                params: {
+                    address: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: (import("./claims.model").ClaimModel & {
+                        token: import("..").Token["model"];
+                    })[];
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

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

@@ -0,0 +1,13 @@
+import { throwOnInvalidRequiredAddress } from "../../../utils/throw";
+import Elysia from "elysia";
+import { UserUniqueDto } from "../user";
+import { ClaimService } from "./claims.service";
+// ─── Claim Controller ───────────────────────────────────────────────────────
+export const ClaimController = new Elysia({ prefix: "/claims", detail: { tags: ["Claims"] } })
+    // ─── Get Historical Claims ────────────────────────────────────────────
+    .get("/:address", async ({ params }) => await ClaimService.getHistoricalClaims(params), {
+    params: UserUniqueDto,
+    beforeHandle: ({ params }) => {
+        params.address = throwOnInvalidRequiredAddress(params.address);
+    },
+});

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

@@ -0,0 +1,9 @@
+export type ClaimModel = {
+    timestamp: number;
+    token: string;
+    user: string;
+    amount: string;
+    rawAmount: string;
+    root: string;
+    txHash?: string;
+};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,5 @@
+import { type MerklChainId } from "@sdk";
+import type { ClaimModel } from "./claims.model";
+export declare class ClaimRepository {
+    static fetch(chainId: MerklChainId, address: string): Promise<ClaimModel[]>;
+}

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

@@ -0,0 +1,39 @@
+import { merklSubgraphClaimsEndpoints } from "@sdk";
+import request, { gql } from "graphql-request";
+export class ClaimRepository {
+    static async fetch(chainId, address) {
+        try {
+            return (await request(merklSubgraphClaimsEndpoints[chainId], 
+            // Request is limited to first 100 by default so needs to be sorted
+            gql `query MerklClaims($user: String) {
+              merklClaims(where: {user: $user }, orderBy: timestamp, orderDirection: desc) {
+                timestamp
+                token
+                user
+                amount
+                rawAmount
+                root
+                id
+                txHash
+              }
+            }
+    `, { user: address?.toLowerCase() })).merklClaims;
+        }
+        catch {
+            return (await request(merklSubgraphClaimsEndpoints[chainId], 
+            // Request is limited to first 100 by default so needs to be sorted
+            gql `query MerklClaims($user: String) {
+                merklClaims(where: {user: $user }, orderBy: timestamp, orderDirection: desc) {
+                  timestamp
+                  token
+                  user
+                  amount
+                  rawAmount
+                  root
+                  id
+                }
+              }
+      `, { user: address?.toLowerCase() })).merklClaims;
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+import type { Token } from "../token";
+import type { UserUniqueModel } from "../user";
+import type { ClaimModel } from "./claims.model";
+export declare abstract class ClaimService {
+    static getHistoricalClaims(params: UserUniqueModel): Promise<(ClaimModel & {
+        token: Token["model"];
+    })[]>;
+}

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

@@ -0,0 +1,31 @@
+import { MerklRootService } from "../merklRoot";
+import { RewardService } from "../reward";
+import { ClaimRepository } from "./claims.repository";
+export class ClaimService {
+    // ─── Get Historical Claims ─────────────────────────────────────────────────
+    static async getHistoricalClaims(params) {
+        const roots = (await MerklRootService.fetchAll()).map(r => r.live);
+        const rewards = await RewardService.getByRecipient(params.address, roots, true);
+        const chainIds = [];
+        for (const reward of rewards) {
+            if (!chainIds.includes(reward.RewardToken.chainId)) {
+                chainIds.push(reward.RewardToken.chainId);
+            }
+        }
+        const tokens = rewards.reduce((acc, reward) => {
+            acc[reward.RewardToken.address.toLowerCase()] = reward.RewardToken;
+            return acc;
+        }, {});
+        const promises = await Promise.allSettled(chainIds.map(chainId => ClaimRepository.fetch(chainId, params.address)));
+        const claims = await promises
+            .filter(p => p.status === "fulfilled")
+            .flatMap(p => p.value)
+            .map(claim => {
+            return {
+                ...claim,
+                token: tokens[claim.token.toLowerCase()],
+            };
+        });
+        return claims.sort((a, b) => Number(b.timestamp) - Number(a.timestamp));
+    }
+}

package/dist/src/modules/v4/claims/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./claims.model";
+export * from "./claims.service";
+export * from "./claims.controller";

package/dist/src/modules/v4/claims/index.js

@@ -0,0 +1,3 @@
+export * from "./claims.model";
+export * from "./claims.service";
+export * from "./claims.controller";