@merkl/api 0.20.58 → 0.20.60

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

@@ -8730,8 +8730,9 @@ declare const eden: {
                 query?: Record<string, unknown> | undefined;
                 fetch?: RequestInit | undefined;
             } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                [x: string]: any;
-                200: any;
+                200: {
+                    [x: string]: any;
+                } | undefined;
             }>>;
         }) & {
             index: {
@@ -8740,8 +8741,11 @@ declare const eden: {
                     query?: Record<string, unknown> | undefined;
                     fetch?: RequestInit | undefined;
                 } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                    [x: string]: any;
-                    200: any;
+                    200: {
+                        [x: string]: {
+                            [poolId: string]: UniswapV4PoolType;
+                        } | undefined;
+                    } | null;
                 }>>;
             };
             pool: ((params: {
@@ -14691,8 +14695,11 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     query: unknown;
                     headers: unknown;
                     response: {
-                        [x: string]: any;
-                        200: any;
+                        200: {
+                            [x: string]: {
+                                [poolId: string]: UniswapV4PoolType;
+                            } | undefined;
+                        } | null;
                     };
                 };
             };
@@ -14706,8 +14713,9 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     query: unknown;
                     headers: unknown;
                     response: {
-                        [x: string]: any;
-                        200: any;
+                        200: {
+                            [x: string]: any;
+                        } | undefined;
                     };
                 };
             };
@@ -23467,8 +23475,9 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 query?: Record<string, unknown> | undefined;
                 fetch?: RequestInit | undefined;
             } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                [x: string]: any;
-                200: any;
+                200: {
+                    [x: string]: any;
+                } | undefined;
             }>>;
         }) & {
             index: {
@@ -23477,8 +23486,11 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     query?: Record<string, unknown> | undefined;
                     fetch?: RequestInit | undefined;
                 } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
-                    [x: string]: any;
-                    200: any;
+                    200: {
+                        [x: string]: {
+                            [poolId: string]: UniswapV4PoolType;
+                        } | undefined;
+                    } | null;
                 }>>;
             };
             pool: ((params: {

package/dist/src/engine/dynamicData/implementations/Erc20.d.ts

@@ -1,4 +1,4 @@
-import { Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
+import { type Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
 import type { DynamicDataBuilder } from "../interface";
 export type ERC20SupportedCampaignType = Campaign.ERC20 | Campaign.ERC20LOGPROCESSOR | Campaign.ERC20REBASELOGPROCESSOR | Campaign.EULER | Campaign.ERC20_FIX_APR;
 export declare class Erc20DynamicData implements DynamicDataBuilder<ERC20SupportedCampaignType> {

package/dist/src/engine/dynamicData/implementations/Erc20.js

@@ -9,7 +9,8 @@ import { TokenRepository } from "@/modules/v4/token/token.repository";
 import { TokenService } from "@/modules/v4/token/token.service";
 import { log } from "@/utils/logger";
 import { Pricer } from "@/utils/pricer";
-import { BN2Number, BalancerPoolInterface, BalancerV3StablePoolInterface, Campaign, ChainId, ChainInteractionService, ERC20Interface, EnzymeInterface, FactoryInterface, LayerBankERC20Interface, MetamorphoInterface, YEAR, getEnv, } from "@sdk";
+import { BN2Number, BalancerPoolInterface, BalancerV3StablePoolInterface, ChainId, ChainInteractionService, ERC20Interface, EnzymeInterface, FactoryInterface, LayerBankERC20Interface, MetamorphoInterface, YEAR, getEnv, } from "@sdk";
+import { getFixedApr, hasFixedAprConfig } from "../utils/getFixedApr";
 export class Erc20DynamicData {
     async build(chainId, campaigns) {
         const pricer = await Pricer.load();
@@ -160,17 +161,8 @@ export class Erc20DynamicData {
             if (rewardToken.isPoint) {
                 apr = apr / 365 / 100;
             }
-            else if (campaign.campaignType === Campaign.ERC20_FIX_APR &&
-                ["tacBTC", "tacETH", "tacUSD"].includes(campaign.campaignParameters.symbolTargetToken)) {
-                if (campaign.campaignParameters.symbolTargetToken === "tacBTC") {
-                    apr = 27.92;
-                }
-                else if (campaign.campaignParameters.symbolTargetToken === "tacETH") {
-                    apr = 32.58;
-                }
-                else if (campaign.campaignParameters.symbolTargetToken === "tacUSD") {
-                    apr = 46.54;
-                }
+            else if (hasFixedAprConfig(campaign.campaignParameters)) {
+                apr = getFixedApr(campaign, priceRewardToken, priceTargetToken);
             }
             if (campaign.chainId === ChainId.ETHERLINK) {
                 whitelistedSupplyTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.totalSupply;

package/dist/src/engine/dynamicData/utils/getFixedApr.d.ts

@@ -0,0 +1,9 @@
+import type { Campaign, CampaignParameters } from "@sdk";
+export type BaseFixAPRConfig = {
+    apr: string;
+    targetTokenPricing: boolean;
+    rewardTokenPricing: boolean;
+};
+export type FixedAprCampaignType = Campaign.ERC20_FIX_APR | Campaign.HYPERDRIVELOGFIXPROCESSOR;
+export declare function hasFixedAprConfig<T>(params: T): params is T & BaseFixAPRConfig;
+export declare function getFixedApr(campaignParameters: CampaignParameters<FixedAprCampaignType>, priceRewardToken: number, priceTargetToken: number): number;

package/dist/src/engine/dynamicData/utils/getFixedApr.js

@@ -0,0 +1,35 @@
+// Type guard to check if campaign parameters have fixed APR config
+export function hasFixedAprConfig(params) {
+    return (typeof params === "object" &&
+        params !== null &&
+        "targetTokenPricing" in params &&
+        "rewardTokenPricing" in params &&
+        "apr" in params);
+}
+// TODO: Enhance APR display for non-dollar denominations when front-end is ready.
+// This should handle cases where one or both token price are unavailable, showing the APR as a direct ratio
+// (e.g., X reward tokens per Y target tokens) instead of dollar values.
+export function getFixedApr(campaignParameters, priceRewardToken, priceTargetToken) {
+    const { targetTokenPricing, rewardTokenPricing, apr: fixedApr } = campaignParameters.campaignParameters;
+    const targetApr = Number(fixedApr);
+    // Handle all pricing configurations
+    if (targetTokenPricing && rewardTokenPricing) {
+        // Case 1: Fixed $ amount of reward per $ of liquidity
+        return targetApr * 100;
+    }
+    if (targetTokenPricing && !rewardTokenPricing) {
+        // Case 2: Fixed # amount of reward per $ of liquidity
+        // Return 0 if reward token price is invalid
+        return !priceRewardToken ? 0 : targetApr * priceRewardToken * 100;
+    }
+    if (!targetTokenPricing && rewardTokenPricing) {
+        // Case 3: Fixed $ amount of reward per # of liquidity
+        // Return 0 if target token price is invalid
+        return !priceTargetToken || priceTargetToken === 0 ? 0 : targetApr * (1 / priceTargetToken) * 100;
+    }
+    // Case 4: Fixed # amount of reward per # of liquidity
+    // Return 0 if either price is invalid
+    return !priceRewardToken || !priceTargetToken || priceTargetToken === 0
+        ? 0
+        : targetApr * (priceRewardToken / priceTargetToken) * 100;
+}

package/dist/src/index.d.ts

@@ -5924,8 +5924,11 @@ declare const app: Elysia<"", false, {
                     query: unknown;
                     headers: unknown;
                     response: {
-                        [x: string]: any;
-                        200: any;
+                        200: {
+                            [x: string]: {
+                                [poolId: string]: UniswapV4PoolType;
+                            } | undefined;
+                        } | null;
                     };
                 };
             };
@@ -5939,8 +5942,9 @@ declare const app: Elysia<"", false, {
                     query: unknown;
                     headers: unknown;
                     response: {
-                        [x: string]: any;
-                        200: any;
+                        200: {
+                            [x: string]: any;
+                        } | undefined;
                     };
                 };
             };

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

@@ -11,6 +11,7 @@ export class OpportunityRepository {
     static #transformQueryToPrismaFilters(query) {
         const { page: _page, items: _items, ...filters } = query;
         //TODO: abstract away query to not be strictly equal to controller
+        const now = moment().unix();
         const chainIds = query.chainId?.split(",").map(n => Number.parseInt(n));
         const actions = query.action?.split(",");
         const status = query.status?.split(",");
@@ -65,17 +66,40 @@ export class OpportunityRepository {
                         : {
                             AND: search?.map(keyword => ({
                                 OR: [
+                                    //IDs
                                     { id: { contains: keyword, mode: "insensitive" } },
                                     { name: { contains: keyword, mode: "insensitive" } },
                                     { identifier: { contains: keyword, mode: "insensitive" } },
                                     { explorerAddress: { contains: keyword, mode: "insensitive" } },
+                                    { Campaigns: { some: { campaignId: { contains: keyword, mode: "insensitive" } } } },
+                                    { Campaigns: { some: { id: { contains: keyword, mode: "insensitive" } } } },
+                                    //ERC20,CLAMM,...
                                     { type: { contains: keyword, mode: "insensitive" } },
+                                    //Protocol
                                     { MainProtocol: { name: { contains: keyword, mode: "insensitive" } } },
                                     { mainProtocolId: { contains: keyword, mode: "insensitive" } },
+                                    //Token
                                     { Tokens: { some: { name: { contains: keyword, mode: "insensitive" } } } },
                                     { Tokens: { some: { symbol: { contains: keyword, mode: "insensitive" } } } },
-                                    { Campaigns: { some: { campaignId: { contains: keyword, mode: "insensitive" } } } },
-                                    { Campaigns: { some: { id: { contains: keyword, mode: "insensitive" } } } },
+                                    { Tokens: { some: { address: { contains: keyword, mode: "insensitive" } } } },
+                                    //Match reward tokens only if campaign is live
+                                    {
+                                        Campaigns: {
+                                            some: {
+                                                endTimestamp: { gte: now },
+                                                RewardToken: {
+                                                    OR: [
+                                                        {
+                                                            symbol: { contains: keyword, mode: "insensitive" },
+                                                        },
+                                                        {
+                                                            address: { contains: keyword, mode: "insensitive" },
+                                                        },
+                                                    ],
+                                                },
+                                            },
+                                        },
+                                    },
                                     { Chain: { name: { contains: keyword, mode: "insensitive" } } },
                                 ],
                             })),

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

@@ -776,8 +776,11 @@ export declare const v3: Elysia<"/v3", false, {
                     query: unknown;
                     headers: unknown;
                     response: {
-                        [x: string]: any;
-                        200: any;
+                        200: {
+                            [x: string]: {
+                                [poolId: string]: UniswapV4PoolType;
+                            } | undefined;
+                        } | null;
                     };
                 };
             };
@@ -791,8 +794,9 @@ export declare const v3: Elysia<"/v3", false, {
                     query: unknown;
                     headers: unknown;
                     response: {
-                        [x: string]: any;
-                        200: any;
+                        200: {
+                            [x: string]: any;
+                        } | undefined;
                     };
                 };
             };

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

@@ -20,8 +20,11 @@ declare const _default: (app: Elysia) => Elysia<"", false, {
                 query: unknown;
                 headers: unknown;
                 response: {
-                    [x: string]: any;
-                    200: any;
+                    200: {
+                        [x: string]: {
+                            [poolId: string]: UniswapV4PoolType;
+                        } | undefined;
+                    } | null;
                 };
             };
         };
@@ -35,8 +38,9 @@ declare const _default: (app: Elysia) => Elysia<"", false, {
                 query: unknown;
                 headers: unknown;
                 response: {
-                    [x: string]: any;
-                    200: any;
+                    200: {
+                        [x: string]: any;
+                    } | undefined;
                 };
             };
         };

package/dist/src/routes/v3/uniswapv4.js

@@ -1,16 +1,16 @@
-import { Redis } from "@/cache";
+import { CacheService } from "@/modules/v4/cache";
 import { ChainUniqueDto } from "@/modules/v4/chain/chain.model";
-import { Bytes32Dto, UniV4ChainIdArray } from "@/modules/v4/uniswap/uniswap.model";
+import { Bytes32Dto, UniV4ChainIdArray, } from "@/modules/v4/uniswap/uniswap.model";
 import { UniswapService } from "@/modules/v4/uniswap/uniswap.service";
 import { UnsupportedNetwork } from "@/utils/error";
 export default (app) => app.group("/uniswapv4", router => router
     .get("/", async () => {
-    return await Redis.getOrSet("UniswapV4Pools", UniswapService.getUniswapV4Pools);
+    return await CacheService.get(UniswapService.getUniswapV4Pools, []);
 }, {
     tags: ["uniswapv4"],
 })
     .get("/:chainId", async ({ params }) => {
-    return (await Redis.getOrSet("UniswapV4Pools", UniswapService.getUniswapV4Pools, params.chainId))[params.chainId];
+    return (await CacheService.get(UniswapService.getUniswapV4Pools, []))?.[params.chainId];
 }, {
     params: ChainUniqueDto,
     beforeHandle: ({ params }) => {
@@ -20,7 +20,7 @@ export default (app) => app.group("/uniswapv4", router => router
     tags: ["uniswapv4"],
 })
     .get("/pool/:poolId", async ({ params }) => {
-    return Object.values((await Redis.getOrSet("UniswapV4Pools", UniswapService.getUniswapV4Pools)))
+    return Object.values((await CacheService.get(UniswapService.getUniswapV4Pools, [])))
         .flatMap(x => (x ? Object.values(x) : []))
         .filter(p => p.poolId === params.poolId);
 }, {