@merkl/api 0.17.7 → 0.17.9

package/dist/src/index.d.ts

@@ -328,6 +328,8 @@ declare const app: Elysia<"", false, {
                                     id: number;
                                     icon: string;
                                 };
+                                endTimestamp: number;
+                                startTimestamp: number;
                                 rewardToken: {
                                     symbol: string;
                                     name: string | null;
@@ -347,15 +349,15 @@ declare const app: Elysia<"", false, {
                                     icon: string;
                                 } | undefined;
                                 campaignStatus: {
+                                    computedUntil: number;
+                                    processingStarted: number;
                                     error: string;
                                     details: import("database/api/.generated/runtime/library").JsonValue;
                                     status: import("../database/api/.generated").$Enums.RunStatus;
                                     campaignId: string;
-                                    computedUntil: bigint;
-                                    processingStarted: bigint;
                                 };
                                 creatorAddress: string;
-                                Creator: {
+                                creator: {
                                     tags: string[];
                                     address: string;
                                     creatorId: string | null;
@@ -363,8 +365,6 @@ declare const app: Elysia<"", false, {
                                 type: string;
                                 id: string;
                                 subType: number | null;
-                                startTimestamp: bigint;
-                                endTimestamp: bigint;
                                 computeChainId: number;
                                 distributionChainId: number;
                                 campaignId: string;
@@ -668,13 +668,18 @@ declare const app: Elysia<"", false, {
                             apr: number;
                             dailyRewards: number;
                             campaigns: {
+                                creator?: {
+                                    tags?: string[] | undefined;
+                                    creatorId?: string | null | undefined;
+                                    address: string;
+                                } | undefined;
                                 campaignStatus?: {
                                     error?: string | undefined;
                                     details?: any;
                                     status: string;
                                     campaignId: string;
-                                    computedUntil: string | bigint;
-                                    processingStarted: string | bigint;
+                                    computedUntil: string | number;
+                                    processingStarted: string | number;
                                 } | undefined;
                                 distributionChain?: {
                                     name: string;
@@ -690,8 +695,8 @@ declare const app: Elysia<"", false, {
                                     id: number;
                                     icon: string;
                                 };
-                                startTimestamp: string | bigint;
-                                endTimestamp: string | bigint;
+                                startTimestamp: string | number;
+                                endTimestamp: string | number;
                                 computeChainId: number;
                                 distributionChainId: number;
                                 campaignId: string;
@@ -825,13 +830,18 @@ declare const app: Elysia<"", false, {
                                 apr: number;
                                 dailyRewards: number;
                                 campaigns: {
+                                    creator?: {
+                                        tags?: string[] | undefined;
+                                        creatorId?: string | null | undefined;
+                                        address: string;
+                                    } | undefined;
                                     campaignStatus?: {
                                         error?: string | undefined;
                                         details?: any;
                                         status: string;
                                         campaignId: string;
-                                        computedUntil: string | bigint;
-                                        processingStarted: string | bigint;
+                                        computedUntil: string | number;
+                                        processingStarted: string | number;
                                     } | undefined;
                                     distributionChain?: {
                                         name: string;
@@ -847,8 +857,8 @@ declare const app: Elysia<"", false, {
                                         id: number;
                                         icon: string;
                                     };
-                                    startTimestamp: string | bigint;
-                                    endTimestamp: string | bigint;
+                                    startTimestamp: string | number;
+                                    endTimestamp: string | number;
                                     computeChainId: number;
                                     distributionChainId: number;
                                     campaignId: string;
@@ -1167,6 +1177,8 @@ declare const app: Elysia<"", false, {
                                 id: number;
                                 icon: string;
                             };
+                            endTimestamp: number;
+                            startTimestamp: number;
                             rewardToken: {
                                 symbol: string;
                                 name: string | null;
@@ -1186,15 +1198,15 @@ declare const app: Elysia<"", false, {
                                 icon: string;
                             } | undefined;
                             campaignStatus: {
+                                computedUntil: number;
+                                processingStarted: number;
                                 error: string;
                                 details: import("database/api/.generated/runtime/library").JsonValue;
                                 status: import("../database/api/.generated").$Enums.RunStatus;
                                 campaignId: string;
-                                computedUntil: bigint;
-                                processingStarted: bigint;
                             };
                             creatorAddress: string;
-                            Creator: {
+                            creator: {
                                 tags: string[];
                                 address: string;
                                 creatorId: string | null;
@@ -1202,8 +1214,6 @@ declare const app: Elysia<"", false, {
                             type: string;
                             id: string;
                             subType: number | null;
-                            startTimestamp: bigint;
-                            endTimestamp: bigint;
                             computeChainId: number;
                             distributionChainId: number;
                             campaignId: string;
@@ -1231,6 +1241,8 @@ declare const app: Elysia<"", false, {
                                 id: number;
                                 icon: string;
                             };
+                            endTimestamp: number;
+                            startTimestamp: number;
                             rewardToken: {
                                 symbol: string;
                                 name: string | null;
@@ -1250,15 +1262,15 @@ declare const app: Elysia<"", false, {
                                 icon: string;
                             } | undefined;
                             campaignStatus: {
+                                computedUntil: number;
+                                processingStarted: number;
                                 error: string;
                                 details: import("database/api/.generated/runtime/library").JsonValue;
                                 status: import("../database/api/.generated").$Enums.RunStatus;
                                 campaignId: string;
-                                computedUntil: bigint;
-                                processingStarted: bigint;
                             };
                             creatorAddress: string;
-                            Creator: {
+                            creator: {
                                 tags: string[];
                                 address: string;
                                 creatorId: string | null;
@@ -1266,8 +1278,6 @@ declare const app: Elysia<"", false, {
                             type: string;
                             id: string;
                             subType: number | null;
-                            startTimestamp: bigint;
-                            endTimestamp: bigint;
                             computeChainId: number;
                             distributionChainId: number;
                             campaignId: string;

package/dist/src/jobs/etl/update-dynamic-data.js

@@ -6,7 +6,8 @@ import { OpportunityRepository } from "../../modules/v4/opportunity/opportunity.
 import { RewardService } from "../../modules/v4/reward";
 import { TvlService } from "../../modules/v4/tvl";
 import { executeSimple } from "../../utils/execute";
-import { Campaign as CampaignTypesEnum } from "@sdk";
+import { log } from "../../utils/logger";
+import { Campaign as CampaignEnum } from "@sdk";
 import moment from "moment";
 // ─── Required Env Variables ──────────────────────────────────────────────────
 const chainId = Number(process.env.CHAIN_ID);
@@ -31,7 +32,7 @@ async function updateDynamicData(liveCampaigns, campaignType) {
     for (const data of dynamicData) {
         if (!!data) {
             // Main Parameter OVERRIDING
-            if (data.campaignType === CampaignTypesEnum.SILO && data.campaignParameters.whitelist?.length === 1)
+            if (data.campaignType === CampaignEnum.SILO && data.campaignParameters.whitelist?.length === 1)
                 data.mainParameter = `${data.mainParameter}-${data.campaignParameters.whitelist[0]}`;
             if (!oppMap[`${data.campaignType}_${data.mainParameter}`])
                 oppMap[`${data.campaignType}_${data.mainParameter}`] = {};
@@ -57,25 +58,9 @@ async function updateDynamicData(liveCampaigns, campaignType) {
     }
 }
 // ─── Get And Transform Live Campaigns Into A Map ─────────────────────────────
-const getLiveCampaignsByType = async (chainId) => {
-    const liveCampaigns = (await CampaignService.getLiveCampaigns({ computeChainId: chainId })).map(c => {
-        return {
-            amount: c.amount,
-            campaignId: c.campaignId,
-            mainParameter: c.Opportunity.identifier,
-            campaignParameters: c.params,
-            campaignSubType: c.subType,
-            campaignType: c.type,
-            chainId: c.distributionChainId,
-            computeChainId: c.computeChainId,
-            creator: c.creatorAddress,
-            endTimestamp: c.endTimestamp,
-            rewardToken: c.rewardTokenId,
-            startTimestamp: c.startTimestamp,
-        };
-    });
+const buildMapByType = async (campaignsToUpdate) => {
     const campaignTypeToCampaigns = new Map();
-    for (const campaign of liveCampaigns) {
+    for (const campaign of campaignsToUpdate) {
         const type = campaign.campaignType;
         let campaigns = campaignTypeToCampaigns.get(campaign.campaignType);
         if (!campaigns)
@@ -87,22 +72,43 @@ const getLiveCampaignsByType = async (chainId) => {
     return campaignTypeToCampaigns;
 };
 // ─── Main function / entry point ─────────────────────────────────────────────
-const main = async () => {
+const updateCampaigns = async (campaignsToUpdate) => {
     // 1. Get a map of campaigns by campaign type
-    const liveCampaigns = await getLiveCampaignsByType(chainId);
+    const campaignTypeToCampaigns = await buildMapByType(campaignsToUpdate);
     // 2. Call updateDynamicData with each entries of the map (process by campaign type)
-    for (const [type, campaigns] of liveCampaigns.entries()) {
+    for (const [campaignType, campaigns] of campaignTypeToCampaigns.entries()) {
+        log.info(`updating dynamic data for ${campaigns.length} campaigns of type ${CampaignEnum[campaignType]}`);
         try {
-            await updateDynamicData(campaigns, type);
+            await updateDynamicData(campaigns, campaignType);
         }
         catch (err) {
-            console.error(`Failed to update dynamic data for campaign type ${type}`, err);
+            console.error(`Failed to update dynamic data for campaign type ${CampaignEnum[campaignType]}`, err);
         }
     }
-    // 3. Update status of opportunities
-    // 3.1 Get current live opportunities
+};
+const main = async () => {
+    const liveCampaigns = (await CampaignService.getLiveCampaigns({ computeChainId: chainId })).map(c => {
+        return {
+            amount: c.amount,
+            campaignId: c.campaignId,
+            mainParameter: c.Opportunity.identifier,
+            campaignParameters: c.params,
+            campaignSubType: c.subType,
+            campaignType: CampaignEnum[c.type],
+            chainId: c.distributionChainId,
+            computeChainId: c.computeChainId,
+            creator: c.creatorAddress,
+            endTimestamp: Number(c.endTimestamp),
+            rewardToken: c.rewardTokenId,
+            startTimestamp: Number(c.startTimestamp),
+            index: 0,
+        };
+    });
+    await updateCampaigns(liveCampaigns);
+    // Update status of opportunities
+    // 1. Get current live opportunities
     const liveOpportunities = await OpportunityService.findLiveWithCampaigns(chainId);
-    // 3.2 For each currently live opportunities, infer its updated status by looping through its campaigns
+    // 2. For each currently live opportunities, infer its updated status by looping through its campaigns
     const now = moment().unix();
     for (const opportunity of liveOpportunities) {
         let status = "NONE";
@@ -117,16 +123,12 @@ const main = async () => {
         }
         await OpportunityService.updateStatus(opportunity.id, status);
     }
-    // 4. Compute opportunity ids of liveCampaigns
-    const opportunities = new Set();
-    for (const [type, campaigns] of liveCampaigns.entries()) {
-        for (const campaign of campaigns) {
-            const opportunityId = OpportunityService.hashId({ chainId, identifier: campaign.mainParameter, type });
-            opportunities.add(opportunityId);
-        }
-    }
-    // 5. Update the status of the liveCampaigns opportunities
-    await OpportunityService.updateMany(Array.from(opportunities), { status: "LIVE" });
+    // 3. Update the status of the opportunities associated to future campaigns
+    const futureOpportunityIds = (await CampaignService.getFutureCampaigns({ computeChainId: chainId })).map(c => c.Opportunity.id);
+    await OpportunityService.updateMany(futureOpportunityIds, { status: "SOON" });
+    // 4. Update the status of the opportunities associated to live campaigns
+    const liveOpportunityIds = (await CampaignService.getLiveCampaigns({ computeChainId: chainId })).map(c => c.Opportunity.id);
+    await OpportunityService.updateMany(liveOpportunityIds, { status: "LIVE" });
 };
 try {
     await main();

package/dist/src/libs/campaigns/campaignTypes/MORPHODynamicData.js

@@ -1,4 +1,4 @@
-import { BN2Number, MorphoSubCampaignType, YEAR, } from "@sdk";
+import { BN2Number, MetamorphoInterface, MorphoSubCampaignType, YEAR, } from "@sdk";
 import { Pricer } from "../../../utils/pricer";
 const axios = require("axios");
 export async function MORPHODynamicData(chainId, campaigns) {
@@ -8,6 +8,15 @@ export async function MORPHODynamicData(chainId, campaigns) {
     const headers = {
         "content-type": "application/json",
     };
+    for (const campaign of campaigns) {
+        if (campaign.subType === MorphoSubCampaignType.META) {
+            calls.push({
+                allowFailure: true,
+                callData: MetamorphoInterface.encodeFunctionData("totalAssets"),
+                target: campaign.campaignParameters.targetToken,
+            });
+        }
+    }
     return {
         cached: false,
         call: {
@@ -23,36 +32,14 @@ export async function MORPHODynamicData(chainId, campaigns) {
                     })) ?? 0;
                     let tvl = 0;
                     let totalSupplyTargetToken = 0;
-                    if (campaign.campaignSubType === MorphoSubCampaignType.META) {
-                        const graphqlQueryVaults = {
-                            query: `query VaultByAddress($address: String!, $chainId: Int) {
-              vaultByAddress(address: $address, chainId: $chainId) {
-                state {
-                  totalAssetsUsd
-                  totalAssets
-                  totalSupply
-                }
-              }
-            }
-            `,
-                            variables: {
-                                address: campaign.campaignParameters.targetToken,
-                                chainId: campaign.computeChainId,
-                            },
-                        };
-                        try {
-                            const response = await axios({
-                                url: endpoint,
-                                method: "post",
-                                headers: headers,
-                                data: graphqlQueryVaults,
-                            });
-                            tvl = response.data.data.vaultByAddress.state.totalAssetsUsd;
-                            totalSupplyTargetToken = response.data.data.vaultByAddress.state.totalAssets;
-                        }
-                        catch (e) {
-                            console.log(e);
-                        }
+                    let index = 0;
+                    if (campaign.subType === MorphoSubCampaignType.META) {
+                        const totalAssets = BN2Number(MetamorphoInterface.decodeFunctionResult("totalAssets", result[index++])[0], campaign.campaignParameters.decimalsUnderlyingToken);
+                        const priceAsset = (await pricer.get({
+                            symbol: campaign.campaignParameters.symbolUnderlyingToken,
+                        })) ?? 0;
+                        tvl = priceAsset * totalAssets;
+                        totalSupplyTargetToken = totalAssets;
                     }
                     if (campaign.campaignSubType === MorphoSubCampaignType.SUPPLY_BLUE ||
                         campaign.campaignSubType === MorphoSubCampaignType.BORROWING_BLUE ||

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

@@ -138,6 +138,8 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                             id: number;
                             icon: string;
                         };
+                        endTimestamp: number;
+                        startTimestamp: number;
                         rewardToken: {
                             symbol: string;
                             name: string | null;
@@ -157,15 +159,15 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                             icon: string;
                         } | undefined;
                         campaignStatus: {
+                            computedUntil: number;
+                            processingStarted: number;
                             error: string;
                             details: import("database/api/.generated/runtime/library").JsonValue;
                             status: import("../../../../database/api/.generated").$Enums.RunStatus;
                             campaignId: string;
-                            computedUntil: bigint;
-                            processingStarted: bigint;
                         };
                         creatorAddress: string;
-                        Creator: {
+                        creator: {
                             tags: string[];
                             address: string;
                             creatorId: string | null;
@@ -173,8 +175,6 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                         type: string;
                         id: string;
                         subType: number | null;
-                        startTimestamp: bigint;
-                        endTimestamp: bigint;
                         computeChainId: number;
                         distributionChainId: number;
                         campaignId: string;
@@ -202,6 +202,8 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                             id: number;
                             icon: string;
                         };
+                        endTimestamp: number;
+                        startTimestamp: number;
                         rewardToken: {
                             symbol: string;
                             name: string | null;
@@ -221,15 +223,15 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                             icon: string;
                         } | undefined;
                         campaignStatus: {
+                            computedUntil: number;
+                            processingStarted: number;
                             error: string;
                             details: import("database/api/.generated/runtime/library").JsonValue;
                             status: import("../../../../database/api/.generated").$Enums.RunStatus;
                             campaignId: string;
-                            computedUntil: bigint;
-                            processingStarted: bigint;
                         };
                         creatorAddress: string;
-                        Creator: {
+                        creator: {
                             tags: string[];
                             address: string;
                             creatorId: string | null;
@@ -237,8 +239,6 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                         type: string;
                         id: string;
                         subType: number | null;
-                        startTimestamp: bigint;
-                        endTimestamp: bigint;
                         computeChainId: number;
                         distributionChainId: number;
                         campaignId: string;

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

@@ -45,6 +45,7 @@ export const CampaignController = new Elysia({ prefix: "/campaigns", detail: { t
         return CampaignService.format(await CampaignService.findUniqueOrThrow({ distributionChain: +distributionChain, campaignId }));
     }
     catch (_err) {
+        console.log(_err);
         throw new NotFoundError("Campaign not found.");
     }
 }, {

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

@@ -8,15 +8,22 @@ import { type Status } from "../status/status.model";
  * @description Target description of rewards campaigns
  * @see {@link Resource}
  */
-export type Campaign = Resource<"Campaign", "opportunityId" | "rewardTokenId" | "params", {
+export type Campaign = Resource<"Campaign", "opportunityId" | "rewardTokenId", {
     chain: Chain["model"];
     rewardToken: Token["model"];
     distributionChain?: Chain["model"];
     campaignStatus?: Status["model"];
+    creator?: {
+        address: string;
+        tags?: string[];
+        creatorId: string | null;
+    };
+    endTimestamp: number;
+    startTimestamp: number;
 }>;
-export type CampaignWithParams<C extends CampaignEnum = CampaignEnum> = Campaign & Resource<"Campaign", "opportunityId" | "rewardTokenId" | (keyof Campaign["model"] & keyof Resource<"Campaign">), {
+export type CampaignWithParams<C extends CampaignEnum = CampaignEnum> = Campaign["model"] & {
     params: CampaignParameters<C>["campaignParameters"];
-}>;
+};
 export declare const CampaignUniqueDto: import("@sinclair/typebox").TObject<{
     distributionChain: import("@sinclair/typebox").TNumber;
     campaignId: import("@sinclair/typebox").TString;
@@ -31,9 +38,14 @@ export declare const CampaignResourceDto: import("@sinclair/typebox").TObject<{
     rewardTokenId: import("@sinclair/typebox").TString;
     amount: import("@sinclair/typebox").TString;
     opportunityId: import("@sinclair/typebox").TString;
-    startTimestamp: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TBigInt, import("@sinclair/typebox").TString]>;
-    endTimestamp: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TBigInt, import("@sinclair/typebox").TString]>;
+    startTimestamp: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNumber]>;
+    endTimestamp: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNumber]>;
     creatorAddress: import("@sinclair/typebox").TString;
+    creator: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+        address: import("@sinclair/typebox").TString;
+        tags: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+        creatorId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNull]>>;
+    }>>;
     params: import("@sinclair/typebox").TAny;
     chain: import("@sinclair/typebox").TObject<{
         id: import("@sinclair/typebox").TNumber;
@@ -59,8 +71,8 @@ export declare const CampaignResourceDto: import("@sinclair/typebox").TObject<{
     }>>;
     campaignStatus: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
         campaignId: import("@sinclair/typebox").TString;
-        computedUntil: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TBigInt, import("@sinclair/typebox").TString]>;
-        processingStarted: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TBigInt, import("@sinclair/typebox").TString]>;
+        computedUntil: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNumber]>;
+        processingStarted: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TNumber]>;
         status: import("@sinclair/typebox").TString;
         error: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
         details: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>;

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

@@ -17,9 +17,14 @@ export const CampaignResourceDto = t.Object({
     rewardTokenId: t.String(),
     amount: t.String(),
     opportunityId: t.String(),
-    startTimestamp: t.Union([t.BigInt(), t.String()]),
-    endTimestamp: t.Union([t.BigInt(), t.String()]),
+    startTimestamp: t.Union([t.String(), t.Numeric()]),
+    endTimestamp: t.Union([t.String(), t.Numeric()]),
     creatorAddress: t.String(),
+    creator: t.Optional(t.Object({
+        address: t.String(),
+        tags: t.Optional(t.Array(t.String())),
+        creatorId: t.Optional(t.Nullable(t.String())),
+    })),
     params: t.Any(),
     chain: ChainResourceDto,
     rewardToken: TokenResourceDto,

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

@@ -71,8 +71,29 @@ export declare abstract class CampaignRepository {
      * A campaign is considered past if the current timestamp is greater than the campaign's end timestamp.
      *
      * @returns A promise that resolves to an array of past campaigns.
+     *
+     * @dev Excludes test campaigns
      */
-    static getPastCampaigns(chainId?: number): Promise<{
+    static getPastCampaigns(query?: {
+        computeChainId?: number;
+        type?: string;
+    }): Promise<({
+        Opportunity: {
+            name: string;
+            type: string;
+            id: string;
+            status: import("../../../../database/api/.generated").$Enums.Status;
+            tags: string[];
+            identifier: string;
+            chainId: number;
+            action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
+            depositUrl: string | null;
+            mainProtocolId: string | null;
+            tvl: number;
+            apr: number;
+            dailyRewards: number;
+        };
+    } & {
         type: string;
         id: string;
         params: Prisma.JsonValue;
@@ -86,12 +107,56 @@ export declare abstract class CampaignRepository {
         amount: string;
         opportunityId: string;
         creatorAddress: string;
-    }[]>;
+    })[]>;
+    /**
+     * Retrieves all past campaigns from the database.
+     * A campaign is considered past if the current timestamp is greater than the campaign's end timestamp.
+     *
+     * @returns A promise that resolves to an array of past campaigns.
+     *
+     * @dev Excludes test campaigns
+     */
+    static getFutureCampaigns(query?: {
+        computeChainId?: number;
+        type?: string;
+    }): Promise<({
+        Opportunity: {
+            name: string;
+            type: string;
+            id: string;
+            status: import("../../../../database/api/.generated").$Enums.Status;
+            tags: string[];
+            identifier: string;
+            chainId: number;
+            action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
+            depositUrl: string | null;
+            mainProtocolId: string | null;
+            tvl: number;
+            apr: number;
+            dailyRewards: number;
+        };
+    } & {
+        type: string;
+        id: string;
+        params: Prisma.JsonValue;
+        subType: number | null;
+        startTimestamp: bigint;
+        endTimestamp: bigint;
+        computeChainId: number;
+        distributionChainId: number;
+        campaignId: string;
+        rewardTokenId: string;
+        amount: string;
+        opportunityId: string;
+        creatorAddress: string;
+    })[]>;
     /**
      * Retrieves all live campaigns from the database.
      * A campaign is considered live if the current timestamp is between the campaign's start and end timestamps.
      *
      * @returns A promise that resolves to an array of live campaigns.
+     *
+     * @dev Excludes test campaigns
      */
     static getLiveCampaigns(query?: {
         computeChainId?: number;