@merkl/api 0.10.181 → 0.10.183

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

@@ -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;
@@ -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: {};
@@ -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

@@ -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/campaignsDynamicData.js

@@ -1,4 +1,3 @@
-import { log } from "../../utils/logger";
 import { engineDbClient } from "../../utils/prisma";
 import { Campaign } from "@sdk";
 import { getAddress } from "ethers/lib/utils";
@@ -25,9 +24,7 @@ export async function campaignsDynamicData(chainId, campaigns, type) {
             campaign.tags = tags[getAddress(campaign.creator)] || [];
         }
     }
-    catch (_err) {
-        log.warn("No tags assigned to creator address in database");
-    }
+    catch (_err) { }
     switch (type) {
         case Campaign.ERC20: {
             const switchRefacto = process.env.SWITCH_REFACTO_SUBTYPES_ERC20 !== undefined ? process.env.SWITCH_REFACTO_SUBTYPES_ERC20 : false;

package/dist/src/libs/campaigns/campaignsDynamicDataRefacto.js

@@ -1,7 +1,6 @@
 import { engineDbClient } from "../../utils/prisma";
 import { Campaign } from "@sdk";
 import { getAddress } from "ethers/lib/utils";
-import { log } from "../../utils/logger";
 import { AjnaDynamicData } from "./campaignTypes/AjnaDynamicData";
 import { BadgerDynamicData } from "./campaignTypes/BadgerDynamicData";
 import { CLAMMDynamicData } from "./campaignTypes/CLAMMDynamicData";
@@ -24,9 +23,7 @@ export async function campaignsDynamicDataRefacto(chainId, campaigns, type, next
             campaign.tags = tags[getAddress(campaign.creator)] || [];
         }
     }
-    catch (e) {
-        log.warn("No tags assigned to creator address in database");
-    }
+    catch (e) { }
     switch (type) {
         case Campaign.ERC20: {
             return ERC20DynamicDataRefacto(chainId, campaigns);

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";

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

@@ -2366,6 +2366,26 @@ export declare const v4: Elysia<"/v4", false, {
             };
         };
     };
+} & {
+    v4: {
+        claims: {
+            ":address": {
+                get: {
+                    body: unknown;
+                    params: {
+                        address: string;
+                    };
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: (import("./claims").ClaimModel & {
+                            token: import("./token").Token["model"];
+                        })[];
+                    };
+                };
+            };
+        };
+    };
 }, {
     derive: {};
     resolve: {};

package/dist/src/modules/v4/router.js

@@ -15,6 +15,7 @@ import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-node";
 import { PrismaInstrumentation } from "@prisma/instrumentation";
 import Elysia from "elysia";
+import { ClaimController } from "./claims";
 import { DynamicDataController } from "./dynamicData";
 import { InteractionController } from "./interaction/interaction.controller";
 import { LiquidityController } from "./liquidity/liquidity.controller";
@@ -59,4 +60,5 @@ export const v4 = new Elysia({ tags: ["v4"], prefix: "/v4" })
     .use(AccountingController)
     .use(DynamicDataController)
     .use(StatusController)
-    .use(LiquidityController);
+    .use(LiquidityController)
+    .use(ClaimController);

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

@@ -21,5 +21,6 @@ export declare const GetManyUserQuery: import("@sinclair/typebox").TObject<{
 export declare const UpdateUserTagsDto: import("@sinclair/typebox").TObject<{
     tags: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
 }>;
+export type UserUniqueModel = typeof UserUniqueDto.static;
 export type UserModel = typeof UserDto.static;
 export type GetManyUserModel = typeof GetManyUserQuery.static;

package/dist/src/routes/v3/blacklist.d.ts

@@ -2390,6 +2390,26 @@ declare const _default: (app: App) => import("elysia").default<"", 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"];
+                        })[];
+                    };
+                };
+            };
+        };
+    };
 } & {
     index: {
         get: {

package/dist/src/routes/v3/campaigns.d.ts

@@ -2393,6 +2393,26 @@ declare const _default: (app: App) => import("elysia").default<"", 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"];
+                        })[];
+                    };
+                };
+            };
+        };
+    };
 } & {
     index: {
         get: {

package/dist/src/routes/v3/campaignsInfo.d.ts

@@ -2384,6 +2384,26 @@ declare const _default: (app: App) => import("elysia").default<"", 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"];
+                        })[];
+                    };
+                };
+            };
+        };
+    };
 } & {
     index: {
         post: {

package/dist/src/routes/v3/multiChainPositions.d.ts

@@ -2389,6 +2389,26 @@ declare const _default: (app: App) => import("elysia").default<"", 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"];
+                        })[];
+                    };
+                };
+            };
+        };
+    };
 } & {
     index: {
         get: {

package/dist/src/routes/v3/opportunity.d.ts

@@ -2407,6 +2407,26 @@ declare const _default: (app: App) => import("elysia").default<"", 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"];
+                        })[];
+                    };
+                };
+            };
+        };
+    };
 } & {
     index: {
         get: {

package/dist/src/routes/v3/positions.d.ts

@@ -2408,6 +2408,26 @@ declare const _default: (app: App) => import("elysia").default<"", 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"];
+                        })[];
+                    };
+                };
+            };
+        };
+    };
 } & {
     index: {
         get: {

package/dist/src/routes/v3/rewards.d.ts

@@ -2390,6 +2390,26 @@ declare const _default: (app: App) => import("elysia").default<"", 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"];
+                        })[];
+                    };
+                };
+            };
+        };
+    };
 } & {
     index: {
         get: {

package/dist/src/routes/v3/updates.d.ts

@@ -2391,6 +2391,26 @@ declare const _default: (app: App) => import("elysia").default<"", 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"];
+                        })[];
+                    };
+                };
+            };
+        };
+    };
 } & {
     index: {
         get: {

package/dist/src/routes/v3/userRewards.d.ts

@@ -2393,6 +2393,26 @@ declare const _default: (app: App) => import("elysia").default<"", 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"];
+                        })[];
+                    };
+                };
+            };
+        };
+    };
 } & {
     index: {
         get: {