@merkl/api 0.10.394 → 0.10.397

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

@@ -119,6 +119,14 @@ export declare abstract class OpportunityRepository {
                 Campaign: {
                     startTimestamp: bigint;
                     endTimestamp: bigint;
+                    CampaignStatus: {
+                        error: string;
+                        details: Prisma.JsonValue;
+                        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                    }[];
                     amount: string;
                     RewardToken: {
                         symbol: string;
@@ -133,14 +141,6 @@ export declare abstract class OpportunityRepository {
                         isTest: boolean;
                         price: number | null;
                     };
-                    CampaignStatus: {
-                        error: string;
-                        details: Prisma.JsonValue;
-                        status: import("../../../../database/api/.generated").$Enums.RunStatus;
-                        campaignId: string;
-                        computedUntil: bigint;
-                        processingStarted: bigint;
-                    }[];
                 };
             } & {
                 id: number;
@@ -237,6 +237,14 @@ export declare abstract class OpportunityRepository {
                 Campaign: {
                     startTimestamp: bigint;
                     endTimestamp: bigint;
+                    CampaignStatus: {
+                        error: string;
+                        details: Prisma.JsonValue;
+                        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                    }[];
                     amount: string;
                     RewardToken: {
                         symbol: string;
@@ -251,14 +259,6 @@ export declare abstract class OpportunityRepository {
                         isTest: boolean;
                         price: number | null;
                     };
-                    CampaignStatus: {
-                        error: string;
-                        details: Prisma.JsonValue;
-                        status: import("../../../../database/api/.generated").$Enums.RunStatus;
-                        campaignId: string;
-                        computedUntil: bigint;
-                        processingStarted: bigint;
-                    }[];
                 };
             } & {
                 id: number;
@@ -301,6 +301,14 @@ export declare abstract class OpportunityRepository {
             icon: string;
         };
         Campaigns: ({
+            CampaignStatus: {
+                error: string;
+                details: Prisma.JsonValue;
+                status: import("../../../../database/api/.generated").$Enums.RunStatus;
+                campaignId: string;
+                computedUntil: bigint;
+                processingStarted: bigint;
+            }[];
             ComputeChain: {
                 name: string;
                 id: number;
@@ -331,14 +339,6 @@ export declare abstract class OpportunityRepository {
                 isTest: boolean;
                 price: number | null;
             };
-            CampaignStatus: {
-                error: string;
-                details: Prisma.JsonValue;
-                status: import("../../../../database/api/.generated").$Enums.RunStatus;
-                campaignId: string;
-                computedUntil: bigint;
-                processingStarted: bigint;
-            }[];
         } & {
             params: Prisma.JsonValue;
             type: import("../../../../database/api/.generated").$Enums.CampaignType;
@@ -416,6 +416,14 @@ export declare abstract class OpportunityRepository {
                 Campaign: {
                     startTimestamp: bigint;
                     endTimestamp: bigint;
+                    CampaignStatus: {
+                        error: string;
+                        details: Prisma.JsonValue;
+                        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                    }[];
                     amount: string;
                     RewardToken: {
                         symbol: string;
@@ -430,14 +438,6 @@ export declare abstract class OpportunityRepository {
                         isTest: boolean;
                         price: number | null;
                     };
-                    CampaignStatus: {
-                        error: string;
-                        details: Prisma.JsonValue;
-                        status: import("../../../../database/api/.generated").$Enums.RunStatus;
-                        campaignId: string;
-                        computedUntil: bigint;
-                        processingStarted: bigint;
-                    }[];
                 };
             } & {
                 id: number;
@@ -485,6 +485,14 @@ export declare abstract class OpportunityRepository {
             icon: string;
         };
         Campaigns: ({
+            CampaignStatus: {
+                error: string;
+                details: Prisma.JsonValue;
+                status: import("../../../../database/api/.generated").$Enums.RunStatus;
+                campaignId: string;
+                computedUntil: bigint;
+                processingStarted: bigint;
+            }[];
             ComputeChain: {
                 name: string;
                 id: number;
@@ -515,14 +523,6 @@ export declare abstract class OpportunityRepository {
                 isTest: boolean;
                 price: number | null;
             };
-            CampaignStatus: {
-                error: string;
-                details: Prisma.JsonValue;
-                status: import("../../../../database/api/.generated").$Enums.RunStatus;
-                campaignId: string;
-                computedUntil: bigint;
-                processingStarted: bigint;
-            }[];
         } & {
             params: Prisma.JsonValue;
             type: import("../../../../database/api/.generated").$Enums.CampaignType;
@@ -600,6 +600,14 @@ export declare abstract class OpportunityRepository {
                 Campaign: {
                     startTimestamp: bigint;
                     endTimestamp: bigint;
+                    CampaignStatus: {
+                        error: string;
+                        details: Prisma.JsonValue;
+                        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                    }[];
                     amount: string;
                     RewardToken: {
                         symbol: string;
@@ -614,14 +622,6 @@ export declare abstract class OpportunityRepository {
                         isTest: boolean;
                         price: number | null;
                     };
-                    CampaignStatus: {
-                        error: string;
-                        details: Prisma.JsonValue;
-                        status: import("../../../../database/api/.generated").$Enums.RunStatus;
-                        campaignId: string;
-                        computedUntil: bigint;
-                        processingStarted: bigint;
-                    }[];
                 };
             } & {
                 id: number;
@@ -763,6 +763,14 @@ export declare abstract class OpportunityRepository {
                 Campaign: {
                     startTimestamp: bigint;
                     endTimestamp: bigint;
+                    CampaignStatus: {
+                        error: string;
+                        details: Prisma.JsonValue;
+                        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                    }[];
                     amount: string;
                     RewardToken: {
                         symbol: string;
@@ -777,14 +785,6 @@ export declare abstract class OpportunityRepository {
                         isTest: boolean;
                         price: number | null;
                     };
-                    CampaignStatus: {
-                        error: string;
-                        details: Prisma.JsonValue;
-                        status: import("../../../../database/api/.generated").$Enums.RunStatus;
-                        campaignId: string;
-                        computedUntil: bigint;
-                        processingStarted: bigint;
-                    }[];
                 };
             } & {
                 id: number;
@@ -820,6 +820,14 @@ export declare abstract class OpportunityRepository {
             icon: string;
         };
         Campaigns: ({
+            CampaignStatus: {
+                error: string;
+                details: Prisma.JsonValue;
+                status: import("../../../../database/api/.generated").$Enums.RunStatus;
+                campaignId: string;
+                computedUntil: bigint;
+                processingStarted: bigint;
+            }[];
             ComputeChain: {
                 name: string;
                 id: number;
@@ -843,14 +851,6 @@ export declare abstract class OpportunityRepository {
                 isTest: boolean;
                 price: number | null;
             };
-            CampaignStatus: {
-                error: string;
-                details: Prisma.JsonValue;
-                status: import("../../../../database/api/.generated").$Enums.RunStatus;
-                campaignId: string;
-                computedUntil: bigint;
-                processingStarted: bigint;
-            }[];
         } & {
             params: Prisma.JsonValue;
             type: import("../../../../database/api/.generated").$Enums.CampaignType;
@@ -928,6 +928,14 @@ export declare abstract class OpportunityRepository {
                 Campaign: {
                     startTimestamp: bigint;
                     endTimestamp: bigint;
+                    CampaignStatus: {
+                        error: string;
+                        details: Prisma.JsonValue;
+                        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
+                    }[];
                     amount: string;
                     RewardToken: {
                         symbol: string;
@@ -942,14 +950,6 @@ export declare abstract class OpportunityRepository {
                         isTest: boolean;
                         price: number | null;
                     };
-                    CampaignStatus: {
-                        error: string;
-                        details: Prisma.JsonValue;
-                        status: import("../../../../database/api/.generated").$Enums.RunStatus;
-                        campaignId: string;
-                        computedUntil: bigint;
-                        processingStarted: bigint;
-                    }[];
                 };
             } & {
                 id: number;

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

@@ -131,7 +131,6 @@ export declare abstract class OpportunityService {
             tags: string[];
             icon: string;
         } | null | undefined;
-        depositUrl?: string | undefined;
         aprRecord?: {
             timestamp: string | bigint;
             cumulated: number;
@@ -143,6 +142,7 @@ export declare abstract class OpportunityService {
                 aprRecordId: string;
             }[];
         } | undefined;
+        depositUrl?: string | undefined;
         tvlRecord?: {
             total: number;
             timestamp: string | bigint;

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

@@ -96,6 +96,106 @@ export declare const RewardController: Elysia<"/rewards", {
                 };
             };
         };
+    } & {
+        campaign: {
+            ":campaignId": {
+                index: {
+                    get: {
+                        body: unknown;
+                        params: {
+                            campaignId: string;
+                        };
+                        query: {
+                            items?: number | undefined;
+                            page?: number | undefined;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                amount: string;
+                                claimed: string;
+                                pending: string;
+                                recipient: string;
+                            }[];
+                            422: {
+                                type: "validation";
+                                on: string;
+                                summary?: string;
+                                message?: string;
+                                found?: unknown;
+                                property?: string;
+                                expected?: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        campaign: {
+            ":campaignId": {
+                total: {
+                    get: {
+                        body: unknown;
+                        params: {
+                            campaignId: string;
+                        };
+                        query: {
+                            items?: number | undefined;
+                            page?: number | undefined;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                tokenId: string;
+                                amount: bigint;
+                            };
+                            422: {
+                                type: "validation";
+                                on: string;
+                                summary?: string;
+                                message?: string;
+                                found?: unknown;
+                                property?: string;
+                                expected?: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    } & {
+        campaign: {
+            ":campaignId": {
+                count: {
+                    get: {
+                        body: unknown;
+                        params: {
+                            campaignId: string;
+                        };
+                        query: {
+                            items?: number | undefined;
+                            page?: number | undefined;
+                        };
+                        headers: unknown;
+                        response: {
+                            200: {
+                                count: number;
+                            };
+                            422: {
+                                type: "validation";
+                                on: string;
+                                summary?: string;
+                                message?: string;
+                                found?: unknown;
+                                property?: string;
+                                expected?: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
     } & {
         token: {
             index: {
@@ -105,12 +205,18 @@ export declare const RewardController: Elysia<"/rewards", {
                     query: {
                         items?: number | undefined;
                         page?: number | undefined;
+                        campaignIds?: string[] | undefined;
                         chainId: number;
                         address: string;
                     };
                     headers: unknown;
                     response: {
-                        200: import("./reward.model").BreakdownForTokenRaw[];
+                        200: {
+                            amount: string;
+                            claimed: string;
+                            pending: string;
+                            recipient: string;
+                        }[];
                         422: {
                             type: "validation";
                             on: string;
@@ -133,6 +239,7 @@ export declare const RewardController: Elysia<"/rewards", {
                     query: {
                         items?: number | undefined;
                         page?: number | undefined;
+                        campaignIds?: string[] | undefined;
                         chainId: number;
                         address: string;
                     };
@@ -164,6 +271,7 @@ export declare const RewardController: Elysia<"/rewards", {
                     query: {
                         items?: number | undefined;
                         page?: number | undefined;
+                        campaignIds?: string[] | undefined;
                         chainId: number;
                         address: string;
                     };

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

@@ -3,7 +3,9 @@ import { AuthorizationHeadersDto, EngineGuard } from "../../../guards/Engine.gua
 import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "../../../utils/throw";
 import Elysia from "elysia";
 import { ChainDto } from "../accounting";
-import { CampaignIdDto, CampaignIdWithoutPageDto, CreateManyBreakdownDto, CreateManyRewardDto, RegisterClaimsDto, TokenIdDto, UpdatePendingDto, } from "./reward.model";
+import { CampaignService } from "../campaign";
+import { TokenService } from "../token";
+import { CampaignIdDto, CampaignIdWithoutPageDto, CampaignRewardsDto, CreateManyBreakdownDto, CreateManyRewardDto, RegisterClaimsDto, TokenIdDto, UpdatePendingDto, } from "./reward.model";
 import { RewardService } from "./reward.service";
 // ─── Rewards Controller ──────────────────────────────────────────────────────
 export const RewardController = new Elysia({ prefix: "/rewards", detail: { tags: ["Rewards"] } })
@@ -33,35 +35,41 @@ export const RewardController = new Elysia({ prefix: "/rewards", detail: { tags:
     },
     detail: { hide: true },
 })
-    .group("/token", app => {
-    return (app
-        // ─── Get Reward Breakdowns For Token ───────────────────────────────
-        .get("/", async ({ query }) => await RewardService.breakdownForToken(query), {
-        query: TokenIdDto,
-        beforeHandle: ({ query }) => {
-            query.address = throwOnInvalidRequiredAddress(query.address);
-            throwOnUnsupportedChainId(query.chainId);
-        },
-        detail: { hide: true },
+    // ─── Get Reward by campaign ─────────────
+    .group("/campaign/:campaignId", app => {
+    return app
+        .resolve(async ({ params: { campaignId } }) => {
+        const campaign = await CampaignService.findUniqueOrThrow(CampaignService.splitIdOrThrow(campaignId));
+        const token = await TokenService.findUniqueOrThrow(campaign.rewardTokenId);
+        const rewardQuery = {
+            chainId: token.chainId,
+            address: token.address,
+            campaignIds: [campaign.campaignId],
+        };
+        return { campaign, token, rewardQuery };
     })
-        // ─── Get Total Amount Rewarded For Token ───────────────────────────
-        .get("/total", async ({ query }) => await RewardService.totalForToken(query), {
-        query: TokenIdDto,
-        beforeHandle: ({ query }) => {
-            query.address = throwOnInvalidRequiredAddress(query.address);
-            throwOnUnsupportedChainId(query.chainId);
-        },
+        .guard({
+        query: CampaignRewardsDto,
         detail: { hide: true },
     })
-        // ─── Get Reward Count By Chain And Root For Token ───────────────────
-        .get("/count", async ({ query }) => await RewardService.countForToken(query), {
+        .get("/", async ({ query, rewardQuery }) => await RewardService.breakdownForToken({ ...query, ...rewardQuery }))
+        .get("/total", async ({ query, rewardQuery }) => await RewardService.totalForToken({ ...query, ...rewardQuery }))
+        .get("/count", async ({ query, rewardQuery }) => await RewardService.countForToken({ ...query, ...rewardQuery }));
+})
+    // ─── Get Reward Breakdowns For Token ───────────────────────────────
+    .group("/token", app => {
+    return app
+        .guard({
         query: TokenIdDto,
         beforeHandle: ({ query }) => {
             query.address = throwOnInvalidRequiredAddress(query.address);
             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));
 })
     .group("/engine", app => {
     return (app

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

@@ -170,6 +170,11 @@ 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").TOptional<import("@sinclair/typebox").TTransform<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>]>, string[]>>;
+    page: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    items: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export declare const CampaignRewardsDto: import("@sinclair/typebox").TObject<{
     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

@@ -118,6 +118,14 @@ export const TokenIdDto = t.Object({
     address: t.String({
         description: "Token Address",
     }),
+    campaignIds: t.Optional(t
+        .Transform(t.Union([t.String(), t.Array(t.String())]))
+        .Decode(value => (typeof value === "string" ? value.split(",") : value))
+        .Encode(value => [...value])),
+    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
+});
+export const CampaignRewardsDto = t.Object({
     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/reward/reward.repository.d.ts

@@ -1,9 +1,8 @@
-import type { Prisma } from "../../../../database/api/.generated";
 import type { ChainId } from "@sdk";
-import type { BreakdownForCampaignsRaw, BreakdownForTokenRaw, CampaignIdModel, CampaignIdWithoutPageModel, CreateManyBreakdownModel, CreateManyRewardModel, PendingEntity, TokenIdModel } from "./reward.model";
+import type { BreakdownForCampaignsRaw, CampaignIdModel, CampaignIdWithoutPageModel, CreateManyBreakdownModel, CreateManyRewardModel, PendingEntity, TokenIdModel } from "./reward.model";
 export declare abstract class RewardRepository {
-    static createManyReward(rewards: CreateManyRewardModel): Promise<Prisma.BatchPayload>;
-    static createManyBreakdown(data: CreateManyBreakdownModel): Promise<Prisma.BatchPayload>;
+    static createManyReward(rewards: CreateManyRewardModel): Promise<import("database/api/.generated/runtime/library").GetBatchResult>;
+    static createManyBreakdown(data: CreateManyBreakdownModel): Promise<import("database/api/.generated/runtime/library").GetBatchResult>;
     static getByRecipient(recipient: string, roots: string[], withToken: boolean, withTestTokens: boolean, chainFilter?: ChainId[]): Promise<({
         RewardToken: {
             symbol: string;
@@ -20,7 +19,6 @@ export declare abstract class RewardRepository {
         };
         Breakdown: ({
             Campaign: {
-                campaignId: string;
                 Opportunity: {
                     Chain: {
                         name: string;
@@ -71,6 +69,7 @@ export declare abstract class RewardRepository {
                     apr: number;
                     dailyRewards: number;
                 };
+                campaignId: string;
             };
         } & {
             reason: string;
@@ -121,8 +120,8 @@ export declare abstract class RewardRepository {
         rewardCount: number;
         breakdownCount: number;
     }>;
-    static updateRewardClaimed(recipient: string, rewardTokenId: string, amount: string): Promise<Prisma.BatchPayload>;
-    static updateBreakdownClaimed(recipient: string, rewardTokenId: string, campaignId: string, reason: string, amount: string): Promise<Prisma.BatchPayload>;
+    static updateRewardClaimed(recipient: string, rewardTokenId: string, amount: string): Promise<import("database/api/.generated/runtime/library").GetBatchResult>;
+    static updateBreakdownClaimed(recipient: string, rewardTokenId: string, campaignId: string, reason: string, amount: string): Promise<import("database/api/.generated/runtime/library").GetBatchResult>;
     static findManyBreakdownUniques(uniques: {
         rewardId: string;
         campaignId: string;
@@ -188,7 +187,12 @@ export declare abstract class RewardRepository {
     static countForCampaign(campaignId: string, root: string): Promise<{
         count: number;
     }>;
-    static breakdownForToken(root: string, id: string, query: TokenIdModel): Promise<BreakdownForTokenRaw[]>;
+    static breakdownForToken(root: string, id: string, query: TokenIdModel): Promise<{
+        amount: string;
+        claimed: string;
+        pending: string;
+        recipient: string;
+    }[]>;
     static totalForToken(tokenId: string, root: string): Promise<{
         tokenId: string;
         amount: bigint;

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

@@ -1,4 +1,6 @@
+import { Campaign, Reward, RewardBreakdown } from "../../../../database/api/.generated/drizzle/schema.ts";
 import { apiDbClient } from "../../../utils/prisma";
+import { and, eq, inArray, sql } from "drizzle-orm";
 import { CampaignService } from "../campaign";
 import { TokenService } from "../token";
 import { UserService } from "../user";
@@ -325,24 +327,19 @@ export class RewardRepository {
         return { count };
     }
     static async breakdownForToken(root, id, query) {
-        const { page: _page, items: _items } = query;
+        const { page: _page, items: _items, campaignIds } = query;
         const page = _page || 0;
         const items = _items || 50;
-        const result = await apiDbClient.$queryRawUnsafe(`
-      SELECT 
-        r."amount",
-        r."claimed",
-        r."pending",
-        r."recipient"
-      FROM 
-        "Reward" r
-      WHERE 
-        r."root" = $1 AND r."rewardTokenId" = $2
-      ORDER BY 
-        (r."amount"::numeric + r."pending"::numeric) DESC
-      LIMIT $3
-      OFFSET $4
-    `, root, id, items, items * page);
+        const ids = typeof campaignIds === "string" ? [campaignIds] : (campaignIds ?? []);
+        const result = await apiDbClient.$drizzle
+            .select({ amount: Reward.amount, claimed: Reward.claimed, pending: Reward.pending, recipient: Reward.recipient })
+            .from(Reward)
+            .innerJoin(RewardBreakdown, eq(RewardBreakdown.rewardId, Reward.id))
+            .innerJoin(Campaign, eq(RewardBreakdown.campaignId, Campaign.id))
+            .where(and(eq(Reward.root, root), eq(Reward.rewardTokenId, id), ids.length > 0 ? inArray(Campaign.campaignId, ids) : sql `TRUE`))
+            .orderBy(sql `(${Reward.amount}::numeric + ${Reward.pending}::numeric) desc`)
+            .limit(items)
+            .offset(items * page);
         return result;
     }
     static async totalForToken(tokenId, root) {