@merkl/api 0.20.38 → 0.20.40

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

@@ -3867,6 +3867,53 @@ declare const eden: {
                 }>>;
             };
         };
+        uniswap: {
+            v3: {
+                reward: {
+                    get: (options: {
+                        headers?: Record<string, unknown> | undefined;
+                        query: {
+                            poolAddress?: string | undefined;
+                            positionId?: string | undefined;
+                            address: string;
+                        };
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            [x: string]: Record<string, any[]>;
+                        };
+                    }>>;
+                };
+            };
+            v4: {
+                pools: {
+                    get: (options: {
+                        headers?: Record<string, unknown> | undefined;
+                        query: {
+                            chainId: number;
+                        };
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            [x: string]: {
+                                poolId: string;
+                                poolKey: {
+                                    hooks: string;
+                                    fee: number;
+                                    tickSpacing: number;
+                                    currency0: string;
+                                    currency1: string;
+                                };
+                                decimalsCurrency0: number;
+                                decimalsCurrency1: number;
+                                symbolCurrency0: string;
+                                symbolCurrency1: string;
+                            };
+                        };
+                    }>>;
+                };
+            };
+        };
     } | {
         derive: {};
         resolve: {};
@@ -7641,6 +7688,53 @@ declare const eden: {
                 }>>;
             };
         };
+        uniswap: {
+            v3: {
+                reward: {
+                    get: (options: {
+                        headers?: Record<string, unknown> | undefined;
+                        query: {
+                            poolAddress?: string | undefined;
+                            positionId?: string | undefined;
+                            address: string;
+                        };
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            [x: string]: Record<string, any[]>;
+                        };
+                    }>>;
+                };
+            };
+            v4: {
+                pools: {
+                    get: (options: {
+                        headers?: Record<string, unknown> | undefined;
+                        query: {
+                            chainId: number;
+                        };
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            [x: string]: {
+                                poolId: string;
+                                poolKey: {
+                                    hooks: string;
+                                    fee: number;
+                                    tickSpacing: number;
+                                    currency0: string;
+                                    currency1: string;
+                                };
+                                decimalsCurrency0: number;
+                                decimalsCurrency1: number;
+                                symbolCurrency0: string;
+                                symbolCurrency1: string;
+                            };
+                        };
+                    }>>;
+                };
+            };
+        };
     };
     v3: {
         app: {
@@ -13090,6 +13184,61 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
             };
         };
     };
+} & {
+    v4: {
+        uniswap: {
+            v3: {
+                reward: {
+                    get: {
+                        body: unknown;
+                        params: {};
+                        query: {
+                            poolAddress?: string | undefined;
+                            positionId?: string | undefined;
+                            address: string;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                [x: string]: Record<string, any[]>;
+                            };
+                        };
+                    };
+                };
+            };
+        } & {
+            v4: {
+                pools: {
+                    get: {
+                        body: unknown;
+                        params: {};
+                        query: {
+                            chainId: number;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                [x: string]: {
+                                    poolId: string;
+                                    poolKey: {
+                                        hooks: string;
+                                        fee: number;
+                                        tickSpacing: number;
+                                        currency0: string;
+                                        currency1: string;
+                                    };
+                                    decimalsCurrency0: number;
+                                    decimalsCurrency1: number;
+                                    symbolCurrency0: string;
+                                    symbolCurrency1: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
 } & {
     v3: {
         app: {
@@ -17768,6 +17917,53 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 }>>;
             };
         };
+        uniswap: {
+            v3: {
+                reward: {
+                    get: (options: {
+                        headers?: Record<string, unknown> | undefined;
+                        query: {
+                            poolAddress?: string | undefined;
+                            positionId?: string | undefined;
+                            address: string;
+                        };
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            [x: string]: Record<string, any[]>;
+                        };
+                    }>>;
+                };
+            };
+            v4: {
+                pools: {
+                    get: (options: {
+                        headers?: Record<string, unknown> | undefined;
+                        query: {
+                            chainId: number;
+                        };
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            [x: string]: {
+                                poolId: string;
+                                poolKey: {
+                                    hooks: string;
+                                    fee: number;
+                                    tickSpacing: number;
+                                    currency0: string;
+                                    currency1: string;
+                                };
+                                decimalsCurrency0: number;
+                                decimalsCurrency1: number;
+                                symbolCurrency0: string;
+                                symbolCurrency1: string;
+                            };
+                        };
+                    }>>;
+                };
+            };
+        };
     } | {
         derive: {};
         resolve: {};
@@ -21542,6 +21738,53 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 }>>;
             };
         };
+        uniswap: {
+            v3: {
+                reward: {
+                    get: (options: {
+                        headers?: Record<string, unknown> | undefined;
+                        query: {
+                            poolAddress?: string | undefined;
+                            positionId?: string | undefined;
+                            address: string;
+                        };
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            [x: string]: Record<string, any[]>;
+                        };
+                    }>>;
+                };
+            };
+            v4: {
+                pools: {
+                    get: (options: {
+                        headers?: Record<string, unknown> | undefined;
+                        query: {
+                            chainId: number;
+                        };
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: {
+                            [x: string]: {
+                                poolId: string;
+                                poolKey: {
+                                    hooks: string;
+                                    fee: number;
+                                    tickSpacing: number;
+                                    currency0: string;
+                                    currency1: string;
+                                };
+                                decimalsCurrency0: number;
+                                decimalsCurrency1: number;
+                                symbolCurrency0: string;
+                                symbolCurrency1: string;
+                            };
+                        };
+                    }>>;
+                };
+            };
+        };
     };
     v3: {
         app: {

package/dist/src/index.d.ts

@@ -4831,6 +4831,61 @@ declare const app: Elysia<"", false, {
             };
         };
     };
+} & {
+    v4: {
+        uniswap: {
+            v3: {
+                reward: {
+                    get: {
+                        body: unknown;
+                        params: {};
+                        query: {
+                            poolAddress?: string | undefined;
+                            positionId?: string | undefined;
+                            address: string;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                [x: string]: Record<string, any[]>;
+                            };
+                        };
+                    };
+                };
+            };
+        } & {
+            v4: {
+                pools: {
+                    get: {
+                        body: unknown;
+                        params: {};
+                        query: {
+                            chainId: number;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                [x: string]: {
+                                    poolId: string;
+                                    poolKey: {
+                                        hooks: string;
+                                        fee: number;
+                                        tickSpacing: number;
+                                        currency0: string;
+                                        currency1: string;
+                                    };
+                                    decimalsCurrency0: number;
+                                    decimalsCurrency1: number;
+                                    symbolCurrency0: string;
+                                    symbolCurrency1: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
 } & {
     v3: {
         app: {

package/dist/src/jobs/update-uniswap-v4-pools.js

@@ -1,8 +1,8 @@
 import { Redis } from "@/cache";
-import { UniswapV4Service } from "@/modules/v4/uniswapV4";
+import { UniswapService } from "@/modules/v4/uniswap/uniswap.service";
 async function main() {
     try {
-        await Redis.safeSet("UniswapV4Pools", await UniswapV4Service.getPools());
+        await Redis.safeSet("UniswapV4Pools", await UniswapService.getPools());
         process.exit(0);
     }
     catch (err) {

package/dist/src/libs/merklChainData.js

@@ -91,8 +91,6 @@ export async function merklChainData(chainId) {
         return acc;
     }, []);
     const validRewardTokenRes = await batchMulticallCallWithRetry(chainId, { calls: validRewardTokensCalls });
-    if (chainId === 1101)
-        console.log(validRewardTokenRes);
     for (let index = 0; index < validRewardTokens.length; index++) {
         try {
             if (validRewardTokenRes[2 * index][0] &&

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

@@ -1,5 +1,5 @@
 import type { PriceSourceMethod } from "@db/api";
-import type { CreatePriceSourceModel, UpdatePriceSourceModel } from ".";
+import type { CreatePriceSourceModel, UpdatePriceSourceModel } from "./price.model";
 export declare class PriceRepository {
     static findBySymbolOrThrow(symbol: string): Promise<{
         symbol: string;

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

@@ -1,5 +1,5 @@
 import { PriceSourceMethod } from "@db/api";
-import type { CreatePriceSourceModel, UpdatePriceSourceModel } from ".";
+import type { CreatePriceSourceModel, UpdatePriceSourceModel } from "./price.model";
 export declare class PriceService {
     static findMany(): Promise<{
         [token: string]: number;

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

@@ -3,7 +3,7 @@ import type { BreakdownForCampaignsRaw, CampaignIdModel, CampaignIdWithoutPageMo
 export declare abstract class RewardRepository {
     static createManyReward(rewards: CreateManyRewardModel): Promise<import("database/api/.generated/runtime/library").GetBatchResult>;
     static createManyBreakdown(data: CreateManyBreakdownModel): Promise<import("database/api/.generated/runtime/library").GetBatchResult>;
-    static getByRecipient(recipient: string, roots: string[], withToken: boolean, withTestTokens: boolean, chainFilter?: ChainId[]): Promise<({
+    static getByRecipient(recipient: string, roots: string[], withToken: boolean, withTestTokens: boolean, chainFilter?: ChainId[] | null, reasonFilter?: string): Promise<({
         RewardToken: {
             symbol: string;
             id: string;

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

@@ -56,7 +56,7 @@ export class RewardRepository {
             data: breakdownsToCreate,
         });
     }
-    static async getByRecipient(recipient, roots, withToken, withTestTokens, chainFilter) {
+    static async getByRecipient(recipient, roots, withToken, withTestTokens, chainFilter, reasonFilter) {
         return await apiDbClient.reward.findMany({
             where: {
                 root: {
@@ -69,9 +69,27 @@ export class RewardRepository {
                         isTest: withTestTokens ? undefined : false,
                     }
                     : undefined,
+                Breakdown: reasonFilter
+                    ? {
+                        some: {
+                            reason: {
+                                contains: reasonFilter,
+                                mode: "insensitive",
+                            },
+                        },
+                    }
+                    : undefined,
             },
             include: {
                 Breakdown: {
+                    where: reasonFilter
+                        ? {
+                            reason: {
+                                contains: reasonFilter,
+                                mode: "insensitive",
+                            },
+                        }
+                        : undefined,
                     include: {
                         Campaign: {
                             select: {

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

@@ -330,7 +330,7 @@ export declare abstract class RewardService {
         proofs: string[];
     }[];
     static createManyBreakdown(data: CreateManyBreakdownModel): Promise<import("database/api/.generated/runtime/library").GetBatchResult | undefined>;
-    static getByRecipient(recipient: string, roots: string[], withToken?: boolean, withTestTokens?: boolean, chainFilter?: ChainId[]): Promise<({
+    static getByRecipient(recipient: string, roots: string[], withToken?: boolean, withTestTokens?: boolean, chainFilter?: ChainId[] | null, reasonFilter?: string): Promise<({
         RewardToken: {
             symbol: string;
             id: string;

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

@@ -133,8 +133,8 @@ export class RewardService {
             log.error(`createManyBreakdown - error creating many breakdowns for campaigns ${foundCampaigns.join(", ")}`, e);
         }
     }
-    static async getByRecipient(recipient, roots, withToken = false, withTestTokens = false, chainFilter) {
-        return RewardRepository.getByRecipient(recipient, roots, withToken, withTestTokens, chainFilter);
+    static async getByRecipient(recipient, roots, withToken = false, withTestTokens = false, chainFilter, reasonFilter) {
+        return RewardRepository.getByRecipient(recipient, roots, withToken, withTestTokens, chainFilter, reasonFilter);
     }
     /**
      * Groups a breakdown array by their corresponding opportunities

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

@@ -4701,6 +4701,61 @@ export declare const v4: Elysia<"/v4", false, {
             };
         };
     };
+} & {
+    v4: {
+        uniswap: {
+            v3: {
+                reward: {
+                    get: {
+                        body: unknown;
+                        params: {};
+                        query: {
+                            poolAddress?: string | undefined;
+                            positionId?: string | undefined;
+                            address: string;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                [x: string]: Record<string, any[]>;
+                            };
+                        };
+                    };
+                };
+            };
+        } & {
+            v4: {
+                pools: {
+                    get: {
+                        body: unknown;
+                        params: {};
+                        query: {
+                            chainId: number;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                [x: string]: {
+                                    poolId: string;
+                                    poolKey: {
+                                        hooks: string;
+                                        fee: number;
+                                        tickSpacing: number;
+                                        currency0: string;
+                                        currency1: string;
+                                    };
+                                    decimalsCurrency0: number;
+                                    decimalsCurrency1: number;
+                                    symbolCurrency0: string;
+                                    symbolCurrency1: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
 }, {
     derive: {};
     resolve: {};

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

@@ -18,6 +18,7 @@ import { ProtocolController } from "@/modules/v4/protocol/protocol.controller";
 import { RewardController } from "@/modules/v4/reward/reward.controller";
 import { StatusController } from "@/modules/v4/status/status.controller";
 import { TokenController } from "@/modules/v4/token/token.controller";
+import { UniswapController } from "@/modules/v4/uniswap/uniswap.controller";
 import { UserController } from "@/modules/v4/user/user.controller";
 import { ErrorHandler } from "@/plugins/error-handling.plugin";
 import bigintToString from "@/utils/bigintToString";
@@ -73,4 +74,5 @@ export const v4 = new Elysia({ tags: ["v4"], prefix: "/v4" })
     .use(BoostController)
     .use(ComputedValueController)
     .use(CreatorController)
-    .use(ReferralController);
+    .use(ReferralController)
+    .use(UniswapController);

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

@@ -1,15 +1,15 @@
 import { HttpError } from "@/errors";
 import { getTokensListWithCache } from "@/libs/getTokensList";
 import { getOnlyUserBalance } from "@/libs/tokens/balances";
+import { BucketService } from "@/modules/v4/bucket/bucket.service";
+import { IconService } from "@/modules/v4/icon/icon.service";
+import { PriceService } from "@/modules/v4/price/price.service";
 import { log } from "@/utils/logger";
 import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "@/utils/throw";
 import { apiDbClient } from "@db";
 import { Prisma } from "@db/api";
 import { ChainInteractionService, DistributionCreatorService, NETWORK_LABELS, bigIntToNumber, } from "@sdk";
 import { getAddress, parseUnits } from "viem";
-import { BucketService } from "../bucket/bucket.service";
-import { IconService } from "../icon/icon.service";
-import { PriceService } from "../price";
 import { TokenRepository } from "./token.repository";
 export class TokenService {
     static hashId(token) {

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

@@ -0,0 +1,75 @@
+import Elysia from "elysia";
+export declare const UniswapController: Elysia<"uniswap", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    uniswap: {
+        v3: {
+            reward: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: {
+                        poolAddress?: string | undefined;
+                        positionId?: string | undefined;
+                        address: string;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: {
+                            [x: string]: Record<string, any[]>;
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        v4: {
+            pools: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: {
+                        chainId: number;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: {
+                            [x: string]: {
+                                poolId: string;
+                                poolKey: {
+                                    hooks: string;
+                                    fee: number;
+                                    tickSpacing: number;
+                                    currency0: string;
+                                    currency1: string;
+                                };
+                                decimalsCurrency0: number;
+                                decimalsCurrency1: number;
+                                symbolCurrency0: string;
+                                symbolCurrency1: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

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

@@ -0,0 +1,34 @@
+import { throwOnInvalidAddress, throwOnInvalidRequiredAddress } from "@/utils/throw";
+import Elysia, { t } from "elysia";
+import { RewardsPerV3PositionDto } from "./uniswap.model";
+import { UniswapService } from "./uniswap.service";
+export const UniswapController = new Elysia({
+    prefix: "uniswap",
+    detail: { tags: ["Uniswap"] },
+})
+    .group("/v3", app => {
+    return app.get("/reward", async ({ query }) => {
+        return await UniswapService.findV3RewardsPerPosition(query);
+    }, {
+        query: RewardsPerV3PositionDto,
+        beforeHandle: ({ query }) => {
+            query.address = throwOnInvalidRequiredAddress(query.address);
+            query.poolAddress = throwOnInvalidAddress(query.poolAddress);
+        },
+        detail: {
+            description: "Get rewards earned grouped by pool and uniswap v3 position",
+        },
+    });
+})
+    .group("/v4", app => {
+    return app.get("/pools", async ({ query }) => {
+        return await UniswapService.getPoolsByChain(query.chainId);
+    }, {
+        query: t.Object({
+            chainId: t.Numeric(),
+        }),
+        detail: {
+            description: "Get Uniswap V4 pools by chain",
+        },
+    });
+});

package/dist/src/modules/v4/{uniswapV4/uniswapV4.model.d.ts → uniswap/uniswap.model.d.ts}

@@ -4,6 +4,11 @@ import type { MerklChainId, UniswapV4PoolType } from "@sdk";
 export declare const Bytes32Dto: import("@sinclair/typebox").TObject<{
     poolId: import("@sinclair/typebox").TRegExp;
 }>;
+export declare const RewardsPerV3PositionDto: import("@sinclair/typebox").TObject<{
+    address: import("@sinclair/typebox").TString;
+    poolAddress: 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<{
     poolKey: import("@sinclair/typebox").TObject<{
         currency0: import("@sinclair/typebox").TString;
@@ -25,3 +30,4 @@ export type UniswapV4PoolsReturnType = {
 };
 export type UniswapV4PoolsEntity = typeof UniswapV4PoolsDto.static;
 export type LoggedCreateBody = Prisma.Args<typeof apiDbClient.logged, "createMany">["data"];
+export type RewardsPerPositionModel = typeof RewardsPerV3PositionDto.static;