@merkl/api 0.10.129 → 0.10.131

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

@@ -0,0 +1,57 @@
+import { AccountingController } from "./accounting";
+import { BlacklistController } from "./blacklist";
+import { CampaignController } from "./campaign";
+import { ChainController } from "./chain";
+import { OpportunityController } from "./opportunity";
+import { PriceController } from "./price";
+import { ProtocolController } from "./protocol";
+import { RewardController } from "./reward";
+import { TokenController } from "./token";
+import { ErrorHandler } from "../../plugins/error-handling.plugin";
+import bigintToString from "../../utils/bigintToString";
+import { opentelemetry } from "@elysiajs/opentelemetry";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-node";
+import Elysia from "elysia";
+import { DynamicDataController } from "./dynamicData";
+import { MerklRootController } from "./merklRoot";
+import { ParticipateController } from "./participate/participate.controller";
+import { StatusController } from "./status";
+import { UserController } from "./user";
+// ─── V4 Router ───────────────────────────────────────────────────────────────
+export const v4 = new Elysia({ tags: ["v4"], prefix: "/v4" })
+    // ─── OpenTelemetry ───────────────────────────────────────────────────
+    .use(process.env.TRACE === "true"
+    ? opentelemetry({
+        spanProcessors: [
+            new BatchSpanProcessor(new OTLPTraceExporter({
+                url: process.env.OTEL_COLLECTOR,
+                headers: {
+                    "signoz-ingestion-key": String(process.env.SIGNOZ_INGESTION_KEY),
+                },
+            })),
+        ],
+    })
+    : new Elysia() // not optimal
+)
+    // ─── Error Handling ──────────────────────────────────────────────────
+    .use(ErrorHandler)
+    // ─── Logger ──────────────────────────────────────────────────────────
+    // .use(Logger)
+    // ─── Response Transformation ─────────────────────────────────────────
+    .onAfterHandle(({ response }) => bigintToString(response))
+    // ─── Route Controllers ───────────────────────────────────────────────
+    .use(OpportunityController)
+    .use(CampaignController)
+    .use(ProtocolController)
+    .use(TokenController)
+    .use(RewardController)
+    .use(ChainController)
+    .use(PriceController)
+    .use(BlacklistController)
+    .use(UserController)
+    .use(MerklRootController)
+    .use(ParticipateController)
+    .use(AccountingController)
+    .use(DynamicDataController)
+    .use(StatusController);

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

@@ -0,0 +1,3 @@
+export * from "./status.model";
+export * from "./status.controller";
+export * from "./status.service";

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

@@ -0,0 +1,48 @@
+import { AuthorizationHeadersDto, EngineGuard } from "../../../guards/Engine.guard";
+import { throwOnUnsupportedChainId } from "../../../utils/throw";
+import Elysia from "elysia";
+import { CampaignUniqueDto } from "../campaign";
+import { ChainDto, RunStatusListDto, UpdateStatusDto } from "./status.model";
+import { StatusService } from "./status.service";
+export const StatusController = new Elysia({ prefix: "/campaignStatus", detail: { tags: ["Status"] } })
+    // ─── Update a Campaign Status ──────────────────────────────────────
+    .post("/engine", async ({ body }) => {
+    return await StatusService.update(body);
+}, {
+    beforeHandle: EngineGuard,
+    headers: AuthorizationHeadersDto,
+    body: UpdateStatusDto,
+})
+    // ─── Get All Status ────────────────────────────────────────────────
+    .get("/", async () => {
+    return await StatusService.findMany();
+})
+    .get("/status", async ({ query }) => {
+    return await StatusService.findManyByRunStatus(query);
+}, { query: RunStatusListDto })
+    // ─── Get A Status By Id ────────────────────────────────────────────
+    .get("/unique", async ({ query }) => {
+    return await StatusService.findUniqueOrThrow(query);
+}, {
+    query: CampaignUniqueDto,
+    beforeHandle: ({ query }) => {
+        throwOnUnsupportedChainId(query.distributionChain);
+    },
+})
+    // ─── Get All Status on a chain ─────────────────────────────────────
+    .get("/computeChain/:chainId", async ({ params }) => {
+    return await StatusService.findManyPerChain(params.chainId);
+}, {
+    params: ChainDto,
+    beforeHandle: ({ params }) => {
+        throwOnUnsupportedChainId(params.chainId);
+    },
+})
+    // ─── Is Safe For Overlaps ──────────────────────────────────────────
+    .get("/engine/overlaps", async ({ query }) => {
+    return await StatusService.isSafeForOverlaps(query);
+}, {
+    beforeHandle: EngineGuard,
+    headers: AuthorizationHeadersDto,
+    query: CampaignUniqueDto,
+});

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

@@ -0,0 +1,24 @@
+import { RunStatus } from "../../../../database/api/.generated";
+import { t } from "elysia";
+export const ChainDto = t.Object({
+    chainId: t.Numeric(),
+});
+export const UpdateStatusDto = t.Object({
+    distributionChain: t.Numeric(),
+    campaignId: t.String(), // Identifier of the campaign
+    status: 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 RunStatusDto = t.Union([
+    t.Literal(RunStatus.SUCCESS),
+    t.Literal(RunStatus.FAILED),
+    t.Literal(RunStatus.PROCESSING),
+    t.Literal(RunStatus.SKIPPED),
+]);
+export const RunStatusListDto = t.Object({
+    status: t.Union([t.Array(RunStatusDto), RunStatusDto]),
+});

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

@@ -0,0 +1,88 @@
+import { apiDbClient } from "../../../utils/prisma";
+import moment from "moment";
+import { CampaignService } from "../campaign";
+export class StatusRepository {
+    static async findMany() {
+        return await apiDbClient.campaignStatus.findMany();
+    }
+    static async findManyByRunStatus(statuses) {
+        return await apiDbClient.campaignStatus.findMany({
+            where: {
+                status: {
+                    in: statuses,
+                },
+            },
+            include: {
+                Campaign: true,
+            },
+        });
+    }
+    static async findManyPerChain(chainId) {
+        return await apiDbClient.campaignStatus.findMany({
+            where: {
+                Campaign: {
+                    computeChainId: chainId,
+                },
+            },
+        });
+    }
+    static async findUniqueOrThrow(campaignUnique) {
+        return await apiDbClient.campaignStatus.findUniqueOrThrow({
+            where: {
+                campaignId: CampaignService.hashId(campaignUnique),
+            },
+        });
+    }
+    static async findUnique(campaignUnique) {
+        return await apiDbClient.campaignStatus.findUnique({
+            where: {
+                campaignId: CampaignService.hashId(campaignUnique),
+            },
+        });
+    }
+    static async create(campaign, startTimestamp) {
+        return await apiDbClient.campaignStatus.create({
+            data: {
+                campaignId: CampaignService.hashId(campaign),
+                computedUntil: startTimestamp,
+            },
+        });
+    }
+    static async updateSuccess(campaignUnique, computedUntil) {
+        return await apiDbClient.campaignStatus.update({
+            where: {
+                campaignId: CampaignService.hashId(campaignUnique),
+            },
+            data: {
+                computedUntil,
+                status: "SUCCESS",
+            },
+        });
+    }
+    static async updateWithError(campaignUnique, status, error, details) {
+        return await apiDbClient.campaignStatus.update({
+            where: {
+                campaignId: CampaignService.hashId(campaignUnique),
+            },
+            data: {
+                status,
+                error,
+                details,
+            },
+        });
+    }
+    static async updateProcessing(campaignUnique) {
+        return await apiDbClient.campaignStatus.update({
+            where: {
+                campaignId: CampaignService.hashId(campaignUnique),
+                status: {
+                    not: "PROCESSING", // To throw an error if the status is already PROCESSING
+                },
+            },
+            data: {
+                status: "PROCESSING",
+                processingStarted: moment().unix(),
+            },
+        });
+    }
+}

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

@@ -0,0 +1,60 @@
+import { RunStatus } from "../../../../database/api/.generated";
+import { MAX_COMPUTE_JOB_TIME } from "@sdk";
+import moment from "moment";
+import { CampaignService } from "../campaign";
+import { StatusRepository } from "./status.repository";
+export class StatusService {
+    static async findMany() {
+        return await StatusRepository.findMany();
+    }
+    static async findManyByRunStatus(x) {
+        return await StatusRepository.findManyByRunStatus(typeof x.status === "string" ? [x.status] : x.status);
+    }
+    static async findManyPerChain(chainId) {
+        return await StatusRepository.findManyPerChain(chainId);
+    }
+    static async findUniqueOrThrow(campaignUnique) {
+        return await StatusRepository.findUniqueOrThrow(campaignUnique);
+    }
+    static async findUnique(campaignUnique) {
+        return await StatusRepository.findUnique(campaignUnique);
+    }
+    static async update(x) {
+        // Check if the status exists already, otherwise create it
+        const campaignUnique = {
+            distributionChain: x.distributionChain,
+            campaignId: x.campaignId,
+        };
+        const campaignExists = await StatusRepository.findUnique(campaignUnique);
+        if (!campaignExists) {
+            let campaign = await CampaignService.findUnique(campaignUnique);
+            if (!campaign) {
+                await CampaignService.fill([campaignUnique]);
+                campaign = await CampaignService.findUniqueOrThrow(campaignUnique);
+            }
+            await StatusRepository.create(campaignUnique, campaign.startTimestamp);
+        }
+        // Update the run status
+        switch (x.status.value) {
+            case RunStatus.SUCCESS:
+                await StatusRepository.updateSuccess(campaignUnique, x.status.computedUntil);
+                return;
+            case RunStatus.PROCESSING:
+                await StatusRepository.updateProcessing(campaignUnique);
+                return;
+            case RunStatus.SKIPPED:
+                await StatusRepository.updateWithError(campaignUnique, x.status.value, x.status.error, x.status.details);
+                return;
+            case RunStatus.FAILED:
+                await StatusRepository.updateWithError(campaignUnique, x.status.value, x.status.error, x.status.details);
+                return;
+        }
+    }
+    static async isSafeForOverlaps(campaignUnique) {
+        const status = await StatusRepository.findUnique(campaignUnique);
+        if (!status) {
+            return true;
+        }
+        return status.status !== RunStatus.PROCESSING || status.processingStarted < moment().unix() - MAX_COMPUTE_JOB_TIME;
+    }
+}

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

@@ -0,0 +1,3 @@
+export * from "./token.service";
+export * from "./token.model";
+export * from "./token.controller";

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

@@ -0,0 +1,32 @@
+import { NotFoundError } from "../../../errors/NotFound.error";
+import Elysia from "elysia";
+import { FindUniqueTokenDto, GetTokenBalanceDto, GetTokenQueryDto } from "./token.model";
+import { TokenService } from "./token.service";
+// ─── Tokens Controller ───────────────────────────────────────────────────────
+export const TokenController = new Elysia({ prefix: "/tokens", detail: { tags: ["Tokens"] } })
+    // ─── Get A Token By Id ───────────────────────────────────────────────
+    .get("/:id", async ({ params }) => {
+    try {
+        const [chainId, address] = params.id.split("-");
+        return await TokenService.findUniqueOrThrow({ chainId: +chainId, address });
+    }
+    catch (err) {
+        if (err.code && err.code === "P2025")
+            throw new NotFoundError();
+    }
+}, { params: FindUniqueTokenDto })
+    // ─── Get Tokens With Balances ────────────────────────────────────────
+    .get("/balances", async ({ query: { chainId, userAddress, tokenAddress, additionalTokenAddresses } }) => {
+    if (tokenAddress)
+        return await TokenService.fetchTokensAndBalances(chainId, userAddress, [tokenAddress].concat(additionalTokenAddresses ?? []));
+    return await TokenService.fetchVerifiedBalances(chainId, userAddress, additionalTokenAddresses);
+}, {
+    query: GetTokenBalanceDto,
+})
+    // ─── Get Many Tokens ─────────────────────────────────────────────────
+    .get("/", async ({ query }) => {
+    return await TokenService.findMany(query);
+}, { query: GetTokenQueryDto })
+    .get("/count", async ({ query }) => {
+    return await TokenService.countMany(query);
+}, { query: GetTokenQueryDto });

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

@@ -0,0 +1,23 @@
+import { ChainId } from "@sdk";
+import { t } from "elysia";
+// ─── Dtos ────────────────────────────────────────────────────────────────────
+export const FindUniqueTokenDto = t.Object({
+    id: t.String(),
+});
+export const GetTokenQueryDto = t.Object({
+    symbol: t.Optional(t.String()),
+    chainId: t.Optional(t.Enum(ChainId)),
+    address: t.Optional(t.String()),
+    name: t.Optional(t.String()),
+    verified: t.Optional(t.Boolean()),
+});
+export const TokenDto = t.Object({
+    address: t.String(),
+    chainId: t.Numeric(),
+});
+export const GetTokenBalanceDto = t.Object({
+    chainId: t.Numeric(),
+    userAddress: t.String(),
+    tokenAddress: t.Optional(t.String({ description: "If provided, the default verified token balances won't be included" })),
+    additionalTokenAddresses: t.Optional(t.Array(t.String())),
+});

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

@@ -0,0 +1,128 @@
+import { getTokenInfo } from "../../../libs/tokens/tokenInfo";
+import { executeSimple } from "../../../utils/execute";
+import { apiDbClient } from "../../../utils/prisma";
+import { NETWORK_LABELS } from "@sdk";
+export class TokenRepository {
+    /**
+     * Fetch token metadata from onchain
+     * @param chainId
+     * @param address
+     * @returns
+     */
+    static async getTokenInfo(token) {
+        //TODO: replace with onchain module
+        const calls = getTokenInfo(token.address);
+        //TODO: replace with onchain module
+        return executeSimple(token.chainId, calls);
+    }
+    /**
+     * Read token from database
+     * @param chainId
+     * @param address
+     */
+    static async findUnique(id) {
+        return (await apiDbClient.token.findUnique({ where: { id } })) ?? undefined;
+    }
+    /**
+     * Read token from database
+     * @param chainId
+     * @param address
+     */
+    static async findUniqueOrThrow(id) {
+        return await apiDbClient.token.findUniqueOrThrow({ where: { id } });
+    }
+    static #transformQueryToPrismaFilters(query) {
+        return {
+            where: {
+                symbol: query.symbol ? { equals: query.symbol, mode: "insensitive" } : undefined,
+                address: query.address ? { equals: query.address, mode: "insensitive" } : undefined,
+                chainId: query.chainId ? { equals: query.chainId } : undefined,
+                name: query.name ? { contains: query.name, mode: "insensitive" } : undefined,
+                verified: query.verified ? { equals: query.verified } : undefined,
+            },
+        };
+    }
+    /**
+     * Read token from database by its symbol
+     * @param symbol
+     */
+    static async findMany(query) {
+        const args = TokenRepository.#transformQueryToPrismaFilters(query);
+        const tokens = await apiDbClient.token.findMany({
+            ...args,
+        });
+        return tokens;
+    }
+    static async countMany(query) {
+        const args = TokenRepository.#transformQueryToPrismaFilters(query);
+        return await apiDbClient.token.count(args);
+    }
+    /**
+     * upsert a token on database
+     * @param token
+     */
+    static async upsert(token) {
+        return await apiDbClient.token.upsert({
+            create: token,
+            update: token,
+            where: { id: token.id },
+        });
+    }
+    /**
+     * Updates price of tokens that share the same symbol
+     * @param symbol
+     * @param price value
+     * @param excludeAddresses to not update even if symbol match
+     */
+    static async updateSymbolPrices(symbol, price, excludeAddresses) {
+        return await apiDbClient.token.updateMany({
+            data: { price },
+            where: {
+                symbol,
+                address: { notIn: excludeAddresses },
+            },
+        });
+    }
+    /**
+     * Updates price of tokens that share the same address
+     * @param address
+     * @param price value
+     * @param chainId
+     */
+    static async updateAddressPrices(address, price, chainId) {
+        return await apiDbClient.token.updateMany({
+            data: { price },
+            where: {
+                chainId: chainId && { equals: chainId },
+                address: { equals: address, mode: "insensitive" },
+            },
+        });
+    }
+    static async findChains() {
+        const tokens = await apiDbClient.token.findMany({
+            select: { chainId: true, id: true },
+        });
+        return tokens.reduce((acc, token) => {
+            acc[token.id] = token.chainId;
+            return acc;
+        }, {});
+    }
+    /**
+     * create a token on database
+     * @param token
+     */
+    static async create(token) {
+        return await apiDbClient.token.create({
+            data: {
+                ...token,
+                chainId: undefined,
+                Chain: {
+                    connectOrCreate: {
+                        where: { id: token.chainId },
+                        create: { id: token.chainId, name: NETWORK_LABELS[token.chainId], icon: "" },
+                    },
+                },
+            },
+        });
+    }
+}