@merkl/api 0.21.46 → 1.0.0

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

@@ -1,455 +0,0 @@
-import { HttpError, NotFoundError } from "@/errors";
-import { OpportunityService } from "@/modules/v4/opportunity/opportunity.service";
-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 { parseDistributionType } from "@/utils/parseDistributionType";
-import { Campaign as CampaignType, HOOK, NETWORK_LABELS, } from "@sdk";
-import { utils } from "ethers";
-import moment from "moment";
-import { ChainService } from "../chain/chain.service";
-import { ComputedValueService } from "../computedValue/computedValue.service";
-import { CampaignRepository } from "./campaign.repository";
-export class CampaignService {
-    static hashId(campaign) {
-        return Bun.hash(`${campaign.distributionChain}${campaign.campaignId}`).toString();
-    }
-    static splitIdOrThrow(chainAndCampaignId) {
-        if (!chainAndCampaignId.includes("-"))
-            throw new InvalidParameter("Campaign id should be formatted as chainId-campaignId");
-        const [chainId, campaignId] = chainAndCampaignId.split("-");
-        return { distributionChain: +chainId, campaignId };
-    }
-    static async getPastCampaigns(query) {
-        return await CampaignRepository.getPastCampaigns(query);
-    }
-    static async getFutureCampaigns(query) {
-        return await CampaignRepository.getFutureCampaigns(query);
-    }
-    static async getLiveCampaigns(query) {
-        return await CampaignRepository.getLiveCampaigns(query);
-    }
-    static async countLives(query) {
-        return await CampaignRepository.countLives(query);
-    }
-    static async create(body, dryRun = false) {
-        log.info(`creating campaign ${body.campaignId} on ${NETWORK_LABELS[body.chainId]}`);
-        const campaignType = CampaignService.getTypeFromV3(body.type);
-        const id = CampaignService.hashId({ distributionChain: body.chainId, campaignId: body.campaignId });
-        const [rewardToken] = await TokenService.findManyOrCreate([
-            { chainId: body.chainId, address: body.rewardTokenAddress },
-        ]);
-        if (!rewardToken)
-            throw new Error(`unable to fetch data for token ${body.rewardTokenAddress}`);
-        const chain = await ChainService.findUniqueOrThrow(body.chainId);
-        const params = JSON.parse(body.params);
-        const campaign = {
-            distributionChainId: body.chainId,
-            computeChainId: body.computeChainId,
-            campaignId: body.campaignId,
-            id,
-            type: campaignType,
-            subType: body.subType ?? null,
-            rewardToken,
-            params,
-            endTimestamp: Number(body.endTimestamp),
-            startTimestamp: Number(body.startTimestamp),
-            distributionType: parseDistributionType(params),
-            amount: body.amount,
-            creatorAddress: body.creator,
-            createdAt: new Date().toISOString(),
-            chain,
-            parentCampaignId: body.parentCampaignId,
-            rootCampaignId: body.rootCampaignId,
-        };
-        // Separate Worldchain ID only campaign opportunities
-        if (campaign.params.hooks?.some(hook => hook.hookType === HOOK.WORLDCHAINID)) {
-            body.opportunityIdentifier += "WORLDCHAINID";
-        }
-        try {
-            const opportunity = await OpportunityService.createFromCampaign(campaign, body.opportunityIdentifier, false, dryRun);
-            if (dryRun)
-                return opportunity;
-        }
-        catch (e) {
-            console.error(e);
-            throw new CannotParseOpportunity(campaign.campaignId, campaign.distributionChainId, campaign.type);
-        }
-        return await CampaignRepository.upsert(campaign, body.opportunityIdentifier);
-    }
-    /**
-     * @dev back-office function
-     * @dev deprecated should be replaced with a manual override
-     */
-    static async updateMetaData(campaign) {
-        const campaignUnique = {
-            distributionChain: campaign.distributionChain,
-            campaignId: campaign.campaignId,
-        };
-        const id = CampaignService.hashId(campaignUnique);
-        let existingCampaign = await CampaignService.findUnique(campaign);
-        if (!existingCampaign) {
-            await CampaignService.fill([campaignUnique]);
-            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.updateParams(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
-     */
-    static async moveToOpportunity(data, upsert = false) {
-        const id = CampaignService.hashId({
-            distributionChain: data.distributionChain,
-            campaignId: data.campaignId,
-        });
-        const campaign = CampaignService.format(await CampaignService.findUniqueOrThrow(id));
-        if (campaign.type === "ERC20" && data.opportunityIdentifier === undefined) {
-            const campaignParams = campaign.params;
-            data.opportunityIdentifier = utils
-                .keccak256(utils.defaultAbiCoder.encode(["string", "address[]"], [campaignParams.targetToken, campaignParams.whitelist.sort()]))
-                .slice(0, 42);
-        }
-        if (data.opportunityIdentifier === undefined) {
-            throw new HttpError("Bad Request: opportunityIdentifier is required for CampaignService campaign type", 400);
-        }
-        const newOpportunityId = OpportunityService.hashId({
-            chainId: campaign.computeChainId,
-            identifier: data.opportunityIdentifier,
-            type: campaign.type,
-        });
-        // Create new opportunity
-        await OpportunityService.createFromCampaign(campaign, data.opportunityIdentifier, upsert);
-        // Move campaign to new opportunity
-        await CampaignRepository.updateOpportunity(id, newOpportunityId);
-        // Return new opportunityId
-        return (await CampaignService.findUniqueOrThrow(data)).opportunityId;
-    }
-    /**
-     * Get the list of campaigns satisfying the query
-     * @param query
-     * @returns A list of campaigns
-     */
-    static async findMany(query) {
-        if (query.subType && !query.type)
-            throw new HttpError("Bad Request: Cannot specify a subType without a type", 400);
-        const campaigns = await CampaignRepository.findMany(query);
-        return campaigns.map(CampaignService.format);
-    }
-    static async findAndGroupByChains(query) {
-        return Map.groupBy(await CampaignService.findMany(query), campaign => campaign.chain.id);
-    }
-    static async countByChains(query) {
-        return CampaignService.countBy(await CampaignService.findAndGroupByChains({ ...query, items: 0 }));
-    }
-    static async findAndGroupByTypes(query) {
-        return Map.groupBy(await CampaignService.findMany(query), campaign => campaign.type);
-    }
-    static async countByTypes(query) {
-        return CampaignService.countBy(await CampaignService.findAndGroupByTypes({ ...query, items: 0 }));
-    }
-    static async findAndGroupByProtocols(query) {
-        return Map.groupBy(await CampaignService.findMany({ ...query, withOpportunity: true }), campaign => campaign.Opportunity.mainProtocolId);
-    }
-    static async countByProtocols(query) {
-        return CampaignService.countBy(await CampaignService.findAndGroupByProtocols({ ...query, items: 0 }));
-    }
-    static countBy(campaignsMap) {
-        const count = {};
-        for (const [key, value] of campaignsMap) {
-            count[key] = value.length;
-        }
-        return count;
-    }
-    /**
-     * Counts the number of campaigns that complies to query
-     * @description used for pagination purposes
-     * @param query
-     * @returns the number of campaigns
-     */
-    static async countMany(query) {
-        if (query.subType && !query.type) {
-            throw new HttpError("Bad Request: Cannot specify a subType without a type", 400);
-        }
-        return await CampaignRepository.countMany(query);
-    }
-    static async checkIfExist(campaign) {
-        const id = typeof campaign === "string" ? campaign : CampaignService.hashId(campaign);
-        return !!(await CampaignRepository.findUnique(id));
-    }
-    static async findUnique(campaign) {
-        const id = typeof campaign === "string" ? campaign : CampaignService.hashId(campaign);
-        return await CampaignRepository.findUnique(id);
-    }
-    static async findUniqueOrThrow(campaign, withOpportunity = false) {
-        const id = typeof campaign === "string" ? campaign : CampaignService.hashId(campaign);
-        return await CampaignRepository.findUniqueOrThrow(id, withOpportunity);
-    }
-    static async findCampaignValue(params) {
-        if (params.campaignId.includes("-") && params.campaignId.startsWith("0x")) {
-            const [campaignId, distributionChain] = params.campaignId.split("-");
-            return await ComputedValueService.findCampaignValue(CampaignService.hashId({ campaignId, distributionChain: Number.parseInt(distributionChain) }), params.field);
-        }
-        const campaignId = (await CampaignService.findMany({ campaignId: params.campaignId }))[0].id;
-        return await ComputedValueService.findCampaignValue(campaignId, params.field);
-    }
-    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)) // Filter out campaigns that have already been processed
-            ?.sort((a, b) => Number((a.CampaignStatus?.[0]?.processingStarted ?? 0n) - (b.CampaignStatus?.[0]?.processingStarted ?? 0n))); // Sort by processingStarted, that is to say campaigns that were processed the most long ago
-    }
-    static async findNextCampaignToProcess(chainId) {
-        const campaigns = await CampaignService.findCampaignsToProcess(chainId);
-        return { campaignId: campaigns?.[0]?.campaignId };
-    }
-    static async pickCampaignToProcess(chainId) {
-        const campaigns = await CampaignService.findCampaignsToProcess(chainId);
-        for (const campaign of campaigns) {
-            try {
-                await StatusService.update({
-                    distributionChain: chainId,
-                    campaignId: campaign.campaignId,
-                }, { value: "PROCESSING" });
-                return { campaignId: campaign.campaignId };
-            }
-            catch { }
-        }
-        throw new Error(`No campaign to process found on ${NETWORK_LABELS[chainId]}`);
-    }
-    static async findEngineCampaigns(campaigns) {
-        const campaignsFromEngine = await CampaignRepository.getFromEngineDbWithId(campaigns);
-        for (const campaign of campaigns) {
-            if (campaignsFromEngine.findIndex(c => c.campaignId === campaign.campaignId) === -1) {
-                log.warn(`Campaign ${campaign.campaignId} on ${NETWORK_LABELS[campaign.distributionChain]} not found in engine db`);
-            }
-        }
-        return 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 fill(campaigns) {
-        const campaignsFromEngine = await CampaignService.findEngineCampaigns(campaigns);
-        let success = 0;
-        let fail = 0;
-        for (const engineCampaign of campaignsFromEngine) {
-            try {
-                await CampaignService.create(engineCampaign);
-                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();
-    }
-    /**
-     * Returns the campaign data
-     * @param type index of Campaign enum from sdk
-     * @returns a string
-     */
-    static getTypeFromV3(type) {
-        return CampaignType[type];
-    }
-    /**
-     * Split a campaigns array into three array for each status
-     * @param campaigns
-     * @param timestamp to compare to campaigns timestamps
-     * @returns a status => campaigns map
-     */
-    static splitOnStatus(campaigns, timestamp = moment().unix()) {
-        const past = campaigns.filter(({ endTimestamp: end }) => end <= timestamp);
-        const live = campaigns.filter(({ startTimestamp: start, endTimestamp: end }) => timestamp >= start && timestamp < end);
-        const soon = campaigns.filter(({ startTimestamp: start }) => start > timestamp);
-        return { past, live, soon };
-    }
-    /**
-     * Convert raw
-     * @param query
-     * @returns A list of opportunities
-     * TODO: remove CampaignService function in favor of prisma client extensions
-     */
-    static format(campaign) {
-        const { DistributionChain, ComputeChain, Creator, RewardToken, params, CampaignStatus, createdAt, manualOverrides: _, description, parentCampaignId, rootCampaignId, ...c } = campaign;
-        const updatedParams = params;
-        return {
-            ...c,
-            params: updatedParams,
-            chain: ComputeChain,
-            endTimestamp: Number(c.endTimestamp),
-            startTimestamp: Number(c.startTimestamp),
-            rewardToken: TokenService.format(RewardToken),
-            distributionChain: DistributionChain === null ? undefined : DistributionChain,
-            // Todo: need to be change to single 1 to 1 with campaign
-            campaignStatus: CampaignStatus?.[0] ? StatusService.format(CampaignStatus?.[0]) : undefined,
-            creatorAddress: Creator.address,
-            creator: Creator,
-            createdAt: createdAt.toISOString(),
-            description: !!description ? description : undefined,
-            parentCampaignId: parentCampaignId ?? undefined,
-            rootCampaignId: rootCampaignId ?? undefined,
-        };
-    }
-    /**
-     * @deprecated Used only in tentative position fetcher
-     */
-    static formatAsCampaignParameters(campaign) {
-        return {
-            campaignSubType: campaign.subType ?? 0,
-            campaignParameters: campaign.params,
-            computeChainId: campaign.computeChainId,
-            campaignId: campaign.campaignId,
-            rewardToken: campaign.rewardToken.address,
-            amount: campaign.amount,
-        };
-    }
-    /**
-     * Shortcut to get daily amount from total
-     * @param start timestamp
-     * @param end timestamp
-     * @param amount
-     * @returns daily token amount
-     */
-    static getDailyAmount(start, end, amount) {
-        const timespan = Math.abs(Number(end - start));
-        const isWithinTimespan = moment().unix() > start && moment().unix() < end;
-        const dayspan = Math.max(1, Math.floor(timespan / (60 * 60 * 24)));
-        const dailyAmount = isWithinTimespan ? BigInt(amount) / BigInt(dayspan) : 0n;
-        return dailyAmount;
-    }
-    static createFakeCampaign(body) {
-        return {
-            amount: body.amount ?? (10n ** 18n).toString(),
-            campaignId: body.campaignId ?? "campaignId",
-            computeChainId: body.computeChainId,
-            campaignParameters: body.params,
-            campaignSubType: body.subType ?? 0,
-            campaignType: CampaignType[body.type],
-            chainId: body.distributionChainId ?? 0,
-            creator: body.creatorAddress ?? "creator.address",
-            index: 0, // DEPRECATED
-            mainParameter: "opportunityIdentifier",
-            endTimestamp: body.endTimestamp,
-            startTimestamp: body.startTimestamp,
-            rewardToken: body.rewardToken,
-            amm: body.params?.amm,
-        };
-    }
-    static createFakeCampaignEngine(body) {
-        const fakeCampaign = CampaignService.createFakeCampaign(body);
-        return {
-            computeChainId: fakeCampaign.computeChainId,
-            chainId: fakeCampaign.chainId,
-            campaignId: fakeCampaign.campaignId,
-            creator: fakeCampaign.creator,
-            type: fakeCampaign.campaignType,
-            subType: fakeCampaign.campaignSubType,
-            rewardTokenAddress: fakeCampaign.rewardToken,
-            amount: fakeCampaign.amount,
-            opportunityIdentifier: fakeCampaign.mainParameter,
-            startTimestamp: fakeCampaign.startTimestamp.toString(),
-            endTimestamp: fakeCampaign.endTimestamp.toString(),
-            params: JSON.stringify(fakeCampaign.campaignParameters),
-        };
-    }
-    static async createFakeERC20Campaign(query) {
-        const token = (await TokenService.findManyOrCreate([
-            {
-                address: query.address,
-                chainId: query.chainId,
-            },
-        ]))?.[0];
-        if (!token)
-            throw new NotFoundError("Token not found");
-        const campaign = {
-            campaignId: token.address,
-            amount: "1000000000000000000", // 1 EXR in wei
-            campaignSubType: 0,
-            chainId: token.chainId,
-            computeChainId: token.chainId,
-            creator: "0xexamplecreatoraddress",
-            endTimestamp: 1672531199, // Example end timestamp
-            index: 0,
-            mainParameter: "0xexamplemainparameter",
-            rewardToken: token.address,
-            startTimestamp: 1672444800, // Example start timestamp
-            lastEligibilityRatio: 1,
-            campaignParameters: {
-                blacklist: [],
-                decimalsRewardToken: 18,
-                decimalsTargetToken: token.decimals,
-                duration: 30,
-                whitelist: [],
-                forwarders: [],
-                hooks: [],
-                shouldIgnore: false,
-                symbolRewardToken: token.symbol,
-                symbolTargetToken: "EXT",
-                targetToken: token.address,
-            },
-            campaignType: CampaignType.ERC20,
-        };
-        log.info(`using fake erc20 campaign on chain: ${NETWORK_LABELS[token.chainId]}`);
-        return campaign;
-    }
-    static async getWalletCount(campaignId) {
-        const id = typeof campaignId === "string" ? campaignId : CampaignService.hashId(campaignId);
-        const campaign = await CampaignRepository.findUniqueOrThrow(id, false);
-        return await CampaignRepository.getWalletCount(campaign);
-    }
-    static async getMetrics(campaignId) {
-        const id = typeof campaignId === "string" ? campaignId : CampaignService.hashId(campaignId);
-        const campaign = await CampaignRepository.findUniqueOrThrow(id, false);
-        const [tvlRecords, aprRecords, dailyRewardsRecords, walletCount] = await Promise.all([
-            CampaignRepository.getTvlRecords(campaign),
-            CampaignRepository.getAprRecords(campaign),
-            CampaignRepository.getDailyRewardsRecords(campaign),
-            CampaignRepository.getWalletCountOverTime(campaign),
-        ]);
-        return {
-            tvlRecords,
-            aprRecords,
-            dailyRewardsRecords,
-            walletCount,
-            tvlInflowPerDollar: tvlRecords.length > 1
-                ? (tvlRecords[tvlRecords.length - 1].total - tvlRecords[0].total) /
-                    ((Number(campaign.amount) / 10 ** campaign.RewardToken.decimals) * (campaign.RewardToken.price ?? 1))
-                : 0,
-        };
-    }
-}

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

@@ -1,127 +0,0 @@
-import { NotFoundError } from "@/errors";
-import { InvalidParameter } from "@/errors/InvalidParameter.error";
-import { BackOfficeGuard } from "@/guards/BackOffice.guard";
-import { AuthorizationHeadersDto } from "@/guards/Engine.guard";
-import { DynamicDataService } from "@/modules/v4/dynamicData/dynamicData.service";
-import { OpportunityConvertorService } from "@/modules/v4/opportunity/opportunity.converter";
-import { Campaign as CampaignType } from "@sdk";
-import Elysia, { t } from "elysia";
-import { CampaignConfigMinimal, CampaignsDto } from "./campaign.model";
-import { CampaignService } from "./campaign.service";
-// ─── Routes for dev and test only ──────────────────────────────────────────────
-export const CampaignTestController = new Elysia({
-    prefix: "/campaigns",
-    detail: { tags: ["Campaigns"], hide: true },
-}).group("/dry-run", app => app
-    .guard({
-    headers: AuthorizationHeadersDto,
-    beforeHandle: BackOfficeGuard,
-})
-    .group("/tvl", app => app
-    // ─── Test TVL computation given a campaignId ───────────────────────
-    .get("/campaign/:campaignId", async ({ params }) => {
-    const id = (await CampaignService.findMany({ campaignId: params.campaignId, test: true }))?.[0]?.id;
-    if (!id)
-        throw new NotFoundError();
-    const campaign = await CampaignService.findUniqueOrThrow(id, true);
-    const campaignV3 = OpportunityConvertorService.convertV4CampaignToV3(CampaignType[campaign.type], CampaignService.format(campaign), campaign.Opportunity.identifier);
-    return await DynamicDataService.update(campaignV3.computeChainId, campaignV3.campaignType, [campaignV3], true);
-}, {
-    params: t.Object({ campaignId: t.String() }),
-})
-    // ─── Test TVL computation given an opportunityId ───────────────────────
-    .get("/opportunity/:opportunityId", async ({ params }) => {
-    const campaigns = (await CampaignService.findMany({
-        opportunityId: params.opportunityId,
-        test: true,
-        withOpportunity: true,
-        items: 10_000,
-    })).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);
-}, {
-    params: t.Object({ opportunityId: t.String() }),
-})
-    // ─── Test TVL computation given a target token address ───────────────────────
-    .get("/erc20", async ({ query }) => {
-    const campaign = await CampaignService.createFakeERC20Campaign(query);
-    return await DynamicDataService.update(campaign.computeChainId, campaign.campaignType, [campaign], true);
-}, {
-    query: t.Object({ address: t.String(), chainId: t.Numeric() }),
-})
-    // ─── Test TVL computation with a list of campaignId ───────────────────────
-    .post("/list", async ({ body }) => {
-    const listCampaigns = [];
-    for (const campaignId of body) {
-        const id = (await CampaignService.findMany({ campaignId: campaignId, test: true }))?.[0]?.id;
-        if (!id)
-            throw new NotFoundError();
-        const campaign = await CampaignService.findUniqueOrThrow(id, true);
-        const campaignV3 = OpportunityConvertorService.convertV4CampaignToV3(CampaignType[campaign.type], CampaignService.format(campaign), campaign.Opportunity.identifier);
-        listCampaigns.push(campaignV3);
-    }
-    for (const campaign of listCampaigns) {
-        if (campaign.campaignType !== listCampaigns[0].campaignType) {
-            throw new InvalidParameter("All campaigns must be of the same type");
-        }
-        if (campaign.computeChainId !== listCampaigns[0].computeChainId) {
-            throw new InvalidParameter("All campaigns must have the same computeChainId");
-        }
-    }
-    return await DynamicDataService.update(listCampaigns[0].computeChainId, listCampaigns[0].campaignType, listCampaigns, true);
-}, { body: CampaignsDto })
-    // ─── Test TVL computation with campaign config ───────────────────────
-    .post("/", async ({ body }) => {
-    const campaign = CampaignService.createFakeCampaign(body);
-    return await DynamicDataService.update(campaign.computeChainId, campaign.campaignType, [campaign], true);
-}, {
-    body: CampaignConfigMinimal,
-}))
-    .group("/metadata", app => app
-    // ─── Test Opportunity creation through a campaign config ───────────────────────
-    // @dev Starts from the engine db to debug opportunity creation failing and preventing the api db to be filled
-    .post("/", async ({ body }) => {
-    const engineCampaign = CampaignService.createFakeCampaignEngine(body);
-    return await CampaignService.create(engineCampaign, true);
-}, {
-    body: CampaignConfigMinimal,
-})
-    // ─── 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("/", 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,
-            campaignId: query.campaignId,
-        },
-    ]);
-    if (!engineCampaigns.length)
-        throw new NotFoundError("Campaign not found in engine db");
-    return await CampaignService.create(engineCampaigns[0], true);
-}, {
-    query: t.Object({
-        distributionChain: t.Optional(t.Numeric()),
-        campaignId: t.String(),
-    }),
-})
-    .get("/erc20", async ({ query }) => {
-    const campaign = await CampaignService.createFakeERC20Campaign(query);
-    const engineCampaign = CampaignService.createFakeCampaignEngine({
-        ...campaign,
-        type: CampaignType[CampaignType.ERC20],
-        params: campaign.campaignParameters,
-        distributionChainId: campaign.chainId,
-    });
-    return await CampaignService.create(engineCampaign, true);
-}, {
-    query: t.Object({ address: t.String(), chainId: t.Numeric() }),
-})));

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

@@ -1,44 +0,0 @@
-import { AuthorizationHeadersDto, BackOfficeGuard } from "@/guards/BackOffice.guard";
-import Elysia, { t } from "elysia";
-import { ChainResourceDto, ChainUniqueDto, CreateChainDto, GetChainQueryDto, UpdateChainDto, } from "./chain.model";
-import { ChainService } from "./chain.service";
-// ─── Chains Controller ───────────────────────────────────────────────────────
-export const ChainController = new Elysia({ prefix: "/chains", detail: { tags: ["Chains"] } })
-    // ─── Get A Chain By Id ───────────────────────────────────────────────
-    .get("/:chainId", async ({ params: { chainId } }) => {
-    const chain = await ChainService.get(chainId);
-    if (!chain)
-        return null;
-    const { Explorer, ...rest } = chain;
-    return { explorers: chain.Explorer, ...rest };
-}, {
-    params: ChainUniqueDto,
-    detail: { hide: true },
-})
-    // ─── Get All Supported Chains ────────────────────────────────────────
-    .get("/", async ({ query }) => {
-    const chains = await ChainService.findMany(query);
-    return chains.map(({ Explorer, ...chain }) => ({ explorers: Explorer, ...chain }));
-}, {
-    query: GetChainQueryDto,
-    response: t.Array(ChainResourceDto),
-    detail: { description: "List chains supported and integrated by Merkl." },
-})
-    // ─── Count Chains ────────────────────────────────────────
-    .get("/count", async ({ query }) => await ChainService.countMany(query), {
-    query: GetChainQueryDto,
-    detail: { hide: true },
-})
-    .patch("/:chainId", async ({ params, body }) => await ChainService.update(params.chainId, body), {
-    params: ChainUniqueDto,
-    body: UpdateChainDto,
-    headers: AuthorizationHeadersDto,
-    beforeHandle: BackOfficeGuard,
-    detail: { hide: true },
-})
-    .post("/", async ({ body }) => await ChainService.create(body), {
-    body: CreateChainDto,
-    headers: AuthorizationHeadersDto,
-    beforeHandle: BackOfficeGuard,
-    detail: { hide: true },
-});

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

@@ -1,36 +0,0 @@
-import { ExplorerType } from "@db/api";
-import { t } from "elysia";
-// ─── DTOs ────────────────────────────────────────────────────────────────────
-export const ChainResourceDto = t.Object({
-    id: t.Number(),
-    name: t.String(),
-    icon: t.String(),
-});
-export const GetChainQueryDto = t.Object({
-    name: t.Optional(t.String({ description: "Search by blockchain name" })),
-    test: t.Optional(t.Boolean({ description: "Includes chains that have only test opportunities.", default: false })),
-});
-export const ChainUniqueDto = t.Object({
-    chainId: t.Numeric(),
-});
-export const ChainUniqueOptionalDto = t.Object({
-    chainId: t.Optional(t.Numeric()),
-});
-export const ChainArrayOptionalDto = t.Object({
-    chainIds: t.Array(t.String()),
-}, {
-    description: "A required comma separated list of chain ids.<br>You can get the list of all supported chains by calling [GET /v4/chains](#tag/chains/GET/v4/chains/)",
-});
-export const UpdateChainDto = t.Object({
-    icon: t.Optional(t.String({ format: "uri" })),
-    dailyRewards: t.Optional(t.Number({})),
-    liveCampaigns: t.Optional(t.Number()),
-    // iconFile: t.Optional(t.File()),
-});
-export const CreateChainDto = t.Object({
-    id: t.Numeric(),
-    name: t.String(),
-    icon: t.String({ format: "uri" }),
-    explorerType: t.Enum(ExplorerType),
-    explorerUrl: t.String({ format: "uri" }),
-});