@merkl/api 0.20.24 → 0.20.26

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

@@ -8190,15 +8190,39 @@ declare const eden: {
                 };
             }>>;
         };
-        uniswapv4: {
-            get: (options: {
+        uniswapv4: ((params: {
+            chainId: string | number;
+        }) => {
+            get: (options?: {
                 headers?: Record<string, unknown> | undefined;
-                query: {};
+                query?: Record<string, unknown> | undefined;
                 fetch?: RequestInit | undefined;
-            }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+            } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                 [x: string]: any;
                 200: any;
             }>>;
+        }) & {
+            index: {
+                get: (options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    [x: string]: any;
+                    200: any;
+                }>>;
+            };
+            pool: ((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[];
+                }>>;
+            }) & {};
         };
     };
 };
@@ -13788,14 +13812,47 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
 } & {
     v3: {
         uniswapv4: {
-            get: {
-                body: unknown;
-                params: {};
-                query: {};
-                headers: unknown;
-                response: {
-                    [x: string]: any;
-                    200: any;
+            index: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        [x: string]: any;
+                        200: any;
+                    };
+                };
+            };
+        } & {
+            ":chainId": {
+                get: {
+                    body: unknown;
+                    params: {
+                        chainId: number;
+                    };
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        [x: string]: any;
+                        200: any;
+                    };
+                };
+            };
+        } & {
+            pool: {
+                ":poolId": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            poolId: string;
+                        };
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: UniswapV4PoolType[];
+                        };
+                    };
                 };
             };
         };
@@ -21998,15 +22055,39 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 };
             }>>;
         };
-        uniswapv4: {
-            get: (options: {
+        uniswapv4: ((params: {
+            chainId: string | number;
+        }) => {
+            get: (options?: {
                 headers?: Record<string, unknown> | undefined;
-                query: {};
+                query?: Record<string, unknown> | undefined;
                 fetch?: RequestInit | undefined;
-            }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+            } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                 [x: string]: any;
                 200: any;
             }>>;
+        }) & {
+            index: {
+                get: (options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    [x: string]: any;
+                    200: any;
+                }>>;
+            };
+            pool: ((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[];
+                }>>;
+            }) & {};
         };
     };
 };

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

@@ -1,8 +1,10 @@
 import { type MerklChainId, type UniswapV4PoolType } from "@sdk";
+export declare const UniV4ChainIdArray: MerklChainId[];
+type UniV4ChainId = (typeof UniV4ChainIdArray)[number];
 export type UniswapV4PoolsReturnType = {
     [chainId in MerklChainId]?: {
         [poolId: string]: UniswapV4PoolType;
     };
 };
-export declare function getUniswapV4Pools(): Promise<UniswapV4PoolsReturnType>;
-export declare const getUniswapV4PoolsWithCache: () => Promise<UniswapV4PoolsReturnType>;
+export declare function getUniswapV4Pools(chainId?: UniV4ChainId): Promise<UniswapV4PoolsReturnType>;
+export {};

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

@@ -1,24 +1,30 @@
-import { Redis } from "@/cache";
 import { log } from "@/utils/logger";
 import { providers } from "@/utils/providers";
 import { apiDbClient } from "@db";
 import { ChainInteractionService, ERC20Interface, NETWORK_LABELS, NULL_ADDRESS, UniswapV4Addresses, UniswapV4PoolManagerInterface, getContractCreationBlock, } from "@sdk";
 import { safeFetchLogs } from "./fetchLogs";
 import { LoggedEntityType } from "./getEulerV2Vaults";
-const UNIV4_CHAINIDS = Object.keys(UniswapV4Addresses).map((x) => Number(x));
-export async function getUniswapV4Pools() {
+export const UniV4ChainIdArray = Object.keys(UniswapV4Addresses).map((x) => Number(x));
+export async function getUniswapV4Pools(chainId) {
+    let chainIdArray;
+    if (!!chainId) {
+        chainIdArray = [chainId];
+    }
+    else {
+        chainIdArray = UniV4ChainIdArray;
+    }
     const pools = {};
     // 0_ Fetch all euler vaults from database
     const storedPools = await apiDbClient.logged.findMany({
         where: { type: LoggedEntityType.UNISWAP_V4 },
     });
-    const res = await Promise.all(UNIV4_CHAINIDS.map(async (chainId) => {
+    const res = await Promise.all(chainIdArray.map(async (chainId) => {
         chainId = chainId;
         const perChainIdRes = {};
         const poolManagerAddress = UniswapV4Addresses[chainId]?.PoolManager ?? NULL_ADDRESS;
         const jsonRPCprovider = providers[chainId];
         try {
-            // 1_ Get latest euler vaults from chain
+            // 1_ Get latest uniswapV4 pools for `chainId`
             const storedPoolsPerChain = storedPools.filter(pool => pool.chainId === chainId);
             log.info(`found ${storedPoolsPerChain.length} already stored pools on ${NETWORK_LABELS[chainId]}`);
             let fromBlock;
@@ -137,13 +143,13 @@ export async function getUniswapV4Pools() {
         }
         return perChainIdRes;
     }));
-    UNIV4_CHAINIDS.forEach((chainId, i) => {
+    chainIdArray.forEach((chainId, i) => {
         if (!!res[i])
             pools[chainId] = res[i];
     });
     // Update the API database
     const tableData = Object.values(pools).flatMap(pools => Object.values(pools));
-    for (const chainId of UNIV4_CHAINIDS) {
+    for (const chainId of chainIdArray) {
         if (tableData.filter(p => p.chainId === chainId).length > 0) {
             try {
                 await apiDbClient.logged.createMany({
@@ -180,4 +186,3 @@ export async function getUniswapV4Pools() {
     log.info("👋 exiting getUniswapV4Pools");
     return pools;
 }
-export const getUniswapV4PoolsWithCache = async () => await Redis.getOrSet("UniswapV4Pools", getUniswapV4Pools);

package/dist/src/engine/opportunityMetadata/implementations/Clamm.d.ts

@@ -36,9 +36,9 @@ export declare class ClammMetadata implements MetadataBuilder<campaignType> {
             address: any;
         }[];
         mainProtocol: ProtocolId;
-        depositUrl: string | undefined;
+        depositUrl: string;
         explorerAddress: `0x${string}`;
     }>;
-    static generateUrl(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): string | undefined;
+    static generateUrl(computeChainId: ChainId, params: CampaignParameters<campaignType>["campaignParameters"]): string;
 }
 export {};

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

@@ -105,118 +105,58 @@ export class ClammMetadata {
         };
     }
     static generateUrl(computeChainId, params) {
-        switch (params.amm) {
-            case AMM.UniswapV3: {
+        const sanitizeChain = (computeChain) => NETWORK_LABELS[computeChain]?.toLowerCase().replaceAll(" ", "");
+        const sanitizeFee = (poolFee) => Number(poolFee) * 10000;
+        const ammLinkMap = {
+            UniswapV3: ({ poolAddress }) => {
                 const availableOnOku = Object.keys(uniswapV3OkuChains).includes(computeChainId?.toString());
-                if (availableOnOku) {
+                if (availableOnOku)
                     return `https://oku.trade/app/${uniswapV3OkuChains[computeChainId]}/liquidity/${params.poolAddress} `;
-                }
-                return `https://app.uniswap.org/explore/pools/${computeChainId === ChainId.MAINNET
-                    ? "ethereum/"
-                    : `${NETWORK_LABELS[computeChainId]?.toLowerCase().replaceAll(" ", "")}/`}${params?.poolAddress?.toLowerCase()}`;
-            }
-            case AMM.PancakeSwapV3: {
-                return `https://pancakeswap.finance/add/${params.token0?.toLowerCase()}/${params.token1?.toLowerCase()}/${Number(params.poolFee) * 10000}?chain=${pancakeswapChains[computeChainId] ?? NETWORK_LABELS[computeChainId]?.replaceAll(" ", "")}`;
-            }
-            case AMM.Sonex: {
-                return `https://app.sonex.so/explore/pools/${params.poolAddress?.toLowerCase()}`;
-            }
-            case AMM.KYO: {
-                return `https://app.kyo.finance/liquidity/${params.poolAddress?.toLowerCase()}`;
-            }
-            case AMM.SushiSwapV3: {
-                return `https://www.sushi.com/${sushiswapv3Chains[computeChainId] ?? NETWORK_LABELS[computeChainId]?.toLowerCase()?.replaceAll(" ", "")}/pool/v3/${params.poolAddress?.toLowerCase()}`;
-            }
-            case AMM.Retro: {
-                return "https://retro.finance/liquidity/managev3";
-            }
-            case AMM.Camelot: {
-                return `https://app.camelot.exchange/liquidity?type=v3&token1=${params.token0?.toLowerCase()}&token2=${params.token1?.toLowerCase()}`;
-            }
-            case AMM.BaseSwap: {
-                return `https://${computeChainId === ChainId.MODE ? "swapmode" : "baseswap"}.fi/addV3?currencyIdA=${params.token0}&currencyIdB=${params.token1}&feeAmount=${Number(params.poolFee) * 10000}`;
-            }
-            case AMM.Horiza: {
-                return "https:/app.horiza.io/liquidity";
-            }
-            case AMM.QuickswapAlgebra: {
-                return `https://quickswap.exchange/#/pools?currency0=${params.token0}&currency1=${params.token1}`;
-            }
-            case AMM.QuickswapUni: {
-                return `https://quickswap.exchange/#/pools?currency0=${params.token0}&currency1=${params.token1}`;
-            }
-            case AMM.QuickswapAlgebraV1_2: {
-                return `https://quickswap.exchange/#/pools?currency0=${params.token0}&currency1=${params.token1}`;
-            }
-            case AMM.Swapr: {
-                return "https://v3.swapr.eth.limo/#/swap";
-            }
-            case AMM.ZERO: {
-                return "https://v3.swapr.eth.limo/#/swap";
-            }
-            case AMM.Crust: {
-                return "https://app.crust.finance/liquidity";
-            }
-            case AMM.Thruster: {
-                return "https://app.thruster.finance/add";
-            }
-            case AMM.Kim: {
-                return "https://app.kim.exchange/positions";
-            }
-            case AMM.Stryke: {
-                return "https://www.stryke.xyz/en/dashboard";
-            }
-            case AMM.StrykePCS: {
-                return `https://pancakeswap.stryke.xyz/${params.symbolToken0}-${params.symbolToken1}?mode=LP`;
-            }
-            case AMM.StrykeSushi: {
-                return `https://sushiswap.stryke.xyz/${params.symbolToken0}-${params.symbolToken1}?mode=LP`;
-            }
-            case AMM.ARTHSWAP: {
-                return "https://app.arthswap.org/#/pools";
-            }
-            case AMM.Fenix: {
-                return "https://www.fenixfinance.io/";
-            }
-            case AMM.Ramses: {
-                return "https://app.ramses.exchange/swap";
-            }
-            case AMM.Voltage: {
-                return `https://app.voltage.finance/add/${params.token0?.toLowerCase()}/${params.token1?.toLowerCase()}?version=v3&feeAmount=${Number(params.poolFee) * 10000}`;
-            }
-            case AMM.Izumi: {
-                return `https://${computeChainId === ChainId.ROOTSTOCK ? "woodswap.org" : "izumi.finance"}/trade/add-liquidity/?token0=${params.token0}&token1=${params.token1}&chainId=${computeChainId}&fee=${Number(params.poolFee) * 10000}`;
-            }
-            case AMM.KOI: {
-                return `https://dapp.koi.finance/pool/v3/new/${params.token0?.toLowerCase()}/${params.token1?.toLowerCase()}`;
-            }
-            case AMM.SupswapV3: {
-                return `https://supswap.xyz/add/${params.token0?.toLowerCase()}/${params.token1?.toLowerCase()}/${Number.parseInt(params.poolFee) * 10000}`;
-            }
-            case AMM.zkSwap: {
-                return `https://www.zkswap.finance/add/${params.token0?.toLowerCase()}/${params.token1?.toLowerCase()}/2000?chain=${computeChainId}`;
-            }
-            case AMM.SyncswapV3: {
-                return "https://www.syncswap.xyz/pools";
-            }
-            case AMM.Neptune: {
-                return "https://app.nep.finance/add/";
-            }
-            case AMM.SwapX: {
-                return "https://swapx.fi/earn";
-            }
-            case AMM.Velodrome: {
-                return "https://app.velodrome.finance/";
-            }
-            case AMM.AERODROME: {
-                return "https://app.aerodrome.finance/";
-            }
-            case AMM.ThirdTrade: {
-                return "https://app.thirdtrade.xyz/";
-            }
-            case AMM.Katana: {
-                return "https://app.roninchain.com/liquidity";
-            }
-        }
+                const chainLabel = computeChainId === ChainId.MAINNET ? "ethereum/" : `${sanitizeChain(computeChainId)}/`;
+                return `https://app.uniswap.org/explore/pools/${chainLabel}${poolAddress?.toLowerCase()}`;
+            },
+            //Pool address mappings
+            Sonex: ({ poolAddress }) => `https://app.sonex.so/explore/pools/${poolAddress}`,
+            KYO: ({ poolAddress }) => `https://app.kyo.finance/liquidity/${poolAddress}`,
+            SushiSwapV3: ({ poolAddress }) => `https://www.sushi.com/${sushiswapv3Chains[computeChainId] ?? sanitizeChain(computeChainId)}/pool/v3/${poolAddress}`,
+            Swapr: ({ poolAddress }) => `https://v3.swapr.eth.limo/#/info/pools/${poolAddress}`,
+            Crust: ({ poolAddress }) => `https://v1.crust.finance/liquidity/${poolAddress}`,
+            ThirdTrade: ({ poolAddress }) => `https://third.trade/pool/${poolAddress}`,
+            Katana: ({ poolAddress }) => `https://app.roninchain.com/liquidity/${poolAddress}`,
+            SyncswapV3: ({ poolAddress }) => `https://syncswap.xyz/pool/${poolAddress}`,
+            //Token address mappings
+            Camelot: ({ token0, token1 }) => `https://app.camelot.exchange/liquidity?type=v3&token1=${token0}&token2=${token1}`,
+            QuickswapAlgebra: ({ token0, token1 }) => `https://quickswap.exchange/#/pools?currency0=${token0}&currency1=${token1}`,
+            QuickswapUni: ({ token0, token1 }) => `https://quickswap.exchange/#/pools?currency0=${token0}&currency1=${token1}`,
+            QuickswapAlgebraV1_2: ({ token0, token1 }) => `https://quickswap.exchange/#/pools?currency0=${token0}&currency1=${token1}`,
+            AERODROME: ({ token0, token1 }) => `https://aerodrome.finance/pools?token0=${token0}&token1=${token1}&type=1&chain=${computeChainId}`,
+            KOI: ({ token0, token1 }) => `https://dapp.koi.finance/pool/v3/new/${token0}/${token1}`,
+            zkSwap: ({ token0, token1 }) => `https://www.zkswap.finance/add/${token0}/${token1}/2000?chain=${computeChainId}`,
+            Velodrome: ({ token0, token1 }) => `https://velodrome.finance/pools?token0=${token0}&token1=${token1}&type=1&chain=${computeChainId}`,
+            //Token address and pool fess
+            PancakeSwapV3: ({ token0, token1, poolFee }) => `https://pancakeswap.finance/add/${token0}/${token1}/${sanitizeFee(poolFee)}?chain=${pancakeswapChains[computeChainId] ?? sanitizeChain(computeChainId)}`,
+            BaseSwap: ({ token0, token1, poolFee }) => `https://${computeChainId === ChainId.MODE ? "swapmode" : "baseswap"}.fi/addV3?currencyIdA=${token0}&currencyIdB=${token1}&feeAmount=${sanitizeFee(poolFee)}`,
+            Voltage: ({ token0, token1, poolFee }) => `https://app.voltage.finance/add/${token0}/${token1}?version=v3&feeAmount=${sanitizeFee(poolFee)}`,
+            Izumi: ({ token0, token1, poolFee }) => `https://${computeChainId === ChainId.ROOTSTOCK ? "woodswap.org" : "izumi.finance"}/trade/add-liquidity/?token0=${token0}&token1=${token1}&chainId=${computeChainId}&fee=${Number(poolFee) * 10000}`,
+            SupswapV3: ({ token0, token1, poolFee }) => `https://supswap.xyz/add/${token0}/${token1}/${sanitizeFee(poolFee)}`,
+            Iguana: ({ token0, token1, poolFee }) => `https://www.iguanadex.com/add/${token0}/${token1}/${sanitizeFee(poolFee)}?chain=${sanitizeChain(computeChainId)}`,
+            //Token symbols
+            Stryke: ({ symbolToken0, symbolToken1 }) => `https://www.stryke.xyz/en/trade/arbitrum/${symbolToken0}-${symbolToken1}`,
+            StrykePCS: ({ symbolToken0, symbolToken1 }) => `https://pancakeswap.stryke.xyz/${symbolToken0}-${symbolToken1}?mode=LP`,
+            StrykeSushi: ({ symbolToken0, symbolToken1 }) => `https://sushiswap.stryke.xyz/${symbolToken0}-${symbolToken1}?mode=LP`,
+            //Token symbols and pool fees
+            Neptune: ({ symbolToken0, symbolToken1, poolFee }) => `https://app.nep.finance/add/${symbolToken0}/${symbolToken1}/${sanitizeFee(poolFee)}`,
+            //Protocols without unique links for pools
+            Retro: () => "https://retro.finance/liquidity/managev3",
+            Horiza: () => "https:/app.horiza.io/liquidity",
+            Thruster: () => "https://app.thruster.finance/add",
+            Kim: () => "https://app.kim.exchange/positions",
+            ARTHSWAP: () => "https://app.arthswap.org/#/pools",
+            Fenix: () => "https://www.fenixfinance.io/",
+            Ramses: () => "https://app.ramses.exchange/swap",
+            SwapX: () => "https://swapx.fi/earn",
+            ZERO: () => "https://www.zkzero.fi/",
+        };
+        return ammLinkMap[params.amm]?.(params)?.toLowerCase();
     }
 }

package/dist/src/index.d.ts

@@ -5577,14 +5577,47 @@ declare const app: Elysia<"", false, {
 } & {
     v3: {
         uniswapv4: {
-            get: {
-                body: unknown;
-                params: {};
-                query: {};
-                headers: unknown;
-                response: {
-                    [x: string]: any;
-                    200: any;
+            index: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        [x: string]: any;
+                        200: any;
+                    };
+                };
+            };
+        } & {
+            ":chainId": {
+                get: {
+                    body: unknown;
+                    params: {
+                        chainId: number;
+                    };
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        [x: string]: any;
+                        200: any;
+                    };
+                };
+            };
+        } & {
+            pool: {
+                ":poolId": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            poolId: string;
+                        };
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: UniswapV4PoolType[];
+                        };
+                    };
                 };
             };
         };

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

@@ -1,6 +1,9 @@
 import type { apiDbClient } from "@db";
 import type { Prisma } from "@db/api";
 import type { MerklChainId, UniswapV4PoolType } from "@sdk";
+export declare const Bytes32Dto: import("@sinclair/typebox").TObject<{
+    poolId: import("@sinclair/typebox").TRegExp;
+}>;
 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;

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

@@ -14,4 +14,9 @@ const UniswapV4PoolDto = t.Object({
     symbolCurrency0: t.String(),
     symbolCurrency1: t.String(),
 });
+export const Bytes32Dto = t.Object({
+    poolId: t.RegExp(/^0x[a-fA-F0-9]{64}$/, {
+        description: "A 32-byte hexadecimal string (bytes32)",
+    }),
+});
 export const UniswapV4PoolsDto = t.Record(t.String(), UniswapV4PoolDto);

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

@@ -769,14 +769,47 @@ export declare const v3: Elysia<"/v3", false, {
 } & {
     v3: {
         uniswapv4: {
-            get: {
-                body: unknown;
-                params: {};
-                query: {};
-                headers: unknown;
-                response: {
-                    [x: string]: any;
-                    200: any;
+            index: {
+                get: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        [x: string]: any;
+                        200: any;
+                    };
+                };
+            };
+        } & {
+            ":chainId": {
+                get: {
+                    body: unknown;
+                    params: {
+                        chainId: number;
+                    };
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        [x: string]: any;
+                        200: any;
+                    };
+                };
+            };
+        } & {
+            pool: {
+                ":poolId": {
+                    get: {
+                        body: unknown;
+                        params: {
+                            poolId: string;
+                        };
+                        query: unknown;
+                        headers: unknown;
+                        response: {
+                            200: UniswapV4PoolType[];
+                        };
+                    };
                 };
             };
         };

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

@@ -1,10 +1,4 @@
-import { type Elysia } from "elysia";
-export declare const response: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-    address: import("@sinclair/typebox").TString;
-    asset: import("@sinclair/typebox").TString;
-    chaind: import("@sinclair/typebox").TNumber;
-    debtTokenAddress: import("@sinclair/typebox").TString;
-}>>;
+import type { Elysia } from "elysia";
 declare const _default: (app: Elysia) => Elysia<"", false, {
     decorator: {};
     store: {};
@@ -19,14 +13,47 @@ declare const _default: (app: Elysia) => Elysia<"", false, {
     macroFn: {};
 }, {
     uniswapv4: {
-        get: {
-            body: unknown;
-            params: {};
-            query: {};
-            headers: unknown;
-            response: {
-                [x: string]: any;
-                200: any;
+        index: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    [x: string]: any;
+                    200: any;
+                };
+            };
+        };
+    } & {
+        ":chainId": {
+            get: {
+                body: unknown;
+                params: {
+                    chainId: number;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    [x: string]: any;
+                    200: any;
+                };
+            };
+        };
+    } & {
+        pool: {
+            ":poolId": {
+                get: {
+                    body: unknown;
+                    params: {
+                        poolId: string;
+                    };
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: UniswapV4PoolType[];
+                    };
+                };
             };
         };
     };

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

@@ -1,9 +1,29 @@
-import { getUniswapV4PoolsWithCache } from "@/engine/dynamicData/utils/getUniswapV4Pools";
-import { t } from "elysia";
-export const response = t.Array(t.Object({ address: t.String(), asset: t.String(), chaind: t.Number(), debtTokenAddress: t.String() }));
-export default (app) => app.get("/uniswapv4", async () => {
-    return await getUniswapV4PoolsWithCache();
+import { Redis } from "@/cache";
+import { UniV4ChainIdArray, getUniswapV4Pools } from "@/engine/dynamicData/utils/getUniswapV4Pools";
+import { ChainUniqueDto } from "@/modules/v4/chain/chain.model";
+import { Bytes32Dto } from "@/modules/v4/uniswapV4";
+import { UnsupportedNetwork } from "@/utils/error";
+export default (app) => app.group("/uniswapv4", router => router
+    .get("/", async () => {
+    return await Redis.getOrSet("UniswapV4Pools", getUniswapV4Pools);
 }, {
-    query: t.Object({}),
-    tags: ["Protocols"],
-});
+    tags: ["uniswapv4"],
+})
+    .get("/:chainId", async ({ params }) => {
+    return (await Redis.getOrSet("UniswapV4Pools", getUniswapV4Pools, params.chainId))[params.chainId];
+}, {
+    params: ChainUniqueDto,
+    beforeHandle: ({ params }) => {
+        if (!UniV4ChainIdArray.includes(params.chainId))
+            throw new UnsupportedNetwork(params.chainId);
+    },
+    tags: ["uniswapv4"],
+})
+    .get("/pool/:poolId", async ({ params }) => {
+    return Object.values((await Redis.getOrSet("UniswapV4Pools", getUniswapV4Pools)))
+        .flatMap(x => (x ? Object.values(x) : []))
+        .filter(p => p.poolId === params.poolId);
+}, {
+    params: Bytes32Dto,
+    tags: ["uniswapv4"],
+}));