@merkl/api 0.17.22 → 0.17.24

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.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;

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

@@ -513,6 +513,7 @@ export declare abstract class OpportunityService {
             rewardTokenId: string;
             amount: string;
             opportunityId: string;
+            manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
         }[] | undefined;
         id: string;
         depositUrl: string | undefined;
@@ -659,6 +660,7 @@ export declare abstract class OpportunityService {
             rewardTokenId: string;
             amount: string;
             opportunityId: string;
+            manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
         }[] | undefined;
         id: string;
         depositUrl: string | undefined;
@@ -801,6 +803,7 @@ export declare abstract class OpportunityService {
             rewardTokenId: string;
             amount: string;
             opportunityId: string;
+            manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
         }[] | undefined;
         id: string;
         depositUrl: string | undefined;

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

@@ -818,7 +818,7 @@ const SwapxInterfaceCampaigns = {
         hooks: [],
         poolAddress: "0xDd35c88B1754879EF86BBF3A24F81fCCA5Eb6B5D",
         whitelist: ["0x640429B0633851F487639BcDd8Ed523DDf1Bbff8"],
-        blacklist: [],
+        blacklist: ["0x646ab1E6D0939672f810781449650A8058BB3C18", "0x45D341eE986532E09266c4ff182f610FaE249b5D"],
         url: "https://swapx.fi/earn?ownerType=pools&filter=conc-liquidity",
         forwarders: [],
         isOutOfRangeIncentivized: false,
@@ -832,7 +832,7 @@ const SwapxInterfaceCampaigns = {
         hooks: [],
         poolAddress: "0xDd35c88B1754879EF86BBF3A24F81fCCA5Eb6B5D",
         whitelist: ["0x4604782BcD6F749B271Fc9d14BFd583be6e5a6cf"],
-        blacklist: [],
+        blacklist: ["0x09AcA88Fc65Ea9BC94C9DDB2C48FC4265e2ba41A", "0xBd58346C2c19CA392f473d1C048c09A6353A2B50"],
         url: "https://swapx.fi/earn?ownerType=pools&filter=conc-liquidity",
         forwarders: [],
         isOutOfRangeIncentivized: false,
@@ -860,7 +860,7 @@ const SwapxInterfaceCampaigns = {
         hooks: [],
         poolAddress: "0xD760791B29e7894FB827A94Ca433254bb5aFB653",
         whitelist: ["0x2f9e2852de03c42c13d3dCdD2C57c0b3cF0382c1"],
-        blacklist: [],
+        blacklist: ["0x90513c7e25330A208CCEfCd975C6F6E8237541d0", "0x8dd81BA99883491Db2070F8E3aD6AAA563D71457"],
         url: "https://swapx.fi/earn?ownerType=pools&filter=conc-liquidity",
         forwarders: [],
         isOutOfRangeIncentivized: false,
@@ -874,7 +874,7 @@ const SwapxInterfaceCampaigns = {
         hooks: [],
         poolAddress: "0xD760791B29e7894FB827A94Ca433254bb5aFB653",
         whitelist: ["0xC693c6fc1d2b44DfB5C5aa05Ca2b02A91DB97528"],
-        blacklist: [],
+        blacklist: ["0x7D2EF0fa1b7b2d237079F3e680aaFa54aA63be91", "0xd1Cb5d8D24Df956eC6C74647730ED4b1507000da"],
         url: "https://swapx.fi/earn?ownerType=pools&filter=conc-liquidity",
         forwarders: [],
         isOutOfRangeIncentivized: false,
@@ -1028,7 +1028,7 @@ const SwapxInterfaceCampaigns = {
         hooks: [],
         poolAddress: "0x0d13400CC7c46D77a43957fE614ba58C827dfde6",
         whitelist: ["0x29985EE262a4C9D878AA6A9B9dC43f2FC87a81c6"],
-        blacklist: [],
+        blacklist: ["0xA49883f4123c2a10bbdBf095950E7F64292E29bF", "0x0b900e9fd1A345c643E995c6Fea4a3Ce9FaDFcdf"],
         url: "https://swapx.fi/earn?ownerType=pools&filter=conc-liquidity",
         forwarders: [],
         isOutOfRangeIncentivized: false,
@@ -1042,7 +1042,7 @@ const SwapxInterfaceCampaigns = {
         hooks: [],
         poolAddress: "0x0d13400CC7c46D77a43957fE614ba58C827dfde6",
         whitelist: ["0x30Df881606c719916b99a0b5bc89e5eB338a226C"],
-        blacklist: [],
+        blacklist: ["0xf9a6Bc526c39925485946FfD93923Ca0906ab8f2", "0xE5B85B2D6A765b64d23089039bB76198Cd65e0E1"],
         url: "https://swapx.fi/earn?ownerType=pools&filter=conc-liquidity",
         forwarders: [],
         isOutOfRangeIncentivized: false,

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

@@ -41,6 +41,7 @@ export declare abstract class ProtocolRepository {
                 amount: string;
                 opportunityId: string;
                 creatorAddress: string;
+                manualOverrides: import("../../../../database/api/.generated").$Enums.CampaignManualOverride[];
             }[];
         } & {
             name: string;

package/dist/src/modules/v4/router.d.ts

@@ -241,6 +241,7 @@ export declare const v4: Elysia<"/v4", false, {
                                 rewardTokenId: string;
                                 amount: string;
                                 opportunityId: string;
+                                manualOverrides: import("../../../database/api/.generated").$Enums.CampaignManualOverride[];
                             }[] | undefined;
                             id: string;
                             depositUrl: string | undefined;
@@ -960,6 +961,7 @@ export declare const v4: Elysia<"/v4", false, {
                             amount: string;
                             opportunityId: string;
                             creatorAddress: string;
+                            manualOverrides: import("../../../database/api/.generated").$Enums.CampaignManualOverride[];
                         } | undefined;
                     };
                 };
@@ -968,7 +970,6 @@ export declare const v4: Elysia<"/v4", false, {
             opportunity: {
                 patch: {
                     body: {
-                        tags?: string[] | undefined;
                         opportunityIdentifier?: string | undefined;
                         campaignId: string;
                         distributionChain: number;
@@ -983,6 +984,42 @@ export declare const v4: Elysia<"/v4", 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: {
@@ -1011,6 +1048,7 @@ export declare const v4: Elysia<"/v4", false, {
                             amount: string;
                             opportunityId: string;
                             creatorAddress: string;
+                            manualOverrides: import("../../../database/api/.generated").$Enums.CampaignManualOverride[];
                         };
                     };
                 };
@@ -1108,6 +1146,7 @@ export declare const v4: Elysia<"/v4", false, {
                             rewardTokenId: string;
                             amount: string;
                             opportunityId: string;
+                            manualOverrides: import("../../../database/api/.generated").$Enums.CampaignManualOverride[];
                         }[];
                     };
                 };
@@ -1172,6 +1211,7 @@ export declare const v4: Elysia<"/v4", false, {
                             rewardTokenId: string;
                             amount: string;
                             opportunityId: string;
+                            manualOverrides: import("../../../database/api/.generated").$Enums.CampaignManualOverride[];
                         };
                     };
                 };

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

@@ -78,7 +78,7 @@ export class StatusService {
     static async findUpdatesAndDelays() {
         const merklRoots = await MerklRootService.fetchAll();
         const delayedCampaignPromises = Promise.allSettled(Object.keys(merklRoots).map(chainId => StatusService.findManyDelay({ chainId: Number.parseInt(chainId), delayLowerBound: 9 * HOUR })));
-        const liveCampaignPromises = await Promise.allSettled(Object.keys(merklRoots).map(chainId => CampaignService.countLives(Number.parseInt(chainId))));
+        const liveCampaignPromises = await Promise.allSettled(Object.keys(merklRoots).map(chainId => CampaignService.countLives({ distributionChainId: Number.parseInt(chainId) })));
         const delayedCampaignArray = await delayedCampaignPromises;
         const liveCampaignArray = await liveCampaignPromises;
         const res = {};

package/dist/src/routes/v3/dolomite.d.ts

@@ -1,4 +1,7 @@
 import type Elysia from "elysia";
+export declare const query: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+}>;
 export declare const response: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
     index: import("@sinclair/typebox").TNumber;
     token: import("@sinclair/typebox").TString;
@@ -21,7 +24,9 @@ declare const _default: (app: Elysia) => Elysia<"", false, {
         get: {
             body: unknown;
             params: {};
-            query: {};
+            query: {
+                chainId: number;
+            };
             headers: unknown;
             response: {
                 [x: string]: any;

package/dist/src/routes/v3/dolomite.js

@@ -1,9 +1,12 @@
 import { t } from "elysia";
 import { getDolomiteMarketWithCache } from "../../libs/campaigns/utils/getDolomiteMarkets";
+export const query = t.Object({
+    chainId: t.Numeric(),
+});
 export const response = t.Array(t.Object({ index: t.Number(), token: t.String(), symbol: t.String() }));
-export default (app) => app.get("/dolomite", async () => {
-    return await getDolomiteMarketWithCache();
+export default (app) => app.get("/dolomite", async ({ query }) => {
+    return await getDolomiteMarketWithCache(query.chainId);
 }, {
-    query: t.Object({}),
+    query: query,
     tags: ["Protocols"],
 });

package/dist/src/routes/v3/router.d.ts

@@ -219,7 +219,9 @@ export declare const v3: Elysia<"/v3", false, {
             get: {
                 body: unknown;
                 params: {};
-                query: {};
+                query: {
+                    chainId: number;
+                };
                 headers: unknown;
                 response: {
                     [x: string]: any;

package/dist/src/utils/error.d.ts

@@ -15,6 +15,12 @@ export declare class OpportunityNotFound extends Error {
     chainId: ChainId;
     constructor(mainParameter: string, chainId: ChainId);
 }
+export declare class CannotParseOpportunity extends Error {
+    campaignId: string;
+    chainId: ChainId;
+    type: number;
+    constructor(campaignId: string, chainId: ChainId, type: number);
+}
 export declare class MerkleRootNotFound extends Error {
     chainId: ChainId;
     constructor(chainId: ChainId);

package/dist/src/utils/error.js

@@ -27,6 +27,18 @@ export class OpportunityNotFound extends Error {
         this.name = "OPPORTUNITY_NOT_FOUND";
     }
 }
+export class CannotParseOpportunity extends Error {
+    campaignId;
+    chainId;
+    type;
+    constructor(campaignId, chainId, type) {
+        super(`Cannot parse opportunity from campaign ${campaignId} of type ${type} on chain ${NETWORK_LABELS[chainId]}`);
+        this.campaignId = campaignId;
+        this.chainId = chainId;
+        this.type = type;
+        this.name = "OPPORTUNITY_CANNOT_BE_PARSED";
+    }
+}
 export class MerkleRootNotFound extends Error {
     chainId;
     constructor(chainId) {