@merkl/api 0.21.32 → 0.21.33

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

@@ -4951,6 +4951,30 @@ declare const eden: {
                 };
             };
         };
+        authlogin: {
+            post: (body: {
+                message: string;
+                address: string;
+                signature: string;
+            }, options?: {
+                headers?: Record<string, unknown> | undefined;
+                query?: Record<string, unknown> | undefined;
+                fetch?: RequestInit | undefined;
+            } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                200: void;
+            }>>;
+        };
+        auth: {
+            revoke: {
+                delete: (body?: unknown, options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: void;
+                }>>;
+            };
+        };
     };
     v3: {
         app: {
@@ -11623,6 +11647,38 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
             };
         };
     };
+} & {
+    v4: {
+        authlogin: {
+            post: {
+                body: {
+                    message: string;
+                    address: string;
+                    signature: string;
+                };
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: void;
+                };
+            };
+        };
+    } & {
+        auth: {
+            revoke: {
+                delete: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: void;
+                    };
+                };
+            };
+        };
+    };
 } & {
     v3: {
         app: {
@@ -17387,6 +17443,30 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 };
             };
         };
+        authlogin: {
+            post: (body: {
+                message: string;
+                address: string;
+                signature: string;
+            }, options?: {
+                headers?: Record<string, unknown> | undefined;
+                query?: Record<string, unknown> | undefined;
+                fetch?: RequestInit | undefined;
+            } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                200: void;
+            }>>;
+        };
+        auth: {
+            revoke: {
+                delete: (body?: unknown, options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: void;
+                }>>;
+            };
+        };
     };
     v3: {
         app: {

package/dist/src/engine/deprecated/erc20SubTypeProcessors/helpers/factoryFinder.js

@@ -26,7 +26,7 @@ const factoryAddresses = {
     "0x5Ea9DD3b6f042A34Df818C6c1324BC5A7c61427a": Erc20SubType.curve, // Curve Corn 2crypto Factory
     "0xd7E72f3615aa65b92A4DBdC211E296a35512988B": Erc20SubType.curveNPool, // Curve Corn Stableswap Factory
     "0x7Ca46A636b02D4aBC66883D7FF164bDE506DC66a": Erc20SubType.curveNPool, // Curve Corn 3crypto Factory
-    "0xbC0797015fcFc47d9C1856639CaE50D0e69FbEE8": Erc20SubType.curveNPool, // Curve Arbitrum 3crypto Factory
+    "0xbC0797015fcFc47d9C1856639CaE50D0e69FbEE8": Erc20SubType.curveTricrypto, // Curve Arbitrum 3crypto Factory
     "0xA5961898870943c68037F6848d2D866Ed2016bcB": Erc20SubType.curveNPool, // Curve Base
     "0xB255D6A720BB7c39fee173cE22113397119cB930": Erc20SubType.katana, // Katana Ronin
     "0x29372c22459a4e373851798bFd6808e71EA34A71": Erc20SubType.punchswap, // Punchswap Flow EVM

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/curveProcessor.js

@@ -2,6 +2,7 @@ import { Erc20SubType } from "@/engine/implementations/Erc20/subTypes";
 import { generateCardName } from "@/utils/generateCardName";
 import { BN2Number } from "@sdk";
 import { GenericProcessor } from "../GenericProcessor";
+import { getCrossCurveTokenPrice } from "../helpers/getCrossCurveTokenPrice";
 export class CurveProcessor extends GenericProcessor {
     rounds = {
         round1: [
@@ -50,8 +51,11 @@ export class CurveProcessor extends GenericProcessor {
         }
         if (type === Erc20SubType.curve_2) {
             const prices = [];
-            for (const symbol of Object.values(typeInfo.poolTokens)) {
-                const price = (await pricer.get({ symbol: symbol })) ?? 0;
+            for (const [address, symbol] of Object.entries(typeInfo.poolTokens)) {
+                let price = (await pricer.get({ symbol: symbol })) ?? 0;
+                if (price === 0) {
+                    price = await getCrossCurveTokenPrice(address);
+                }
                 prices.push(price);
             }
             let minPrice = Math.min(...prices);

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/processorMapping.js

@@ -155,4 +155,5 @@ export const processorMapping = {
     [Erc20SubType.stability]: StabilityProcessor,
     [Erc20SubType.stability_lending]: AaveProcessor,
     [Erc20SubType.hyperswap]: UniswapProcessor,
+    [Erc20SubType.curveTricrypto]: CurveNPoolProcessor,
 };

package/dist/src/engine/deprecated/erc20SubTypeProcessors/tokenTypeToProtocolAndAction.js

@@ -128,6 +128,10 @@ export const tokenTypeToProtocolAndAction = {
         protocol: "curve",
         action: OpportunityAction.POOL,
     },
+    [Erc20SubType.curveTricrypto]: {
+        protocol: "curve",
+        action: OpportunityAction.POOL,
+    },
     [Erc20SubType.sake_borrowing]: {
         protocol: "sake",
         action: OpportunityAction.BORROW,

package/dist/src/engine/implementations/Erc20/subTypes/implementations/euler/tvl.js

@@ -37,7 +37,11 @@ export class EulerTVLBuilder {
             if (!underlyingToken.decimals || !underlyingToken.price) {
                 throw new Error(`Missing decimals or price for token ${underlylingTokenAddress}`);
             }
-            const tvl = bigIntToNumber(totalAssets, underlyingToken.decimals) * underlyingToken.price;
+            let tvl = bigIntToNumber(totalAssets, underlyingToken.decimals) * underlyingToken.price;
+            // If TVL is zero, set to 0.01
+            if (tvl === 0) {
+                tvl = 0.01;
+            }
             tvls.push({
                 campaign,
                 tvl,

package/dist/src/engine/implementations/Erc20/subTypes/index.d.ts

@@ -113,5 +113,6 @@ export declare enum Erc20SubType {
     stability_lending = "stability_lending",
     lendle_vaults = "lendle_vaults",
     termmax = "termmax",
-    hyperswap = "hyperswap"
+    hyperswap = "hyperswap",
+    curveTricrypto = "curveTricrypto"
 }

package/dist/src/engine/implementations/Erc20/subTypes/index.js

@@ -113,4 +113,5 @@ export var Erc20SubType;
     Erc20SubType["lendle_vaults"] = "lendle_vaults";
     Erc20SubType["termmax"] = "termmax";
     Erc20SubType["hyperswap"] = "hyperswap";
+    Erc20SubType["curveTricrypto"] = "curveTricrypto";
 })(Erc20SubType || (Erc20SubType = {}));

package/dist/src/guards/BackOffice.guard.d.ts

@@ -4,4 +4,4 @@ export declare const AuthorizationHeadersDto: import("@sinclair/typebox").TObjec
 export type AuthorizationHeaders = typeof AuthorizationHeadersDto.static;
 export declare function BackOfficeGuard({ headers }: {
     headers: AuthorizationHeaders;
-}): Promise<void>;
+}): void;

package/dist/src/guards/BackOffice.guard.js

@@ -3,7 +3,7 @@ import { t } from "elysia";
 export const AuthorizationHeadersDto = t.Object({
     authorization: t.String(),
 });
-export async function BackOfficeGuard({ headers }) {
+export function BackOfficeGuard({ headers }) {
     if (headers.authorization !== `Bearer ${process.env.BACKOFFICE_SECRET}`) {
         throw new UnauthorizedError();
     }

package/dist/src/guards/Engine.guard.d.ts

@@ -4,4 +4,4 @@ export declare const AuthorizationHeadersDto: import("@sinclair/typebox").TObjec
 export type AuthorizationHeaders = typeof AuthorizationHeadersDto.static;
 export declare function EngineGuard({ headers }: {
     headers: AuthorizationHeaders;
-}): Promise<void>;
+}): void;

package/dist/src/guards/Engine.guard.js

@@ -3,8 +3,7 @@ import { t } from "elysia";
 export const AuthorizationHeadersDto = t.Object({
     authorization: t.String(),
 });
-export async function EngineGuard({ headers }) {
-    if (headers.authorization !== `Bearer ${process.env.ENGINE_SECRET}`) {
+export function EngineGuard({ headers }) {
+    if (headers.authorization !== `Bearer ${process.env.ENGINE_SECRET}`)
         throw new UnauthorizedError();
-    }
 }

package/dist/src/guards/VerifyJwt.guard.d.ts

@@ -0,0 +1,10 @@
+export declare const JwtCookieDto: import("@sinclair/typebox").TObject<{
+    jwt: import("@sinclair/typebox").TString;
+}>;
+export declare function VerifyJwtGuard({ cookie }: {
+    cookie: {
+        jwt: {
+            value: string;
+        };
+    };
+}): Promise<void>;

package/dist/src/guards/VerifyJwt.guard.js

@@ -0,0 +1,13 @@
+import { UnauthorizedError } from "@/errors";
+import { CacheService } from "@/modules/v4/cache/cache.service";
+import { t } from "elysia";
+import { jwtVerify } from "jose";
+export const JwtCookieDto = t.Cookie({
+    jwt: t.String(),
+});
+const JWT_SECRET = new TextEncoder().encode(process.env.JWT_SECRET);
+export async function VerifyJwtGuard({ cookie }) {
+    const decodedJwt = await jwtVerify(cookie.jwt.value, JWT_SECRET);
+    if (!decodedJwt.payload.jti || (await CacheService.sIsMember("token:revoked", decodedJwt.payload.jti)))
+        throw new UnauthorizedError("Failed to verify JWT.");
+}

package/dist/src/index.d.ts

@@ -6046,6 +6046,38 @@ declare const app: Elysia<"", false, {
             };
         };
     };
+} & {
+    v4: {
+        authlogin: {
+            post: {
+                body: {
+                    message: string;
+                    address: string;
+                    signature: string;
+                };
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: void;
+                };
+            };
+        };
+    } & {
+        auth: {
+            revoke: {
+                delete: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: void;
+                    };
+                };
+            };
+        };
+    };
 } & {
     v3: {
         app: {

package/dist/src/index.js

@@ -10,6 +10,8 @@ import { v2 } from "./routes/v2/router";
 import { v3 } from "./routes/v3/router";
 import { errorHandler } from "./utils/error";
 import { log } from "./utils/logger";
+if (!process.env.JWT_SECRET)
+    throw new Error("Environment variable JWT_SECRET is missing.");
 // Axios with bun workaround
 axios.defaults.headers.common["Accept-Encoding"] = "gzip";
 const PORT = process.env.PORT || 3000;

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

@@ -7,30 +7,24 @@ export const AccountingController = new Elysia({ prefix: "/accounting", detail:
     .get("/", async ({ query }) => await AccountingService.findMany(query), {
     query: GetTransactionsQueryModel,
     headers: AuthorizationHeadersDto,
-    beforeHandle: async ({ headers }) => {
-        await BackOfficeGuard({ headers });
-    },
+    beforeHandle: BackOfficeGuard,
 })
     .group("/revenues", app => {
     return app
         .get("", async () => await AccountingService.getAllRevenueBreakdownByChain(), {
         headers: AuthorizationHeadersDto,
-        beforeHandle: async ({ headers }) => {
-            await BackOfficeGuard({ headers });
-        },
+        beforeHandle: BackOfficeGuard,
     })
         .get("/per-month/:year/:month", async ({ params }) => await AccountingService.getMonthlyRevenue(params.year, params.month), {
         params: DateDto,
         headers: AuthorizationHeadersDto,
-        beforeHandle: async ({ headers }) => {
-            await BackOfficeGuard({ headers });
-        },
+        beforeHandle: BackOfficeGuard,
     })
         .get("/chains/:chainId", async ({ params }) => await AccountingService.getRevenueByChain(params.chainId), {
         params: ChainDto,
         headers: AuthorizationHeadersDto,
         beforeHandle: async ({ params, headers }) => {
-            await BackOfficeGuard({ headers });
+            BackOfficeGuard({ headers });
             throwOnUnsupportedChainId(params.chainId);
         },
     })
@@ -38,7 +32,7 @@ export const AccountingController = new Elysia({ prefix: "/accounting", detail:
         params: RevenuesDto,
         headers: AuthorizationHeadersDto,
         beforeHandle: async ({ params, headers }) => {
-            await BackOfficeGuard({ headers });
+            BackOfficeGuard({ headers });
             throwOnUnsupportedChainId(params.chainId);
         },
     });
@@ -50,7 +44,7 @@ export const AccountingController = new Elysia({ prefix: "/accounting", detail:
         params: TokensDto,
         headers: AuthorizationHeadersDto,
         beforeHandle: async ({ params, headers }) => {
-            await BackOfficeGuard({ headers });
+            BackOfficeGuard({ headers });
             params.tokenAddress = throwOnInvalidRequiredAddress(params.tokenAddress);
             throwOnUnsupportedChainId(params.chainId);
         },
@@ -59,7 +53,7 @@ export const AccountingController = new Elysia({ prefix: "/accounting", detail:
         params: TokensDateDto,
         headers: AuthorizationHeadersDto,
         beforeHandle: async ({ params, headers }) => {
-            await BackOfficeGuard({ headers });
+            BackOfficeGuard({ headers });
             params.tokenAddress = throwOnInvalidRequiredAddress(params.tokenAddress);
             throwOnUnsupportedChainId(params.chainId);
         },

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

@@ -0,0 +1,52 @@
+import Elysia from "elysia";
+export declare const AuthController: Elysia<"/auth", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    authlogin: {
+        post: {
+            body: {
+                message: string;
+                address: string;
+                signature: string;
+            };
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: void;
+            };
+        };
+    };
+} & {
+    auth: {
+        revoke: {
+            delete: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: void;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

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

@@ -0,0 +1,23 @@
+import { JwtCookieDto, VerifyJwtGuard } from "@/guards/VerifyJwt.guard";
+import Elysia from "elysia";
+import { LoginDto } from "./authentication.model";
+import { AuthService } from "./authentication.service";
+const authService = new AuthService();
+export const AuthController = new Elysia({
+    prefix: "/auth",
+    detail: { tags: ["Authentication"] },
+})
+    .post("login", async ({ body, cookie: { jwt } }) => {
+    jwt.value = await authService.login(body);
+    jwt.sameSite = true;
+    jwt.path = "/";
+    jwt.httpOnly = true;
+    jwt.secure = true;
+    jwt.maxAge = 2 * 60 * 60; // 2h
+    return;
+}, { body: LoginDto })
+    .delete("/revoke", async ({ cookie: { jwt } }) => {
+    await authService.revokeToken(jwt.value);
+    jwt.remove();
+    return;
+}, { beforeHandle: VerifyJwtGuard, cookie: JwtCookieDto });

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

@@ -0,0 +1,10 @@
+export declare const LoginDto: import("@sinclair/typebox").TObject<{
+    address: import("@sinclair/typebox").TString;
+    message: import("@sinclair/typebox").TString;
+    signature: import("@sinclair/typebox").TString;
+}>;
+export type MessageModel = {
+    address: `0x${string}`;
+    message: string;
+    signature: `0x${string}`;
+};

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

@@ -0,0 +1,6 @@
+import { t } from "elysia";
+export const LoginDto = t.Object({
+    address: t.String({ pattern: "^(0x)?[0-9a-fA-F]{40}$" }),
+    message: t.String(),
+    signature: t.String({ pattern: "^(0x)?[0-9a-fA-F]{130}$" }),
+});

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

@@ -0,0 +1,10 @@
+import type { MessageModel } from "./authentication.model";
+export declare class AuthService {
+    #private;
+    login(message: MessageModel): Promise<string>;
+    generateJwt(user: {
+        address: string;
+        creatorId: string | null;
+    }): Promise<string>;
+    revokeToken(jwt: string): Promise<void>;
+}

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

@@ -0,0 +1,31 @@
+import { UnauthorizedError } from "@/errors";
+import { SignJWT, decodeJwt } from "jose";
+import { http, createPublicClient } from "viem";
+import { mainnet } from "viem/chains";
+import { CacheService } from "../cache/cache.service";
+import { UserService } from "../user/user.service";
+export class AuthService {
+    #publicClient = createPublicClient({ chain: mainnet, transport: http() });
+    #encodedJwtSecret = new TextEncoder().encode(process.env.JWT_SECRET);
+    async login(message) {
+        if (!this.#publicClient.verifyMessage(message))
+            throw new UnauthorizedError("Failed to verify the message signature.");
+        let user = await UserService.findUnique(message.address);
+        if (!user)
+            user = await UserService.create({ address: message.address, tags: [] });
+        return await this.generateJwt(user);
+    }
+    async generateJwt(user) {
+        return await new SignJWT({ creator: user.creatorId })
+            .setProtectedHeader({ alg: "HS256" })
+            .setExpirationTime("2h")
+            .setAudience(user.address)
+            .setIssuer("merkl")
+            .setSubject("studio")
+            .setJti(Bun.randomUUIDv7())
+            .sign(this.#encodedJwtSecret);
+    }
+    async revokeToken(jwt) {
+        return await CacheService.sAdd("token:revoked", decodeJwt(jwt).jti);
+    }
+}

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

@@ -23,7 +23,7 @@ export const BlacklistController = new Elysia({ prefix: "/blacklists", detail: {
     body: AddBlacklistDto,
     headers: AuthorizationHeadersDto,
     beforeHandle: async ({ body, headers }) => {
-        await BackOfficeGuard({ headers });
+        BackOfficeGuard({ headers });
         body.userAddress = throwOnInvalidRequiredAddress(body.userAddress);
         body.poolAddress = throwOnInvalidRequiredAddress(body.poolAddress ?? NULL_ADDRESS);
         throwOnUnsupportedChainId(body.chainId);
@@ -35,7 +35,7 @@ export const BlacklistController = new Elysia({ prefix: "/blacklists", detail: {
     params: RemoveBlacklistDto,
     headers: AuthorizationHeadersDto,
     beforeHandle: async ({ headers, params }) => {
-        await BackOfficeGuard({ headers });
+        BackOfficeGuard({ headers });
         params.address = throwOnInvalidRequiredAddress(params.address);
     },
     detail: { hide: true },

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

@@ -2,4 +2,7 @@ export declare abstract class CacheRepository {
     static set(ttl: number, key: string, value: string): Promise<void>;
     static ttl(key: string): Promise<number>;
     static get(key: string): Promise<string | null>;
+    static sAdd(sName: string, sValue: string): Promise<void>;
+    static sRem(sName: string, sValue: string): Promise<void>;
+    static sIsMember(sName: string, sValue: string): Promise<any>;
 }

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

@@ -10,4 +10,13 @@ export class CacheRepository {
     static async get(key) {
         return await withRetry(withTimeout, [redisClient.get(key), REDIS_READ_TIMEOUT], REDIS_RETRIES);
     }
+    static async sAdd(sName, sValue) {
+        await withRetry(withTimeout, [redisClient.sAdd(sName, sValue), REDIS_WRITE_TIMEOUT], REDIS_RETRIES);
+    }
+    static async sRem(sName, sValue) {
+        await withRetry(withTimeout, [redisClient.sRem(sName, sValue), REDIS_WRITE_TIMEOUT], REDIS_RETRIES);
+    }
+    static async sIsMember(sName, sValue) {
+        return await withRetry(withTimeout, [redisClient.sIsMember(sName, sValue), REDIS_READ_TIMEOUT], REDIS_RETRIES);
+    }
 }

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

@@ -6,4 +6,7 @@ export declare abstract class CacheService {
     static keyAndTTL<Fn extends (...args: Args) => Promise<unknown>, Args extends unknown[]>(fn: Fn, ...args: Args): Promise<[string, number]>;
     static set<Fn extends (...args: Args) => Promise<unknown>, Args extends unknown[], T extends Awaited<ReturnType<Fn>>>(ttl: number, fn: Fn, ...args: Args): Promise<T>;
     static get<Fn extends (...args: Args) => Promise<unknown>, Args extends unknown[], T extends Awaited<ReturnType<Fn>>>(fn: Fn, args: Args): Promise<T | null>;
+    static sAdd(sName: string, sValue: string): Promise<void>;
+    static sRem(sName: string, sValue: string): Promise<void>;
+    static sIsMember(sName: string, sValue: string): Promise<any>;
 }

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

@@ -47,4 +47,13 @@ export class CacheService {
             return null;
         return CacheService.#uncompress(cached);
     }
+    static async sAdd(sName, sValue) {
+        return CacheRepository.sAdd(sName, sValue);
+    }
+    static async sRem(sName, sValue) {
+        return CacheRepository.sRem(sName, sValue);
+    }
+    static async sIsMember(sName, sValue) {
+        return await CacheRepository.sIsMember(sName, sValue);
+    }
 }

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

@@ -13,9 +13,7 @@ import { validateId } from "./validate-id.pipe";
 // ─── Opportunities Controller ────────────────────────────────────────────────
 export const OpportunityController = new Elysia({
     prefix: "/opportunities",
-    detail: {
-        tags: ["Opportunities"],
-    },
+    detail: { tags: ["Opportunities"] },
 })
     // ─── Get All Opportunities ───────────────────────────────────────────
     .get("/", async ({ query }) => OpportunityService.findMany(query), {

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

@@ -68,11 +68,20 @@ export const RewardController = new Elysia({ prefix: "/rewards", detail: { tags:
             query.campaignIds = query?.campaignIds?.flatMap(x => x.split(","));
             throwOnUnsupportedChainId(query.chainId);
         },
-        detail: { hide: true },
     })
-        .get("/", async ({ query }) => await RewardService.breakdownForToken(query))
-        .get("/total", async ({ query }) => await RewardService.totalForToken(query))
-        .get("/count", async ({ query }) => await RewardService.countForToken(query));
+        .get("/", async ({ query }) => await RewardService.breakdownForToken(query), {
+        detail: {
+            description: "Returns the all the address that received rewards of a given token, sorted by descending amounts",
+        },
+    })
+        .get("/total", async ({ query }) => await RewardService.totalForToken(query), {
+        detail: { description: "Returns the total amount distributed for a given token" },
+    })
+        .get("/count", async ({ query }) => await RewardService.countForToken(query), {
+        detail: {
+            description: "Returns the number of recipients that earned rewards in a given token",
+        },
+    });
 })
     .group("/engine", {
     headers: AuthorizationHeadersDto,

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

@@ -5916,6 +5916,38 @@ export declare const v4: Elysia<"/v4", false, {
             };
         };
     };
+} & {
+    v4: {
+        authlogin: {
+            post: {
+                body: {
+                    message: string;
+                    address: string;
+                    signature: string;
+                };
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: void;
+                };
+            };
+        };
+    } & {
+        auth: {
+            revoke: {
+                delete: {
+                    body: unknown;
+                    params: {};
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: void;
+                    };
+                };
+            };
+        };
+    };
 }, {
     derive: {};
     resolve: {};

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

@@ -30,6 +30,7 @@ import { RedisInstrumentation } from "@opentelemetry/instrumentation-redis-4";
 import { AlwaysOffSampler, BatchSpanProcessor } from "@opentelemetry/sdk-trace-node";
 import { PrismaInstrumentation } from "@prisma/instrumentation";
 import Elysia from "elysia";
+import { AuthController } from "./authentication/authentication.controller";
 import { ReferralController } from "./referral/referral.controller";
 import { TurtleController } from "./turtle/turtle.controller";
 // ─── V4 Router ───────────────────────────────────────────────────────────────
@@ -88,4 +89,5 @@ export const v4 = new Elysia({ tags: ["v4"], prefix: "/v4" })
     .use(CreatorController)
     .use(ReferralController)
     .use(UniswapController)
-    .use(TurtleController);
+    .use(TurtleController)
+    .use(AuthController);