@merkl/api 0.17.22 → 0.17.24

package/dist/src/libs/campaigns/utils/getDolomiteMarkets.js

@@ -1,19 +1,22 @@
 import { Redis } from "../../../cache";
-import { DOLOMITE_CHAINID, DOLOMITE_MARGIN, DolomiteInterface, DolomiteMargin__factory, ERC20Interface } from "@sdk";
+import { DOLOMITE_MARGIN_MAPPING, DolomiteInterface, DolomiteMargin__factory, ERC20Interface } from "@sdk";
 import { batchMulticallCallWithRetry } from "../../../utils/generic";
 import { providers } from "../../../utils/providers";
-export const getDomiteMarkets = async () => {
-    const dolomiteMarginContract = await DolomiteMargin__factory.connect(DOLOMITE_MARGIN, providers[DOLOMITE_CHAINID]);
+export const getDomiteMarkets = async (chainId) => {
+    if (!DOLOMITE_MARGIN_MAPPING[chainId]) {
+        throw "Dolomite is not supported on this chain";
+    }
+    const dolomiteMarginContract = await DolomiteMargin__factory.connect(DOLOMITE_MARGIN_MAPPING[chainId], providers[chainId]);
     const numMarkets = (await dolomiteMarginContract.getNumMarkets()).toNumber();
     const calls = [];
     for (let index = 0; index < numMarkets; index++) {
         calls.push({
             allowFailure: true,
             callData: DolomiteInterface.encodeFunctionData("getMarket", [index]),
-            target: DOLOMITE_MARGIN,
+            target: DOLOMITE_MARGIN_MAPPING[chainId],
         });
     }
-    const res = await batchMulticallCallWithRetry(DOLOMITE_CHAINID, {
+    const res = await batchMulticallCallWithRetry(chainId, {
         calls,
     });
     if (!res.every(r => r.success)) {
@@ -29,7 +32,7 @@ export const getDomiteMarkets = async () => {
             target: token,
         });
     }
-    const secondRes = await batchMulticallCallWithRetry(DOLOMITE_CHAINID, {
+    const secondRes = await batchMulticallCallWithRetry(chainId, {
         calls: secondCalls,
     });
     for (let index = 0; index < numMarkets; index++) {
@@ -47,4 +50,4 @@ export const getDomiteMarkets = async () => {
     }
     return markets;
 };
-export const getDolomiteMarketWithCache = async () => await Redis.getOrSet("DolomiteMarkets", getDomiteMarkets);
+export const getDolomiteMarketWithCache = async (chainId) => await Redis.getOrSet("DolomiteMarkets", getDomiteMarkets, chainId);

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

@@ -51,6 +51,7 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                         amount: string;
                         opportunityId: string;
                         creatorAddress: string;
+                        manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
                     } | undefined;
                 };
             };
@@ -59,7 +60,6 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
         opportunity: {
             patch: {
                 body: {
-                    tags?: string[] | undefined;
                     opportunityIdentifier?: string | undefined;
                     campaignId: string;
                     distributionChain: number;
@@ -74,6 +74,42 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                 };
             };
         };
+    } & {
+        creator: {
+            patch: {
+                body: {
+                    campaignId: string;
+                    creatorAddress: string;
+                    distributionChain: number;
+                };
+                params: {};
+                query: unknown;
+                headers: {
+                    authorization: string;
+                };
+                response: {
+                    200: void;
+                };
+            };
+        };
+    } & {
+        "remove-override": {
+            patch: {
+                body: {
+                    campaignId: string;
+                    field: "opportunityId" | "creatorAddress";
+                    distributionChain: number;
+                };
+                params: {};
+                query: unknown;
+                headers: {
+                    authorization: string;
+                };
+                response: {
+                    200: void;
+                };
+            };
+        };
     } & {
         metadata: {
             patch: {
@@ -102,6 +138,7 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                         amount: string;
                         opportunityId: string;
                         creatorAddress: string;
+                        manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
                     };
                 };
             };
@@ -199,6 +236,7 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                         rewardTokenId: string;
                         amount: string;
                         opportunityId: string;
+                        manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
                     }[];
                 };
             };
@@ -263,6 +301,7 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                         rewardTokenId: string;
                         amount: string;
                         opportunityId: string;
+                        manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
                     };
                 };
             };

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

@@ -6,7 +6,7 @@ import { Campaign } from "@sdk";
 import Elysia, { t } from "elysia";
 import { throwOnUnsupportedChainId } from "src/utils/throw";
 import { DynamicDataService } from "../dynamicData/dynamicData.service";
-import { CampaignResourceDto, CreateCampaignDto, GetCampaignQueryDto, UpdateCampaignDto, UpdateMetaDataCampaignDto, } from "./campaign.model";
+import { CampaignResourceDto, CreateCampaignDto, GetCampaignQueryDto, RemoveManualOverrideDto, UpdateCampaignCreatorDto, UpdateCampaignDto, UpdateMetaDataCampaignDto, } from "./campaign.model";
 import { CampaignService } from "./campaign.service";
 // ─── Campaigns Controller ────────────────────────────────────────────────────
 export const CampaignController = new Elysia({ prefix: "/campaigns", detail: { tags: ["Campaigns"] } })
@@ -22,6 +22,21 @@ export const CampaignController = new Elysia({ prefix: "/campaigns", detail: { t
     headers: AuthorizationHeadersDto,
     body: UpdateCampaignDto,
     detail: { hide: true },
+})
+    .patch("/creator", async ({ body }) => await CampaignService.updateCreator(body), {
+    beforeHandle: BackOfficeGuard,
+    headers: AuthorizationHeadersDto,
+    body: UpdateCampaignCreatorDto,
+    detail: { hide: true },
+})
+    .patch("/remove-override", async ({ body }) => await CampaignService.removeManualOverride({
+    distributionChain: body.distributionChain,
+    campaignId: body.campaignId,
+}, body.field), {
+    beforeHandle: BackOfficeGuard,
+    headers: AuthorizationHeadersDto,
+    body: RemoveManualOverrideDto,
+    detail: { hide: true },
 })
     .patch("/metadata", async ({ body }) => await CampaignService.updateMetaData(body), {
     beforeHandle: BackOfficeGuard,

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

@@ -98,7 +98,19 @@ export declare const UpdateCampaignDto: import("@sinclair/typebox").TObject<{
     distributionChain: import("@sinclair/typebox").TNumber;
     campaignId: import("@sinclair/typebox").TString;
     opportunityIdentifier: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    tags: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+}>;
+export declare const UpdateCampaignCreatorDto: import("@sinclair/typebox").TObject<{
+    distributionChain: import("@sinclair/typebox").TNumber;
+    campaignId: import("@sinclair/typebox").TString;
+    creatorAddress: import("@sinclair/typebox").TString;
+}>;
+export declare const RemoveManualOverrideDto: import("@sinclair/typebox").TObject<{
+    distributionChain: import("@sinclair/typebox").TNumber;
+    campaignId: import("@sinclair/typebox").TString;
+    field: import("@sinclair/typebox").TEnum<{
+        opportunityId: "opportunityId";
+        creatorAddress: "creatorAddress";
+    }>;
 }>;
 export declare const UpdateMetaDataCampaignDto: import("@sinclair/typebox").TObject<{
     distributionChain: import("@sinclair/typebox").TNumber;
@@ -130,6 +142,7 @@ export type CreateCampaignModel = typeof CreateCampaignDto.static & {
 export type UpdateCampaignModel = typeof UpdateCampaignDto.static & {
     id: string;
 };
+export type UpdateCampaignCreatorModel = typeof UpdateCampaignCreatorDto.static;
 export type UpdateMetaDataCampaignModel = typeof UpdateMetaDataCampaignDto.static & {
     url: string;
 };

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

@@ -1,4 +1,5 @@
 import { TokenResourceDto } from "../token/token.model";
+import { CampaignManualOverride } from "../../../../database/api/.generated";
 import { t } from "elysia";
 import { ChainResourceDto } from "../chain/chain.model";
 import { CampaignStatusResourceDto } from "../status/status.model";
@@ -51,7 +52,16 @@ export const UpdateCampaignDto = t.Object({
     distributionChain: t.Numeric(),
     campaignId: t.String(),
     opportunityIdentifier: t.Optional(t.String()),
-    tags: t.Optional(t.Array(t.String())),
+});
+export const UpdateCampaignCreatorDto = t.Object({
+    distributionChain: t.Numeric(),
+    campaignId: t.String(),
+    creatorAddress: t.String(),
+});
+export const RemoveManualOverrideDto = t.Object({
+    distributionChain: t.Numeric(),
+    campaignId: t.String(),
+    field: t.Enum(CampaignManualOverride),
 });
 export const UpdateMetaDataCampaignDto = t.Object({
     distributionChain: t.Numeric(),

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

@@ -1,5 +1,5 @@
 import type { CampaignUnique, CreateCampaignModel, GetCampaignQueryModel, extendedUpdateCampaignModel } from "./";
-import { Prisma } from "../../../../database/api/.generated";
+import { type CampaignManualOverride, Prisma } from "../../../../database/api/.generated";
 import { type ChainId } from "@sdk";
 export declare abstract class CampaignRepository {
     static transformQueryToPrismaFilters(query: GetCampaignQueryModel): {
@@ -107,6 +107,7 @@ export declare abstract class CampaignRepository {
         amount: string;
         opportunityId: string;
         creatorAddress: string;
+        manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
     })[]>;
     /**
      * Retrieves all past campaigns from the database.
@@ -149,6 +150,7 @@ export declare abstract class CampaignRepository {
         amount: string;
         opportunityId: string;
         creatorAddress: string;
+        manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
     })[]>;
     /**
      * Retrieves all live campaigns from the database.
@@ -159,6 +161,7 @@ export declare abstract class CampaignRepository {
      * @dev Excludes test campaigns
      */
     static getLiveCampaigns(query?: {
+        distributionChainId?: number;
         computeChainId?: number;
         type?: string;
     }): Promise<({
@@ -191,7 +194,13 @@ export declare abstract class CampaignRepository {
         amount: string;
         opportunityId: string;
         creatorAddress: string;
+        manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
     })[]>;
+    static countLives(query?: {
+        distributionChainId?: number;
+        computeChainId?: number;
+        type?: string;
+    }): Promise<number>;
     /**
      * Upserts a campaign in the database. If the campaign already exists, it updates the existing record;
      * otherwise, it creates a new one.
@@ -199,6 +208,8 @@ export declare abstract 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
@@ -225,18 +236,14 @@ export declare abstract class CampaignRepository {
         amount: string;
         opportunityId: string;
         creatorAddress: string;
+        manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
     } | undefined>;
-    static upsertMany(campaigns: CreateCampaignModel[]): Promise<{
-        success: number;
-        fail: number;
-    }>;
     /**
-     * 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 getFromEngineDb(chainId: number, timestamp: number): Promise<CampaignParameters<CampaignV3>[]>;
     static getFromEngineDbWithId(campaignIds: CampaignUnique[]): Promise<{
         index: number;
         creator: string;
@@ -252,8 +259,44 @@ export declare abstract class CampaignRepository {
         mainParameter: string;
         campaignParameters: import("database/engine/.generated/runtime/library").JsonValue;
     }[]>;
-    static checkIfExist(id: string): Promise<boolean>;
-    static findUnique(id: string): Promise<{
+    static findUnique(id: 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: Prisma.JsonValue;
+            status: import("../../../../database/api/.generated").$Enums.RunStatus;
+            campaignId: string;
+            computedUntil: bigint;
+            processingStarted: bigint;
+        }[];
+    } & {
         type: string;
         id: string;
         params: Prisma.JsonValue;
@@ -267,7 +310,8 @@ export declare abstract class CampaignRepository {
         amount: string;
         opportunityId: string;
         creatorAddress: string;
-    } | null>;
+        manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
+    }) | null>;
     static findUniqueOrThrow(id: string, withOpportunity: boolean): Promise<{
         ComputeChain: {
             name: string;
@@ -334,6 +378,7 @@ export declare abstract class CampaignRepository {
         amount: string;
         opportunityId: string;
         creatorAddress: string;
+        manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
     }>;
     static findCampaignsToProcess(distributionChainId: ChainId): Promise<{
         endTimestamp: bigint;
@@ -395,28 +440,14 @@ export declare abstract class CampaignRepository {
         amount: string;
         opportunityId: string;
         creatorAddress: string;
+        manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
     })[]>;
     static countMany(query: GetCampaignQueryModel): Promise<number>;
-    static countLives(chainId: number): Promise<number>;
-    static findManyCampaignId(chainId: ChainId): Promise<{
-        campaignId: string;
-    }[]>;
     static findChains(): Promise<Record<string, ChainId>>;
-    static updateOpportunity(id: string, data: extendedUpdateCampaignModel): Promise<{
-        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;
-    }>;
+    static addManualOverride(id: string, field: CampaignManualOverride): Promise<void>;
+    static removeManualOverride(id: string, field: CampaignManualOverride): Promise<void>;
+    static updateOpportunity(id: string, data: extendedUpdateCampaignModel): Promise<void>;
+    static updateCreator(id: string, creatorAddress: string): Promise<void>;
     static updateMetaData(id: string, params: string): Promise<{
         type: string;
         id: string;
@@ -431,5 +462,6 @@ export declare abstract class CampaignRepository {
         amount: string;
         opportunityId: string;
         creatorAddress: string;
+        manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
     }>;
 }

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 = {