@merkl/api 0.10.345 → 0.10.347

package/dist/src/cache/declaration.d.ts

@@ -125,4 +125,9 @@ export declare const CacheDeclaration: {
         redisTTL: TTLType.Minutes2;
         localCache: true;
     };
+    UniswapV4Pools: {
+        compressed: false;
+        redisTTL: TTLType.Minutes30;
+        localCache: false;
+    };
 };

package/dist/src/cache/declaration.js

@@ -113,4 +113,9 @@ export const CacheDeclaration = {
         redisTTL: TTLType.Minutes2,
         localCache: true,
     },
+    UniswapV4Pools: {
+        compressed: false,
+        redisTTL: TTLType.Minutes30,
+        localCache: false,
+    },
 };

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

@@ -1,4 +1,4 @@
-import type { Campaign as CampaignResource } from "../modules/v4";
+import type { Campaign as CampaignResource, CampaignWithParams } from "../modules/v4";
 import type { CampaignType } from "../../database/api/.generated";
 declare const eden: {
     index: {
@@ -724,6 +724,35 @@ declare const eden: {
                     200: string;
                 }>>;
             };
+            metadata: {
+                patch: (body: {
+                    url: string;
+                    campaignId: string;
+                    distributionChain: number;
+                }, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        type: import("../../database/api/.generated").$Enums.CampaignType;
+                        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;
+                    };
+                }>>;
+            };
             index: {
                 get: (options: {
                     headers?: Record<string, unknown> | undefined;
@@ -2612,8 +2641,8 @@ declare const eden: {
                 query: {
                     types?: string | number | string[] | number[] | undefined;
                     chainIds?: string | string[] | undefined;
-                    live?: boolean | undefined;
                     creatorTag?: string | undefined;
+                    live?: boolean | undefined;
                     hideTestTokens?: string | undefined;
                 };
                 fetch?: RequestInit | undefined;
@@ -3130,6 +3159,19 @@ declare const eden: {
                 };
             }>>;
         };
+        uniswapv4: {
+            get: (options: {
+                headers?: Record<string, unknown> | undefined;
+                query: {};
+                fetch?: RequestInit | undefined;
+            }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                200: {
+                    [x: string]: {
+                        [poolId: string]: UniswapV4PoolType;
+                    } | undefined;
+                };
+            }>>;
+        };
     };
 };
 type Api = typeof eden;
@@ -3993,6 +4035,38 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     };
                 };
             };
+        } & {
+            metadata: {
+                patch: {
+                    body: {
+                        url: string;
+                        campaignId: string;
+                        distributionChain: number;
+                    };
+                    params: {};
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: {
+                            type: import("../../database/api/.generated").$Enums.CampaignType;
+                            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;
+                        };
+                    };
+                };
+            };
         } & {
             index: {
                 get: {
@@ -6393,8 +6467,8 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 query: {
                     types?: string | number | string[] | number[] | undefined;
                     chainIds?: string | string[] | undefined;
-                    live?: boolean | undefined;
                     creatorTag?: string | undefined;
+                    live?: boolean | undefined;
                     hideTestTokens?: string | undefined;
                 };
                 headers: unknown;
@@ -7068,6 +7142,24 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
             };
         };
     };
+} & {
+    v3: {
+        uniswapv4: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {};
+                headers: unknown;
+                response: {
+                    200: {
+                        [x: string]: {
+                            [poolId: string]: UniswapV4PoolType;
+                        } | undefined;
+                    };
+                };
+            };
+        };
+    };
 }, {
     derive: {};
     resolve: {};
@@ -7800,6 +7892,35 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     200: string;
                 }>>;
             };
+            metadata: {
+                patch: (body: {
+                    url: string;
+                    campaignId: string;
+                    distributionChain: number;
+                }, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        type: import("../../database/api/.generated").$Enums.CampaignType;
+                        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;
+                    };
+                }>>;
+            };
             index: {
                 get: (options: {
                     headers?: Record<string, unknown> | undefined;
@@ -9688,8 +9809,8 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 query: {
                     types?: string | number | string[] | number[] | undefined;
                     chainIds?: string | string[] | undefined;
-                    live?: boolean | undefined;
                     creatorTag?: string | undefined;
+                    live?: boolean | undefined;
                     hideTestTokens?: string | undefined;
                 };
                 fetch?: RequestInit | undefined;
@@ -10206,11 +10327,25 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 };
             }>>;
         };
+        uniswapv4: {
+            get: (options: {
+                headers?: Record<string, unknown> | undefined;
+                query: {};
+                fetch?: RequestInit | undefined;
+            }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                200: {
+                    [x: string]: {
+                        [poolId: string]: UniswapV4PoolType;
+                    } | undefined;
+                };
+            }>>;
+        };
     };
 };
 export type Opportunity = FromPromise<Api["v4"]["opportunities"]["index"]["get"]>;
 export type Protocol = FromPromise<Api["v4"]["protocols"]["index"]["get"]>;
 export type Campaign<C extends CampaignType = CampaignType> = CampaignResource<C>["model"];
+export type CampaignParams<C extends CampaignType = CampaignType> = CampaignWithParams<C>["model"]["params"];
 export type Chain = FromPromise<Api["v4"]["chains"]["index"]["get"]>;
 export type Explorer = FromPromise<Api["v4"]["chains"]["index"]["get"]>["explorers"][number];
 export type Token = FromPromise<Api["v4"]["tokens"]["index"]["get"]>;

package/dist/src/index.d.ts

@@ -852,6 +852,38 @@ declare const app: Elysia<"", false, {
                     };
                 };
             };
+        } & {
+            metadata: {
+                patch: {
+                    body: {
+                        url: string;
+                        campaignId: string;
+                        distributionChain: number;
+                    };
+                    params: {};
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: {
+                            type: import("../database/api/.generated").$Enums.CampaignType;
+                            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;
+                        };
+                    };
+                };
+            };
         } & {
             index: {
                 get: {
@@ -3252,8 +3284,8 @@ declare const app: Elysia<"", false, {
                 query: {
                     types?: string | number | string[] | number[] | undefined;
                     chainIds?: string | string[] | undefined;
-                    live?: boolean | undefined;
                     creatorTag?: string | undefined;
+                    live?: boolean | undefined;
                     hideTestTokens?: string | undefined;
                 };
                 headers: unknown;
@@ -3927,6 +3959,24 @@ declare const app: Elysia<"", false, {
             };
         };
     };
+} & {
+    v3: {
+        uniswapv4: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {};
+                headers: unknown;
+                response: {
+                    200: {
+                        [x: string]: {
+                            [poolId: string]: UniswapV4PoolType;
+                        } | undefined;
+                    };
+                };
+            };
+        };
+    };
 }, {
     derive: {};
     resolve: {};

package/dist/src/libs/campaigns/utils/getUniswapV4Pools.d.ts

@@ -0,0 +1,7 @@
+import { type MerklChainId, type UniswapV4PoolType } from "@sdk";
+export type UniswapV4PoolsReturnType = {
+    [chainId in MerklChainId]?: {
+        [poolId: string]: UniswapV4PoolType;
+    };
+};
+export declare const getUniswapV4PoolsWithCache: () => Promise<UniswapV4PoolsReturnType>;

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

@@ -0,0 +1,109 @@
+import { Redis } from "../../../cache";
+import { log } from "../../../utils/logger";
+import { providers } from "../../../utils/providers";
+import { ChainInteractionService, ERC20Interface, NETWORK_LABELS, NULL_ADDRESS, PoolManagerInterface, UniswapV4Addresses, getContractCreationBlock, } from "@sdk";
+import { safeFetchLogs } from "./fetchLogs";
+const UNIV4_CHAINIDS = Object.keys(UniswapV4Addresses).map((x) => Number(x));
+async function getUniswapV4Pools() {
+    const res = {};
+    for (let chainId of UNIV4_CHAINIDS) {
+        chainId = chainId;
+        res[chainId] = {};
+        const poolManagerAddress = UniswapV4Addresses[chainId]?.PoolManager ?? NULL_ADDRESS;
+        const jsonRPCprovider = providers[chainId];
+        try {
+            const fromBlock = await getContractCreationBlock(poolManagerAddress, jsonRPCprovider);
+            const toBlock = await jsonRPCprovider.getBlockNumber();
+            const logs = await safeFetchLogs(chainId, // TODO: rm type enforcing
+            [PoolManagerInterface.getEventTopic("Initialize")], [poolManagerAddress], fromBlock, toBlock);
+            const decodedPools = await Promise.all(logs.map(async (log) => {
+                const [id, currency0, currency1, fee, tickSpacing, hooks] = PoolManagerInterface.decodeEventLog("Initialize", log.data, log.topics);
+                // Respect typing
+                return {
+                    poolId: id,
+                    chainId: chainId,
+                    currency0: currency0,
+                    currency1: currency1,
+                    tickSpacing: tickSpacing,
+                    lpFee: fee,
+                    hooks: hooks,
+                    initializeBlock: Number(log.blockNumber),
+                };
+            }));
+            log.local(`fetched ${decodedPools.length} pool(s) on ${NETWORK_LABELS[chainId] ?? "Sepolia"} between blocks ${fromBlock} and ${toBlock}`);
+            /** Extra calls batch to get the collateral addresses */
+            const resCurrencies = await ChainInteractionService(chainId).fetchState(decodedPools.flatMap(pool => {
+                return [
+                    {
+                        allowFailure: true,
+                        callData: ERC20Interface.encodeFunctionData("symbol"),
+                        target: pool.currency0,
+                    },
+                    {
+                        allowFailure: true,
+                        callData: ERC20Interface.encodeFunctionData("decimals"),
+                        target: pool.currency0,
+                    },
+                    {
+                        allowFailure: true,
+                        callData: ERC20Interface.encodeFunctionData("symbol"),
+                        target: pool.currency1,
+                    },
+                    {
+                        allowFailure: true,
+                        callData: ERC20Interface.encodeFunctionData("decimals"),
+                        target: pool.currency1,
+                    },
+                ].filter(x => x.target !== NULL_ADDRESS);
+            }));
+            let index = 0;
+            for (const pool of decodedPools) {
+                let symbolCurrency0;
+                let decimalsCurrency0;
+                if (pool.currency0 !== NULL_ADDRESS) {
+                    symbolCurrency0 = ERC20Interface.decodeFunctionResult("symbol", resCurrencies[index].returnData)[0];
+                    decimalsCurrency0 = ERC20Interface.decodeFunctionResult("decimals", resCurrencies[index + 1].returnData)[0];
+                }
+                else {
+                    symbolCurrency0 = "ETH";
+                    decimalsCurrency0 = 18;
+                    index -= 2;
+                }
+                let symbolCurrency1;
+                let decimalsCurrency1;
+                if (pool.currency1 !== NULL_ADDRESS) {
+                    symbolCurrency1 = ERC20Interface.decodeFunctionResult("symbol", resCurrencies[index + 2].returnData)[0];
+                    decimalsCurrency1 = ERC20Interface.decodeFunctionResult("decimals", resCurrencies[index + 3].returnData)[0];
+                }
+                else {
+                    symbolCurrency1 = "ETH";
+                    decimalsCurrency1 = 18;
+                    index -= 2;
+                }
+                const id = pool.poolId;
+                res[chainId][id ?? "unknownKey"] = {
+                    chainId: pool.chainId,
+                    currency0: pool.currency0,
+                    currency1: pool.currency1,
+                    decimalsCurrency0,
+                    decimalsCurrency1,
+                    hooks: pool.hooks,
+                    initializeBlock: pool.initializeBlock,
+                    lpFee: pool.lpFee,
+                    poolId: id,
+                    poolKey: pool.poolKey,
+                    symbolCurrency0,
+                    symbolCurrency1,
+                    tickSpacing: pool.tickSpacing,
+                };
+                index += 4;
+            }
+        }
+        catch (e) {
+            log.error(`issue when fetching UniswapV4 pools on ${chainId}`, e);
+        }
+    }
+    log.info("✅ successfully fetched pools on UniswapV4");
+    return res;
+}
+export const getUniswapV4PoolsWithCache = async () => await Redis.getOrSet("UniswapV4Pools", getUniswapV4Pools);

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

@@ -74,6 +74,38 @@ export declare const CampaignController: Elysia<"/campaigns", false, {
                 };
             };
         };
+    } & {
+        metadata: {
+            patch: {
+                body: {
+                    url: string;
+                    campaignId: string;
+                    distributionChain: number;
+                };
+                params: {};
+                query: unknown;
+                headers: {
+                    authorization: string;
+                };
+                response: {
+                    200: {
+                        type: import("../../../../database/api/.generated").$Enums.CampaignType;
+                        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;
+                    };
+                };
+            };
+        };
     } & {
         index: {
             get: {

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

@@ -3,7 +3,7 @@ import { AuthorizationHeadersDto, EngineGuard } from "../../../guards/Engine.gua
 import Elysia, { t } from "elysia";
 import { throwOnUnsupportedChainId } from "src/utils/throw";
 import { ChainUniqueDto } from "../chain";
-import { CampaignResourceDto, CreateCampaignDto, GetCampaignQueryDto, UpdateCampaignDto } from "./campaign.model";
+import { CampaignResourceDto, CreateCampaignDto, GetCampaignQueryDto, UpdateCampaignDto, UpdateMetaDataCampaignDto, } from "./campaign.model";
 import { CampaignService } from "./campaign.service";
 // ─── Campaigns Controller ────────────────────────────────────────────────────
 export const CampaignController = new Elysia({ prefix: "/campaigns", detail: { tags: ["Campaigns"] } })
@@ -19,6 +19,12 @@ export const CampaignController = new Elysia({ prefix: "/campaigns", detail: { t
     headers: AuthorizationHeadersDto,
     body: UpdateCampaignDto,
     detail: { hide: true },
+})
+    .patch("/metadata", async ({ body }) => await CampaignService.updateMetaData(body), {
+    beforeHandle: BackOfficeGuard,
+    headers: AuthorizationHeadersDto,
+    body: UpdateMetaDataCampaignDto,
+    detail: { hide: true },
 })
     // ─── Get Many Campaigns ──────────────────────────────────────────────
     .get("/", async ({ query }) => await CampaignService.findMany(query), {

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

@@ -2,8 +2,8 @@ import type { Resource } from "../prisma";
 import { type Token } from "../token";
 import { CampaignType } from "../../../../database/api/.generated";
 import { type CampaignParameters } from "@sdk";
-import { type Chain } from "../chain";
-import { type Status } from "../status";
+import { type Chain } from "../chain/chain.model";
+import { type Status } from "../status/status.model";
 /**
  * Campaign
  * @description Target description of rewards campaigns
@@ -112,6 +112,11 @@ export declare const UpdateCampaignDto: import("@sinclair/typebox").TObject<{
     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 UpdateMetaDataCampaignDto: import("@sinclair/typebox").TObject<{
+    distributionChain: import("@sinclair/typebox").TNumber;
+    campaignId: import("@sinclair/typebox").TString;
+    url: import("@sinclair/typebox").TString;
+}>;
 export declare const GetCampaignQueryDto: import("@sinclair/typebox").TObject<{
     creatorTag: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
@@ -156,6 +161,9 @@ export type CreateCampaignModel = typeof CreateCampaignDto.static & {
 export type UpdateCampaignModel = typeof UpdateCampaignDto.static & {
     id: string;
 };
+export type UpdateMetaDataCampaignModel = typeof UpdateMetaDataCampaignDto.static & {
+    url: string;
+};
 export type extendedUpdateCampaignModel = UpdateCampaignModel & {
     opportunityId: string;
 };

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

@@ -2,8 +2,8 @@ import { TokenResourceDto } from "../token";
 import { CampaignType } from "../../../../database/api/.generated";
 import { Campaign as CampaignTypeEnum } from "@sdk";
 import { t } from "elysia";
-import { ChainResourceDto } from "../chain";
-import { CampaignStatusResourceDto } from "../status";
+import { ChainResourceDto } from "../chain/chain.model";
+import { CampaignStatusResourceDto } from "../status/status.model";
 // ─── Utils ───────────────────────────────────────────────────────────────────
 export const campaignTypeToEnumMap = {
     INVALID: CampaignTypeEnum.INVALID,
@@ -73,6 +73,11 @@ export const UpdateCampaignDto = t.Object({
     opportunityIdentifier: t.Optional(t.String()),
     tags: t.Optional(t.Array(t.String())),
 });
+export const UpdateMetaDataCampaignDto = t.Object({
+    distributionChain: t.Numeric(),
+    campaignId: t.String(),
+    url: t.String(),
+});
 export const GetCampaignQueryDto = t.Object({
     creatorTag: t.Optional(t.String({ description: "Filter campaigns created by a user who has a specific tag" })),
     chainId: t.Optional(t.Numeric({

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

@@ -135,7 +135,22 @@ export declare abstract class CampaignRepository {
         campaignId: string;
     }[]>;
     static findChains(): Promise<Record<string, ChainId>>;
-    static update(id: string, data: extendedUpdateCampaignModel): Promise<{
+    static updateOpportunity(id: string, data: extendedUpdateCampaignModel): Promise<{
+        type: import("../../../../database/api/.generated").$Enums.CampaignType;
+        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 updateMetaData(id: string, params: string): Promise<{
         type: import("../../../../database/api/.generated").$Enums.CampaignType;
         id: string;
         params: Prisma.JsonValue;

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

@@ -313,7 +313,7 @@ export class CampaignRepository {
             return acc;
         }, {});
     }
-    static async update(id, data) {
+    static async updateOpportunity(id, data) {
         const updateData = {
             Opportunity: {
                 connect: { id: data.opportunityId },
@@ -321,4 +321,10 @@ export class CampaignRepository {
         };
         return await apiDbClient.campaign.update({ where: { id }, data: updateData });
     }
+    static async updateMetaData(id, params) {
+        const updateData = {
+            params: JSON.parse(params),
+        };
+        return await apiDbClient.campaign.update({ where: { id }, data: updateData });
+    }
 }

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

@@ -1,4 +1,4 @@
-import { type CampaignUnique, type CampaignWithParams, type ConvertedCampaignType, type CreateCampaignModel, type GetCampaignQueryModel, type UpdateCampaignModel } from "./";
+import { type CampaignUnique, type CampaignWithParams, type ConvertedCampaignType, type CreateCampaignModel, type GetCampaignQueryModel, type UpdateCampaignModel, type UpdateMetaDataCampaignModel } from "./";
 import { CampaignRepository } from "./campaign.repository";
 import type { CampaignType } from "../../../../database/api/.generated";
 import { type CampaignParameters, type Campaign as CampaignTypeV3, type ChainId } from "@sdk";
@@ -19,6 +19,21 @@ export declare abstract class CampaignService {
         opportunityId: string;
         creatorAddress: string;
     } | undefined>;
+    static updateMetaData(campaign: Omit<UpdateMetaDataCampaignModel, "id">): Promise<{
+        type: import("../../../../database/api/.generated").$Enums.CampaignType;
+        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 moveToOpportunity(campaign: Omit<UpdateCampaignModel, "id">, upsert?: boolean): Promise<string>;
     static createMany(campaigns: Omit<CreateCampaignModel, "id">[], upsert?: boolean): Promise<{
         success: number;

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

@@ -20,6 +20,19 @@ export class CampaignService {
         await OpportunityService.createFromCampaign(campaign);
         return await CampaignRepository.upsert({ id, ...campaign });
     }
+    static async updateMetaData(campaign) {
+        const id = CampaignService.hashId({
+            distributionChain: campaign.distributionChain,
+            campaignId: campaign.campaignId,
+        });
+        const existingCampaign = await CampaignService.findUniqueOrThrow(campaign);
+        const params = existingCampaign.params;
+        if ("url" in params) {
+            params.url = campaign.url;
+        }
+        const updatedParams = JSON.stringify(params);
+        return await CampaignRepository.updateMetaData(id, updatedParams);
+    }
     static async moveToOpportunity(campaign, upsert = false) {
         const id = CampaignService.hashId({
             distributionChain: campaign.distributionChain,
@@ -61,7 +74,7 @@ export class CampaignService {
         // Create new opportunity
         await OpportunityService.createFromCampaign(updatedCampaign, upsert);
         // Move campaign to new opportunity
-        await CampaignRepository.update(id, { id, ...updatedCampaignData });
+        await CampaignRepository.updateOpportunity(id, { id, ...updatedCampaignData });
         // Update new opportunity with campaign
         // await OpportunityService.recreate(opportunityId);
         // Remov (update) campaign from old opportunity

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

@@ -1,12 +1,12 @@
 import { type AprRecord } from "../apr/apr.model";
+import { type Campaign } from "../campaign/campaign.model";
 import type { Resource } from "../prisma";
 import { type Protocol, type ProtocolId } from "../protocol/protocol.model";
-import { type DailyRewardsRecord } from "../reward";
+import { type DailyRewardsRecord } from "../reward/reward.model";
 import { type Token } from "../token/token.model";
 import { type TvlRecord } from "../tvl/tvl.model";
 import { CampaignType, OpportunityAction } from "../../../../database/api/.generated";
 import type { ChainId } from "@sdk";
-import { type Campaign } from "../campaign";
 import { type Chain } from "../chain/chain.model";
 import type { OpportunityRepository } from "./opportunity.repository";
 /**