@merkl/api 0.17.6 → 0.17.8

package/dist/src/backgroundJobs/jobs/opportunityUpdater.js

@@ -53,8 +53,10 @@ export const opportunityUpdater = (app) => {
         await Redis.safeSet("Opportunities", opportunities);
         await Redis.safeSet("OpportunitiesWithTest", opportunitiesWithTest);
         log.info("✅ opportunity cache updated successfully");
+        await OpportunityConvertorService.logKeyAndTTLV3Opportunities(true, false, undefined, undefined);
         await OpportunityConvertorService.setV3Opportunities(true, false, undefined, undefined);
         log.info("✅ opportunity v3 cache updated successfully");
+        await OpportunityConvertorService.logKeyAndTTLV3Opportunities(true, true, undefined, undefined);
         await OpportunityConvertorService.setV3Opportunities(true, true, undefined, undefined);
         log.info("✅ opportunity v3 test cache updated successfully");
         return new Response(JSON.stringify({

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);
@@ -14,74 +15,52 @@ if (!chainId)
     throw new Error("Environment variable CHAIN_ID is required.");
 // ─── Update Dynamic Data (APR / TVL / Daily Rewards) ─────────────────────────
 async function updateDynamicData(liveCampaigns, campaignType) {
-    try {
-        // Input: list of campaigns of same type
-        // Output: for each campaign, APR, TVL, Daily Rewards
-        // Constraint: needs to use multicalls to reduce RPC calls and speed
-        // - Needs to be robust to a single campaign's call failing
-        // - Needs to be quite easy for the engine team to setup new campaign types
-        // abstract GenericDynamicDataComputer
-        // compute(chainId, type, campaigns) => { apr, tvl, dailyRewards } with breakdowns
-        // UNISWAP V4
-        // Round 1 - (chainId, type, campaigns) -> tokens of the pools
-        // Round 2 - (chainId, type, campaigns, output of previous round) -> balance in tokens of forwarders
-        // Round 3 - ...
-        // Round Final - (chainId, type, campaigns, output of previous round) -> { apr, tvl, dailyRewards }
-        const dynamicData = await executeSimple(chainId, campaignsDynamicData(chainId, liveCampaigns, campaignType));
-        const oppMap = {};
-        for (const data of dynamicData) {
-            if (!!data) {
-                // Main Parameter OVERRIDING
-                if (data.campaignType === CampaignTypesEnum.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}`] = {};
-                oppMap[`${data.campaignType}_${data.mainParameter}`][data.campaignId] = data;
-            }
-        }
-        for (const entry of Object.entries(oppMap)) {
-            const [type, mainParameter] = entry[0].split("_");
-            try {
-                const apr = AprService.extractFromDynamicData(+type, Object.values(entry[1]));
-                const tvl = TvlService.extractFromDynamicData(+type, Object.values(entry[1]));
-                const dailyRewards = await RewardService.extractDailyRewardsRecordFromDynamicData(+type, Object.values(entry[1]));
-                const opportunityId = OpportunityService.hashId({
-                    chainId,
-                    identifier: mainParameter,
-                    type: type,
-                });
-                await OpportunityRepository.updateRecords(opportunityId, apr, tvl, dailyRewards);
-            }
-            catch (err) {
-                console.log(mainParameter);
-                console.error(err);
-            }
+    // Input: list of campaigns of same type
+    // Output: for each campaign, APR, TVL, Daily Rewards
+    // Constraint: needs to use multicalls to reduce RPC calls and speed
+    // - Needs to be robust to a single campaign's call failing
+    // - Needs to be quite easy for the engine team to setup new campaign types
+    // abstract GenericDynamicDataComputer
+    // compute(chainId, type, campaigns) => { apr, tvl, dailyRewards } with breakdowns
+    // UNISWAP V4
+    // Round 1 - (chainId, type, campaigns) -> tokens of the pools
+    // Round 2 - (chainId, type, campaigns, output of previous round) -> balance in tokens of forwarders
+    // Round 3 - ...
+    // Round Final - (chainId, type, campaigns, output of previous round) -> { apr, tvl, dailyRewards }
+    const dynamicData = await executeSimple(chainId, campaignsDynamicData(chainId, liveCampaigns, campaignType));
+    const oppMap = {};
+    for (const data of dynamicData) {
+        if (!!data) {
+            // Main Parameter OVERRIDING
+            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}`] = {};
+            oppMap[`${data.campaignType}_${data.mainParameter}`][data.campaignId] = data;
         }
     }
-    catch (err) {
-        console.error(err);
+    for (const entry of Object.entries(oppMap)) {
+        const [type, mainParameter] = entry[0].split("_");
+        try {
+            const apr = AprService.extractFromDynamicData(+type, Object.values(entry[1]));
+            const tvl = TvlService.extractFromDynamicData(+type, Object.values(entry[1]));
+            const dailyRewards = await RewardService.extractDailyRewardsRecordFromDynamicData(+type, Object.values(entry[1]));
+            const opportunityId = OpportunityService.hashId({
+                chainId,
+                identifier: mainParameter,
+                type: type,
+            });
+            await OpportunityRepository.updateRecords(opportunityId, apr, tvl, dailyRewards);
+        }
+        catch (err) {
+            console.error(err);
+        }
     }
 }
 // ─── 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)
@@ -93,46 +72,69 @@ const getLiveCampaignsByType = async (chainId) => {
     return campaignTypeToCampaigns;
 };
 // ─── Main function / entry point ─────────────────────────────────────────────
-const main = async () => {
-    try {
-        // 1. Get a map of campaigns by campaign type
-        const liveCampaigns = await getLiveCampaignsByType(chainId);
-        // 2. Call updateDynamicData with each entries of the map (process by campaign type)
-        for (const [type, campaigns] of liveCampaigns.entries())
-            await updateDynamicData(campaigns, type);
-        // 3. Update status of opportunities
-        // 3.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
-        const now = moment().unix();
-        for (const opportunity of liveOpportunities) {
-            let status = "NONE";
-            const campaigns = opportunity.campaigns;
-            for (const campaign of campaigns) {
-                if (status !== "LIVE" && campaign.endTimestamp < now)
-                    status = "PAST";
-                else if (campaign.startTimestamp < now && campaign.endTimestamp > now)
-                    status = "LIVE";
-                else if (status !== "LIVE" && campaign.startTimestamp > now)
-                    status = "SOON";
-            }
-            await OpportunityService.updateStatus(opportunity.id, status);
+const updateCampaigns = async (campaignsToUpdate) => {
+    // 1. Get a map of campaigns by campaign type
+    const campaignTypeToCampaigns = await buildMapByType(campaignsToUpdate);
+    // 2. Call updateDynamicData with each entries of the map (process by campaign type)
+    for (const [campaignType, campaigns] of campaignTypeToCampaigns.entries()) {
+        log.info(`updating dynamic data for ${campaigns.length} campaigns of type ${CampaignEnum[campaignType]}`);
+        try {
+            await updateDynamicData(campaigns, campaignType);
         }
-        // 4. Compute the opportunity ids of the 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);
-            }
+        catch (err) {
+            console.error(`Failed to update dynamic data for campaign type ${CampaignEnum[campaignType]}`, err);
         }
-        // 5. Update the status of the liveCampaigns opportunities
-        await OpportunityService.updateMany(Array.from(opportunities), { status: "LIVE" });
-        process.exit(0);
     }
-    catch (err) {
-        console.error(err);
-        process.exit(1);
+};
+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);
+    // 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";
+        const campaigns = opportunity.campaigns;
+        for (const campaign of campaigns) {
+            if (status !== "LIVE" && campaign.endTimestamp < now)
+                status = "PAST";
+            else if (campaign.startTimestamp < now && campaign.endTimestamp > now)
+                status = "LIVE";
+            else if (status !== "LIVE" && campaign.startTimestamp > now)
+                status = "SOON";
+        }
+        await OpportunityService.updateStatus(opportunity.id, status);
     }
+    // 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" });
 };
-await main();
+try {
+    await main();
+    process.exit(0);
+}
+catch (err) {
+    console.error(err);
+    process.exit(1);
+}

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/helpers/hardcoded.js

@@ -20,6 +20,9 @@ const chainAddressToType = {
     [ChainId.BOB]: {
         "0x9998e05030Aee3Af9AD3df35A34F5C51e1628779": tokenType.veda,
     },
+    [ChainId.ETHERLINK]: {
+        "0x79052Ab3C166D4899a1e0DD033aC3b379AF0B1fD": tokenType.xU308,
+    },
 };
 export function getTypeFromAddressChain(chain, token) {
     if (!!chainAddressToType[chain] && !!chainAddressToType[chain][token]) {

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType.d.ts

@@ -89,7 +89,8 @@ export declare enum tokenType {
     hourglass = "hourglass",
     katana = "katana",
     balancerV3 = "balancerV3",
-    hanji_liquidity_vault_token = "hanji_liquidity_vault_token"
+    hanji_liquidity_vault_token = "hanji_liquidity_vault_token",
+    xU308 = "xU308"
 }
 export declare const tokenTypeToProtocol: {
     [key in tokenType]: {

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType.js

@@ -91,6 +91,7 @@ export var tokenType;
     tokenType["katana"] = "katana";
     tokenType["balancerV3"] = "balancerV3";
     tokenType["hanji_liquidity_vault_token"] = "hanji_liquidity_vault_token";
+    tokenType["xU308"] = "xU308";
 })(tokenType || (tokenType = {}));
 export const tokenTypeToProtocol = {
     [tokenType.aave_borrowing]: { protocol: "Aave", action: OpportunityAction.BORROW },
@@ -182,4 +183,5 @@ export const tokenTypeToProtocol = {
     [tokenType.katana]: { protocol: "Katana", action: OpportunityAction.POOL },
     [tokenType.balancerV3]: { protocol: "Balancer", action: OpportunityAction.POOL },
     [tokenType.hanji_liquidity_vault_token]: { protocol: "Hanji", action: OpportunityAction.POOL },
+    [tokenType.xU308]: { protocol: "Uranium", action: OpportunityAction.HOLD },
 };

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/implementations/processorMapping.js

@@ -42,6 +42,7 @@ import { ZkSwapThreePoolProcessor } from "./ZkSwapThreePoolProcessor";
 import { CurveNPoolProcessor } from "./curveNPoolProcessor";
 import { CurveProcessor } from "./curveProcessor";
 import { StakedCurveProcessor } from "./stakedCurveProcessor";
+import { xU308Processor } from "./xU308Processor";
 export const processorMapping = {
     [tokenType.uniswapv2]: UniswapProcessor,
     [tokenType.balancerGauge]: BalancerGaugeProcessor,
@@ -132,4 +133,5 @@ export const processorMapping = {
     [tokenType.katana]: UniswapProcessor,
     [tokenType.balancerV3]: BalancerV3PoolProcessor,
     [tokenType.hanji_liquidity_vault_token]: HanjiVaultProcessor,
+    [tokenType.xU308]: xU308Processor,
 };

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/implementations/xU308Processor.d.ts

@@ -0,0 +1,37 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+import type { tokenType } from "../helpers/tokenType";
+type callType = {
+    key: keyof dataRawxU308;
+    call: string;
+    target: keyof callKeysxU308;
+    metaData?: keyof callKeysxU308;
+};
+type callKeysxU308 = mandatoryCallKeys & {
+    pool: string;
+    token0: string;
+    token1: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    decimalsToken0: string;
+    decimalsToken1: string;
+    balanceToken0: string;
+    balanceToken1: string;
+    totalAssets: string;
+};
+type dataRawxU308 = callKeysxU308 & {};
+type dataTypexU308 = dataType & {
+    pool: string;
+};
+export declare class xU308Processor extends GenericProcessor<callKeysxU308, dataRawxU308, dataTypexU308> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawxU308): void;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawxU308, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypexU308>;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/implementations/xU308Processor.js

@@ -0,0 +1,49 @@
+import { generateCardName } from "../../../../../utils/generateCardName";
+import { BN2Number } from "@sdk";
+import { GenericProcessor } from "../GenericProcessor";
+export class xU308Processor extends GenericProcessor {
+    rounds = {
+        round1: [],
+        round2: [
+            { key: "token0", call: "token0", target: "pool" },
+            { key: "token1", call: "token1", target: "pool" },
+        ],
+        round3: [
+            { key: "symbolToken0", call: "symbol", target: "token0" },
+            { key: "symbolToken1", call: "symbol", target: "token1" },
+            { key: "decimalsToken0", call: "decimals", target: "token0" },
+            { key: "decimalsToken1", call: "decimals", target: "token1" },
+            { key: "balanceToken0", call: "balanceOf", target: "token0", metaData: "pool" },
+            { key: "balanceToken1", call: "balanceOf", target: "token1", metaData: "pool" },
+        ],
+        round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
+    };
+    // override computeRound1(): void {}
+    processingRound2(typeInfo) {
+        typeInfo.pool = "0xB387D0A73619791420De4a1e5e710023Cb0f49c0";
+    }
+    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
+        const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
+        let priceTargetToken = 0;
+        if (typeInfo.token0 !== typeInfo.tokenAddress) {
+            const priceToken0 = (await pricer.get({ symbol: typeInfo.symbolToken0 })) ?? 0;
+            priceTargetToken =
+                (priceToken0 * BN2Number(typeInfo.balanceToken0, Number(typeInfo.decimalsToken0))) /
+                    BN2Number(typeInfo.balanceToken1, Number(typeInfo.decimalsToken1));
+        }
+        const priceToken1 = (await pricer.get({ symbol: typeInfo.symbolToken1 })) ?? 0;
+        priceTargetToken =
+            (priceToken1 * BN2Number(typeInfo.balanceToken1, Number(typeInfo.decimalsToken1))) /
+                BN2Number(typeInfo.balanceToken0, Number(typeInfo.decimalsToken0));
+        const tvl = priceTargetToken * totalSupply;
+        return {
+            ...typeInfo,
+            tvl,
+            whitelistedSupplyTargetToken,
+            blacklistedSupply,
+            priceTargetToken,
+            totalSupply,
+            cardName: generateCardName(type, typeInfo, campaign),
+        };
+    }
+}

package/dist/src/libs/positions/clamm/index.js

@@ -1,6 +1,6 @@
 import { CacheService } from "../../../modules/v4/cache";
 import { TTLPresets } from "../../../modules/v4/cache/cache.model";
-import { ChainInteractionService } from "../../../modules/v4/chainInteraction";
+import { ChainInteractionService } from "../../../modules/v4/chainInteraction/chainInteraction.service";
 import { ALM, AMMAlgorithmMapping, BN2Number, NETWORK_LABELS, NFTManagerAddress, NonFungiblePositionManagerInterface, PoolInterface, PoolState, SqrtPrice, YEAR, getAmountsForLiquidity, getSupportedNFPWrapperMapping, getTickAtSqrtRatio, spNFTInterface, } from "@sdk";
 import { BigNumber, Contract, utils } from "ethers";
 import JSBI from "jsbi";

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

@@ -1,9 +1,9 @@
 import { NotFoundError } from "../../../errors";
 import { BackOfficeGuard } from "../../../guards/BackOffice.guard";
 import { AuthorizationHeadersDto, EngineGuard } from "../../../guards/Engine.guard";
+import { ChainUniqueDto } from "../chain/chain.model";
 import Elysia, { t } from "elysia";
 import { throwOnUnsupportedChainId } from "src/utils/throw";
-import { ChainUniqueDto } from "../chain";
 import { CampaignResourceDto, CreateCampaignDto, GetCampaignQueryDto, UpdateCampaignDto, UpdateMetaDataCampaignDto, } from "./campaign.model";
 import { CampaignService } from "./campaign.service";
 // ─── Campaigns Controller ────────────────────────────────────────────────────

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;

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

@@ -54,15 +54,50 @@ export 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 async getPastCampaigns(chainId) {
+    static async getPastCampaigns(query) {
         const now = moment().unix();
+        const where = {
+            ...query,
+            endTimestamp: {
+                lt: now,
+            },
+            RewardToken: {
+                isTest: false,
+            },
+        };
         return await apiDbClient.campaign.findMany({
-            where: {
-                computeChainId: chainId,
-                endTimestamp: {
-                    lt: now,
-                },
+            where,
+            include: {
+                Opportunity: true,
+            },
+        });
+    }
+    /**
+     * 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 async getFutureCampaigns(query) {
+        const now = moment().unix();
+        const where = {
+            ...query,
+            startTimestamp: {
+                gt: now,
+            },
+            RewardToken: {
+                isTest: false,
+            },
+        };
+        return await apiDbClient.campaign.findMany({
+            where,
+            include: {
+                Opportunity: true,
             },
         });
     }
@@ -71,6 +106,8 @@ export class CampaignRepository {
      * 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 async getLiveCampaigns(query) {
         const now = moment().unix();
@@ -78,6 +115,9 @@ export class CampaignRepository {
             ...query,
             endTimestamp: { gte: now },
             startTimestamp: { lte: now },
+            RewardToken: {
+                isTest: false,
+            },
         };
         return await apiDbClient.campaign.findMany({
             where,

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

@@ -4,7 +4,26 @@ import { CampaignRepository } from "./campaign.repository";
 export declare abstract class CampaignService {
     static hashId(campaign: CampaignUnique): string;
     static splitIdOrThrow(chainAndCampaignId: `${number}-${string}` | string): CampaignUnique;
-    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: import("database/api/.generated/runtime/library").JsonValue;
@@ -18,7 +37,41 @@ export declare abstract class CampaignService {
         amount: string;
         opportunityId: string;
         creatorAddress: string;
-    }[]>;
+    })[]>;
+    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: import("database/api/.generated/runtime/library").JsonValue;
+        subType: number | null;
+        startTimestamp: bigint;
+        endTimestamp: bigint;
+        computeChainId: number;
+        distributionChainId: number;
+        campaignId: string;
+        rewardTokenId: string;
+        amount: string;
+        opportunityId: string;
+        creatorAddress: string;
+    })[]>;
     static getLiveCampaigns(query?: {
         computeChainId?: number;
         type?: string;

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

@@ -21,8 +21,11 @@ export class CampaignService {
         const [chainId, campaignId] = chainAndCampaignId.split("-");
         return { distributionChain: +chainId, campaignId };
     }
-    static async getPastCampaigns(chainId) {
-        return await CampaignRepository.getPastCampaigns(chainId);
+    static async getPastCampaigns(query) {
+        return await CampaignRepository.getPastCampaigns(query);
+    }
+    static async getFutureCampaigns(query) {
+        return await CampaignRepository.getFutureCampaigns(query);
     }
     static async getLiveCampaigns(query) {
         return await CampaignRepository.getLiveCampaigns(query);