@merkl/api 0.20.53 → 0.20.55

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

@@ -1,27 +1,43 @@
 import { AuthorizationHeadersDto, BackOfficeGuard } from "@/guards/BackOffice.guard";
 import { UnsupportedNetwork } from "@/utils/error";
-import { throwOnInvalidAddress, throwOnInvalidRequiredAddress } from "@/utils/throw";
+import { throwOnInvalidAddress, throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "@/utils/throw";
 import Elysia, { t } from "elysia";
 import { CacheService } from "../cache";
 import { TTLPresets } from "../cache/cache.model";
 import { ChainUniqueDto } from "../chain/chain.model";
-import { Bytes32Dto, RewardsPerV3PositionDto, UniV4ChainIdArray, UniswapV4PoolDto, } from "./uniswap.model";
+import { Bytes32Dto, RewardsPerPositionDto, UniV4ChainIdArray, UniswapV4PoolDto, } from "./uniswap.model";
 import { UniswapService } from "./uniswap.service";
 export const UniswapController = new Elysia({
     prefix: "uniswap",
     detail: { tags: ["Uniswap"] },
 })
     .group("/reward", app => {
-    return app.get("", async ({ query }) => {
-        return await UniswapService.findV3RewardsPerPosition(query);
+    return app
+        .get("/3", async ({ query }) => {
+        return await UniswapService.findRewardsPerPosition("v3", query);
+    }, {
+        query: RewardsPerPositionDto,
+        beforeHandle: ({ query }) => {
+            query.address = throwOnInvalidRequiredAddress(query.address);
+            if (!!query.chainId)
+                throwOnUnsupportedChainId(query.chainId);
+            query.pool = throwOnInvalidAddress(query.pool);
+        },
+        detail: {
+            description: "Get rewards earned grouped by pool and Uniswap V3 position. Warning: this endpoint is still in beta.",
+        },
+    })
+        .get("/4", async ({ query }) => {
+        return await UniswapService.findRewardsPerPosition("v4", query);
     }, {
-        query: RewardsPerV3PositionDto,
+        query: RewardsPerPositionDto,
         beforeHandle: ({ query }) => {
             query.address = throwOnInvalidRequiredAddress(query.address);
-            query.poolAddress = throwOnInvalidAddress(query.poolAddress);
+            if (!!query.chainId)
+                throwOnUnsupportedChainId(query.chainId);
         },
         detail: {
-            description: "Get rewards earned grouped by pool and uniswap v3 position",
+            description: "Get rewards earned grouped by pool and Uniswap V4 position. Warning: this endpoint is still in beta.",
         },
     });
 })

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

@@ -30,9 +30,10 @@ export declare const UniswapV4PoolDto: import("@sinclair/typebox").TObject<{
 export declare const Bytes32Dto: import("@sinclair/typebox").TObject<{
     poolId: import("@sinclair/typebox").TRegExp;
 }>;
-export declare const RewardsPerV3PositionDto: import("@sinclair/typebox").TObject<{
+export declare const RewardsPerPositionDto: import("@sinclair/typebox").TObject<{
     address: import("@sinclair/typebox").TString;
-    poolAddress: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    pool: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     positionId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
 }>;
 export declare const UniswapV4PoolsDto: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TObject<{
@@ -49,4 +50,4 @@ export declare const UniswapV4PoolsDto: import("@sinclair/typebox").TRecord<impo
     symbolCurrency1: import("@sinclair/typebox").TString;
     tickSpacing: import("@sinclair/typebox").TNumber;
 }>>;
-export type RewardsPerPositionModel = typeof RewardsPerV3PositionDto.static;
+export type RewardsPerPositionModel = typeof RewardsPerPositionDto.static;

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

@@ -33,10 +33,11 @@ export const Bytes32Dto = t.Object({
         description: "A 32-byte hexadecimal string (bytes32)",
     }),
 });
-export const RewardsPerV3PositionDto = t.Object({
+export const RewardsPerPositionDto = t.Object({
     address: t.String({ description: "Address of the rewarded user" }),
-    poolAddress: t.Optional(t.String({
-        description: "Address of the Uniswap pool. Default: returns rewards for all pools.",
+    chainId: t.Optional(t.Numeric({ description: "Filter on Uniswap pool on a given chain. Default: returns rewards for all chains." })),
+    pool: t.Optional(t.String({
+        description: "Address Or Id of the Uniswap pool. Default: returns rewards for all pools.",
     })),
     positionId: t.Optional(t.String({
         description: "PositionId of the Uniswap position. Can be a tokenId if the position is an NFT or a bytes32 id if held directly on the pool. Default: returns rewards for all positions on the pools.",

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

@@ -1,7 +1,17 @@
 import { type MerklChainId } from "@sdk";
+import { type Opportunity } from "../opportunity";
+import type { Token } from "../token/token.model";
 import { type RewardsPerPositionModel, type UniV4ChainId, type UniswapV4PoolsReturnType } from "./uniswap.model";
 export declare abstract class UniswapService {
-    static findV3RewardsPerPosition(query: RewardsPerPositionModel): Promise<Record<string, Record<string, any[]>>>;
+    static findRewardsPerPosition(version: "v3" | "v4", query: RewardsPerPositionModel): Promise<Record<number, Record<string, Record<string, {
+        campaignId: string;
+        amount: string;
+        claimed: string;
+        pending: string;
+        reason: string;
+        rewardToken: Token["model"];
+        opportunity: Opportunity["model"];
+    }[]>>>>;
     static getUniswapV4Pools(chainId?: UniV4ChainId): Promise<UniswapV4PoolsReturnType>;
     /** @deprecated */
     static getUniswapV4PoolsForChain(chainId: MerklChainId): Promise<UniswapV4PoolsReturnType>;

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

@@ -11,10 +11,10 @@ import { RewardService } from "../reward";
 import { LoggedEntityType, UniV4ChainIdArray, } from "./uniswap.model";
 import { UniswapRepository } from "./uniswap.repository";
 export class UniswapService {
-    static async findV3RewardsPerPosition(query) {
+    static async findRewardsPerPosition(version, query) {
         /** Check if the user is blacklisted */
         const isBlacklisted = !!(await BlacklistService.isBlacklisted(query.address));
-        // pool address => NFT or Position ID => [rewards]
+        // chainId => pool => NFT or Position ID => [rewards]
         const res = {};
         if (isBlacklisted)
             return res;
@@ -25,26 +25,37 @@ export class UniswapService {
         const merkleRoots = merkleRootsPromises
             .filter(({ status }) => status === "fulfilled")
             .map(x => x.value);
-        const rewards = RewardService.format(await RewardService.getByRecipient(query.address, merkleRoots.map(({ live }) => live), true, false, null, "UniswapV3"));
+        /** Get breakdowns of rewards containing the correct version */
+        const rewards = RewardService.format(await RewardService.getByRecipient(query.address, merkleRoots.map(({ live }) => live), true, false, null, version === "v3" ? "UniswapV3" : "UniswapV4"));
         for (const reward of rewards) {
             const rewardToken = reward.token;
             for (const breakdown of reward.breakdowns) {
-                let poolAddress = breakdown.opportunity.explorerAddress;
-                if (!!poolAddress) {
-                    poolAddress = getAddress(poolAddress);
-                    res[poolAddress] = res[poolAddress] ?? {};
-                    if (!query.poolAddress || poolAddress === query.poolAddress) {
-                        const positionId = breakdown.reason.split("_")[1];
-                        if (!res[poolAddress][positionId])
-                            res[poolAddress][positionId] = [];
-                        const { opportunity, ...props } = breakdown;
-                        res[poolAddress][positionId].push({
-                            ...props,
-                            opportunity: OpportunityService.formatResponseBase(opportunity),
-                            rewardToken: rewardToken,
-                        });
+                if (version === "v3" && !breakdown.opportunity.explorerAddress)
+                    continue;
+                const pool = version === "v3" ? getAddress(breakdown.opportunity.explorerAddress) : breakdown.reason.split("_")[1];
+                const { opportunity: rawOpportunity, ...props } = breakdown;
+                const opportunity = OpportunityService.formatResponseBase(rawOpportunity);
+                const chainId = opportunity.chainId;
+                try {
+                    if (!!chainId && (!query.chainId || chainId === query.chainId)) {
+                        res[chainId] = res[chainId] ?? {};
+                        if (!!pool && (!query.pool || pool === query.pool)) {
+                            res[chainId][pool] = res[chainId][pool] ?? {};
+                            const positionId = breakdown.reason.split("_")[version === "v3" ? 1 : 2];
+                            if (!!positionId && (!query.positionId || positionId === query.positionId)) {
+                                res[chainId][pool][positionId] = res[chainId][pool][positionId] ?? [];
+                                res[chainId][pool][positionId].push({
+                                    ...props,
+                                    opportunity,
+                                    rewardToken,
+                                });
+                            }
+                        }
                     }
                 }
+                catch {
+                    log.warn(`failed to parse positionId for reason for pool ${pool} and version ${version}`);
+                }
             }
         }
         return res;