@merkl/api 0.10.259 → 0.10.260

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

@@ -130,11 +130,13 @@ declare const eden: {
                     tags: string[];
                 };
             }>>;
-            get: (options?: {
+            get: (options: {
                 headers?: Record<string, unknown> | undefined;
-                query?: Record<string, unknown> | undefined;
+                query: {
+                    test?: boolean | undefined;
+                };
                 fetch?: RequestInit | undefined;
-            } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+            }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                 200: {
                     protocol?: {
                         name: string;
@@ -2151,7 +2153,7 @@ declare const eden: {
                 fetch?: RequestInit | undefined;
             }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                 200: (import("../modules/v4/claims").ClaimModel & {
-                    token: import("../modules/v4").Token["model"] | null;
+                    token?: import("../modules/v4").Token["model"];
                 })[];
             }>>;
         }) & {};
@@ -3180,7 +3182,9 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     params: {
                         id: string;
                     };
-                    query: unknown;
+                    query: {
+                        test?: boolean | undefined;
+                    };
                     headers: unknown;
                     response: {
                         200: {
@@ -5471,7 +5475,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     headers: unknown;
                     response: {
                         200: (import("../modules/v4/claims").ClaimModel & {
-                            token: import("../modules/v4").Token["model"] | null;
+                            token?: import("../modules/v4").Token["model"];
                         })[];
                     };
                 };
@@ -6441,11 +6445,13 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     tags: string[];
                 };
             }>>;
-            get: (options?: {
+            get: (options: {
                 headers?: Record<string, unknown> | undefined;
-                query?: Record<string, unknown> | undefined;
+                query: {
+                    test?: boolean | undefined;
+                };
                 fetch?: RequestInit | undefined;
-            } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+            }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                 200: {
                     protocol?: {
                         name: string;
@@ -8462,7 +8468,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 fetch?: RequestInit | undefined;
             }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                 200: (import("../modules/v4/claims").ClaimModel & {
-                    token: import("../modules/v4").Token["model"] | null;
+                    token?: import("../modules/v4").Token["model"];
                 })[];
             }>>;
         }) & {};

package/dist/src/index.d.ts

@@ -382,7 +382,9 @@ declare const app: Elysia<"", false, {
                     params: {
                         id: string;
                     };
-                    query: unknown;
+                    query: {
+                        test?: boolean | undefined;
+                    };
                     headers: unknown;
                     response: {
                         200: {
@@ -2673,7 +2675,7 @@ declare const app: Elysia<"", false, {
                     headers: unknown;
                     response: {
                         200: (import("./modules/v4/claims").ClaimModel & {
-                            token: import("./modules/v4").Token["model"] | null;
+                            token?: import("./modules/v4").Token["model"];
                         })[];
                     };
                 };

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

@@ -25,7 +25,7 @@ export declare const ClaimController: Elysia<"/claims", false, {
                 headers: unknown;
                 response: {
                     200: (import("./claims.model").ClaimModel & {
-                        token: import("..").Token["model"] | null;
+                        token?: import("..").Token["model"];
                     })[];
                 };
             };

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

@@ -4,6 +4,6 @@ import type { UserUniqueModel } from "../user";
 import type { ClaimModel } from "./claims.model";
 export declare abstract class ClaimService {
     static getHistoricalClaims(params: UserUniqueModel, chainFilter?: ChainId[]): Promise<(ClaimModel & {
-        token: Token["model"] | null;
+        token?: Token["model"];
     })[]>;
 }

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

@@ -25,11 +25,11 @@ export class ClaimService {
             .flatMap(p => p.value ?? []) // null/undefined claim arrays
             .filter(claim => {
             // Ensure the claim's token exists and matches the chainFilter
-            const token = claim?.token ? tokens[claim.token.toLowerCase()] : null;
+            const token = claim?.token ? tokens[claim.token.toLowerCase()] : undefined;
             return token && (!chainFilter.length || chainFilter.includes(token.chainId));
         })
             .map(claim => {
-            const token = claim?.token ? tokens[claim.token.toLowerCase()] : null;
+            const token = claim?.token ? tokens[claim.token.toLowerCase()] : undefined;
             return {
                 ...claim,
                 token,

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

@@ -251,7 +251,9 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
                 params: {
                     id: string;
                 };
-                query: unknown;
+                query: {
+                    test?: boolean | undefined;
+                };
                 headers: unknown;
                 response: {
                     200: {

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

@@ -2,7 +2,7 @@ import { HttpErrorDto, NotFoundError, NotFoundErrorDto } from "../../../errors";
 import { BackOfficeGuard } from "../../../guards/BackOffice.guard";
 import { AuthorizationHeadersDto, TokenAuthGuard } from "../../../guards/TokenAuth.guard";
 import Elysia, { t } from "elysia";
-import { CreateOpportunityDto, GetOpportunitiesQueryDto, OpportunityAggregateFieldDto, OpportunityIdDto, OpportunityResourceDto, OpportunityUniqueDto, OpportunityWithCampaignsResourceDto, UpdateOpportunityDto, } from "./opportunity.model";
+import { CreateOpportunityDto, GetOpportunitiesQueryDto, GetOpportunityQueryDto, OpportunityAggregateFieldDto, OpportunityIdDto, OpportunityResourceDto, OpportunityUniqueDto, OpportunityWithCampaignsResourceDto, UpdateOpportunityDto, } from "./opportunity.model";
 import { OpportunityService } from "./opportunity.service";
 import { transformId } from "./transform-id.pipe";
 import { validateId } from "./validate-id.pipe";
@@ -59,16 +59,16 @@ export const OpportunityController = new Elysia({
     response: { 200: t.Number() },
 })
     // ─── Get An Opportunity By Id ────────────────────────────────────────
-    .get("/:id", async ({ params }) => {
+    .get("/:id", async ({ params, query }) => {
     try {
         if (!params.id.includes("-"))
-            return await OpportunityService.getUniqueOrThrow(params.id);
+            return await OpportunityService.getUniqueOrThrow(params.id, query.test ?? false);
         const [chainId, type, identifier] = params.id.split("-");
         return await OpportunityService.getUniqueOrThrow({
             chainId: +chainId,
             type: type,
             identifier,
-        });
+        }, query.test ?? false);
     }
     catch (err) {
         if (err.code && err.code === "P2025")
@@ -77,6 +77,7 @@ export const OpportunityController = new Elysia({
     }
 }, {
     params: OpportunityUniqueDto,
+    query: GetOpportunityQueryDto,
     transform: transformId,
     beforeHandle: validateId,
     response: {

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

@@ -291,6 +291,9 @@ export declare const GetOpportunitiesQueryDto: import("@sinclair/typebox").TObje
     page: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
     items: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
 }>;
+export declare const GetOpportunityQueryDto: import("@sinclair/typebox").TObject<{
+    test: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;
 export declare const CreateOpportunityDto: import("@sinclair/typebox").TObject<{
     chainId: import("@sinclair/typebox").TNumber;
     type: import("@sinclair/typebox").TEnum<{
@@ -347,6 +350,7 @@ 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 & {
     id: string;
 };

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

@@ -70,6 +70,9 @@ export const GetOpportunitiesQueryDto = t.Object({
     page: t.Optional(t.Numeric({ description: "0-indexed page number", default: 0 })),
     items: t.Optional(t.Numeric({ description: "Number of items returned by page", default: 20 })), // items per page
 });
+export const GetOpportunityQueryDto = t.Object({
+    test: t.Optional(t.Boolean({ description: "Include test campaigns" })),
+});
 export const CreateOpportunityDto = t.Object({
     chainId: t.Number(),
     type: t.Enum(CampaignType),

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

@@ -168,7 +168,7 @@ export declare abstract class OpportunityRepository {
         apr: number;
         dailyRewards: number;
     }) | null>;
-    static findUniqueOrThrow(id: string): Promise<{
+    static findUniqueOrThrow(id: string, withTest?: boolean): Promise<{
         Chain: {
             name: string;
             id: number;

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

@@ -6,7 +6,7 @@ import { ProtocolService } from "../protocol";
 import { RewardService } from "../reward";
 import { TvlService } from "../tvl";
 export class OpportunityRepository {
-    static #getRecordInclusion() {
+    static #getRecordInclusion(withTest = true) {
         return {
             AprRecords: {
                 take: 1,
@@ -23,6 +23,11 @@ export class OpportunityRepository {
                 orderBy: { timestamp: "desc" },
                 include: {
                     DailyRewardsBreakdown: {
+                        where: {
+                            Campaign: {
+                                RewardToken: { isTest: withTest },
+                            },
+                        },
                         include: {
                             Campaign: {
                                 select: {
@@ -120,10 +125,10 @@ export class OpportunityRepository {
             where: { id },
         });
     }
-    static async findUniqueOrThrow(id) {
+    static async findUniqueOrThrow(id, withTest = true) {
         return await apiDbClient.opportunity.findUniqueOrThrow({
             include: {
-                ...OpportunityRepository.#getRecordInclusion(),
+                ...OpportunityRepository.#getRecordInclusion(withTest),
                 Chain: true,
                 MainProtocol: true,
                 Protocols: true,
@@ -241,7 +246,7 @@ export class OpportunityRepository {
             take: items,
             skip: page * items,
             include: {
-                ...OpportunityRepository.#getRecordInclusion(),
+                ...OpportunityRepository.#getRecordInclusion(test),
                 MainProtocol: true,
                 Chain: true,
                 Protocols: true,

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

@@ -1,9 +1,10 @@
 import { type CreateCampaignModel } from "../campaign";
 import { Prisma } from "../../../../database/api/.generated";
 import type { ChainId, MerklChainId } from "@sdk";
-import type { CreateOpportunityModel, GetOpportunitiesQueryModel, LightOpportunityFromDB, OpportunityMetadata, OpportunityResourceModel, OpportunityUnique, OpportunityWithCampaignsResourceModel, UpdateOpportunityModel } from "./opportunity.model";
+import type { CreateOpportunityModel, GetOpportunitiesQueryModel, LightOpportunityFromDB, OpportunityResourceModel, OpportunityUnique, OpportunityWithCampaignsResourceModel, UpdateOpportunityModel } from "./opportunity.model";
 import { OpportunityRepository } from "./opportunity.repository";
 export declare abstract class OpportunityService {
+    #private;
     static hashId(opportunity: OpportunityUnique): string;
     /**
      * create an opportunity without campaigns
@@ -78,15 +79,9 @@ export declare abstract class OpportunityService {
         depositUrl: any;
         tags: string[];
     }>;
-    /**
-     * build/fetch metadata of a campaign's opportunity
-     * @param campaign
-     * @returns {OpportunityMetadata}
-     */
-    static getMetadata(campaign: Omit<CreateCampaignModel, "id">): Promise<OpportunityMetadata>;
     static updateMetadata(chain: ChainId): Promise<void>;
     static getUniqueWithCampaignsOrThrow(opportunityId: string | OpportunityUnique): Promise<OpportunityWithCampaignsResourceModel>;
-    static getUniqueOrThrow(opportunityId: string | OpportunityUnique): Promise<OpportunityResourceModel>;
+    static getUniqueOrThrow(opportunityId: string | OpportunityUnique, withTest?: boolean): Promise<OpportunityResourceModel>;
     /**
      * Get the list of opportunities satisfying the query
      * @param query

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

@@ -34,9 +34,56 @@ export class OpportunityService {
         const id = OpportunityService.hashId(newOpp);
         return await OpportunityRepository.create({ ...newOpp, id });
     }
+    /**
+     * build/fetch metadata of a campaign's opportunity
+     * @param campaign
+     * @returns {OpportunityMetadata}
+     */
+    static async #getMetadata(campaign) {
+        const campaignType = CampaignService.getTypeFromV3(campaign.type);
+        const campaignParams = JSON.parse(campaign.params);
+        const chainId = campaign.computeChainId === 0 ? campaign.chainId : campaign.computeChainId;
+        switch (campaignType) {
+            case "CLAMM":
+                return getClammMetadata(chainId, campaignParams);
+            case "ERC20":
+                return getErc20Metadata(chainId, campaign.chainId, // distributionChainId
+                campaign.campaignId, campaign.rewardTokenAddress, campaign.amount, campaignParams);
+            case "ERC20_SNAPSHOT":
+                return getErc20SnapshotMetadata(chainId, campaignParams);
+            case "JSON_AIRDROP":
+                return getJsonAirdropMetadata(chainId, campaign.creator, campaignParams);
+            case "SILO":
+                return getSiloMetadata(chainId, campaign.subType, campaignParams);
+            case "RADIANT":
+                return getRadiantMetadata(chainId, campaign.subType, campaignParams);
+            case "MORPHO":
+                return getMorphoMetadata(chainId, campaign.subType, campaignParams);
+            case "DOLOMITE":
+                return getDolomiteMetadata(chainId, campaign.subType, campaignParams);
+            case "BADGER":
+                return getBadgerMetadata(chainId, campaignParams);
+            case "COMPOUND":
+                return getCompoundMetadata(chainId, campaign.subType, campaignParams);
+            case "AJNA":
+                return getAjnaMetadata(chainId, campaign.subType, campaignParams);
+            case "EIGENLAYER":
+                return getEigenLayerMetadata(chainId, campaignParams);
+            case "EULER":
+                return getEulerMetadata(chainId, campaign.campaignId, campaign.subType, campaign.rewardTokenAddress, campaign.amount, campaignParams);
+            case "INVALID":
+                return {
+                    name: "Invalid Campaigns",
+                    action: OpportunityAction.INVALID,
+                    tokens: [],
+                };
+            default:
+                throw "UNKNOWN CAMPAIGN TYPE";
+        }
+    }
     static async createFromCampaign(campaign, upsert = false) {
         const campaignType = CampaignService.getTypeFromV3(campaign.type);
-        const metadata = await OpportunityService.getMetadata(campaign);
+        const metadata = await OpportunityService.#getMetadata(campaign);
         metadata.tags = [...((await UserService.findUnique(campaign.creator))?.tags ?? []), ...(campaign?.tags ?? [])];
         const opportunityId = OpportunityService.hashId({
             chainId: campaign.computeChainId,
@@ -89,53 +136,6 @@ export class OpportunityService {
         }, true // Upserting
         );
     }
-    /**
-     * build/fetch metadata of a campaign's opportunity
-     * @param campaign
-     * @returns {OpportunityMetadata}
-     */
-    static async getMetadata(campaign) {
-        const campaignType = CampaignService.getTypeFromV3(campaign.type);
-        const campaignParams = JSON.parse(campaign.params);
-        const chainId = campaign.computeChainId === 0 ? campaign.chainId : campaign.computeChainId;
-        switch (campaignType) {
-            case "CLAMM":
-                return getClammMetadata(chainId, campaignParams);
-            case "ERC20":
-                return getErc20Metadata(chainId, campaign.chainId, // distributionChainId
-                campaign.campaignId, campaign.rewardTokenAddress, campaign.amount, campaignParams);
-            case "ERC20_SNAPSHOT":
-                return getErc20SnapshotMetadata(chainId, campaignParams);
-            case "JSON_AIRDROP":
-                return getJsonAirdropMetadata(chainId, campaign.creator, campaignParams);
-            case "SILO":
-                return getSiloMetadata(chainId, campaign.subType, campaignParams);
-            case "RADIANT":
-                return getRadiantMetadata(chainId, campaign.subType, campaignParams);
-            case "MORPHO":
-                return getMorphoMetadata(chainId, campaign.subType, campaignParams);
-            case "DOLOMITE":
-                return getDolomiteMetadata(chainId, campaign.subType, campaignParams);
-            case "BADGER":
-                return getBadgerMetadata(chainId, campaignParams);
-            case "COMPOUND":
-                return getCompoundMetadata(chainId, campaign.subType, campaignParams);
-            case "AJNA":
-                return getAjnaMetadata(chainId, campaign.subType, campaignParams);
-            case "EIGENLAYER":
-                return getEigenLayerMetadata(chainId, campaignParams);
-            case "EULER":
-                return getEulerMetadata(chainId, campaign.campaignId, campaign.subType, campaign.rewardTokenAddress, campaign.amount, campaignParams);
-            case "INVALID":
-                return {
-                    name: "Invalid Campaigns",
-                    action: OpportunityAction.INVALID,
-                    tokens: [],
-                };
-            default:
-                throw "UNKNOWN CAMPAIGN TYPE";
-        }
-    }
     static async updateMetadata(chain) {
         try {
             const opportunities = await OpportunityRepository.findManyWithCampaigns({
@@ -163,9 +163,9 @@ export class OpportunityService {
         const formatted = OpportunityService.formatResponse(opportunity);
         return Object.assign(formatted, { campaigns: Campaigns.map(CampaignService.format) });
     }
-    static async getUniqueOrThrow(opportunityId) {
+    static async getUniqueOrThrow(opportunityId, withTest = false) {
         const id = typeof opportunityId === "string" ? opportunityId : OpportunityService.hashId(opportunityId);
-        const opportunity = await OpportunityRepository.findUniqueOrThrow(id);
+        const opportunity = await OpportunityRepository.findUniqueOrThrow(id, withTest);
         return OpportunityService.formatResponse(opportunity);
     }
     /**

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

@@ -260,7 +260,9 @@ export declare const v4: Elysia<"/v4", false, {
                     params: {
                         id: string;
                     };
-                    query: unknown;
+                    query: {
+                        test?: boolean | undefined;
+                    };
                     headers: unknown;
                     response: {
                         200: {
@@ -2551,7 +2553,7 @@ export declare const v4: Elysia<"/v4", false, {
                     headers: unknown;
                     response: {
                         200: (import("./claims").ClaimModel & {
-                            token: import("./token").Token["model"] | null;
+                            token?: import("./token").Token["model"];
                         })[];
                     };
                 };