@merkl/api 0.21.46 → 1.0.0

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

@@ -1,406 +0,0 @@
-import { BlacklistService } from "@/modules/v4/blacklist/blacklist.service";
-import { TTLPresets } from "@/modules/v4/cache/cache.model";
-import { CacheService } from "@/modules/v4/cache/cache.service";
-import { CampaignService } from "@/modules/v4/campaign/campaign.service";
-import { ChainService } from "@/modules/v4/chain/chain.service";
-import { MerklRootService } from "@/modules/v4/merklRoot/merklRoot.service";
-import { OpportunityService } from "@/modules/v4/opportunity/opportunity.service";
-import { TokenService } from "@/modules/v4/token/token.service";
-import { log } from "@/utils/logger";
-import { Campaign as CampaignType, DAY, DistributorService, NETWORK_LABELS, } from "@sdk";
-import moment from "moment";
-import { RewardRepository } from "./reward.repository";
-export class RewardService {
-    static hashId(root, recipient, rewardTokenId) {
-        return Bun.hash(`${root}${recipient}${rewardTokenId}`).toString();
-    }
-    static hashBreakdownId(rewardId, campaignId, reason) {
-        return Bun.hash(`${rewardId}${campaignId}${reason}`).toString();
-    }
-    static hashDailyRewardsRecordId(opportunityId, timestamp) {
-        return Bun.hash(`${opportunityId}${timestamp}`).toString();
-    }
-    static async createManyReward(rewards) {
-        return await RewardRepository.createManyReward(rewards);
-    }
-    static async getTotalDistributedByOpportunities(since) {
-        const opportunities = await OpportunityService.findMany({ items: 0 });
-        const promiseArray = [];
-        let i = 0;
-        const oppToDailyRewards = new Map();
-        for (i = 0; i < opportunities.length; i++) {
-            promiseArray.push(RewardRepository.sumDailyRewardsAvgByOpportunity(since, opportunities[i].id));
-        }
-        const result = await Promise.all(promiseArray);
-        i = 0;
-        for (i = 0; i < result.length; i++) {
-            // need an upper threshold bc certain opportunities have crazy daily rewards (cf. vicuna)
-            if (result[i] !== null && result[i] > 0 && result[i] <= 1_000_000_000)
-                oppToDailyRewards.set(opportunities[i], result[i]);
-        }
-        return oppToDailyRewards;
-    }
-    static async getTotalDistributed(since) {
-        const oppToDailyRewards = await RewardService.getTotalDistributedByOpportunities(since);
-        return oppToDailyRewards.values().reduce((prev, curr) => prev + curr, 0);
-    }
-    static async getTotalDistributedByChain(since) {
-        const oppToDailyRewards = await RewardService.getTotalDistributedByOpportunities(since);
-        const chainsToDailyRewards = new Map();
-        for (const [opp, dr] of oppToDailyRewards.entries()) {
-            const dailyRewards = chainsToDailyRewards.get(opp.chainId) === undefined ? dr : chainsToDailyRewards.get(opp.chainId) + dr;
-            chainsToDailyRewards.set(opp.chainId, dailyRewards);
-        }
-        return Object.fromEntries(chainsToDailyRewards);
-    }
-    static async getTotalDistributedByProtocol(since) {
-        const oppToDailyRewards = await RewardService.getTotalDistributedByOpportunities(since);
-        const protocolToDailyRewards = new Map();
-        for (const [opp, dr] of oppToDailyRewards.entries()) {
-            const dailyRewards = protocolToDailyRewards.get(opp.protocol?.id) === undefined
-                ? dr
-                : protocolToDailyRewards.get(opp.protocol?.id) + dr;
-            protocolToDailyRewards.set(opp.protocol?.id, dailyRewards);
-        }
-        return Object.fromEntries(protocolToDailyRewards);
-    }
-    static async getTotalDistributedByType(since) {
-        const oppToDailyRewards = await RewardService.getTotalDistributedByOpportunities(since);
-        const typeToDailyRewards = new Map();
-        for (const [opp, dr] of oppToDailyRewards.entries()) {
-            const dailyRewards = typeToDailyRewards.get(opp.type) === undefined ? dr : typeToDailyRewards.get(opp.type) + dr;
-            typeToDailyRewards.set(opp.type, dailyRewards);
-        }
-        return Object.fromEntries(typeToDailyRewards);
-    }
-    /**
-     * Format the reward breakdown to conform to its resource model declaration
-     * @param breakdown straight from db
-     * @returns a RewardBreakdown model
-     */
-    static formatBreakdown(breakdown) {
-        const { Campaign, id, rewardId, protocolId, subCampaignId, ...rest } = breakdown;
-        return {
-            ...rest,
-            campaignId: Campaign.campaignId,
-            subCampaignId: subCampaignId ?? undefined,
-            opportunity: Campaign.Opportunity,
-        };
-    }
-    /**
-     * Format the reward to conform to its resource model declaration
-     * @param reward straight from db
-     * @returns a Reward model
-     */
-    static format(rewards) {
-        return rewards.map(reward => {
-            const { Breakdown, RewardToken, id, rewardTokenId, ...rest } = reward;
-            return {
-                ...rest,
-                token: RewardToken,
-                breakdowns: Breakdown.map(RewardService.formatBreakdown),
-                claimed: BigInt(rest.claimed),
-                amount: BigInt(rest.amount),
-                pending: BigInt(rest.pending),
-            };
-        });
-    }
-    static async createManyBreakdown(data) {
-        const missingCampaigns = [];
-        const foundCampaigns = [];
-        for (const dataPerCampaign of data) {
-            const campaignUnique = {
-                distributionChain: dataPerCampaign.distributionChainId,
-                campaignId: dataPerCampaign.campaignId,
-            };
-            const campaignExists = await CampaignService.checkIfExist(campaignUnique);
-            if (!campaignExists) {
-                const { success, fail } = await CampaignService.fill([campaignUnique]);
-                if (fail === 1 || success !== 1) {
-                    missingCampaigns.push(CampaignService.hashId(campaignUnique));
-                    log.warn(`createManyBreakdown - Missing campaign: ${campaignUnique.campaignId} on ${NETWORK_LABELS[campaignUnique.distributionChain]}`);
-                    continue;
-                }
-            }
-            foundCampaigns.push(CampaignService.hashId(campaignUnique));
-        }
-        try {
-            return await RewardRepository.createManyBreakdown(data.filter(dataPerCampaign => !missingCampaigns.includes(CampaignService.hashId({
-                distributionChain: dataPerCampaign.distributionChainId,
-                campaignId: dataPerCampaign.campaignId,
-            }))));
-        }
-        catch (e) {
-            log.error(`createManyBreakdown - error creating many breakdowns for campaigns ${foundCampaigns.join(", ")}`, e);
-        }
-    }
-    static async getByRecipient(recipient, roots, withToken = false, withTestTokens = false, chainFilter, reasonFilter) {
-        return RewardRepository.getByRecipient(recipient, roots, withToken, withTestTokens, chainFilter, reasonFilter);
-    }
-    /**
-     * Groups a breakdown array by their corresponding opportunities
-     * @param breakdowns with campaignIds
-     * @returns array of breakdown group, including the opportunity they belong to
-     */
-    static splitBreakdownByOpportunity(breakdowns) {
-        const opportunities = breakdowns.reduce((aux, { opportunity }) => {
-            if (!aux.some(o => o.id === opportunity.id))
-                aux.push(opportunity);
-            return aux;
-        }, []);
-        if (!opportunities)
-            return [];
-        return opportunities.map(opportunity => {
-            const relatedBreakdowns = breakdowns.filter(b => opportunity.id.includes(b.opportunity.id));
-            const formattedOpportunity = OpportunityService.formatResponseBase(opportunity);
-            return {
-                opportunity: formattedOpportunity,
-                claimed: relatedBreakdowns.reduce((total, { claimed }) => total + BigInt(claimed), 0n),
-                amount: relatedBreakdowns.reduce((total, { amount }) => total + BigInt(amount), 0n),
-                pending: relatedBreakdowns.reduce((total, { pending }) => total + BigInt(pending), 0n),
-            };
-        });
-    }
-    /**
-     * Applies the splitBreakdownByOpportunity function to each rewards in the array
-     * @param rewards return type for most of the rewards functions
-     * @returns rewards with updated breakdowns, including the opportunity they belong to
-     */
-    static splitRewardsBreakdownByOpportunity(rewards) {
-        return rewards.map(rewardByChain => {
-            const rewards = rewardByChain.rewards.map(reward => {
-                const breakdowns = RewardService.splitBreakdownByOpportunity(reward.breakdowns);
-                return Object.assign(reward, { breakdowns });
-            });
-            const distributor = DistributorService(rewardByChain.chain.id).address;
-            return Object.assign(rewardByChain, { rewards }, { distributor });
-        });
-    }
-    static removeOpportunityFromRewardBreakdown(rewards) {
-        return rewards.map(rewardByChain => {
-            const rewards = rewardByChain.rewards.map(reward => {
-                const breakdowns = reward.breakdowns.map(breakdown => {
-                    const { opportunity, ...rest } = breakdown;
-                    return rest;
-                });
-                return Object.assign(reward, { breakdowns });
-            });
-            return Object.assign(rewardByChain, { rewards });
-        });
-    }
-    static async findManyRootsOnChain(chainId) {
-        return await CacheService.wrap(TTLPresets.MIN_10, RewardRepository.findManyRootsWithRewardOnChain, chainId);
-    }
-    static async checkLastClaim(chainId, user, rewards) {
-        // Fetch the root of the last claim for each reward token
-        const claims = await DistributorService(chainId).claimedMultiple(user, rewards.map(reward => reward.RewardToken.address));
-        const rootsWithRewardOnChain = await RewardService.findManyRootsOnChain(chainId);
-        for (const [index, reward] of rewards.entries()) {
-            const tokenId = TokenService.hashId(reward.RewardToken);
-            const merklRootClaimedOn = claims[index].merkleRoot;
-            // -> claim is on the current root (chainData.merklRoot) -> claimed === accumulated
-            if (merklRootClaimedOn === reward.root) {
-                reward.claimed = reward.amount;
-                await RewardRepository.updateRewardClaimed(user, tokenId, reward.amount);
-                for (const breakdown of reward.Breakdown) {
-                    if (BigInt(breakdown.claimed) === BigInt(breakdown.amount))
-                        continue;
-                    breakdown.claimed = breakdown.amount; // Set unclaim to 0
-                    await RewardRepository.updateBreakdownClaimed(user, tokenId, breakdown.campaignId, breakdown.reason, breakdown.amount);
-                }
-            }
-            // -> claim is on a tree we have in db -> claimed === accumulated of the rewards of lastTree
-            else if (rootsWithRewardOnChain.includes(merklRootClaimedOn)) {
-                const lastTreeRewards = await RewardRepository.getByChainRecipientToken(user, merklRootClaimedOn, TokenService.hashId(reward.RewardToken));
-                if (!lastTreeRewards)
-                    continue;
-                reward.claimed = lastTreeRewards.amount;
-                await RewardRepository.updateRewardClaimed(user, tokenId, lastTreeRewards.amount);
-                for (const breakdown of reward.Breakdown) {
-                    const lastTreeRewardsBreakdown = lastTreeRewards.Breakdown.find(lastTreeBreakdown => lastTreeBreakdown.reason === breakdown.reason &&
-                        lastTreeBreakdown.Campaign.campaignId === breakdown.Campaign.campaignId);
-                    if (!lastTreeRewardsBreakdown)
-                        continue;
-                    breakdown.claimed = lastTreeRewardsBreakdown.amount;
-                    await RewardRepository.updateBreakdownClaimed(user, tokenId, breakdown.campaignId, breakdown.reason, breakdown.claimed);
-                }
-            }
-        }
-        return rewards;
-    }
-    static async getUserRewardsByChain(user, withToken, chainFilter = [], connectedChainId = null, withTestTokens = false, claimableOnly = false) {
-        const chains = await ChainService.findAll();
-        let chainIds = !chainFilter || !chainFilter.length
-            ? chains.map(({ id }) => id)
-            : chains.map(({ id }) => id).filter(id => chainFilter.includes(id));
-        /** Check if the user is blacklisted */
-        const isBlacklisted = !!(await BlacklistService.isBlacklisted(user));
-        const res = [];
-        if (isBlacklisted)
-            return res;
-        /** Fetch current Merkle Roots */
-        const merkleRootsPromises = await Promise.allSettled(chainIds.map(chainId => MerklRootService.fetchFromCache(chainId)));
-        /** Filter out unsuccessful chainIds */
-        chainIds = chainIds.filter((_, index) => merkleRootsPromises[index].status === "fulfilled");
-        const merkleRoots = merkleRootsPromises
-            .filter(({ status }) => status === "fulfilled")
-            .map(x => x.value);
-        /** Load rewards from api DB */
-        const rewards = (await RewardService.getByRecipient(user, merkleRoots.map(({ live }) => live), withToken, withTestTokens)).filter(reward => chainIds.includes(reward.RewardToken.chainId) &&
-            (claimableOnly ? BigInt(reward.amount) - BigInt(reward.claimed) > 0n : true));
-        const promises = [];
-        for (const chainId of chainIds) {
-            const chain = chains.find(chain => chain.id === chainId);
-            if (!chain)
-                throw new Error(`Chain ${chainId} not found`);
-            const chainRewards = rewards.filter(reward => reward.RewardToken.chainId === chainId);
-            /** Check when the last claim happened */
-            if (chain.id === connectedChainId && chainRewards.length > 0) {
-                promises.push(RewardService.checkLastClaim(chainId, user, chainRewards).then(r => {
-                    return { chain, rewards: r };
-                }));
-            }
-            else if (chainRewards.length > 0) {
-                promises.push(Promise.resolve({ chain, rewards: chainRewards }));
-            }
-        }
-        const settledPromises = await Promise.allSettled(promises);
-        for (const promise of settledPromises) {
-            if (promise.status === "rejected") {
-                log.error("checkLastClaim failed", promise.reason);
-            }
-            else {
-                res.push({ chain: promise.value.chain, rewards: RewardService.format(promise.value.rewards) });
-            }
-        }
-        return res;
-    }
-    static async registerClaims(claims) {
-        for (const claim of claims) {
-            const tokenId = TokenService.hashId({
-                chainId: claim.chainId,
-                address: claim.token,
-            });
-            const rewards = await RewardRepository.getByChainRecipientToken(claim.recipient, claim.root, tokenId);
-            if (!rewards)
-                continue;
-            await RewardRepository.updateRewardClaimed(claim.recipient, tokenId, rewards.amount);
-            for (const breakdown of rewards.Breakdown) {
-                await RewardRepository.updateBreakdownClaimed(claim.recipient, tokenId, breakdown.campaignId, breakdown.reason, breakdown.amount);
-            }
-        }
-    }
-    static async countOnChain(chainId) {
-        const roots = await MerklRootService.fetchFromCache(chainId);
-        const promises = [
-            RewardRepository.countRewardAndBreakdownOnChain(chainId, roots.tree),
-            RewardRepository.countRewardAndBreakdownOnChain(chainId, roots.lastTree),
-        ];
-        await Promise.all(promises);
-        return {
-            [roots.tree]: await promises[0],
-            [roots.lastTree]: await promises[1],
-        };
-    }
-    static async breakdownForCampaign(query) {
-        const root = await MerklRootService.fetchFromCache(query.chainId);
-        const id = CampaignService.hashId({ distributionChain: query.chainId, campaignId: query.campaignId });
-        return RewardRepository.breakdownForCampaign(root.live, id, query);
-    }
-    static async countForCampaign(query) {
-        const root = await MerklRootService.fetchFromCache(query.chainId);
-        const id = CampaignService.hashId({ distributionChain: query.chainId, campaignId: query.campaignId });
-        return RewardRepository.countForCampaign(id, root.live);
-    }
-    static async totalForCampaign(query) {
-        const root = await MerklRootService.fetchFromCache(query.chainId);
-        return RewardRepository.totalForCampaign(CampaignService.hashId({ distributionChain: query.chainId, campaignId: query.campaignId }), root.live);
-    }
-    static async breakdownForToken(query) {
-        return CacheService.wrap(TTLPresets.MIN_10, async (query) => {
-            const root = await MerklRootService.fetchFromCache(query.chainId);
-            const id = TokenService.hashId({ chainId: query.chainId, address: query.address });
-            return RewardRepository.breakdownForToken(root.live, id, query);
-        }, query);
-    }
-    static async countForToken(query) {
-        return CacheService.wrap(TTLPresets.MIN_10, async (query) => {
-            const root = await MerklRootService.fetchFromCache(query.chainId);
-            const id = TokenService.hashId({ chainId: query.chainId, address: query.address });
-            return RewardRepository.countForToken(id, root.live);
-        }, query);
-    }
-    static async totalForToken(query) {
-        return CacheService.wrap(TTLPresets.MIN_10, async (query) => {
-            const root = await MerklRootService.fetchFromCache(query.chainId);
-            const id = TokenService.hashId({ chainId: query.chainId, address: query.address });
-            return RewardRepository.totalForToken(id, root.live);
-        }, query);
-    }
-    static async getAmountAndClaimedForCampaigns(x) {
-        const currentRoot = await MerklRootService.fetchFromCache(x.chainId);
-        return await RewardRepository.getAmountAndClaimedForCampaigns(currentRoot.live, x);
-    }
-    static async getUnclaimed(x) {
-        const campaignToCampaignIds = x.campaignIds.reduce((acc, campaignId) => {
-            acc[CampaignService.hashId({ distributionChain: x.chainId, campaignId })] = campaignId;
-            return acc;
-        }, {});
-        const data = await RewardService.getAmountAndClaimedForCampaigns(x);
-        return data.reduce((acc, { amount, campaignId, claimed }) => {
-            if (!acc[campaignToCampaignIds[campaignId]])
-                acc[campaignToCampaignIds[campaignId]] = "0";
-            acc[campaignToCampaignIds[campaignId]] = (BigInt(acc[campaignToCampaignIds[campaignId]]) +
-                BigInt(amount) -
-                BigInt(claimed)).toString();
-            return acc;
-        }, {});
-    }
-    /**
-     * @deprecated
-     */
-    static async extractDailyRewardsRecordFromDynamicData(type, dynamicData, timestamp = BigInt(moment().unix())) {
-        const typesWithoutApr = [CampaignType.INVALID];
-        if (typesWithoutApr.includes(type))
-            return { timestamp, total: 0, breakdowns: [] };
-        const breakdowns = [];
-        for (const { amount, rewardToken, chainId, startTimestamp: start, endTimestamp: end, campaignId } of dynamicData) {
-            if (end < moment().unix())
-                continue;
-            const timespan = Number(end - start);
-            const isWithinTimespan = moment().unix() > start && moment().unix() < end;
-            const dayspan = Math.max(1, timespan / DAY);
-            const dailyAmount = isWithinTimespan
-                ? (BigInt(amount) * BigInt(10 ** 6)) / BigInt(Math.floor(dayspan * 10 ** 6))
-                : BigInt(0);
-            const campaignIdInDb = CampaignService.hashId({ campaignId, distributionChain: chainId });
-            try {
-                let token;
-                try {
-                    token = await TokenService.findUniqueOrThrow({ address: rewardToken, chainId });
-                }
-                catch {
-                    await TokenService.findManyOrCreate([{ address: rewardToken, chainId }]);
-                    token = await TokenService.findUniqueOrThrow({ address: rewardToken, chainId });
-                }
-                const campaignDailyValue = await TokenService.getValueByTokenId(TokenService.hashId({ address: rewardToken, chainId }), dailyAmount);
-                breakdowns.push({
-                    campaignId: campaignIdInDb,
-                    value: campaignDailyValue,
-                    amount: dailyAmount,
-                    token,
-                });
-            }
-            catch (_err) {
-                log.warn(`token ${rewardToken} not found`);
-            }
-        }
-        return {
-            timestamp,
-            total: breakdowns.reduce((sum, { value }) => {
-                return sum + value;
-            }, 0),
-            breakdowns,
-        };
-    }
-}

package/dist/src/modules/v4/router.js

@@ -1,93 +0,0 @@
-import { AccountingController } from "@/modules/v4/accounting/accounting.controller";
-import { BlacklistController } from "@/modules/v4/blacklist/blacklist.controller";
-import { BoostController } from "@/modules/v4/boost/boost.controller";
-import { CampaignController } from "@/modules/v4/campaign/campaign.controller";
-import { CampaignTestController } from "@/modules/v4/campaign/campaign.test.controller";
-import { ChainController } from "@/modules/v4/chain/chain.controller";
-import { ClaimController } from "@/modules/v4/claims/claims.controller";
-import { ComputedValueController } from "@/modules/v4/computedValue/computedValue.controller";
-import { CreatorController } from "@/modules/v4/creator/creator.controller";
-import { ExplorerController } from "@/modules/v4/explorer/explorer.controller";
-import { InteractionController } from "@/modules/v4/interaction/interaction.controller";
-import { LiquidityController } from "@/modules/v4/liquidity/liquidity.controller";
-import { MerklRootController } from "@/modules/v4/merklRoot/merklRoot.controller";
-import { OpportunityController } from "@/modules/v4/opportunity/opportunity.controller";
-import { PriceController } from "@/modules/v4/price/price.controller";
-import { ProgramPayloadController } from "@/modules/v4/programPayload/programPayload.controller";
-import { ProtocolController } from "@/modules/v4/protocol/protocol.controller";
-import { RewardController } from "@/modules/v4/reward/reward.controller";
-import { StatusController } from "@/modules/v4/status/status.controller";
-import { TokenController } from "@/modules/v4/token/token.controller";
-import { UniswapController } from "@/modules/v4/uniswap/uniswap.controller";
-import { UserController } from "@/modules/v4/user/user.controller";
-import { ErrorHandler } from "@/plugins/error-handling.plugin";
-import { TailSampler } from "@/utils/TailSampler";
-import bigintToString from "@/utils/bigintToString";
-import { opentelemetry } from "@elysiajs/opentelemetry";
-import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
-import { RedisInstrumentation } from "@opentelemetry/instrumentation-redis-4";
-import { AlwaysOffSampler, BatchSpanProcessor } from "@opentelemetry/sdk-trace-node";
-import { PrismaInstrumentation } from "@prisma/instrumentation";
-import Elysia from "elysia";
-import { AuthController } from "./authentication/authentication.controller";
-import { ReferralController } from "./referral/referral.controller";
-import { TurtleController } from "./turtle/turtle.controller";
-// ─── V4 Router ───────────────────────────────────────────────────────────────
-export const v4 = new Elysia({ tags: ["v4"], prefix: "/v4" })
-    // ─── OpenTelemetry ───────────────────────────────────────────────────
-    .use(opentelemetry({
-    sampler: process.env.TRACE === "true" ? new TailSampler(0.01) : new AlwaysOffSampler(),
-    spanProcessors: [
-        new BatchSpanProcessor(new OTLPTraceExporter({
-            url: process.env.OTEL_COLLECTOR,
-            headers: {
-                "signoz-ingestion-key": String(process.env.SIGNOZ_INGESTION_KEY),
-            },
-        })),
-    ],
-    instrumentations: [
-        getNodeAutoInstrumentations({
-            "@opentelemetry/instrumentation-redis": { enabled: false },
-        }),
-        new PrismaInstrumentation(),
-        new RedisInstrumentation({
-            enabled: true,
-            requireParentSpan: false,
-            dbStatementSerializer: (cmdName, cmdArgs) => {
-                return [cmdName, ...cmdArgs].join(" ");
-            },
-        }),
-    ],
-    serviceName: "merkl-api",
-}))
-    // ─── Error Handling ──────────────────────────────────────────────────
-    .use(ErrorHandler)
-    // ─── Response Transformation ─────────────────────────────────────────
-    .onAfterHandle(({ response }) => bigintToString(response))
-    // ─── Route Controllers ───────────────────────────────────────────────
-    .use(OpportunityController)
-    .use(CampaignController)
-    .use(CampaignTestController)
-    .use(ProtocolController)
-    .use(ExplorerController)
-    .use(TokenController)
-    .use(RewardController)
-    .use(ChainController)
-    .use(PriceController)
-    .use(BlacklistController)
-    .use(UserController)
-    .use(MerklRootController)
-    .use(InteractionController)
-    .use(AccountingController)
-    .use(StatusController)
-    .use(LiquidityController)
-    .use(ClaimController)
-    .use(ProgramPayloadController)
-    .use(BoostController)
-    .use(ComputedValueController)
-    .use(CreatorController)
-    .use(ReferralController)
-    .use(UniswapController)
-    .use(TurtleController)
-    .use(AuthController);

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

@@ -1,68 +0,0 @@
-import { BackOfficeGuard } from "@/guards/BackOffice.guard";
-import { AuthorizationHeadersDto, EngineGuard } from "@/guards/Engine.guard";
-import { throwOnUnsupportedChainId } from "@/utils/throw";
-import Elysia from "elysia";
-import { CampaignUniqueDto, ComputedUntilDto, DelayDto, QueryCampaignStatusDto, StatusErrorDto, UpdateCampaignStatusDto, } from "./status.model";
-import { StatusService } from "./status.service";
-export const StatusController = new Elysia({ prefix: "/campaign-status", detail: { tags: ["Status"], hide: true } })
-    // ─── Update a Campaign Status ──────────────────────────────────────
-    .put("/engine/:campaignId", async ({ params, body }) => {
-    const [distributionChain, campaignId] = params.campaignId.split("-");
-    return await StatusService.update({ distributionChain: +distributionChain, campaignId }, body);
-}, {
-    beforeHandle: EngineGuard,
-    headers: AuthorizationHeadersDto,
-    body: UpdateCampaignStatusDto,
-})
-    // ─── Updates only the computed until field ───────────────────────────
-    .put("/engine/computedUntil/:campaignId", async ({ params, body }) => {
-    const [distributionChain, campaignId] = params.campaignId.split("-");
-    return await StatusService.updateComputedUntil({ distributionChain: +distributionChain, campaignId }, body.computedUntil);
-}, {
-    beforeHandle: EngineGuard,
-    headers: AuthorizationHeadersDto,
-    body: ComputedUntilDto,
-})
-    // ─── Updates only the computed until field ───────────────────────────
-    .put("/error/:campaignId", async ({ params, body }) => {
-    const [distributionChain, campaignId] = params.campaignId.split("-");
-    return await StatusService.updateErrorMessage({ distributionChain: +distributionChain, campaignId }, body.error);
-}, {
-    beforeHandle: BackOfficeGuard,
-    headers: AuthorizationHeadersDto,
-    body: StatusErrorDto,
-})
-    // ─── Is Safe For Overlaps ───────────────────────────────────────────
-    .get("/engine/overlaps", async ({ query }) => await StatusService.isSafeForOverlaps(query), {
-    beforeHandle: EngineGuard,
-    headers: AuthorizationHeadersDto,
-    query: CampaignUniqueDto,
-})
-    // ─── Find Many Status ─────────────────────────────────────────────────
-    .get("/", async ({ query }) => await StatusService.findMany(query), { query: QueryCampaignStatusDto })
-    // ─── Get A Status By Id ───────────────────────────────────────────────
-    // campaignId will be either a rough campaignId in the engine sense, a campaignId in the api db way, or a distributionChain_campaignId
-    .get("/:campaignId", async ({ params }) => {
-    if (!params.campaignId.includes("-") && params.campaignId.startsWith("0x"))
-        return await StatusService.findManyByCampaignId(params.campaignId);
-    if (!params.campaignId.includes("-"))
-        return await StatusService.findUniqueOrThrow(params.campaignId);
-    const [distributionChain, campaignId] = params.campaignId.split("-");
-    return await StatusService.findUniqueOrThrow({ distributionChain: +distributionChain, campaignId });
-})
-    // ─── Fetch information about delays ────────────────────────────────────
-    .group("/delay", app => {
-    return app
-        .get("/", async ({ query }) => StatusService.findManyDelay(query), {
-        query: DelayDto,
-        beforeHandle: ({ query }) => {
-            if (!!query.chainId) {
-                throwOnUnsupportedChainId(query.chainId);
-            }
-        },
-        detail: { hide: true },
-    })
-        .get("/status", async () => StatusService.findUpdatesAndDelays(), {
-        detail: { hide: true },
-    });
-});

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

@@ -1,34 +0,0 @@
-import { RunStatus } from "@db/api";
-import { t } from "elysia";
-// ─── DTOs ────────────────────────────────────────────────────────────────────
-export const CampaignUniqueDto = t.Object({
-    distributionChain: t.Numeric(),
-    campaignId: t.String(),
-});
-export const DelayDto = t.Object({
-    endTimestampLowerBound: t.Optional(t.Numeric({
-        description: "Lower bound of end timestamps - by default it'll take all campaigns where endTimestamp is more than now - 1 week",
-    })),
-    delayLowerBound: t.Optional(t.Numeric({ description: "To filter small delays (in seconds)" })),
-    chainId: t.Optional(t.Numeric({ description: "To get delays for Campaigns on a given chain only" })),
-});
-export const CampaignStatusResourceDto = t.Object({
-    campaignId: t.String(),
-    computedUntil: t.Union([t.String(), t.Numeric()]),
-    processingStarted: t.Union([t.String(), t.Numeric()]),
-    status: t.String(),
-    error: t.Optional(t.String()),
-    details: t.Optional(t.Any()),
-});
-export const UpdateCampaignStatusDto = t.Union([
-    t.Object({ value: t.Literal(RunStatus.SUCCESS), computedUntil: t.Numeric() }),
-    t.Object({ value: t.Literal(RunStatus.PROCESSING) }),
-    t.Object({ value: t.Literal(RunStatus.SKIPPED), error: t.String(), details: t.String() }),
-    t.Object({ value: t.Literal(RunStatus.FAILED), error: t.String(), details: t.String() }),
-]);
-export const ComputedUntilDto = t.Object({ computedUntil: t.Numeric() });
-export const StatusErrorDto = t.Object({ error: t.String() });
-export const QueryCampaignStatusDto = t.Object({
-    computeChainId: t.Optional(t.Numeric()),
-    status: t.Optional(t.Union([t.Array(t.Enum(RunStatus)), t.Enum(RunStatus)])),
-});