@merkl/api 0.17.21 → 0.17.23

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

@@ -2,7 +2,6 @@ import { CampaignService } from "./campaign.service";
 import { TokenService } from "../token/token.service";
 import { log } from "../../../utils/logger";
 import { apiDbClient, engineDbClient } from "../../../utils/prisma";
-import { ALL_CAMPAIGNS_FOR_CHAIN_AFTER } from "../../../utils/queries/allCampaigns";
 import { Prisma, RunStatus } from "../../../../database/api/.generated";
 import { MAX_COMPUTE_JOB_TIME } from "@sdk";
 import moment from "moment";
@@ -126,6 +125,17 @@ export class CampaignRepository {
             },
         });
     }
+    static async countLives(query) {
+        const now = moment().unix();
+        const where = {
+            ...query,
+            endTimestamp: { gte: now },
+            startTimestamp: { lte: now },
+        };
+        return await apiDbClient.campaign.count({
+            where,
+        });
+    }
     /**
      * Upserts a campaign in the database. If the campaign already exists, it updates the existing record;
      * otherwise, it creates a new one.
@@ -133,6 +143,8 @@ export class CampaignRepository {
      * @param {CreateCampaignModel} campaign - The campaign data to be upserted.
      * @returns The upserted campaign record.
      *
+     * @dev Should be the only way of creating campaigns in the database.
+     *
      * @throws {Error} If unable to fetch data for the reward token.
      *
      * @remarks
@@ -154,12 +166,18 @@ export class CampaignRepository {
             if (!rewardToken) {
                 throw new Error(`unable to fetch data for token ${campaign.rewardTokenAddress}`);
             }
+            const previousCampaign = await CampaignRepository.findUnique(campaign.id);
+            const creatorAddress = previousCampaign?.manualOverrides?.includes("creatorAddress")
+                ? previousCampaign.creatorAddress
+                : campaign.creator;
             const params = JSON.parse(campaign.params);
-            const opportunityId = OpportunityService.hashId({
-                chainId: campaign.computeChainId,
-                identifier: campaign.opportunityIdentifier,
-                type: campaignType,
-            });
+            const opportunityId = previousCampaign?.manualOverrides?.includes("opportunityId")
+                ? previousCampaign.opportunityId
+                : OpportunityService.hashId({
+                    chainId: campaign.computeChainId,
+                    identifier: campaign.opportunityIdentifier,
+                    type: campaignType,
+                });
             const data = {
                 id: campaign.id,
                 amount: campaign.amount,
@@ -175,9 +193,9 @@ export class CampaignRepository {
                 },
                 Creator: {
                     connectOrCreate: {
-                        where: { address: campaign.creator },
+                        where: { address: creatorAddress },
                         create: {
-                            address: campaign.creator,
+                            address: creatorAddress,
                         },
                     },
                 },
@@ -202,83 +220,12 @@ export class CampaignRepository {
             log.error(`Failed to upsert campaign ${campaign.campaignId}`, err);
         }
     }
-    static async upsertMany(campaigns) {
-        if (!campaigns.length)
-            return { success: 0, fail: 0 };
-        const campaignType = CampaignService.getTypeFromV3(campaigns[0].type);
-        const data = [];
-        for (const campaign of campaigns) {
-            const [rewardToken] = await TokenService.getManyOrCreate([
-                { chainId: campaign.chainId, address: campaign.rewardTokenAddress },
-            ]);
-            const opportunityId = OpportunityService.hashId({
-                chainId: campaign.computeChainId,
-                identifier: campaign.opportunityIdentifier,
-                type: campaignType,
-            });
-            data.push({
-                id: campaign.id,
-                amount: campaign.amount,
-                campaignId: campaign.campaignId,
-                endTimestamp: BigInt(campaign.endTimestamp),
-                params: JSON.parse(campaign.params),
-                startTimestamp: BigInt(campaign.startTimestamp),
-                type: campaignType,
-                ComputeChain: {
-                    connect: {
-                        id: campaign.computeChainId,
-                    },
-                },
-                Creator: {
-                    connectOrCreate: {
-                        where: { address: campaign.creator },
-                        create: { address: campaign.creator },
-                    },
-                },
-                Opportunity: {
-                    connect: { id: opportunityId },
-                },
-                RewardToken: {
-                    connect: rewardToken ? { id: TokenService.hashId(rewardToken) } : undefined,
-                },
-                subType: campaign.subType,
-                DistributionChain: { connect: { id: campaign.chainId } },
-            });
-        }
-        const failedCampaigns = [];
-        const successCampaigns = [];
-        for (const campaign of data) {
-            try {
-                await apiDbClient.campaign.upsert({
-                    where: {
-                        // TODO: use id
-                        id: CampaignService.hashId({
-                            campaignId: campaign.campaignId,
-                            distributionChain: campaign.DistributionChain.connect?.id,
-                        }),
-                    },
-                    create: campaign,
-                    update: campaign,
-                });
-                successCampaigns.push(campaign);
-            }
-            catch (err) {
-                log.error(`Failed to upsert campaign ${campaign.campaignId}`, err);
-                failedCampaigns.push(campaign);
-            }
-        }
-        return { success: successCampaigns.length, fail: failedCampaigns.length };
-    }
     /**
-     * Fetches the campaign data for a v3 campaign in database
-     * @param chainId
-     * @param timestamp from which campaigns endTimestamp are filtered
-     * @returns
+     * Retrieves a campaign from the engine database by its chain and campaign id.
+     * @dev Types are different from the API database.
+     * @dev IDs are different from the API database.
+     * id in the engine database = campaignId in the API database
      */
-    static async getFromEngineDb(chainId, timestamp) {
-        //TODO use a typesafe fetching methode (this one is from campaignUpdater)
-        return (await engineDbClient.$queryRaw(ALL_CAMPAIGNS_FOR_CHAIN_AFTER(chainId, timestamp)));
-    }
     static async getFromEngineDbWithId(campaignIds) {
         return await engineDbClient.campaigns.findMany({
             where: {
@@ -291,18 +238,15 @@ export class CampaignRepository {
             },
         });
     }
-    static async checkIfExist(id) {
-        return !!(await apiDbClient.campaign.findFirst({
-            select: {
-                id: true,
-            },
-            where: {
-                id,
-            },
-        }));
-    }
     static async findUnique(id) {
         return await apiDbClient.campaign.findUnique({
+            include: {
+                DistributionChain: true,
+                ComputeChain: true,
+                RewardToken: true,
+                CampaignStatus: true,
+                Creator: true,
+            },
             where: {
                 id,
             },
@@ -410,30 +354,6 @@ export class CampaignRepository {
         const args = CampaignRepository.transformQueryToPrismaFilters(query);
         return await apiDbClient.campaign.count(args);
     }
-    static async countLives(chainId) {
-        const now = moment().unix();
-        return await apiDbClient.campaign.count({
-            where: {
-                distributionChainId: chainId,
-                endTimestamp: {
-                    gte: now,
-                },
-                startTimestamp: {
-                    lte: now,
-                },
-            },
-        });
-    }
-    static async findManyCampaignId(chainId) {
-        return await apiDbClient.campaign.findMany({
-            select: {
-                campaignId: true,
-            },
-            where: {
-                distributionChainId: chainId,
-            },
-        });
-    }
     static async findChains() {
         const campaigns = await apiDbClient.campaign.findMany({
             select: { distributionChainId: true, id: true },
@@ -443,13 +363,55 @@ export class CampaignRepository {
             return acc;
         }, {});
     }
+    static async addManualOverride(id, field) {
+        const manualOverrides = (await apiDbClient.campaign.findUnique({
+            where: { id },
+            select: { manualOverrides: true },
+        }))?.manualOverrides ?? [];
+        if (!manualOverrides?.includes(field))
+            manualOverrides?.push(field);
+        await apiDbClient.campaign.update({
+            where: { id },
+            data: {
+                manualOverrides: {
+                    set: manualOverrides,
+                },
+            },
+        });
+    }
+    static async removeManualOverride(id, field) {
+        const manualOverrides = (await apiDbClient.campaign.findUnique({
+            where: { id },
+            select: { manualOverrides: true },
+        }))?.manualOverrides ?? [];
+        await apiDbClient.campaign.update({
+            where: { id },
+            data: {
+                manualOverrides: {
+                    set: manualOverrides.filter(override => override !== field),
+                },
+            },
+        });
+    }
     static async updateOpportunity(id, data) {
-        const updateData = {
-            Opportunity: {
-                connect: { id: data.opportunityId },
+        await apiDbClient.campaign.update({
+            where: { id },
+            data: {
+                Opportunity: {
+                    connect: { id: data.opportunityId },
+                },
             },
-        };
-        return await apiDbClient.campaign.update({ where: { id }, data: updateData });
+        });
+        await CampaignRepository.addManualOverride(id, "opportunityId");
+    }
+    static async updateCreator(id, creatorAddress) {
+        await apiDbClient.campaign.update({
+            where: { id },
+            data: {
+                creatorAddress: creatorAddress,
+            },
+        });
+        await CampaignRepository.addManualOverride(id, "creatorAddress");
     }
     static async updateMetaData(id, params) {
         const updateData = {

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

@@ -1,4 +1,5 @@
-import type { CampaignUnique, CampaignWithParams, CreateCampaignModel, GetCampaignQueryModel, UpdateCampaignModel, UpdateMetaDataCampaignModel } from "./";
+import type { CampaignUnique, CampaignWithParams, CreateCampaignModel, GetCampaignQueryModel, UpdateCampaignCreatorModel, UpdateCampaignModel, UpdateMetaDataCampaignModel } from "./";
+import type { CampaignManualOverride } from "../../../../database/api/.generated";
 import { Campaign as CampaignEnum, type CampaignParameters, type ChainId } from "@sdk";
 import { CampaignRepository } from "./campaign.repository";
 export declare abstract class CampaignService {
@@ -37,6 +38,7 @@ export declare abstract class CampaignService {
         amount: string;
         opportunityId: string;
         creatorAddress: string;
+        manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
     })[]>;
     static getFutureCampaigns(query?: {
         computeChainId?: number;
@@ -71,8 +73,10 @@ export declare abstract class CampaignService {
         amount: string;
         opportunityId: string;
         creatorAddress: string;
+        manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
     })[]>;
     static getLiveCampaigns(query?: {
+        distributionChainId?: number;
         computeChainId?: number;
         type?: string;
     }): Promise<({
@@ -105,7 +109,13 @@ export declare abstract class CampaignService {
         amount: string;
         opportunityId: string;
         creatorAddress: string;
+        manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
     })[]>;
+    static countLives(query?: {
+        distributionChainId?: number;
+        computeChainId?: number;
+        type?: string;
+    }): Promise<number>;
     static create(campaign: Omit<CreateCampaignModel, "id">): Promise<{
         type: string;
         id: string;
@@ -120,11 +130,8 @@ export declare abstract class CampaignService {
         amount: string;
         opportunityId: string;
         creatorAddress: string;
+        manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
     } | undefined>;
-    static createMany(campaigns: Omit<CreateCampaignModel, "id">[], upsert?: boolean): Promise<{
-        success: number;
-        fail: number;
-    }>;
     /**
      * @dev back-office function
      * @dev deprecated should be replaced with a manual override
@@ -143,7 +150,12 @@ export declare abstract class CampaignService {
         amount: string;
         opportunityId: string;
         creatorAddress: string;
+        manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
     }>;
+    /**
+     * @dev back-office function for manual overrides
+     */
+    static updateCreator(campaign: UpdateCampaignCreatorModel): Promise<void>;
     /**
      * @dev back-office function
      */
@@ -203,6 +215,7 @@ export declare abstract class CampaignService {
         rewardTokenId: string;
         amount: string;
         opportunityId: string;
+        manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
     }[]>;
     /**
      * Counts the number of campaigns that complies to query
@@ -211,9 +224,45 @@ export declare abstract class CampaignService {
      * @returns the number of campaigns
      */
     static countMany(query: GetCampaignQueryModel): Promise<number>;
-    static countLives(chainId: number): Promise<number>;
     static checkIfExist(campaign: CampaignUnique | string): Promise<boolean>;
-    static findUnique(campaign: CampaignUnique | string): Promise<{
+    static findUnique(campaign: CampaignUnique | string): Promise<({
+        ComputeChain: {
+            name: string;
+            id: number;
+            icon: string;
+        };
+        DistributionChain: {
+            name: string;
+            id: number;
+            icon: string;
+        };
+        RewardToken: {
+            symbol: string;
+            name: string | null;
+            id: string;
+            icon: string;
+            chainId: number;
+            address: string;
+            decimals: number;
+            displaySymbol: string;
+            verified: boolean;
+            isTest: boolean;
+            price: number | null;
+        };
+        Creator: {
+            tags: string[];
+            address: string;
+            creatorId: string | null;
+        };
+        CampaignStatus: {
+            error: string;
+            details: import("database/api/.generated/runtime/library").JsonValue;
+            status: import("../../../../database/api/.generated").$Enums.RunStatus;
+            campaignId: string;
+            computedUntil: bigint;
+            processingStarted: bigint;
+        }[];
+    } & {
         type: string;
         id: string;
         params: import("database/api/.generated/runtime/library").JsonValue;
@@ -227,7 +276,8 @@ export declare abstract class CampaignService {
         amount: string;
         opportunityId: string;
         creatorAddress: string;
-    } | null>;
+        manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
+    }) | null>;
     static findUniqueOrThrow(campaign: CampaignUnique | string, withOpportunity?: boolean): Promise<{
         ComputeChain: {
             name: string;
@@ -294,7 +344,9 @@ export declare abstract class CampaignService {
         amount: string;
         opportunityId: string;
         creatorAddress: string;
+        manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
     }>;
+    static removeManualOverride(campaign: CampaignUnique | string, field: CampaignManualOverride): Promise<void>;
     static findCampaignsToProcess(distributionChainId: ChainId): Promise<{
         endTimestamp: bigint;
         campaignId: string;
@@ -314,10 +366,6 @@ export declare abstract class CampaignService {
         success: number;
         fail: number;
     }>;
-    static fetchMissingCampaigns(chainId: ChainId, campaignIds: CampaignUnique[]): Promise<{
-        success: number;
-        fail: number;
-    }>;
     static findChains(): Promise<Record<string, ChainId>>;
     /**
      * Returns the campaign data
@@ -339,13 +387,6 @@ export declare abstract class CampaignService {
         live: C[];
         soon: C[];
     };
-    /**
-     * Returns the campaign data
-     * @param chainId to fetch campaigns for
-     * @param timestamp from which campaigns endTimestamp are filtered
-     * @returns
-     */
-    static getFromEngineDb(chainId: number, timestamp: number): Promise<CampaignParameters<CampaignV3>[]>;
     /**
      * Convert raw
      * @param query
@@ -402,6 +443,7 @@ export declare abstract class CampaignService {
         rewardTokenId: string;
         amount: string;
         opportunityId: string;
+        manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
     };
     static formatAsCampaignParameters<C extends CampaignEnum>(campaign: CampaignWithParams): CampaignParameters<C>;
     /**

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

@@ -4,7 +4,7 @@ import { OpportunityService } from "../opportunity";
 import { StatusService } from "../status/status.service";
 import { TokenRepository } from "../token/token.repository";
 import { TokenService } from "../token/token.service";
-import { InvalidParameter } from "../../../utils/error";
+import { CannotParseOpportunity, InvalidParameter } from "../../../utils/error";
 import { executeSimple } from "../../../utils/execute";
 import { log } from "../../../utils/logger";
 import { Campaign as CampaignEnum, NETWORK_LABELS, } from "@sdk";
@@ -30,32 +30,19 @@ export class CampaignService {
     static async getLiveCampaigns(query) {
         return await CampaignRepository.getLiveCampaigns(query);
     }
+    static async countLives(query) {
+        return await CampaignRepository.countLives(query);
+    }
     static async create(campaign) {
         const id = CampaignService.hashId({ distributionChain: campaign.chainId, campaignId: campaign.campaignId });
-        await OpportunityService.createFromCampaign(campaign);
+        try {
+            await OpportunityService.createFromCampaign(campaign);
+        }
+        catch {
+            throw new CannotParseOpportunity(campaign.campaignId, campaign.chainId, campaign.type);
+        }
         return await CampaignRepository.upsert({ id, ...campaign });
     }
-    static async createMany(campaigns, upsert = false) {
-        const failedToFetchMetadata = [];
-        const campaignsToInsert = [];
-        await Promise.all(campaigns.map(async (campaign) => {
-            const id = CampaignService.hashId({ distributionChain: campaign.chainId, campaignId: campaign.campaignId });
-            campaign.computeChainId = campaign.computeChainId === 0 ? campaign.chainId : campaign.computeChainId;
-            try {
-                if (upsert || !(await CampaignService.checkIfExist(id))) {
-                    await OpportunityService.createFromCampaign(campaign);
-                    campaignsToInsert.push({ id, ...campaign });
-                }
-            }
-            catch (err) {
-                log.error(`Cannot get Opportunity metadata for campaign ${campaign.campaignId} of type ${campaign.type}`, err);
-                failedToFetchMetadata.push(campaign);
-            }
-        }));
-        let { success, fail } = await CampaignRepository.upsertMany(campaignsToInsert);
-        fail += failedToFetchMetadata.length;
-        return { success, fail };
-    }
     /**
      * @dev back-office function
      * @dev deprecated should be replaced with a manual override
@@ -73,6 +60,16 @@ export class CampaignService {
         const updatedParams = JSON.stringify(params);
         return await CampaignRepository.updateMetaData(id, updatedParams);
     }
+    /**
+     * @dev back-office function for manual overrides
+     */
+    static async updateCreator(campaign) {
+        const id = CampaignService.hashId({
+            distributionChain: campaign.distributionChain,
+            campaignId: campaign.campaignId,
+        });
+        return await CampaignRepository.updateCreator(id, campaign.creatorAddress);
+    }
     /**
      * @dev back-office function
      */
@@ -117,10 +114,6 @@ export class CampaignService {
         await OpportunityService.createFromCampaign(updatedCampaign, upsert);
         // Move campaign to new opportunity
         await CampaignRepository.updateOpportunity(id, { id, ...updatedCampaignData });
-        // Update new opportunity with campaign
-        // await OpportunityService.recreate(opportunityId);
-        // Remov (update) campaign from old opportunity
-        await OpportunityService.recreate(existingCampaign.opportunityId);
         // Return new opportunityId
         return (await CampaignService.findUniqueOrThrow(campaign)).opportunityId;
     }
@@ -148,12 +141,9 @@ export class CampaignService {
         }
         return await CampaignRepository.countMany(query);
     }
-    static async countLives(chainId) {
-        return await CampaignRepository.countLives(chainId);
-    }
     static async checkIfExist(campaign) {
         const id = typeof campaign === "string" ? campaign : CampaignService.hashId(campaign);
-        return await CampaignRepository.checkIfExist(id);
+        return !!(await CampaignRepository.findUnique(id));
     }
     static async findUnique(campaign) {
         const id = typeof campaign === "string" ? campaign : CampaignService.hashId(campaign);
@@ -163,6 +153,10 @@ export class CampaignService {
         const id = typeof campaign === "string" ? campaign : CampaignService.hashId(campaign);
         return await CampaignRepository.findUniqueOrThrow(id, withOpportunity);
     }
+    static async removeManualOverride(campaign, field) {
+        const id = typeof campaign === "string" ? campaign : CampaignService.hashId(campaign);
+        return await CampaignRepository.removeManualOverride(id, field);
+    }
     static async findCampaignsToProcess(distributionChainId) {
         return (await CampaignRepository.findCampaignsToProcess(distributionChainId))
             .filter(campaign => campaign.endTimestamp > (campaign?.CampaignStatus?.[0]?.computedUntil ?? 0n))
@@ -193,29 +187,32 @@ export class CampaignService {
                 log.warn(`Campaign ${campaign.campaignId} on ${NETWORK_LABELS[campaign.distributionChain]} not found in engine db`);
             }
         }
-        return await CampaignService.createMany(campaignsFromEngine.map(campaign => {
-            return {
-                amount: campaign.amount,
-                chainId: campaign.chainId,
-                computeChainId: campaign.computeChainId,
-                creator: campaign.creator,
-                endTimestamp: campaign.endTimestamp.toString(),
-                campaignId: campaign.campaignId,
-                opportunityIdentifier: campaign.mainParameter,
-                params: JSON.stringify(campaign.campaignParameters),
-                rewardTokenAddress: campaign.rewardToken,
-                startTimestamp: campaign.startTimestamp.toString(),
-                type: campaign.campaignType,
-                subType: campaign.campaignSubType,
-            };
-        }));
-    }
-    static async fetchMissingCampaigns(chainId, campaignIds) {
-        const foundCampaignIds = (await CampaignRepository.findManyCampaignId(chainId)).reduce((acc, { campaignId }) => acc.add(CampaignService.hashId({ distributionChain: chainId, campaignId })), new Set());
-        const missingCampaigns = campaignIds.filter(campaignId => !foundCampaignIds.has(CampaignService.hashId(campaignId)));
-        if (!missingCampaigns.length)
-            return { success: 0, fail: 0 };
-        return await CampaignService.fill(missingCampaigns);
+        let success = 0;
+        let fail = 0;
+        for (const engineCampaign of campaignsFromEngine) {
+            try {
+                await CampaignService.create({
+                    amount: engineCampaign.amount,
+                    chainId: engineCampaign.chainId,
+                    computeChainId: engineCampaign.computeChainId,
+                    creator: engineCampaign.creator,
+                    endTimestamp: engineCampaign.endTimestamp.toString(),
+                    campaignId: engineCampaign.campaignId,
+                    opportunityIdentifier: engineCampaign.mainParameter,
+                    params: JSON.stringify(engineCampaign.campaignParameters),
+                    rewardTokenAddress: engineCampaign.rewardToken,
+                    startTimestamp: engineCampaign.startTimestamp.toString(),
+                    type: engineCampaign.campaignType,
+                    subType: engineCampaign.campaignSubType,
+                });
+                success++;
+            }
+            catch {
+                log.warn(`Failed to create campaign ${engineCampaign.campaignId} on ${NETWORK_LABELS[engineCampaign.chainId]}`);
+                fail++;
+            }
+        }
+        return { success, fail };
     }
     static async findChains() {
         return await CampaignRepository.findChains();
@@ -240,15 +237,6 @@ export class CampaignService {
         const soon = campaigns.filter(({ startTimestamp: start }) => start > timestamp);
         return { past, live, soon };
     }
-    /**
-     * Returns the campaign data
-     * @param chainId to fetch campaigns for
-     * @param timestamp from which campaigns endTimestamp are filtered
-     * @returns
-     */
-    static async getFromEngineDb(chainId, timestamp) {
-        return CampaignRepository.getFromEngineDb(chainId, timestamp);
-    }
     /**
      * Convert raw
      * @param query

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

@@ -226,6 +226,7 @@ export declare const OpportunityController: Elysia<"/opportunities", false, {
                             rewardTokenId: string;
                             amount: string;
                             opportunityId: string;
+                            manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
                         }[] | undefined;
                         id: string;
                         depositUrl: string | undefined;

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

@@ -21,6 +21,7 @@ export class OpportunityConvertorService {
             endTimestamp: Number(campaign.endTimestamp),
             startTimestamp: Number(campaign.startTimestamp),
             rewardToken: campaign.rewardToken.address,
+            amm: campaign.params?.amm,
         };
     }
     static convertV4toV3(opportunity, withCampaigns = false) {

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

@@ -56,6 +56,7 @@ export declare abstract class OpportunityRepository {
             amount: string;
             opportunityId: string;
             creatorAddress: string;
+            manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
         })[];
         Tokens: {
             symbol: string;
@@ -189,6 +190,7 @@ export declare abstract class OpportunityRepository {
             amount: string;
             opportunityId: string;
             creatorAddress: string;
+            manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
         }[];
         Tokens: {
             symbol: string;
@@ -378,6 +380,7 @@ export declare abstract class OpportunityRepository {
             amount: string;
             opportunityId: string;
             creatorAddress: string;
+            manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
         })[];
         Tokens: {
             symbol: string;
@@ -511,6 +514,7 @@ export declare abstract class OpportunityRepository {
             amount: string;
             opportunityId: string;
             creatorAddress: string;
+            manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
         }[];
         Tokens: {
             symbol: string;
@@ -688,6 +692,7 @@ export declare abstract class OpportunityRepository {
             amount: string;
             opportunityId: string;
             creatorAddress: string;
+            manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
         })[];
         Tokens: {
             symbol: string;