npm - @merkl/api - Versions diffs - 0.20.52 → 0.20.54 - Mend

@merkl/api 0.20.52 → 0.20.54

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (25) hide show

package/dist/src/backgroundJobs/index.js CHANGED Viewed

@@ -2,7 +2,9 @@
 import { Redis } from "@/cache";
 import { redisClient } from "@/cache/redis";
 import { getEulerV2Vaults, updateEulerVaultsCollatInDatabase } from "@/engine/dynamicData/utils/getEulerV2Vaults";
-import { getUniswapV4Pools } from "@/engine/dynamicData/utils/getUniswapV4Pools";
+import { CacheService } from "@/modules/v4/cache";
+import { TTLPresets } from "@/modules/v4/cache/cache.model";
+import { UniswapService } from "@/modules/v4/uniswap/uniswap.service";
 import { log } from "@/utils/logger";
 import { engineDbClient } from "@db";
 import { swagger } from "@elysiajs/swagger";
@@ -25,11 +27,11 @@ new Elysia({
     .get("/eulerUpdate", async () => {
     log.info("🔃 updating Euler vaults...");
     await updateEulerVaultsCollatInDatabase();
-    await Redis.safeSet("EulerV2Vaults", await getEulerV2Vaults());
+    await Redis.safeSet("EulerV2Vaults", await getEulerV2Vaults()); // TODO: keeping it with Redis for debug purposes, will do the transition soon
 })
     .get("/uniswapv4Update", async () => {
     log.info("🔃 updating UniswapV4 pools...");
-    await Redis.safeSet("UniswapV4Pools", await getUniswapV4Pools());
+    await CacheService.set(TTLPresets.DAY_1, UniswapService.getUniswapV4Pools);
 })
     .onError(ctx => {
     console.error(ctx.error.message);

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

@@ -4019,34 +4019,67 @@ declare const eden: {
                     };
                 }>>;
             };
-            v4: {
+            v4: ((params: {
+                poolId: 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: UniswapV4PoolType[];
+                }>>;
+            }) & {
                 pools: {
-                    get: (options: {
+                    get: (options?: {
                         headers?: Record<string, unknown> | undefined;
-                        query: {
-                            chainId: number;
-                        };
+                        query?: Record<string, unknown> | undefined;
                         fetch?: RequestInit | undefined;
-                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    } | 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;
-                            };
+                                [poolId: string]: UniswapV4PoolType;
+                            } | undefined;
                         };
                     }>>;
                 };
+                update: ((params: {
+                    chainId: string | number;
+                }) => {
+                    post: (body: unknown, options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: void;
+                    }>>;
+                }) & {
+                    post: (body: unknown, options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: void;
+                    }>>;
+                };
             };
+            v4pools: ((params: {
+                chainId: 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: {
+                        [x: string]: any;
+                    };
+                }>>;
+            }) & {};
         };
     } | {
         derive: {};
@@ -7974,34 +8007,67 @@ declare const eden: {
                     };
                 }>>;
             };
-            v4: {
+            v4: ((params: {
+                poolId: 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: UniswapV4PoolType[];
+                }>>;
+            }) & {
                 pools: {
-                    get: (options: {
+                    get: (options?: {
                         headers?: Record<string, unknown> | undefined;
-                        query: {
-                            chainId: number;
-                        };
+                        query?: Record<string, unknown> | undefined;
                         fetch?: RequestInit | undefined;
-                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    } | 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;
-                            };
+                                [poolId: string]: UniswapV4PoolType;
+                            } | undefined;
                         };
                     }>>;
                 };
+                update: ((params: {
+                    chainId: string | number;
+                }) => {
+                    post: (body: unknown, options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: void;
+                    }>>;
+                }) & {
+                    post: (body: unknown, options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: void;
+                    }>>;
+                };
             };
+            v4pools: ((params: {
+                chainId: 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: {
+                        [x: string]: any;
+                    };
+                }>>;
+            }) & {};
         };
     };
     v3: {
@@ -13651,26 +13717,83 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     get: {
                         body: unknown;
                         params: {};
-                        query: {
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: {
+                                [x: string]: {
+                                    [poolId: string]: UniswapV4PoolType;
+                                } | undefined;
+                            };
+                        };
+                    };
+                };
+            };
+        } & {
+            v4pools: {
+                ":chainId": {
+                    get: {
+                        body: unknown;
+                        params: {
                             chainId: number;
                         };
+                        query: unknown;
                         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;
-                                };
+                                [x: string]: any;
+                            };
+                        };
+                    };
+                };
+            };
+        } & {
+            v4: {
+                ":poolId": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            poolId: string;
+                        };
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: UniswapV4PoolType[];
+                        };
+                    };
+                };
+            };
+        } & {
+            v4: {
+                update: {
+                    post: {
+                        body: unknown;
+                        params: {};
+                        query: unknown;
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: void;
+                        };
+                    };
+                };
+            };
+        } & {
+            v4: {
+                update: {
+                    ":chainId": {
+                        post: {
+                            body: unknown;
+                            params: {
+                                chainId: number;
+                            };
+                            query: unknown;
+                            headers: {
+                                authorization: string;
+                            };
+                            response: {
+                                200: void;
                             };
                         };
                     };
@@ -18508,34 +18631,67 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     };
                 }>>;
             };
-            v4: {
+            v4: ((params: {
+                poolId: 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: UniswapV4PoolType[];
+                }>>;
+            }) & {
                 pools: {
-                    get: (options: {
+                    get: (options?: {
                         headers?: Record<string, unknown> | undefined;
-                        query: {
-                            chainId: number;
-                        };
+                        query?: Record<string, unknown> | undefined;
                         fetch?: RequestInit | undefined;
-                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    } | 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;
-                            };
+                                [poolId: string]: UniswapV4PoolType;
+                            } | undefined;
+                        };
+                    }>>;
+                };
+                update: ((params: {
+                    chainId: string | number;
+                }) => {
+                    post: (body: unknown, options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: void;
+                    }>>;
+                }) & {
+                    post: (body: unknown, options: {
+                        headers: {
+                            authorization: string;
                         };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: void;
                     }>>;
                 };
             };
+            v4pools: ((params: {
+                chainId: 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: {
+                        [x: string]: any;
+                    };
+                }>>;
+            }) & {};
         };
     } | {
         derive: {};
@@ -22463,34 +22619,67 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     };
                 }>>;
             };
-            v4: {
+            v4: ((params: {
+                poolId: 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: UniswapV4PoolType[];
+                }>>;
+            }) & {
                 pools: {
-                    get: (options: {
+                    get: (options?: {
                         headers?: Record<string, unknown> | undefined;
-                        query: {
-                            chainId: number;
-                        };
+                        query?: Record<string, unknown> | undefined;
                         fetch?: RequestInit | undefined;
-                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    } | 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;
-                            };
+                                [poolId: string]: UniswapV4PoolType;
+                            } | undefined;
+                        };
+                    }>>;
+                };
+                update: ((params: {
+                    chainId: string | number;
+                }) => {
+                    post: (body: unknown, options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: void;
+                    }>>;
+                }) & {
+                    post: (body: unknown, options: {
+                        headers: {
+                            authorization: string;
                         };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: void;
                     }>>;
                 };
             };
+            v4pools: ((params: {
+                chainId: 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: {
+                        [x: string]: any;
+                    };
+                }>>;
+            }) & {};
         };
     };
     v3: {

package/dist/src/engine/dynamicData/factory.js CHANGED Viewed

@@ -51,5 +51,11 @@ const map = {
     [Campaign.MORPHOSUPPLY]: new DefaultDynamicData(), // TODO
     [Campaign.SYNCSWAP_VAULT]: new DefaultDynamicData(), // TODO
     [Campaign.MAVERICK_BP]: new DefaultDynamicData(), // TODO
+    [Campaign.ERC6909]: new DefaultDynamicData(), // TODO
+    [Campaign.ERC6909FIXAPR]: new DefaultDynamicData(), // TODO
+    [Campaign.COMPOUND_V3]: new DefaultDynamicData(), // TODO,
+    [Campaign.COMPOUND_V3_FIXAPR]: new DefaultDynamicData(), // TODO
+    [Campaign.ERC1155]: new DefaultDynamicData(), // TODO
+    [Campaign.ERC1155FIXAPR]: new DefaultDynamicData(), // TODO
 };
 export const dynamicDataBuilderFactory = (campaignType) => map[campaignType];

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

@@ -1,6 +1,6 @@
-import { type Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
+import { Campaign, type CampaignParameters, type MerklChainId } from "@sdk";
 import type { DynamicDataBuilder } from "../interface";
-export type ERC20SupportedCampaignType = Campaign.ERC20 | Campaign.ERC20LOGPROCESSOR | Campaign.ERC20REBASELOGPROCESSOR | Campaign.EULER;
+export type ERC20SupportedCampaignType = Campaign.ERC20 | Campaign.ERC20LOGPROCESSOR | Campaign.ERC20REBASELOGPROCESSOR | Campaign.EULER | Campaign.ERC20_FIX_APR;
 export declare class Erc20DynamicData implements DynamicDataBuilder<ERC20SupportedCampaignType> {
     build(chainId: MerklChainId, campaigns: CampaignParameters<ERC20SupportedCampaignType>[]): Promise<any[]>;
 }

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

@@ -9,7 +9,7 @@ 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, ChainId, ChainInteractionService, ERC20Interface, EnzymeInterface, FactoryInterface, LayerBankERC20Interface, MetamorphoInterface, YEAR, getEnv, } from "@sdk";
+import { BN2Number, BalancerPoolInterface, BalancerV3StablePoolInterface, Campaign, ChainId, ChainInteractionService, ERC20Interface, EnzymeInterface, FactoryInterface, LayerBankERC20Interface, MetamorphoInterface, YEAR, getEnv, } from "@sdk";
 export class Erc20DynamicData {
     async build(chainId, campaigns) {
         const pricer = await Pricer.load();
@@ -157,7 +157,21 @@ export class Erc20DynamicData {
                 { chainId: campaign.chainId, address: campaign.rewardToken },
             ]);
             const rewardToken = rewardTokens[0];
-            apr = rewardToken.isPoint ? apr / 365 / 100 : apr;
+            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;
+                }
+            }
             if (campaign.chainId === ChainId.ETHERLINK) {
                 whitelistedSupplyTargetToken = tokenTypesByCampaign[campaign.campaignId].typeInfo.totalSupply;
             }

package/dist/src/engine/dynamicData/implementations/UniswapV4.js CHANGED Viewed

@@ -121,7 +121,7 @@ export class UniswapV4DynamicData {
                         chainId: chainId,
                         symbol: symbolCurrency1,
                     }));
-                    const { tvl, amount0, amount1, blockNumber } = await computeUniV4PoolTVLFromMostRecentStateSave(chainId, pool.poolId, priceToken0, priceToken1, decimalsCurrency0, decimalsCurrency1);
+                    const { amount0, amount1 } = await computeUniV4PoolTVLFromMostRecentStateSave(chainId, pool.poolId, priceToken0, priceToken1, decimalsCurrency0, decimalsCurrency1);
                     poolBalanceToken0 += amount0;
                     poolBalanceToken1 += amount1;
                     /** Iterate over distributions to compute APRs */

package/dist/src/engine/opportunityMetadata/factory.js CHANGED Viewed

@@ -54,5 +54,11 @@ const map = {
     [Campaign.EVENT_BASED]: new EventBasedMetadata(),
     [Campaign.ERC20REBASEFIXAPR]: new Erc20Metadata(),
     [Campaign.MAVERICK_BP]: new DefaultMetadata(), // TODO
+    [Campaign.ERC6909]: new DefaultMetadata(), // TODO
+    [Campaign.ERC6909FIXAPR]: new DefaultMetadata(), // TODO
+    [Campaign.COMPOUND_V3]: new DefaultMetadata(), // TODO,
+    [Campaign.COMPOUND_V3_FIXAPR]: new DefaultMetadata(), // TODO
+    [Campaign.ERC1155]: new DefaultMetadata(), // TODO
+    [Campaign.ERC1155FIXAPR]: new DefaultMetadata(), // TODO
 };
 export const metadataBuilderFactory = (campaignType) => map[campaignType];

package/dist/src/engine/opportunityMetadata/implementations/Clamm.js CHANGED Viewed

@@ -161,6 +161,13 @@ export class ClammMetadata {
             SwapX: () => "https://swapx.fi/earn",
             ZERO: () => "https://www.zkzero.fi/",
         };
-        return ammLinkMap[params.amm]?.(params)?.toLowerCase();
+        let ammString = params.amm.toString();
+        try {
+            if (params.amm === Number(Number.parseInt(params.amm.toString()))) {
+                ammString = AMM[params.amm];
+            }
+        }
+        catch { }
+        return ammLinkMap[ammString]?.(params)?.toLowerCase();
     }
 }

package/dist/src/index.d.ts CHANGED Viewed

@@ -5030,26 +5030,83 @@ declare const app: Elysia<"", false, {
                     get: {
                         body: unknown;
                         params: {};
-                        query: {
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: {
+                                [x: string]: {
+                                    [poolId: string]: UniswapV4PoolType;
+                                } | undefined;
+                            };
+                        };
+                    };
+                };
+            };
+        } & {
+            v4pools: {
+                ":chainId": {
+                    get: {
+                        body: unknown;
+                        params: {
                             chainId: number;
                         };
+                        query: unknown;
                         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;
-                                };
+                                [x: string]: any;
+                            };
+                        };
+                    };
+                };
+            };
+        } & {
+            v4: {
+                ":poolId": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            poolId: string;
+                        };
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: UniswapV4PoolType[];
+                        };
+                    };
+                };
+            };
+        } & {
+            v4: {
+                update: {
+                    post: {
+                        body: unknown;
+                        params: {};
+                        query: unknown;
+                        headers: {
+                            authorization: string;
+                        };
+                        response: {
+                            200: void;
+                        };
+                    };
+                };
+            };
+        } & {
+            v4: {
+                update: {
+                    ":chainId": {
+                        post: {
+                            body: unknown;
+                            params: {
+                                chainId: number;
+                            };
+                            query: unknown;
+                            headers: {
+                                authorization: string;
+                            };
+                            response: {
+                                200: void;
                             };
                         };
                     };