@merkl/api 0.20.52 → 0.20.53

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

@@ -14,9 +14,18 @@ export class AccountingRepository {
             where: {
                 fromTokenId,
                 NOT: {
-                    recipient: {
-                        equals: apiDbClient.dump.fields.multisig,
-                    },
+                    OR: [
+                        {
+                            recipient: {
+                                equals: apiDbClient.dump.fields.multisig,
+                            },
+                        },
+                        {
+                            recipient: {
+                                equals: "0xb08AB4332AD871F89da24df4751968A61e58013c",
+                            },
+                        },
+                    ],
                 },
             },
         });
@@ -38,9 +47,18 @@ export class AccountingRepository {
     static async getForMultisigBetweenDates(startDate, endDate) {
         return await apiDbClient.dump.findMany({
             where: {
-                recipient: {
-                    equals: apiDbClient.dump.fields.multisig,
-                },
+                OR: [
+                    {
+                        recipient: {
+                            equals: apiDbClient.dump.fields.multisig,
+                        },
+                    },
+                    {
+                        recipient: {
+                            equals: "0xb08AB4332AD871F89da24df4751968A61e58013c",
+                        },
+                    },
+                ],
                 datetime: {
                     gte: startDate,
                     lt: endDate,
@@ -51,9 +69,18 @@ export class AccountingRepository {
     static async getForMultisig() {
         return await apiDbClient.dump.findMany({
             where: {
-                recipient: {
-                    equals: apiDbClient.dump.fields.multisig,
-                },
+                OR: [
+                    {
+                        recipient: {
+                            equals: apiDbClient.dump.fields.multisig,
+                        },
+                    },
+                    {
+                        recipient: {
+                            equals: "0xb08AB4332AD871F89da24df4751968A61e58013c",
+                        },
+                    },
+                ],
             },
         });
     }
@@ -61,9 +88,18 @@ export class AccountingRepository {
         return await apiDbClient.dump.findMany({
             where: {
                 chainId,
-                recipient: {
-                    equals: apiDbClient.dump.fields.multisig,
-                },
+                OR: [
+                    {
+                        recipient: {
+                            equals: apiDbClient.dump.fields.multisig,
+                        },
+                    },
+                    {
+                        recipient: {
+                            equals: "0xb08AB4332AD871F89da24df4751968A61e58013c",
+                        },
+                    },
+                ],
             },
         });
     }
@@ -75,9 +111,18 @@ export class AccountingRepository {
                     gte: startDate,
                     lte: endDate,
                 },
-                recipient: {
-                    equals: apiDbClient.dump.fields.multisig,
-                },
+                OR: [
+                    {
+                        recipient: {
+                            equals: apiDbClient.dump.fields.multisig,
+                        },
+                    },
+                    {
+                        recipient: {
+                            equals: "0xb08AB4332AD871F89da24df4751968A61e58013c",
+                        },
+                    },
+                ],
             },
         });
     }
@@ -90,9 +135,18 @@ export class AccountingRepository {
                     lte: endDate,
                 },
                 NOT: {
-                    recipient: {
-                        equals: apiDbClient.dump.fields.multisig,
-                    },
+                    OR: [
+                        {
+                            recipient: {
+                                equals: apiDbClient.dump.fields.multisig,
+                            },
+                        },
+                        {
+                            recipient: {
+                                equals: "0xb08AB4332AD871F89da24df4751968A61e58013c",
+                            },
+                        },
+                    ],
                 },
             },
         });

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

@@ -4900,26 +4900,83 @@ export declare const v4: Elysia<"/v4", 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;
                             };
                         };
                     };

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

@@ -36,26 +36,83 @@ export declare const UniswapController: Elysia<"uniswap", 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;
                         };
                     };
                 };

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

@@ -1,6 +1,11 @@
+import { AuthorizationHeadersDto, BackOfficeGuard } from "@/guards/BackOffice.guard";
+import { UnsupportedNetwork } from "@/utils/error";
 import { throwOnInvalidAddress, throwOnInvalidRequiredAddress } from "@/utils/throw";
 import Elysia, { t } from "elysia";
-import { RewardsPerV3PositionDto } from "./uniswap.model";
+import { CacheService } from "../cache";
+import { TTLPresets } from "../cache/cache.model";
+import { ChainUniqueDto } from "../chain/chain.model";
+import { Bytes32Dto, RewardsPerV3PositionDto, UniV4ChainIdArray, UniswapV4PoolDto, } from "./uniswap.model";
 import { UniswapService } from "./uniswap.service";
 export const UniswapController = new Elysia({
     prefix: "uniswap",
@@ -21,14 +26,52 @@ export const UniswapController = new Elysia({
     });
 })
     .group("/v4", app => {
-    return app.get("/pools", async ({ query }) => {
-        return await UniswapService.getPoolsByChain(query.chainId);
+    return app
+        .get(
+    // TODO: add pagination
+    "/pools", async () => {
+        return await CacheService.wrap(TTLPresets.DAY_1, UniswapService.getUniswapV4Pools);
     }, {
-        query: t.Object({
-            chainId: t.Numeric(),
-        }),
         detail: {
             description: "Get Uniswap V4 pools by chain",
         },
+    })
+        .get("pools/:chainId", async ({ params }) => {
+        return ((await CacheService.wrap(TTLPresets.DAY_1, UniswapService.getUniswapV4Pools))[params.chainId] ?? {});
+    }, {
+        params: ChainUniqueDto,
+        beforeHandle: ({ params }) => {
+            if (!UniV4ChainIdArray.includes(params.chainId))
+                throw new UnsupportedNetwork(params.chainId);
+        },
+        response: t.Record(t.String(), // poolId
+        UniswapV4PoolDto),
+    })
+        .get("/:poolId", async ({ params }) => {
+        return Object.values(await CacheService.wrap(TTLPresets.DAY_1, UniswapService.getUniswapV4Pools))
+            .flatMap(x => (x ? Object.values(x) : []))
+            .filter(p => p.poolId === params.poolId);
+    }, {
+        params: Bytes32Dto,
+        response: t.Array(UniswapV4PoolDto),
+    })
+        .post("/update", async () => {
+        await CacheService.set(TTLPresets.DAY_1, UniswapService.getUniswapV4Pools);
+    }, {
+        headers: AuthorizationHeadersDto,
+        beforeHandle: BackOfficeGuard,
+        detail: { hide: true },
+    })
+        .post("/update/:chainId", async ({ params }) => {
+        await CacheService.set(TTLPresets.DAY_1, UniswapService.getUniswapV4Pools, params.chainId);
+    }, {
+        params: ChainUniqueDto,
+        headers: AuthorizationHeadersDto,
+        beforeHandle: async ({ params, headers }) => {
+            await BackOfficeGuard({ headers });
+            if (!UniV4ChainIdArray.includes(params.chainId))
+                throw new UnsupportedNetwork(params.chainId);
+        },
+        detail: { hide: true },
     });
 });

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

@@ -1,6 +1,32 @@
 import type { apiDbClient } from "@db";
 import type { Prisma } from "@db/api";
-import type { MerklChainId, UniswapV4PoolType } from "@sdk";
+import { type MerklChainId, type UniswapV4PoolType } from "@sdk";
+export declare const UniV4ChainIdArray: MerklChainId[];
+export declare enum LoggedEntityType {
+    EULER = "EULER_VAULT",
+    UNISWAP_V4 = "UNISWAP_V4"
+}
+export type UniV4ChainId = (typeof UniV4ChainIdArray)[number];
+export type UniswapV4PoolsReturnType = {
+    [chainId in MerklChainId]?: {
+        [poolId: string]: UniswapV4PoolType;
+    };
+};
+export type LoggedCreateBody = Prisma.Args<typeof apiDbClient.logged, "createMany">["data"];
+export declare const UniswapV4PoolDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    currency0: import("@sinclair/typebox").TString;
+    currency1: import("@sinclair/typebox").TString;
+    decimalsCurrency0: import("@sinclair/typebox").TNumber;
+    decimalsCurrency1: import("@sinclair/typebox").TNumber;
+    hooks: import("@sinclair/typebox").TString;
+    fetchedAtBlock: import("@sinclair/typebox").TNumber;
+    lpFee: import("@sinclair/typebox").TNumber;
+    poolId: import("@sinclair/typebox").TString;
+    symbolCurrency0: import("@sinclair/typebox").TString;
+    symbolCurrency1: import("@sinclair/typebox").TString;
+    tickSpacing: import("@sinclair/typebox").TNumber;
+}>;
 export declare const Bytes32Dto: import("@sinclair/typebox").TObject<{
     poolId: import("@sinclair/typebox").TRegExp;
 }>;
@@ -10,24 +36,17 @@ export declare const RewardsPerV3PositionDto: import("@sinclair/typebox").TObjec
     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;
-        currency1: import("@sinclair/typebox").TString;
-        fee: import("@sinclair/typebox").TNumber;
-        tickSpacing: import("@sinclair/typebox").TNumber;
-        hooks: import("@sinclair/typebox").TString;
-    }>;
-    poolId: import("@sinclair/typebox").TString;
+    chainId: import("@sinclair/typebox").TNumber;
+    currency0: import("@sinclair/typebox").TString;
+    currency1: import("@sinclair/typebox").TString;
     decimalsCurrency0: import("@sinclair/typebox").TNumber;
     decimalsCurrency1: import("@sinclair/typebox").TNumber;
+    hooks: import("@sinclair/typebox").TString;
+    fetchedAtBlock: import("@sinclair/typebox").TNumber;
+    lpFee: import("@sinclair/typebox").TNumber;
+    poolId: import("@sinclair/typebox").TString;
     symbolCurrency0: import("@sinclair/typebox").TString;
     symbolCurrency1: import("@sinclair/typebox").TString;
+    tickSpacing: import("@sinclair/typebox").TNumber;
 }>>;
-export type UniswapV4PoolsReturnType = {
-    [chainId in MerklChainId]?: {
-        [poolId: string]: UniswapV4PoolType;
-    };
-};
-export type UniswapV4PoolsEntity = typeof UniswapV4PoolsDto.static;
-export type LoggedCreateBody = Prisma.Args<typeof apiDbClient.logged, "createMany">["data"];
 export type RewardsPerPositionModel = typeof RewardsPerV3PositionDto.static;

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

@@ -1,18 +1,32 @@
+import { UniswapV4Addresses } from "@sdk";
 import { t } from "elysia";
-const UniswapV4PoolKeyDto = t.Object({
+export const UniV4ChainIdArray = Object.keys(UniswapV4Addresses).map((x) => Number(x));
+export var LoggedEntityType;
+(function (LoggedEntityType) {
+    LoggedEntityType["EULER"] = "EULER_VAULT";
+    LoggedEntityType["UNISWAP_V4"] = "UNISWAP_V4";
+})(LoggedEntityType || (LoggedEntityType = {}));
+// DTOs
+// const UniswapV4PoolKeyDto = t.Object({
+//   currency0: t.String(),
+//   currency1: t.String(),
+//   fee: t.Numeric(),
+//   tickSpacing: t.Numeric(),
+//   hooks: t.String(),
+// });
+export const UniswapV4PoolDto = t.Object({
+    chainId: t.Numeric(), // Assuming MerklChainId is a numeric type
     currency0: t.String(),
     currency1: t.String(),
-    fee: t.Numeric(),
-    tickSpacing: t.Numeric(),
-    hooks: t.String(),
-});
-const UniswapV4PoolDto = t.Object({
-    poolKey: UniswapV4PoolKeyDto,
-    poolId: t.String(),
     decimalsCurrency0: t.Numeric(),
     decimalsCurrency1: t.Numeric(),
+    hooks: t.String(),
+    fetchedAtBlock: t.Numeric(),
+    lpFee: t.Numeric(),
+    poolId: t.String(),
     symbolCurrency0: t.String(),
     symbolCurrency1: t.String(),
+    tickSpacing: t.Numeric(),
 });
 export const Bytes32Dto = t.Object({
     poolId: t.RegExp(/^0x[a-fA-F0-9]{64}$/, {

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

@@ -1,6 +1,6 @@
-import type { LoggedCreateBody } from "./uniswap.model";
+import type { LoggedCreateBody, UniV4ChainId } from "./uniswap.model";
 export declare abstract class UniswapRepository {
-    static getStoredPools(): Promise<{
+    static getStoredUniswapV4Pools(chainId?: UniV4ChainId): Promise<{
         id: string;
         type: import("@db/api").$Enums.LoggedEntityType;
         address: string | null;

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

@@ -1,9 +1,9 @@
 import { apiDbClient } from "@db";
 import { LoggedEntityType } from "@db/api";
 export class UniswapRepository {
-    static async getStoredPools() {
+    static async getStoredUniswapV4Pools(chainId) {
         return await apiDbClient.logged.findMany({
-            where: { type: LoggedEntityType.UNISWAP_V4 },
+            where: { type: LoggedEntityType.UNISWAP_V4, ...(!!chainId && { chainId: chainId }) },
         });
     }
     static async createMany(data) {

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

@@ -1,23 +1,8 @@
 import { type MerklChainId } from "@sdk";
-import type { RewardsPerPositionModel, UniswapV4PoolsReturnType } from "./uniswap.model";
-export declare const PoolManagerInterface: any;
+import { type RewardsPerPositionModel, type UniV4ChainId, type UniswapV4PoolsReturnType } from "./uniswap.model";
 export declare abstract class UniswapService {
     static findV3RewardsPerPosition(query: RewardsPerPositionModel): Promise<Record<string, Record<string, any[]>>>;
-    static getPoolsByChain(chainId: MerklChainId): Promise<{
-        [x: string]: {
-            poolId: string;
-            poolKey: {
-                hooks: string;
-                fee: number;
-                tickSpacing: number;
-                currency0: string;
-                currency1: string;
-            };
-            decimalsCurrency0: number;
-            decimalsCurrency1: number;
-            symbolCurrency0: string;
-            symbolCurrency1: string;
-        };
-    }>;
-    static getPools(): Promise<UniswapV4PoolsReturnType>;
+    static getUniswapV4Pools(chainId?: UniV4ChainId): Promise<UniswapV4PoolsReturnType>;
+    /** @deprecated */
+    static getUniswapV4PoolsForChain(chainId: MerklChainId): Promise<UniswapV4PoolsReturnType>;
 }