@merkl/api 0.21.32 → 0.21.34

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.d.ts

@@ -1135,6 +1135,45 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
             };
         };
     };
+} & {
+    opportunities: {
+        ":id": {
+            patch: {
+                body: {
+                    tags?: string[] | undefined;
+                };
+                params: {
+                    id: string;
+                };
+                query: unknown;
+                headers: {
+                    authorization: string;
+                };
+                response: {
+                    200: {
+                        status: import("@db/api").$Enums.Status;
+                        type: string;
+                        name: string;
+                        description: string;
+                        id: string;
+                        tags: string[];
+                        identifier: string;
+                        action: import("@db/api").$Enums.OpportunityAction;
+                        manualOverrides: import("@db/api").$Enums.OpportunityManualOverride[];
+                        chainId: number;
+                        howToSteps: string[];
+                        depositUrl: string | null;
+                        explorerAddress: string | null;
+                        mainProtocolId: string | null;
+                        tvl: number;
+                        apr: number;
+                        dailyRewards: number;
+                        lastCampaignCreatedAt: Date;
+                    };
+                };
+            };
+        };
+    };
 } & {
     opportunities: {
         ":id": {
@@ -1147,6 +1186,7 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
                         howToSteps?: string[] | undefined;
                         depositUrl?: string | undefined;
                         explorerAddress?: string | undefined;
+                        mainProtocolId?: string | undefined;
                     };
                     params: {
                         id: string;
@@ -1186,7 +1226,7 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
         ":id": {
             override: {
                 delete: {
-                    body: ("name" | "description" | "action" | "howToSteps" | "depositUrl" | "explorerAddress")[];
+                    body: ("name" | "description" | "action" | "howToSteps" | "depositUrl" | "explorerAddress" | "mainProtocolId")[];
                     params: {
                         id: string;
                     };
@@ -1287,7 +1327,9 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
             authorization: string;
         };
         query: unknown;
-        params: unknown;
+        params: {
+            id: string;
+        };
         cookie: unknown;
         response: {};
     };

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

@@ -6,16 +6,14 @@ import { log } from "@/utils/logger";
 import { throwOnUnsupportedActionList } from "@/utils/throw";
 import { ChainId } from "@sdk";
 import Elysia, { t } from "elysia";
-import { CreateOpportunityDto, GetOpportunitiesQueryDto, GetOpportunityQueryDto, OpportunityAggregateFieldDto, OpportunityDeleteOverrideDto, OpportunityOverrideDto, OpportunityResourceDto, OpportunityUniqueDto, OpportunityUniqueUpdateDto, OpportunityWithCampaignsResourceDto, } from "./opportunity.model";
+import { CreateOpportunityDto, GetOpportunitiesQueryDto, GetOpportunityQueryDto, OpportunityAggregateFieldDto, OpportunityDeleteOverrideDto, OpportunityOverrideDto, OpportunityResourceDto, OpportunityUniqueDto, OpportunityUniqueUpdateDto, OpportunityWithCampaignsResourceDto, UpdateOpportunityDto, } from "./opportunity.model";
 import { OpportunityService } from "./opportunity.service";
 import { transformId } from "./transform-id.pipe";
 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), {
@@ -179,11 +177,13 @@ export const OpportunityController = new Elysia({
     }
 }, { params: OpportunityUniqueUpdateDto })
     // ─── Override An Opportunity Field ───────────────────────────────────
+    .guard({ params: OpportunityUniqueDto })
+    .patch("/:id", async ({ params, body }) => await OpportunityService.update(params.id, body), {
+    body: UpdateOpportunityDto,
+})
     .patch("/:id/override", async ({ params, body }) => await OpportunityService.override(params.id, body), {
-    params: OpportunityUniqueDto,
     body: OpportunityOverrideDto,
 })
     .delete("/:id/override", async ({ params, body }) => await OpportunityService.deleteOverrides(params.id, body), {
-    params: OpportunityUniqueDto,
     body: OpportunityDeleteOverrideDto,
 });

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

@@ -388,6 +388,7 @@ export declare const OpportunityOverrideDto: import("@sinclair/typebox").TObject
         SWAP: "SWAP";
         INVALID: "INVALID";
     }>>;
+    mainProtocolId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
 }>;
 export declare const OpportunityDeleteOverrideDto: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TEnum<{
     name: "name";
@@ -396,7 +397,11 @@ export declare const OpportunityDeleteOverrideDto: import("@sinclair/typebox").T
     action: "action";
     description: "description";
     howToSteps: "howToSteps";
+    mainProtocolId: "mainProtocolId";
 }>>;
+export declare const UpdateOpportunityDto: import("@sinclair/typebox").TObject<{
+    tags: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+}>;
 export type GetOpportunitiesQueryModel = typeof GetOpportunitiesQueryDto.static;
 export type GetOpportunityQueryModel = typeof GetOpportunityQueryDto.static;
 export type CreateOpportunityModel = typeof CreateOpportunityDto.static;

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

@@ -124,5 +124,9 @@ export const OpportunityOverrideDto = t.Object({
     depositUrl: t.Optional(t.String({ format: "uri" })),
     explorerAddress: t.Optional(t.String({ format: "uri" })),
     action: t.Optional(t.Enum(OpportunityAction)),
+    mainProtocolId: t.Optional(t.String()),
 });
 export const OpportunityDeleteOverrideDto = t.Array(t.Enum(OpportunityManualOverride));
+export const UpdateOpportunityDto = t.Object({
+    tags: t.Optional(t.Array(t.String())),
+});

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

@@ -1150,6 +1150,45 @@ export declare const v4: Elysia<"/v4", false, {
                 };
             };
         };
+    } & {
+        opportunities: {
+            ":id": {
+                patch: {
+                    body: {
+                        tags?: string[] | undefined;
+                    };
+                    params: {
+                        id: string;
+                    };
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: {
+                            status: import("@db/api").$Enums.Status;
+                            type: string;
+                            name: string;
+                            description: string;
+                            id: string;
+                            tags: string[];
+                            identifier: string;
+                            action: import("@db/api").$Enums.OpportunityAction;
+                            manualOverrides: import("@db/api").$Enums.OpportunityManualOverride[];
+                            chainId: number;
+                            howToSteps: string[];
+                            depositUrl: string | null;
+                            explorerAddress: string | null;
+                            mainProtocolId: string | null;
+                            tvl: number;
+                            apr: number;
+                            dailyRewards: number;
+                            lastCampaignCreatedAt: Date;
+                        };
+                    };
+                };
+            };
+        };
     } & {
         opportunities: {
             ":id": {
@@ -1162,6 +1201,7 @@ export declare const v4: Elysia<"/v4", false, {
                             howToSteps?: string[] | undefined;
                             depositUrl?: string | undefined;
                             explorerAddress?: string | undefined;
+                            mainProtocolId?: string | undefined;
                         };
                         params: {
                             id: string;
@@ -1201,7 +1241,7 @@ export declare const v4: Elysia<"/v4", false, {
             ":id": {
                 override: {
                     delete: {
-                        body: ("name" | "description" | "action" | "howToSteps" | "depositUrl" | "explorerAddress")[];
+                        body: ("name" | "description" | "action" | "howToSteps" | "depositUrl" | "explorerAddress" | "mainProtocolId")[];
                         params: {
                             id: string;
                         };
@@ -5916,6 +5956,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);

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

@@ -94,7 +94,7 @@ export const TokenController = new Elysia({ prefix: "/tokens", detail: { tags: [
     body: CreateTokenDto,
     headers: AuthorizationHeadersDto,
     beforeHandle: async ({ headers, body }) => {
-        await BackOfficeGuard({ headers });
+        BackOfficeGuard({ headers });
         body.address = throwOnInvalidRequiredAddress(body.address);
         throwOnUnsupportedChainId(body.chainId);
     },

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

@@ -91,7 +91,7 @@ export const UniswapController = new Elysia({
         params: ChainUniqueDto,
         headers: AuthorizationHeadersDto,
         beforeHandle: async ({ params, headers }) => {
-            await BackOfficeGuard({ headers });
+            BackOfficeGuard({ headers });
             if (!UniV4ChainIdArray.includes(params.chainId))
                 throw new UnsupportedNetwork(params.chainId);
         },

package/dist/src/utils/decodeCalls.js

@@ -193,11 +193,21 @@ export function decodeReturnValue(returnData, key, type) {
         case "coin2":
             return CurveInterface.decodeFunctionResult("coins", returnData)[0];
         case "N_COINS":
-            try {
-                return CurveStableSwapNGInterface.decodeFunctionResult("N_COINS", returnData)[0];
-            }
-            catch (e) {
-                return 2;
+            switch (type) {
+                case Erc20SubType.curveTricrypto:
+                    try {
+                        return CurveStableSwapNGInterface.decodeFunctionResult("N_COINS", returnData)[0];
+                    }
+                    catch (e) {
+                        return 3;
+                    }
+                default:
+                    try {
+                        return CurveStableSwapNGInterface.decodeFunctionResult("N_COINS", returnData)[0];
+                    }
+                    catch (e) {
+                        return 2;
+                    }
             }
         case "balances":
             return CurveStableSwapNGInterface.decodeFunctionResult("balances", returnData)[0];

package/dist/src/utils/generateCardName.js

@@ -160,6 +160,7 @@ export function generateCardName(type, typeInfo, campaign, symbols = [""], displ
             }
             return `${typeInfo.name}`;
         case Erc20SubType.curveNPool:
+        case Erc20SubType.curveTricrypto:
             return `Curve ${typeInfo.name}`;
         case Erc20SubType.vicuna: {
             const parsedName = typeInfo.name.split(" ");