@merkl/api 0.10.128 → 0.10.130

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

@@ -0,0 +1,44 @@
+import bigintToString from "../../../utils/bigintToString";
+import { CacheRepository } from "./cache.repository";
+export class CacheService {
+    static encoder = new TextEncoder();
+    static decoder = new TextDecoder();
+    static #hashKey(fn, args) {
+        const prototype = [Bun.hash(fn.toString()).toString()];
+        return Bun.hash(JSON.stringify(prototype.concat(args?.map(a => JSON.stringify(a))))).toString();
+    }
+    static #compress(result) {
+        const encoded = CacheService.encoder.encode(JSON.stringify(result));
+        return Buffer.from(Bun.gzipSync(encoded)).toString("base64");
+    }
+    static #uncompress(compressedData) {
+        const encoded = Buffer.from(compressedData, "base64");
+        const uncompressed = Bun.gunzipSync(encoded);
+        const decoded = CacheService.decoder.decode(uncompressed);
+        return JSON.parse(decoded);
+    }
+    static async wrap(ttl, fn, ...args) {
+        const key = CacheService.#hashKey(fn, args);
+        const cached = await CacheRepository.get(key);
+        if (cached !== null)
+            return CacheService.#uncompress(cached);
+        const result = await fn(...args);
+        const compressed = CacheService.#compress(bigintToString(result));
+        await CacheRepository.set(ttl, key, compressed);
+        return result;
+    }
+    static async set(ttl, fn, ...args) {
+        const key = CacheService.#hashKey(fn, args);
+        const result = await fn(...args);
+        const compressed = CacheService.#compress(bigintToString(result));
+        await CacheRepository.set(ttl, key, compressed);
+        return result;
+    }
+    static async get(fn, args) {
+        const key = CacheService.#hashKey(fn, args);
+        const cached = await CacheRepository.get(key);
+        if (cached === null)
+            return null;
+        return CacheService.#uncompress(cached);
+    }
+}

package/dist/src/modules/v4/cache/index.js

@@ -0,0 +1 @@
+export * from "./cache.service";

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

@@ -0,0 +1,56 @@
+import { AuthorizationHeadersDto, EngineGuard } from "../../../guards/Engine.guard";
+import Elysia from "elysia";
+import { throwOnUnsupportedChainId } from "src/utils/throw";
+import { ChainDto } from "../status";
+import { CreateCampaignDto, GetCampaignQueryDto } from "./campaign.model";
+import { CampaignService } from "./campaign.service";
+// ─── Campaigns Controller ────────────────────────────────────────────────────
+export const CampaignController = new Elysia({ prefix: "/campaigns", detail: { tags: ["Campaigns"] } })
+    // ─── Create A Campaign ───────────────────────────────────────────────
+    .post("/", async ({ body }) => {
+    return await CampaignService.create(body);
+}, {
+    beforeHandle: EngineGuard,
+    headers: AuthorizationHeadersDto,
+    body: CreateCampaignDto,
+})
+    // ─── Get Many Campaigns ──────────────────────────────────────────────
+    .get("/", async ({ query }) => {
+    return await CampaignService.findMany(query);
+}, { query: GetCampaignQueryDto })
+    // ─── Get Total Campaigns Count ───────────────────────────────────────
+    .get("/count", async ({ query }) => {
+    return await CampaignService.countMany(query);
+}, { query: GetCampaignQueryDto })
+    .group("/campaignsToProcess", app => {
+    return (app
+        // ─── Get the List of CampaignsToProcess ─────────────────────────────-
+        .get("/", async ({ query }) => {
+        return await CampaignService.findCampaignsToProcess(query.chainId);
+    }, {
+        query: ChainDto,
+        beforeHandle: ({ query }) => {
+            throwOnUnsupportedChainId(query.chainId);
+        },
+    })
+        // ─── Get Count of CampaignsToProcess ─────────────────────────────────
+        .get("/count", async ({ query }) => {
+        return (await CampaignService.findCampaignsToProcess(query.chainId)).length;
+    }, {
+        query: ChainDto,
+        beforeHandle: ({ query }) => {
+            throwOnUnsupportedChainId(query.chainId);
+        },
+    })
+        // ─── Returns a CampaignId to Process and flags it as PROCESSING ──────-
+        .post("/", async ({ query }) => {
+        return await CampaignService.pickCampaignToProcess(query.chainId);
+    }, {
+        query: ChainDto,
+        beforeHandle: async ({ query, headers }) => {
+            await EngineGuard({ headers });
+            throwOnUnsupportedChainId(query.chainId);
+        },
+        headers: AuthorizationHeadersDto,
+    }));
+});

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

@@ -0,0 +1,54 @@
+import { CampaignType } from "../../../../database/api/.generated";
+import { Campaign as CampaignTypeEnum } from "@sdk";
+import { t } from "elysia";
+// ─── Utils ───────────────────────────────────────────────────────────────────
+export const campaignTypeToEnumMap = {
+    INVALID: CampaignTypeEnum.INVALID,
+    CLAMM: CampaignTypeEnum.CLAMM,
+    ERC20: CampaignTypeEnum.ERC20,
+    BADGER: CampaignTypeEnum.BADGER,
+    AJNA: CampaignTypeEnum.AJNA,
+    COMPOUND: CampaignTypeEnum.COMPOUND,
+    EULER: CampaignTypeEnum.EULER,
+    DOLOMITE: CampaignTypeEnum.DOLOMITE,
+    ERC20_SNAPSHOT: CampaignTypeEnum.ERC20_SNAPSHOT,
+    MORPHO: CampaignTypeEnum.MORPHO,
+    RADIANT: CampaignTypeEnum.RADIANT,
+    SILO: CampaignTypeEnum.SILO,
+    JSON_AIRDROP: CampaignTypeEnum.JSON_AIRDROP,
+    UNISWAP_V4: CampaignTypeEnum.UNISWAP_V4,
+};
+// ─── DTOs ────────────────────────────────────────────────────────────────────
+export const CampaignUniqueDto = t.Object({
+    distributionChain: t.Numeric(),
+    campaignId: t.String(),
+});
+export const CreateCampaignDto = t.Object({
+    computeChainId: t.Number(),
+    chainId: t.Number(),
+    campaignId: t.String(),
+    identifier: t.Optional(t.String()),
+    creator: t.String(),
+    type: t.Number(),
+    subType: t.Optional(t.Number()),
+    rewardTokenAddress: t.String(),
+    amount: t.String(),
+    opportunityIdentifier: t.String(),
+    startTimestamp: t.String(),
+    endTimestamp: t.String(),
+    params: t.String(),
+});
+export const GetCampaignQueryDto = t.Object({
+    page: t.Optional(t.Numeric()),
+    items: t.Optional(t.Numeric()),
+    chainId: t.Optional(t.Numeric()),
+    type: t.Optional(t.Enum(CampaignType)),
+    subType: t.Optional(t.Number()),
+    campaignId: t.Optional(t.String()),
+    mainParameter: t.Optional(t.String()),
+    tokenSymbol: t.Optional(t.String()),
+    tokenAddress: t.Optional(t.String()),
+    opportunityId: t.Optional(t.String()),
+    startTimestamp: t.Optional(t.String({ pattern: "[0-9].*" })),
+    endTimestamp: t.Optional(t.String({ pattern: "[0-9].*" })),
+});

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

@@ -0,0 +1,346 @@
+import { CampaignService } from "./";
+import { log } from "../../../utils/logger";
+import { apiDbClient, engineDbClient } from "../../../utils/prisma";
+import { ALL_CAMPAIGNS_FOR_CHAIN_AFTER } from "../../../utils/queries/allCampaigns";
+import { RunStatus, Status } from "../../../../database/api/.generated";
+import { MAX_COMPUTE_JOB_TIME, WEEK } from "@sdk";
+import moment from "moment";
+import { OpportunityService } from "../opportunity";
+import { TokenService } from "../token";
+export class CampaignRepository {
+    // ─── Private Methods ─────────────────────────────────────────────────
+    static #transformQueryToPrismaFilters(query) {
+        const { chainId, endTimestamp, opportunityId, mainParameter, campaignId, startTimestamp, subType, type, tokenAddress, tokenSymbol, } = query;
+        return {
+            where: {
+                computeChainId: chainId,
+                endTimestamp: endTimestamp ? { gte: +endTimestamp } : undefined,
+                opportunityId,
+                campaignId,
+                Opportunity: {
+                    identifier: mainParameter,
+                },
+                startTimestamp: startTimestamp ? { gte: +startTimestamp } : undefined,
+                subType,
+                type,
+                RewardToken: {
+                    address: tokenAddress ? tokenAddress : undefined,
+                    symbol: tokenSymbol ? tokenSymbol : undefined,
+                },
+            },
+        };
+    }
+    // ─── Public Methods ──────────────────────────────────────────────────
+    static async upsert(campaign, metadata) {
+        const campaignType = CampaignService.getTypeFromV3(campaign.type);
+        try {
+            let tokens = await TokenService.getManyOrCreate(metadata.tokens);
+            const [rewardToken] = await TokenService.getManyOrCreate([
+                { chainId: campaign.chainId, address: campaign.rewardTokenAddress },
+            ]);
+            if (!rewardToken) {
+                throw new Error(`unable to fetch data for token ${campaign.rewardTokenAddress}`);
+            }
+            tokens = tokens.filter(t => t !== undefined);
+            const opportunityId = OpportunityService.hashId({
+                chainId: campaign.computeChainId,
+                identifier: campaign.opportunityIdentifier,
+                type: campaignType,
+            });
+            const opportunityTokens = tokens.map(t => {
+                return {
+                    chainId_address: { chainId: t.chainId, address: t.address }, //TODO: use id
+                };
+            });
+            const data = {
+                id: campaign.id,
+                amount: campaign.amount,
+                campaignId: campaign.campaignId,
+                endTimestamp: BigInt(campaign.endTimestamp),
+                params: JSON.parse(campaign.params),
+                startTimestamp: BigInt(campaign.startTimestamp),
+                type: campaignType,
+                ComputeChain: {
+                    connect: {
+                        id: campaign.computeChainId,
+                    },
+                },
+                Creator: {
+                    connectOrCreate: {
+                        where: { address: campaign.creator },
+                        create: {
+                            address: campaign.creator,
+                        },
+                    },
+                },
+                Opportunity: {
+                    connectOrCreate: {
+                        where: { id: opportunityId },
+                        create: {
+                            id: opportunityId,
+                            Chain: { connect: { id: campaign.chainId } },
+                            type: campaignType,
+                            identifier: campaign.opportunityIdentifier, // mainParameter
+                            name: metadata.name,
+                            status: +campaign.startTimestamp >= new Date().getTime() * 1000
+                                ? Status.LIVE
+                                : +campaign.endTimestamp < new Date().getTime() * 1000
+                                    ? Status.PAST
+                                    : Status.SOON,
+                            action: metadata.action,
+                            Tokens: { connect: opportunityTokens },
+                            MainProtocol: {
+                                connect: metadata.mainProtocol && { id: metadata.mainProtocol },
+                            },
+                        },
+                    },
+                },
+                RewardToken: {
+                    connectOrCreate: { where: { id: rewardToken?.id }, create: rewardToken },
+                },
+                subType: campaign.subType,
+                DistributionChain: { connect: { id: campaign.chainId } },
+            };
+            return await apiDbClient.campaign.upsert({
+                where: {
+                    id: campaign.id,
+                },
+                create: data,
+                update: data,
+            });
+        }
+        catch (err) {
+            log.error(`Failed to upsert campaign ${campaign.campaignId}`, err);
+        }
+    }
+    static async upsertMany(campaigns, campaignToOpp) {
+        const data = [];
+        for (const campaign of campaigns) {
+            const campaignType = CampaignService.getTypeFromV3(campaign.type);
+            let tokens = await TokenService.getManyOrCreate(campaignToOpp[campaign.id].tokens);
+            const [rewardToken] = await TokenService.getManyOrCreate([
+                { chainId: campaign.chainId, address: campaign.rewardTokenAddress },
+            ]);
+            tokens = tokens.filter(t => t !== undefined);
+            const opportunityId = OpportunityService.hashId({
+                chainId: campaign.computeChainId,
+                identifier: campaign.opportunityIdentifier,
+                type: campaignType,
+            });
+            const opportunityTokens = tokens.map(t => {
+                return { id: t?.id };
+            });
+            data.push({
+                id: campaign.id,
+                amount: campaign.amount,
+                campaignId: campaign.campaignId,
+                endTimestamp: BigInt(campaign.endTimestamp),
+                params: JSON.parse(campaign.params),
+                startTimestamp: BigInt(campaign.startTimestamp),
+                type: campaignType,
+                ComputeChain: {
+                    connect: {
+                        id: campaign.computeChainId,
+                    },
+                },
+                Creator: {
+                    connectOrCreate: {
+                        where: { address: campaign.creator },
+                        create: { address: campaign.creator },
+                    },
+                },
+                Opportunity: {
+                    connectOrCreate: {
+                        where: { id: opportunityId },
+                        create: {
+                            id: opportunityId,
+                            Chain: {
+                                connect: {
+                                    id: campaign.computeChainId,
+                                },
+                            },
+                            type: campaignType,
+                            identifier: campaign.opportunityIdentifier, // mainParameter
+                            name: campaignToOpp[campaign.id].name,
+                            status: +campaign.startTimestamp >= new Date().getTime() * 1000
+                                ? Status.LIVE
+                                : +campaign.endTimestamp < new Date().getTime() * 1000
+                                    ? Status.PAST
+                                    : Status.SOON,
+                            action: campaignToOpp[campaign.id].action,
+                            Tokens: { connect: opportunityTokens },
+                            MainProtocol: {
+                                connect: campaignToOpp[campaign.id].mainProtocol && {
+                                    id: campaignToOpp[campaign.id].mainProtocol,
+                                },
+                            },
+                        },
+                    },
+                },
+                RewardToken: {
+                    connect: rewardToken ? { id: TokenService.hashId(rewardToken) } : undefined,
+                },
+                subType: campaign.subType,
+                DistributionChain: { connect: { id: campaign.chainId } },
+            });
+        }
+        const failedCampaigns = [];
+        const successCampaigns = [];
+        for (const campaign of data) {
+            try {
+                await apiDbClient.campaign.upsert({
+                    where: {
+                        // TODO: use id
+                        id: CampaignService.hashId({
+                            campaignId: campaign.campaignId,
+                            distributionChain: campaign.DistributionChain.connect?.id,
+                        }),
+                    },
+                    create: campaign,
+                    update: campaign,
+                });
+                successCampaigns.push(campaign);
+            }
+            catch (err) {
+                log.error(`Failed to upsert campaign ${campaign.campaignId}`, err);
+                failedCampaigns.push(campaign);
+            }
+        }
+        return { success: successCampaigns.length, fail: failedCampaigns.length };
+    }
+    /**
+     * Fetches the campaign static data for a v3 campaign in database
+     * @param chainId
+     * @param timestamp from which campaigns endTimestamp are filtered
+     * @returns
+     */
+    static async getFromEngineDb(chainId, timestamp) {
+        //TODO use a typesafe fetching methode (this one is from campaignUpdater)
+        return (await engineDbClient.$queryRaw(ALL_CAMPAIGNS_FOR_CHAIN_AFTER(chainId, timestamp)));
+    }
+    static async getFromEngineDbWithId(campaignIds) {
+        return await engineDbClient.campaigns.findMany({
+            where: {
+                OR: campaignIds.map(campaign => {
+                    return {
+                        chainId: campaign.distributionChain,
+                        campaignId: campaign.campaignId,
+                    };
+                }),
+            },
+        });
+    }
+    static async checkIfExist(campaign) {
+        return !!(await apiDbClient.campaign.findFirst({
+            select: {
+                id: true,
+            },
+            where: {
+                id: CampaignService.hashId(campaign),
+            },
+        }));
+    }
+    static async findUnique(campaign) {
+        return await apiDbClient.campaign.findUnique({
+            where: {
+                id: CampaignService.hashId(campaign),
+            },
+        });
+    }
+    static async findUniqueOrThrow(campaign) {
+        return await apiDbClient.campaign.findUniqueOrThrow({
+            where: {
+                id: CampaignService.hashId(campaign),
+            },
+        });
+    }
+    static async findCampaignsToProcess(distributionChainId) {
+        const currentTime = moment().startOf("minute").unix(); // Round to the minute for concurrency mismatchs
+        return await apiDbClient.campaign.findMany({
+            where: {
+                distributionChainId,
+                startTimestamp: { lte: currentTime }, // The campaign has started
+                endTimestamp: { gte: currentTime - WEEK }, // The campaign ended less than a week ago
+                params: {
+                    path: ["shouldIgnore"], // There is no "shouldIgnore" flag in the api database
+                    not: "true",
+                },
+                CampaignStatus: {
+                    some: {
+                        // The campaign is not currently processing or has been processing for too long
+                        OR: [
+                            {
+                                status: {
+                                    not: RunStatus.PROCESSING,
+                                },
+                            },
+                            {
+                                status: RunStatus.PROCESSING,
+                                processingStarted: {
+                                    lt: currentTime - MAX_COMPUTE_JOB_TIME,
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+            select: {
+                campaignId: true,
+                endTimestamp: true,
+                CampaignStatus: {
+                    // To be able to filter out campaigns that are already fully computed
+                    take: 1,
+                    select: {
+                        computedUntil: true,
+                    },
+                },
+            },
+            orderBy: {
+                amount: "desc",
+            },
+        });
+    }
+    // ─── Search Many Campaigns ───────────────────────────────────────────
+    static async findMany(query) {
+        const { page: _page, items: _items, ...filters } = query;
+        const page = _page ? _page : 0;
+        const items = _items ? _items : 20;
+        const args = CampaignRepository.#transformQueryToPrismaFilters(query);
+        return await apiDbClient.campaign.findMany({
+            take: items,
+            skip: page * items,
+            include: {
+                DistributionChain: true,
+                ComputeChain: true,
+                RewardToken: true,
+            },
+            orderBy: {
+                endTimestamp: "desc",
+            },
+            ...args,
+        });
+    }
+    static async countMany(query) {
+        const args = CampaignRepository.#transformQueryToPrismaFilters(query);
+        return await apiDbClient.campaign.count(args);
+    }
+    static async findManyCampaignId(chainId) {
+        return await apiDbClient.campaign.findMany({
+            select: {
+                campaignId: true,
+            },
+            where: {
+                distributionChainId: chainId,
+            },
+        });
+    }
+    static async findChains() {
+        const campaigns = await apiDbClient.campaign.findMany({
+            select: { distributionChainId: true, id: true },
+        });
+        return campaigns.reduce((acc, campaign) => {
+            acc[campaign.id] = campaign.distributionChainId;
+            return acc;
+        }, {});
+    }
+}