@merkl/api 0.21.31 → 0.21.33

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

@@ -144,9 +144,9 @@ export declare const RewardController: Elysia<"/rewards", false, {
                     query: {
                         items?: number | undefined;
                         page?: number | undefined;
+                        campaignIds?: string[] | undefined;
                         address: string;
                         chainId: number;
-                        campaignIds: string[];
                     };
                     headers: unknown;
                     response: {
@@ -169,9 +169,9 @@ export declare const RewardController: Elysia<"/rewards", false, {
                     query: {
                         items?: number | undefined;
                         page?: number | undefined;
+                        campaignIds?: string[] | undefined;
                         address: string;
                         chainId: number;
-                        campaignIds: string[];
                     };
                     headers: unknown;
                     response: {
@@ -192,9 +192,9 @@ export declare const RewardController: Elysia<"/rewards", false, {
                     query: {
                         items?: number | undefined;
                         page?: number | undefined;
+                        campaignIds?: string[] | undefined;
                         address: string;
                         chainId: number;
-                        campaignIds: string[];
                     };
                     headers: unknown;
                     response: {

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

@@ -65,14 +65,23 @@ export const RewardController = new Elysia({ prefix: "/rewards", detail: { tags:
         query: TokenIdDto,
         beforeHandle: ({ query }) => {
             query.address = throwOnInvalidRequiredAddress(query.address);
-            query.campaignIds = query.campaignIds.flatMap(x => x.split(","));
+            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/reward/reward.model.d.ts

@@ -172,7 +172,7 @@ export declare const CampaignIdDto: import("@sinclair/typebox").TObject<{
 export declare const TokenIdDto: import("@sinclair/typebox").TObject<{
     chainId: import("@sinclair/typebox").TNumber;
     address: import("@sinclair/typebox").TString;
-    campaignIds: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+    campaignIds: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
     page: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
     items: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
 }>;

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

@@ -109,7 +109,7 @@ export const TokenIdDto = t.Object({
     address: t.String({
         description: "Token Address",
     }),
-    campaignIds: t.Array(t.String()),
+    campaignIds: t.Optional(t.Array(t.String())),
     page: t.Optional(t.Numeric({ description: "Page number", default: 0 })), // 0-indexed
     items: t.Optional(t.Numeric({ description: "Number of returned rows", default: 20 })), // items per page
 });

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

@@ -3212,9 +3212,9 @@ export declare const v4: Elysia<"/v4", false, {
                         query: {
                             items?: number | undefined;
                             page?: number | undefined;
+                            campaignIds?: string[] | undefined;
                             address: string;
                             chainId: number;
-                            campaignIds: string[];
                         };
                         headers: unknown;
                         response: {
@@ -3237,9 +3237,9 @@ export declare const v4: Elysia<"/v4", false, {
                         query: {
                             items?: number | undefined;
                             page?: number | undefined;
+                            campaignIds?: string[] | undefined;
                             address: string;
                             chainId: number;
-                            campaignIds: string[];
                         };
                         headers: unknown;
                         response: {
@@ -3260,9 +3260,9 @@ export declare const v4: Elysia<"/v4", false, {
                         query: {
                             items?: number | undefined;
                             page?: number | undefined;
+                            campaignIds?: string[] | undefined;
                             address: string;
                             chainId: number;
-                            campaignIds: string[];
                         };
                         headers: unknown;
                         response: {
@@ -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);

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(" ");