@merkl/api 0.20.113 → 0.20.115

package/dist/src/engine/implementations/Morpho/metadata.d.ts

@@ -1,9 +1,9 @@
 import type { MetadataBuilder } from "@/engine/metadata/interface";
 import type { CampaignWithParams } from "@/modules/v4/campaign";
 import type { ProtocolId } from "@/modules/v4/protocol/protocol.model";
-import { type Campaign as CampaignEnum, type CampaignParameters, ChainId } from "@sdk";
+import { type CampaignParameters, type Campaign as CampaignType, ChainId } from "@sdk";
 import type { BigNumberish } from "ethers";
-type campaignType = CampaignEnum.MORPHO;
+type campaignType = CampaignType.MORPHO;
 export declare class MorphoMetadata implements MetadataBuilder<campaignType> {
     build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         action: "LEND" | "BORROW";

package/dist/src/engine/implementations/Radiant/metadata.d.ts

@@ -1,8 +1,8 @@
 import type { CampaignWithParams } from "@/modules/v4/campaign";
 import type { ProtocolId } from "@/modules/v4/protocol/protocol.model";
-import { type Campaign as CampaignEnum } from "@sdk";
+import { type Campaign as CampaignType } from "@sdk";
 import type { MetadataBuilder } from "../../metadata/interface";
-type campaignType = CampaignEnum.RADIANT;
+type campaignType = CampaignType.RADIANT;
 export declare class RadiantMetadata implements MetadataBuilder<campaignType> {
     build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         action: "LEND" | "BORROW";

package/dist/src/engine/implementations/Silo/metadata.d.ts

@@ -1,8 +1,8 @@
 import type { MetadataBuilder } from "@/engine/metadata/interface";
 import type { CampaignWithParams } from "@/modules/v4/campaign";
 import type { ProtocolId } from "@/modules/v4/protocol/protocol.model";
-import type { Campaign as CampaignEnum } from "@sdk";
-type campaignType = CampaignEnum.SILO;
+import type { Campaign as CampaignType } from "@sdk";
+type campaignType = CampaignType.SILO;
 export declare class SiloMetadata implements MetadataBuilder<campaignType> {
     build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         action: "LEND" | "BORROW";

package/dist/src/engine/implementations/UniswapV4/metadata.d.ts

@@ -1,8 +1,8 @@
 import type { MetadataBuilder } from "@/engine/metadata/interface";
 import type { CampaignWithParams } from "@/modules/v4/campaign";
 import type { ProtocolId } from "@/modules/v4/protocol/protocol.model";
-import type { Campaign as CampaignEnum, CampaignParameters, ChainId } from "@sdk";
-type campaignType = CampaignEnum.UNISWAP_V4;
+import type { CampaignParameters, Campaign as CampaignType, ChainId } from "@sdk";
+type campaignType = CampaignType.UNISWAP_V4;
 export declare class UniswapV4Metadata implements MetadataBuilder<campaignType> {
     build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         name: string;

package/dist/src/engine/implementations/Vest/metadata.d.ts

@@ -1,8 +1,8 @@
 import type { MetadataBuilder } from "@/engine/metadata/interface";
 import type { CampaignWithParams } from "@/modules/v4/campaign";
 import type { ProtocolId } from "@/modules/v4/protocol/protocol.model";
-import type { Campaign as CampaignEnum } from "@sdk";
-type campaignType = CampaignEnum.VEST;
+import type { Campaign as CampaignType } from "@sdk";
+type campaignType = CampaignType.VEST;
 export declare class VestMetadata implements MetadataBuilder<campaignType> {
     build(campaign: Omit<CampaignWithParams<campaignType>, "manualOverrides">): Promise<{
         action: "LEND";

package/dist/src/engine/metadata/factory.js

@@ -67,5 +67,6 @@ const map = {
     [Campaign.ERC1155FIXAPR]: new ErcMultiTokenMetadata(),
     [Campaign.ERC721]: new Erc721Metadata(),
     [Campaign.ERC721FIXAPR]: new Erc721Metadata(),
+    [Campaign.MULTILOG]: new DefaultMetadata(), // TODO
 };
 export const metadataBuilderFactory = (campaignType) => map[campaignType];

package/dist/src/engine/tvl/factory.js

@@ -2,6 +2,7 @@ import { UniswapV4TVLBuilder } from "@/engine/implementations/UniswapV4/tvl";
 import { Campaign } from "@sdk";
 import { AjnaTVLBuilder } from "../implementations/Ajna/tvl";
 import { AmbiantTVLBuilder } from "../implementations/Ambient/tvl";
+import { EigenLayerTVLBuilder } from "../implementations/EigenLayer/tvl";
 import { Erc20TVLBuilder } from "../implementations/Erc20/tvl";
 /**
  * @dev TYPE SAFETY DISABLED FOR NOW AS WE DON'T HAVE ALL THE CAMPAIGNS IMPLEMENTED
@@ -11,6 +12,7 @@ import { Erc20TVLBuilder } from "../implementations/Erc20/tvl";
  */
 const map = {
     [Campaign.AJNA]: new AjnaTVLBuilder(),
+    [Campaign.EIGENLAYER]: new EigenLayerTVLBuilder(),
     [Campaign.AMBIENTPROCESSOR]: new AmbiantTVLBuilder(),
     [Campaign.UNISWAP_V4]: new UniswapV4TVLBuilder(),
     [Campaign.ERC20]: new Erc20TVLBuilder(),

package/dist/src/index.d.ts

@@ -2133,8 +2133,8 @@ declare const app: Elysia<"", false, {
                         body: unknown;
                         params: {};
                         query: {
+                            distributionChain?: number | undefined;
                             campaignId: string;
-                            distributionChain: number;
                         };
                         headers: {
                             authorization: string;

package/dist/src/jobs/update-dynamic-data.js

@@ -3,7 +3,7 @@ import { DynamicDataService } from "@/modules/v4/dynamicData/dynamicData.service
 import { OpportunityService } from "@/modules/v4/opportunity";
 import { OpportunityConvertorService } from "@/modules/v4/opportunity/opportunity.converter";
 import { logger } from "@/utils/logger";
-import { Campaign as CampaignEnum } from "@sdk";
+import { Campaign as CampaignType } from "@sdk";
 import moment from "moment";
 // ─── Required Env Variables ──────────────────────────────────────────────────
 const chainId = Number(process.env.CHAIN_ID);
@@ -52,7 +52,7 @@ const main = async () => {
     // 4. Update the status of the opportunities associated to live campaigns
     await OpportunityService.updateMany(liveOpportunityIds, { status: "LIVE" });
     // 5. Update records for all live campaigns
-    const liveCampaigns = (await CampaignService.findMany({ chainId, status: "LIVE", test: true, withOpportunity: true, items: 10_000 })).map(campaign => OpportunityConvertorService.convertV4CampaignToV3(CampaignEnum[campaign.type], campaign, campaign.Opportunity.identifier));
+    const liveCampaigns = (await CampaignService.findMany({ chainId, status: "LIVE", test: true, withOpportunity: true, items: 10_000 })).map(campaign => OpportunityConvertorService.convertV4CampaignToV3(CampaignType[campaign.type], campaign, campaign.Opportunity.identifier));
     const promises = [];
     for (const type of new Set(liveCampaigns.map(c => c.campaignType))) {
         promises.push(DynamicDataService.update(chainId, type, liveCampaigns.filter(c => c.campaignType === type)));

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

@@ -1,6 +1,6 @@
 import type { Resource } from "@/modules/v4/prisma";
 import { type Token } from "@/modules/v4/token/token.model";
-import type { Campaign as CampaignEnum, CampaignParameters } from "@sdk";
+import type { CampaignParameters, Campaign as CampaignType } from "@sdk";
 import { type Chain } from "../chain/chain.model";
 import { type Status as StatusModel } from "../status/status.model";
 /**
@@ -22,7 +22,7 @@ export type Campaign = Resource<"Campaign", "opportunityId" | "rewardTokenId", {
     startTimestamp: number;
     createdAt: string;
 }>;
-export type CampaignWithParams<C extends CampaignEnum = CampaignEnum> = Campaign["model"] & {
+export type CampaignWithParams<C extends CampaignType = CampaignType> = Campaign["model"] & {
     params: CampaignParameters<C>["campaignParameters"];
 };
 export declare const CampaignUniqueDto: import("@sinclair/typebox").TObject<{

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

@@ -1,6 +1,6 @@
 import type { CampaignConfigMinimalModel, CampaignUnique, CampaignWithParams, CreateCampaignModel, GetCampaignQueryModel, UpdateCampaignCreatorModel, UpdateCampaignModel, UpdateMetaDataCampaignModel } from "@/modules/v4/campaign";
 import type { CampaignManualOverride } from "@db/api";
-import { Campaign as CampaignEnum, type CampaignParameters, type ChainId } from "@sdk";
+import { type CampaignParameters, Campaign as CampaignType, type ChainId } from "@sdk";
 import type { GetCampaignComputedValueModel } from "../computedValue/computedValue.model";
 import { CampaignRepository } from "./campaign.repository";
 export declare abstract class CampaignService {
@@ -708,7 +708,7 @@ export declare abstract class CampaignService {
      * @param type index of Campaign enum from sdk
      * @returns a string
      */
-    static getTypeFromV3(type: CampaignEnum): string;
+    static getTypeFromV3(type: CampaignType): string;
     /**
      * Split a campaigns array into three array for each status
      * @param campaigns
@@ -805,7 +805,7 @@ export declare abstract class CampaignService {
     /**
      * @deprecated Used only in tentative position fetcher
      */
-    static formatAsCampaignParameters<C extends CampaignEnum>(campaign: CampaignWithParams): CampaignParameters<C>;
+    static formatAsCampaignParameters<C extends CampaignType>(campaign: CampaignWithParams): CampaignParameters<C>;
     /**
      * Shortcut to get daily amount from total
      * @param start timestamp
@@ -814,7 +814,7 @@ export declare abstract class CampaignService {
      * @returns daily token amount
      */
     static getDailyAmount<T extends bigint | number>(start: T, end: T, amount: bigint): bigint;
-    static createFakeCampaign<C extends CampaignEnum>(body: CampaignConfigMinimalModel): CampaignParameters<C>;
+    static createFakeCampaign<C extends CampaignType>(body: CampaignConfigMinimalModel): CampaignParameters<C>;
     static createFakeCampaignEngine(body: CampaignConfigMinimalModel): {
         computeChainId: any;
         chainId: any;

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

@@ -4,7 +4,7 @@ import { StatusService } from "@/modules/v4/status/status.service";
 import { TokenService } from "@/modules/v4/token/token.service";
 import { CannotParseOpportunity, InvalidParameter } from "@/utils/error";
 import { log } from "@/utils/logger";
-import { Campaign as CampaignEnum, NETWORK_LABELS, } from "@sdk";
+import { Campaign as CampaignType, NETWORK_LABELS, } from "@sdk";
 import { utils } from "ethers";
 import moment from "moment";
 import { ChainService } from "../chain/chain.service";
@@ -276,7 +276,7 @@ export class CampaignService {
      * @returns a string
      */
     static getTypeFromV3(type) {
-        return CampaignEnum[type];
+        return CampaignType[type];
     }
     /**
      * Split a campaigns array into three array for each status
@@ -348,7 +348,7 @@ export class CampaignService {
             computeChainId: body.computeChainId,
             campaignParameters: body.params,
             campaignSubType: body.subType ?? 0,
-            campaignType: CampaignEnum[body.type],
+            campaignType: CampaignType[body.type],
             chainId: body.distributionChainId ?? 0,
             creator: body.creatorAddress ?? "creator.address",
             index: 0, // DEPRECATED

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

@@ -204,8 +204,8 @@ export declare const CampaignTestController: Elysia<"/campaigns", false, {
                     body: unknown;
                     params: {};
                     query: {
+                        distributionChain?: number | undefined;
                         campaignId: string;
-                        distributionChain: number;
                     };
                     headers: {
                         authorization: string;

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

@@ -3,12 +3,12 @@ import { InvalidParameter } from "@/errors/InvalidParameter.error";
 import { BackOfficeGuard } from "@/guards/BackOffice.guard";
 import { AuthorizationHeadersDto } from "@/guards/Engine.guard";
 import { throwOnUnsupportedChainId } from "@/utils/throw";
-import { Campaign as CampaignEnum } from "@sdk";
-import Elysia from "elysia";
+import { Campaign as CampaignType } from "@sdk";
+import Elysia, { t } from "elysia";
 import { DynamicDataSourceIdentifier } from "../dynamicData/dynamicData.model";
 import { DynamicDataService } from "../dynamicData/dynamicData.service";
 import { OpportunityConvertorService } from "../opportunity/opportunity.converter";
-import { CampaignConfigMinimal, CampaignUniqueDto, CampaignsDto } from "./campaign.model";
+import { CampaignConfigMinimal, CampaignsDto } from "./campaign.model";
 import { CampaignService } from "./campaign.service";
 // ─── Routes for dev and test only ──────────────────────────────────────────────
 export const CampaignTestController = new Elysia({
@@ -25,7 +25,7 @@ export const CampaignTestController = new Elysia({
     if (!id)
         throw new NotFoundError();
     const campaign = await CampaignService.findUniqueOrThrow(id, true);
-    const campaignV3 = OpportunityConvertorService.convertV4CampaignToV3(CampaignEnum[campaign.type], CampaignService.format(campaign), campaign.Opportunity.identifier);
+    const campaignV3 = OpportunityConvertorService.convertV4CampaignToV3(CampaignType[campaign.type], CampaignService.format(campaign), campaign.Opportunity.identifier);
     return await DynamicDataService.update(campaignV3.computeChainId, campaignV3.campaignType, [campaignV3], true);
 })
     // ─── Test TVL computation given a campaignId ───────────────────────
@@ -36,7 +36,7 @@ export const CampaignTestController = new Elysia({
         test: true,
         withOpportunity: true,
         items: 10_000,
-    })).map(campaign => OpportunityConvertorService.convertV4CampaignToV3(CampaignEnum[campaign.type], campaign, campaign.Opportunity.identifier));
+    })).map(campaign => OpportunityConvertorService.convertV4CampaignToV3(CampaignType[campaign.type], campaign, campaign.Opportunity.identifier));
     if (!campaigns.length)
         throw new NotFoundError("Opportunity not found");
     return await DynamicDataService.update(campaigns[0]?.computeChainId, campaigns[0].campaignType, campaigns, true);
@@ -50,7 +50,7 @@ export const CampaignTestController = new Elysia({
         if (!id)
             throw new NotFoundError();
         const campaign = await CampaignService.findUniqueOrThrow(id, true);
-        const campaignV3 = OpportunityConvertorService.convertV4CampaignToV3(CampaignEnum[campaign.type], CampaignService.format(campaign), campaign.Opportunity.identifier);
+        const campaignV3 = OpportunityConvertorService.convertV4CampaignToV3(CampaignType[campaign.type], CampaignService.format(campaign), campaign.Opportunity.identifier);
         listCampaigns.push(campaignV3);
     }
     if (!type)
@@ -84,6 +84,14 @@ export const CampaignTestController = new Elysia({
     // ─── Test Opportunity creation through a campaign Id and a chain ───────────────────────
     // @dev Starts from the engine db to debug opportunity creation failing and preventing the api db to be filled
     .get("/metadata", async ({ query }) => {
+    if (!query.distributionChain) {
+        try {
+            query.distributionChain = (await CampaignService.findMany({ campaignId: query.campaignId, test: true }))?.[0]?.distributionChainId;
+        }
+        catch {
+            throw new NotFoundError("Campaign not found");
+        }
+    }
     const engineCampaigns = await CampaignService.findEngineCampaigns([
         {
             distributionChain: query.distributionChain,
@@ -94,5 +102,8 @@ export const CampaignTestController = new Elysia({
         throw new NotFoundError("Campaign not found in engine db");
     return await CampaignService.create(engineCampaigns[0], true);
 }, {
-    query: CampaignUniqueDto,
+    query: t.Object({
+        distributionChain: t.Optional(t.Numeric()),
+        campaignId: t.String(),
+    }),
 }));

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

@@ -1,11 +1,11 @@
-import { Campaign as CampaignEnum, type CampaignParameters, type ChainId, type MerklChainId } from "@sdk";
+import { type CampaignParameters, Campaign as CampaignType, type ChainId, type MerklChainId } from "@sdk";
 export declare class DynamicDataService {
     /**
      * @notice Updates all records for opportunities associated to the given campaigns
      *
      * @dev The list must ONLY contain campaigns of the same type and the same computeChainId
      */
-    static update(chainId: ChainId, type: CampaignEnum, campaigns: CampaignParameters<CampaignEnum>[], dryRun?: boolean): Promise<unknown[]>;
+    static update(chainId: ChainId, type: CampaignType, campaigns: CampaignParameters<CampaignType>[], dryRun?: boolean): Promise<unknown[]>;
     /**
      * @dev Test function used to create mock ERC20 static campaigns and check tvl and metadata
      */
@@ -20,5 +20,5 @@ export declare class DynamicDataService {
     /**
      * @dev Recursive function to handle errors in fetching dynamic data
      */
-    static fetchWithRecursiveErrorHandling<R>(fn: (chainId: MerklChainId, campaigns: CampaignParameters<CampaignEnum>[]) => Promise<R[]>, campaigns: CampaignParameters<CampaignEnum>[], chainId: number): Promise<R[]>;
+    static fetchWithRecursiveErrorHandling<R>(fn: (chainId: MerklChainId, campaigns: CampaignParameters<CampaignType>[]) => Promise<R[]>, campaigns: CampaignParameters<CampaignType>[], chainId: number): Promise<R[]>;
 }

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

@@ -10,7 +10,7 @@ import { TvlService } from "@/modules/v4/tvl/tvl.service";
 import bigintToString from "@/utils/bigintToString";
 import { log } from "@/utils/logger";
 import { AprType } from "@db/api";
-import { Campaign as CampaignEnum, DAY, NETWORK_LABELS, bigIntToNumber, } from "@sdk";
+import { Campaign as CampaignType, DAY, NETWORK_LABELS, bigIntToNumber, } from "@sdk";
 import moment from "moment";
 import { AprService } from "../apr";
 import { CampaignService } from "../campaign";
@@ -38,7 +38,7 @@ export class DynamicDataService {
             const opportunityIds = new Set(records.map(r => OpportunityService.hashId({
                 chainId,
                 identifier: r.campaign.mainParameter,
-                type: CampaignEnum[+type],
+                type: CampaignType[+type],
             })));
             const now = moment().unix();
             const updates = [];
@@ -46,7 +46,7 @@ export class DynamicDataService {
                 const recordsForOpportunity = records.filter(r => OpportunityService.hashId({
                     chainId,
                     identifier: r.campaign.mainParameter,
-                    type: CampaignEnum[+type],
+                    type: CampaignType[+type],
                 }) === opportunityId);
                 const tvl = {
                     timestamp: BigInt(now),
@@ -96,7 +96,7 @@ export class DynamicDataService {
                         let campaignDailyValue = await TokenService.getValueByTokenId(TokenService.hashId({ address: rewardTokenAddress, chainId: record.campaign.chainId }), dailyAmount);
                         // Fixed APR campaigns
                         if (hasFixedAprConfig(campaignParameters)) {
-                            log.local(`[${NETWORK_LABELS[chainId]}][${CampaignEnum[type]}] calculating fixed APR for ${record.campaign.campaignId}`);
+                            log.local(`[${NETWORK_LABELS[chainId]}][${CampaignType[type]}] calculating fixed APR for ${record.campaign.campaignId}`);
                             const { targetTokenPricing, rewardTokenPricing, apr: fixedApr } = campaignParameters;
                             const targetApr = Number(fixedApr);
                             if (targetTokenPricing && rewardTokenPricing) {
@@ -182,7 +182,7 @@ export class DynamicDataService {
                         });
                     }
                 }
-                log.info(`[${NETWORK_LABELS[chainId]}][${CampaignEnum[type]}] updated ${updates.length}/${campaigns.length} campaigns using campaignTVLBuilder`);
+                log.info(`[${NETWORK_LABELS[chainId]}][${CampaignType[type]}] updated ${updates.length}/${campaigns.length} campaigns using campaignTVLBuilder`);
             }
             return updates;
         }
@@ -192,7 +192,7 @@ export class DynamicDataService {
         for (const data of dynamicData) {
             if (!!data) {
                 // Main Parameter OVERRIDING
-                if (data.campaignType === CampaignEnum.SILO && data.campaignParameters.whitelist?.length === 1)
+                if (data.campaignType === CampaignType.SILO && data.campaignParameters.whitelist?.length === 1)
                     data.mainParameter = `${data.mainParameter}-${data.campaignParameters.whitelist[0]}`;
                 if (!oppMap[`${data.campaignType}_${data.mainParameter}`])
                     oppMap[`${data.campaignType}_${data.mainParameter}`] = {};
@@ -207,7 +207,7 @@ export class DynamicDataService {
             const opportunityId = OpportunityService.hashId({
                 chainId,
                 identifier: mainParameter,
-                type: CampaignEnum[+type],
+                type: CampaignType[+type],
             });
             try {
                 if (!dryRun)
@@ -218,7 +218,7 @@ export class DynamicDataService {
             }
             dynamicDataArray.push(bigintToString({ campaignId: Object.values(entry[1])[0].campaignId, apr, tvl, dailyRewards }));
         }
-        log.info(`[${NETWORK_LABELS[chainId]}][${CampaignEnum[type]}] updated ${dynamicData.length}/${campaigns.length} campaigns`);
+        log.info(`[${NETWORK_LABELS[chainId]}][${CampaignType[type]}] updated ${dynamicData.length}/${campaigns.length} campaigns`);
         return dynamicDataArray;
     }
     /**
@@ -252,11 +252,11 @@ export class DynamicDataService {
                     symbolTargetToken: "EXT",
                     targetToken: tokenAddress,
                 },
-                campaignType: CampaignEnum.ERC20,
+                campaignType: CampaignType.ERC20,
             },
         ];
         log.info(`querying mock campaign on chain: ${NETWORK_LABELS[chainId]}`);
-        const result = await dynamicDataBuilderFactory(CampaignEnum.ERC20).build(Number(chainId), campaigns);
+        const result = await dynamicDataBuilderFactory(CampaignType.ERC20).build(Number(chainId), campaigns);
         return {
             priceTargetToken: result[0]?.typeInfo.priceTargetToken,
             totalSupply: result[0]?.typeInfo.totalSupply,

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

@@ -1,9 +1,9 @@
-import { Campaign as CampaignEnum, type CampaignParameters, type Opportunity as OpportunityV3 } from "@sdk";
+import { type CampaignParameters, Campaign as CampaignType, type Opportunity as OpportunityV3 } from "@sdk";
 import type { CampaignWithParams } from "../campaign";
 import { OpportunityService } from "./opportunity.service";
 export declare abstract class OpportunityConvertorService {
     #private;
-    static convertV4CampaignToV3<C extends CampaignEnum>(campaignType: C, campaign: Exclude<Awaited<ReturnType<(typeof OpportunityService)["findMany"]>>[number]["campaigns"], undefined>[number] | Omit<CampaignWithParams<C>, "manualOverrides">, opportunityIdentifier: string): CampaignParameters<C>;
+    static convertV4CampaignToV3<C extends CampaignType>(campaignType: C, campaign: Exclude<Awaited<ReturnType<(typeof OpportunityService)["findMany"]>>[number]["campaigns"], undefined>[number] | Omit<CampaignWithParams<C>, "manualOverrides">, opportunityIdentifier: string): CampaignParameters<C>;
     static convertV4toV3(opportunity: Awaited<ReturnType<(typeof OpportunityService)["findMany"]>>[number], withCampaigns?: boolean): OpportunityV3;
     static setV3Opportunities(showCampaigns: boolean, test: boolean | undefined, identifier: string | undefined, chainId: string | undefined): Promise<{}>;
     static logKeyAndTTLV3Opportunities(showCampaigns: boolean, test: boolean | undefined, identifier: string | undefined, chainId: string | undefined): Promise<void>;

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

@@ -1,6 +1,6 @@
 import { kebabToPascalCase } from "@/utils/caseChanges";
 import { log } from "@/utils/logger";
-import { Campaign as CampaignEnum, EAprBreakdownType, opportunityActions, } from "@sdk";
+import { Campaign as CampaignType, EAprBreakdownType, opportunityActions, } from "@sdk";
 import moment from "moment";
 import { CacheService } from "../cache";
 import { TTLPresets } from "../cache/cache.model";
@@ -26,7 +26,7 @@ export class OpportunityConvertorService {
     }
     static convertV4toV3(opportunity, withCampaigns = false) {
         const now = moment().unix();
-        const id = `${CampaignEnum[opportunity.type]}_${opportunity.identifier}`; // V3 id
+        const id = `${CampaignType[opportunity.type]}_${opportunity.identifier}`; // V3 id
         // Convert v4 actions to old type
         let action = opportunity.action.toLowerCase();
         if (!opportunityActions.includes(action)) {
@@ -117,17 +117,17 @@ export class OpportunityConvertorService {
                 return acc;
             }, []) ?? [],
             campaigns: {
-                type: CampaignEnum[opportunity.type],
+                type: CampaignType[opportunity.type],
                 ids: opportunity.campaigns?.map(campaign => campaign.campaignId) ?? [],
                 active: withCampaigns
                     ? opportunity.campaigns
                         ?.filter(campaign => campaign.startTimestamp < BigInt(now) && BigInt(now) < campaign.endTimestamp)
-                        .map(campaign => OpportunityConvertorService.convertV4CampaignToV3(CampaignEnum[campaign.type], campaign, opportunity.identifier))
+                        .map(campaign => OpportunityConvertorService.convertV4CampaignToV3(CampaignType[campaign.type], campaign, opportunity.identifier))
                     : undefined,
                 inactive: withCampaigns
                     ? opportunity.campaigns
                         ?.filter(campaign => !(campaign.startTimestamp < BigInt(now) && BigInt(now) < campaign.endTimestamp))
-                        .map(campaign => OpportunityConvertorService.convertV4CampaignToV3(CampaignEnum[campaign.type], campaign, opportunity.identifier))
+                        .map(campaign => OpportunityConvertorService.convertV4CampaignToV3(CampaignType[campaign.type], campaign, opportunity.identifier))
                     : undefined,
             },
         };

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

@@ -7,7 +7,7 @@ import { TokenService } from "@/modules/v4/token/token.service";
 import { UserService } from "@/modules/v4/user/user.service";
 import { log } from "@/utils/logger";
 import { Status } from "@db/api";
-import { Campaign as CampaignEnum } from "@sdk";
+import { Campaign as CampaignType } from "@sdk";
 import moment from "moment";
 import { metadataBuilderFactory } from "../../../engine/metadata/factory";
 import { ProtocolService } from "../protocol/protocol.service";
@@ -43,7 +43,7 @@ export class OpportunityService {
      * @param campaign
      */
     static async #getMetadata(campaign, opportunityIdentifier) {
-        const campaignType = CampaignEnum[campaign.type];
+        const campaignType = CampaignType[campaign.type];
         return await metadataBuilderFactory(campaignType).build(campaign, opportunityIdentifier);
     }
     /**

package/dist/src/modules/v4/opportunity/validate-id.pipe.js

@@ -1,5 +1,5 @@
 import { BadRequestError } from "@/errors";
-import { Campaign as CampaignEnum } from "@sdk";
+import { Campaign as CampaignType } from "@sdk";
 export const validateId = ({ params }) => {
     if (!params.id.includes("-")) {
         if (/[0-9]{1,20}/.test(params.id))
@@ -7,6 +7,6 @@ export const validateId = ({ params }) => {
         throw new BadRequestError("Invalid Opportunity id");
     }
     const [_chainId, type, _campaignId] = params.id.split("-");
-    if (!Object.values(CampaignEnum).includes(type))
-        throw new BadRequestError("Invalid Campaign type", Object.keys(CampaignEnum));
+    if (!Object.values(CampaignType).includes(type))
+        throw new BadRequestError("Invalid Campaign type", Object.keys(CampaignType));
 };

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

@@ -1,6 +1,6 @@
 import type { CacheKeys } from "@/cache/keys";
 import type { Chain } from "@db/api";
-import { type CampaignDynamicData, Campaign as CampaignEnum, type ChainId, type MerklChainId } from "@sdk";
+import { type CampaignDynamicData, Campaign as CampaignType, type ChainId, type MerklChainId } from "@sdk";
 import { type LightOpportunityFromDB, type Opportunity } from "../opportunity";
 import type { CampaignIdModel, CampaignIdWithoutPageModel, CreateManyBreakdownModel, CreateManyRewardModel, DailyRewardsRecord, RegisterClaimsModel, RewardBreakdown, TokenIdModel } from "./reward.model";
 import { RewardRepository } from "./reward.repository";
@@ -785,5 +785,5 @@ export declare abstract class RewardService {
     /**
      * @deprecated
      */
-    static extractDailyRewardsRecordFromDynamicData<C extends CampaignEnum>(type: C, dynamicData: CampaignDynamicData<C>[], timestamp?: bigint): Promise<DailyRewardsRecord["model"]>;
+    static extractDailyRewardsRecordFromDynamicData<C extends CampaignType>(type: C, dynamicData: CampaignDynamicData<C>[], timestamp?: bigint): Promise<DailyRewardsRecord["model"]>;
 }

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

@@ -1,5 +1,5 @@
 import { log } from "@/utils/logger";
-import { Campaign as CampaignEnum, DAY, DistributorService, NETWORK_LABELS, } from "@sdk";
+import { Campaign as CampaignType, DAY, DistributorService, NETWORK_LABELS, } from "@sdk";
 import moment from "moment";
 import { BlacklistService } from "../blacklist";
 import { CacheService } from "../cache";
@@ -358,7 +358,7 @@ export class RewardService {
      * @deprecated
      */
     static async extractDailyRewardsRecordFromDynamicData(type, dynamicData, timestamp = BigInt(moment().unix())) {
-        const typesWithoutApr = [CampaignEnum.INVALID];
+        const typesWithoutApr = [CampaignType.INVALID];
         if (typesWithoutApr.includes(type))
             return { timestamp, total: 0, breakdowns: [] };
         const breakdowns = [];

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

@@ -2003,8 +2003,8 @@ export declare const v4: Elysia<"/v4", false, {
                         body: unknown;
                         params: {};
                         query: {
+                            distributionChain?: number | undefined;
                             campaignId: string;
-                            distributionChain: number;
                         };
                         headers: {
                             authorization: string;

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

@@ -114,6 +114,26 @@ export declare abstract class TokenService {
     } & {
         price?: number | null | undefined;
     }>;
+    /**
+     * Read token from database, tries to fill it if unexistant
+     * @param chainId
+     * @param address
+     */
+    static findUniqueFillOrThrow(token: TokenUnique): Promise<{
+        symbol: string;
+        id: string;
+        name: string | null;
+        icon: string;
+        address: string;
+        chainId: number;
+        decimals: number;
+        verified: boolean;
+        isTest: boolean;
+        isPoint: boolean;
+        isNative: boolean;
+    } & {
+        price?: number | null | undefined;
+    }>;
     /**
      * Checks if two tokens are the same based on chainId/address combo
      * @param a token

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

@@ -163,6 +163,25 @@ export class TokenService {
         const id = typeof token === "string" ? token : TokenService.hashId(token);
         return await TokenRepository.findUniqueOrThrow(id);
     }
+    /**
+     * Read token from database, tries to fill it if unexistant
+     * @param chainId
+     * @param address
+     */
+    static async findUniqueFillOrThrow(token) {
+        const id = TokenService.hashId(token);
+        let result = await TokenRepository.findUnique(id);
+        if (!result) {
+            await TokenService.fillAndCreate({
+                chainId: token.chainId,
+                address: token.address,
+                verified: false,
+                icon: "",
+            });
+            result = await TokenRepository.findUniqueOrThrow(id);
+        }
+        return result;
+    }
     /**
      * Checks if two tokens are the same based on chainId/address combo
      * @param a token

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

@@ -2,7 +2,7 @@ import { Redis } from "@/cache";
 import { CampaignService } from "@/modules/v4/campaign";
 import { OpportunityConvertorService } from "@/modules/v4/opportunity/opportunity.converter";
 import { UnsupportedNetwork } from "@/utils/error";
-import { ANGLE_NETWORKS, Campaign as CampaignEnum, ChainId, isSupportedChain, registry, } from "@sdk";
+import { ANGLE_NETWORKS, Campaign as CampaignType, ChainId, isSupportedChain, registry, } from "@sdk";
 import { t } from "elysia";
 export const query = t.Object({
     chainIds: t.Optional(t.Union([t.String(), t.Array(t.String())])),
@@ -72,7 +72,7 @@ export default (app) => app.get("/campaigns", async ({ query }) => {
     if (process.env.FF_OPPORTUNITY === "true") {
         const campaigns = await CampaignService.findMany({
             distributionChainIds: chainIds,
-            types: !types.length ? undefined : types.map(type => CampaignEnum[type]),
+            types: !types.length ? undefined : types.map(type => CampaignType[type]),
             status: query.live ? "LIVE" : undefined,
             creatorTag: query.creatorTag,
             test: !hideTestTokens,
@@ -84,7 +84,7 @@ export default (app) => app.get("/campaigns", async ({ query }) => {
                 res[campaign.distributionChainId] = {};
             }
             const opportunityIdentifier = campaign.Opportunity.identifier;
-            const campaignType = CampaignEnum[campaign.type];
+            const campaignType = CampaignType[campaign.type];
             if (!res[campaign.distributionChainId][`${campaignType}_${opportunityIdentifier}`]) {
                 res[campaign.distributionChainId][`${campaignType}_${opportunityIdentifier}`] = {
                     ...OpportunityConvertorService.convertV4CampaignToV3(campaignType, campaign, opportunityIdentifier),

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

@@ -1,6 +1,6 @@
 import { NotFoundError } from "@/errors";
 import { OpportunityService } from "@/modules/v4/opportunity";
-import { BN2Number, Campaign as CampaignEnum } from "@sdk";
+import { BN2Number, Campaign as CampaignType } from "@sdk";
 import { t } from "elysia";
 import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
 export const query = t.Object({
@@ -19,7 +19,7 @@ export default (app) => app.use(checkQueryChainIdValidity()).get("/campaignsForM
     return (await OpportunityService.getUniqueWithCampaignsOrThrow(opportunityId))?.campaigns
         ?.map(c => ({
         campaignId: c.campaignId,
-        campaignType: CampaignEnum[c.type],
+        campaignType: CampaignType[c.type],
         rewardToken: c.rewardToken.address,
         rewardTokenSymbol: c.rewardToken.symbol,
         amountDecimal: BN2Number(c.amount, c.rewardToken.decimals),