@merkl/api 0.10.129 → 0.10.130

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

@@ -0,0 +1,24 @@
+import { ExplorerRepository } from "./explorer.repository";
+export class ExplorerService {
+    static hashId(type, chainId) {
+        return Bun.hash(`${type}${chainId}`).toString();
+    }
+    static async getByChainId(chainId) {
+        return await ExplorerRepository.getByChainId(chainId);
+    }
+    static format(explorer) {
+        const { id, ...rest } = explorer;
+        return {
+            ...rest,
+        };
+    }
+    /**
+     * Creates an explorer
+     * @param chainId to attach explorer to
+     * @param type that defines the subsequents links for transactions, addresses...
+     * @param url base url without / suffix
+     */
+    static async create(chainId, type, url) {
+        return await ExplorerRepository.create(chainId, type, url);
+    }
+}

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

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

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

@@ -0,0 +1,4 @@
+export * from "./opportunity";
+export * from "./campaign";
+export * from "./token";
+export * from "./apr";

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

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

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

@@ -0,0 +1,19 @@
+import { throwOnUnsupportedChainId } from "../../../utils/throw";
+import Elysia from "elysia";
+import { RootByTimestampsDto } from "./merklRoot.model";
+import { MerklRootService } from "./merklRoot.service";
+// ─── Merkl Roots Controller ──────────────────────────────────────────────────
+export const MerklRootController = new Elysia({ prefix: "/roots", detail: { tags: ["Roots"] } })
+    // ─── Get Merkl Root By Timestamp ─────────────────────────────────────
+    .get("/timestamps", async ({ query }) => {
+    return await MerklRootService.rootForTimestamp(query);
+}, {
+    query: RootByTimestampsDto,
+    beforeHandle: async ({ query }) => {
+        throwOnUnsupportedChainId(query.chainId);
+    },
+})
+    // ─── Get all live Merkl Roots ─────────────────────────────────────────
+    .get("/", async () => {
+    return await MerklRootService.fetchAll();
+});

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

@@ -0,0 +1,6 @@
+import { t } from "elysia";
+export const RootByTimestampsDto = t.Object({
+    chainId: t.Numeric(),
+    fromTimestamp: t.String(),
+    toTimestamp: t.String(),
+});

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

@@ -0,0 +1,31 @@
+import { apiDbClient } from "../../../utils/prisma";
+import { DistributorService } from "@sdk";
+export class MerklRootRepository {
+    static async firstRoot(chainId) {
+        return await apiDbClient.merklRoot.findFirst({
+            where: { chainId },
+            orderBy: { timestamp: "desc" },
+        });
+    }
+    static async rootForTimestamp(x) {
+        const res = await apiDbClient.$transaction([
+            apiDbClient.merklRoot.findFirst({
+                where: { chainId: x.chainId, timestamp: { lte: BigInt(x.toTimestamp) } },
+                orderBy: { timestamp: "desc" },
+            }),
+            apiDbClient.merklRoot.findFirst({
+                where: { chainId: x.chainId, timestamp: { lte: BigInt(x.fromTimestamp) } },
+                orderBy: { timestamp: "desc" },
+            }),
+        ]);
+        if (!res[0] || !res[1]) {
+            throw new Error("Root not found");
+        }
+        return [res[0], res[1]];
+    }
+    static async fetch(chainId) {
+        const live = await DistributorService(chainId).fetchLiveMerklRoot();
+        const [tree, lastTree] = await DistributorService(chainId).fetchTreeAndLastTreeMerklRoots();
+        return { live, tree, lastTree };
+    }
+}

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

@@ -0,0 +1,38 @@
+import { CacheService } from "../cache";
+import { TTLPresets } from "../cache/cache.model";
+import { ChainService } from "../chain";
+import { MerklRootRepository } from "./merklRoot.repository";
+export class MerklRootService {
+    static async firstRoot(chainId) {
+        return await MerklRootRepository.firstRoot(chainId);
+    }
+    static async rootForTimestamp(x) {
+        return await MerklRootRepository.rootForTimestamp(x);
+    }
+    /**
+     * Fetch roots for the provided chain
+     * @param chainId to fetch roots for
+     * @returns object with live and last tree roots
+     */
+    static async fetch(chainId) {
+        return await CacheService.wrap(TTLPresets.MIN_1, MerklRootRepository.fetch, chainId);
+    }
+    /**
+     * Fetch all roots for the provided chains
+     * @param chainIds to fetch roots for
+     * @returns record of chains to object with live and last tree roots
+     */
+    static async fetchAll(chainIds) {
+        return await CacheService.wrap(TTLPresets.MIN_1, async () => {
+            let ids = chainIds ?? (await ChainService.getIds());
+            /** Fetch current Merkle Roots */
+            const merkleRootsPromises = await Promise.allSettled(ids.map(chainId => MerklRootService.fetch(chainId)));
+            /** Filter out unsuccessful chainIds */
+            ids = ids.filter((_, index) => merkleRootsPromises[index].status === "fulfilled");
+            const roots = merkleRootsPromises
+                .filter(({ status }) => status === "fulfilled")
+                .map(x => x.value);
+            return roots;
+        });
+    }
+}

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

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

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

@@ -0,0 +1,69 @@
+import { NotFoundError } from "../../../errors";
+import { AuthorizationHeadersDto, TokenAuthGuard } from "../../../guards/TokenAuth.guard";
+import Elysia from "elysia";
+import { CreateOpportunityDto, GetOpportunitiesQueryDto, OpportunityUniqueDto } from "./opportunity.model";
+import { OpportunityService } from "./opportunity.service";
+import { transformId } from "./transform-id.pipe";
+import { validateId } from "./validate-id.pipe";
+// ─── Opportunities Controller ────────────────────────────────────────────────
+export const OpportunityController = new Elysia({ prefix: "/opportunities", detail: { tags: ["Opportunities"] } })
+    // ─── Create An Opportunity ───────────────────────────────────────────
+    .post("/", async ({ body }) => {
+    return await OpportunityService.create(body);
+}, {
+    beforeHandle: TokenAuthGuard,
+    headers: AuthorizationHeadersDto,
+    body: CreateOpportunityDto,
+})
+    // ─── Get An Opportunity By Id ────────────────────────────────────────
+    .get("/:id", async ({ params }) => {
+    try {
+        if (!params.id.includes("-"))
+            return await OpportunityService.getUniqueOrThrow(params.id);
+        const [chainId, type, identifier] = params.id.split("-");
+        return await OpportunityService.getUniqueOrThrow({
+            chainId: +chainId,
+            type: type,
+            identifier,
+        });
+    }
+    catch (err) {
+        if (err.code && err.code === "P2025")
+            throw new NotFoundError();
+    }
+}, {
+    params: OpportunityUniqueDto,
+    transform: transformId,
+    beforeHandle: validateId,
+})
+    // ─── Get An Opportunity By Id With Related Campaigns ─────────────────
+    .get("/:id/campaigns", async ({ params }) => {
+    try {
+        if (!params.id.includes("-"))
+            return await OpportunityService.getUniqueWithCampaignsOrThrow(params.id);
+        const [chainId, type, identifier] = params.id.split("-");
+        return await OpportunityService.getUniqueWithCampaignsOrThrow({
+            chainId: +chainId,
+            type: type,
+            identifier,
+        });
+    }
+    catch (err) {
+        if (err.code && err.code === "P2025")
+            throw new NotFoundError();
+    }
+}, {
+    params: OpportunityUniqueDto,
+    transform: transformId,
+    beforeHandle: validateId,
+})
+    // ─── Get All Opportunities ───────────────────────────────────────────
+    .get("/", async ({ query }) => {
+    return await OpportunityService.getMany(query);
+}, {
+    query: GetOpportunitiesQueryDto,
+})
+    // ─── Get Opportunities Count ─────────────────────────────────────────
+    .get("/count", async ({ query }) => {
+    return await OpportunityService.countMany(query);
+}, { query: GetOpportunitiesQueryDto });

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

@@ -0,0 +1,36 @@
+import { TokenDto } from "../token/token.model";
+import { CampaignType, OpportunityAction, Status } from "../../../../database/api/.generated";
+import { t } from "elysia";
+// ─── DTOs ────────────────────────────────────────────────────────────────────
+export const OpportunityUniqueDto = t.Object({
+    id: t.String({
+        pattern: "(([0-9]*)-([0-9A-Z]*)-(0x([0-9A-Za-z])*))|([0-9]{1,20})",
+        default: undefined,
+    }),
+});
+export const GetOpportunitiesQueryDto = t.Object({
+    name: t.Optional(t.String()),
+    //TODO: find a systemic way of handling query param arrays
+    chainId: t.Optional(t.RegExp(/^\d+(,\d+)*$/)),
+    //TODO: find a systemic way of handling query param arrays
+    action: t.Optional(t.Union([t.Enum(OpportunityAction), t.RegExp(/^(POOL|HOLD|DROP|LEND|BORROW)+(,(POOL|HOLD|DROP|LEND|BORROW)+)*$/)])),
+    tags: t.Optional(t.String()),
+    tokens: t.Optional(t.String({ title: "Symbol" })),
+    status: t.Optional(t.Union([t.Enum(Status), t.RegExp(/^(LIVE|PAST|SOON)+(,(LIVE|PAST|SOON)+)*$/)])),
+    sort: t.Optional(t.Union(["apr", "tvl", "rewards"].map(v => t.Literal(v)))),
+    order: t.Optional(t.Union(["desc", "asc"].map(v => t.Literal(v)))),
+    mainProtocolId: t.Optional(t.String()),
+    page: t.Optional(t.Numeric()), // 0-indexed
+    items: t.Optional(t.Numeric()), // items per page
+});
+export const CreateOpportunityDto = t.Object({
+    chainId: t.Number(),
+    type: t.Enum(CampaignType),
+    identifier: t.String(),
+    name: t.Optional(t.String()),
+    status: t.Enum(Status),
+    action: t.Enum(OpportunityAction),
+    tokens: t.Array(TokenDto),
+    protocols: t.Array(t.String()),
+    mainProtocol: t.String(),
+});

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

@@ -462,4 +462,18 @@ export declare abstract class OpportunityRepository {
         apr: number;
         dailyRewards: number;
     }>;
+    static updateApr(id: string, apr: number): Promise<{
+        name: string;
+        type: import("../../../../database/api/.generated").$Enums.CampaignType;
+        id: string;
+        status: import("../../../../database/api/.generated").$Enums.Status;
+        tags: string[];
+        identifier: string;
+        chainId: number;
+        action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
+        mainProtocolId: string | null;
+        tvl: number;
+        apr: number;
+        dailyRewards: number;
+    }>;
 }

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

@@ -0,0 +1,217 @@
+import { apiDbClient } from "../../../utils/prisma";
+import { AprService } from "../apr";
+import { RewardService } from "../reward";
+import { TvlService } from "../tvl";
+export class OpportunityRepository {
+    static #getRecordInclusion() {
+        return {
+            AprRecords: {
+                take: 1,
+                orderBy: { timestamp: "desc" },
+                include: { AprBreakdown: true },
+            },
+            TvlRecords: {
+                take: 1,
+                orderBy: { timestamp: "desc" },
+                include: { TvlBreakdown: true },
+            },
+            DailyRewardsRecords: {
+                take: 1,
+                orderBy: { timestamp: "desc" },
+                include: {
+                    DailyRewardsBreakdown: {
+                        include: {
+                            Campaign: { select: { startTimestamp: true, endTimestamp: true, amount: true, RewardToken: true } },
+                        },
+                    },
+                },
+            },
+        };
+    }
+    static async create(newOpp) {
+        await apiDbClient.opportunity.create({
+            data: {
+                id: newOpp.id,
+                action: newOpp.action,
+                identifier: newOpp.identifier,
+                name: newOpp.name,
+                status: newOpp.status,
+                type: newOpp.type,
+                Chain: { connect: { id: newOpp.chainId } },
+                MainProtocol: { connect: { id: newOpp.mainProtocol } },
+                Protocols: {
+                    connect: newOpp.protocols.map((protocol) => {
+                        return { id: protocol };
+                    }),
+                },
+                Tokens: {
+                    connect: newOpp.tokens.map((token) => {
+                        return {
+                            chainId_address: {
+                                chainId: token.chainId,
+                                address: token.address,
+                            },
+                        };
+                    }),
+                },
+            },
+        });
+    }
+    static async findUniqueOrThrow(id) {
+        return await apiDbClient.opportunity.findUniqueOrThrow({
+            include: {
+                ...OpportunityRepository.#getRecordInclusion(),
+                Chain: true,
+                MainProtocol: true,
+                Protocols: true,
+                Tokens: true,
+            },
+            where: { id },
+        });
+    }
+    static async findUniqueOrThrowWithCampaigns(id) {
+        return await apiDbClient.opportunity.findUniqueOrThrow({
+            include: {
+                ...OpportunityRepository.#getRecordInclusion(),
+                Chain: true,
+                Campaigns: {
+                    include: {
+                        RewardToken: true,
+                        ComputeChain: true,
+                        DistributionChain: true,
+                    },
+                    orderBy: {
+                        endTimestamp: "desc",
+                    },
+                },
+                MainProtocol: true,
+                Protocols: true,
+                Tokens: true,
+            },
+            where: { id },
+        });
+    }
+    static async findManyWithCampaigns(filters) {
+        return await apiDbClient.opportunity.findMany({ ...filters, include: { Campaigns: true } });
+    }
+    static #transformQueryToPrismaFilters(query) {
+        const { page: _page, items: _items, ...filters } = query;
+        //TODO: abstract away query to not be strictly equal to controller
+        const chainIds = query.chainId?.split(",").map(n => Number.parseInt(n));
+        const actions = query.action?.split(",");
+        const status = query.status?.split(",");
+        const tokens = query.tokens?.split(",");
+        const sort = (query.sort === "rewards" ? "dailyRewards" : query.sort) ?? "dailyRewards";
+        const order = query.order ?? "desc";
+        const noFilters = Object.values(filters).every(v => v === undefined);
+        const tokensFilters = tokens?.map(symbol => ({
+            Tokens: { some: { symbol: { equals: symbol, mode: "insensitive" } } },
+        }));
+        const orderBy = {
+            [sort]: order,
+        };
+        return {
+            orderBy,
+            where: noFilters
+                ? { OR: tokensFilters }
+                : {
+                    AND: [
+                        ...(tokensFilters ?? []),
+                        { tags: !filters.tags ? undefined : { has: filters.tags } },
+                        { chainId: !chainIds ? undefined : { in: chainIds } },
+                        { name: !filters.name ? undefined : { contains: filters.name, mode: "insensitive" } },
+                        {
+                            action: !actions ? undefined : { in: actions },
+                        },
+                        {
+                            status: !status ? undefined : { in: status },
+                        },
+                        { mainProtocolId: !filters.mainProtocolId ? undefined : { equals: filters.mainProtocolId } },
+                    ],
+                },
+        };
+    }
+    static async findMany(query) {
+        // pagination by offset; might have to change to cursor based for performance
+        const { page: _page, items: _items } = query;
+        const page = _page ? _page : 0;
+        const items = _items ? _items : 20;
+        const args = OpportunityRepository.#transformQueryToPrismaFilters(query);
+        return await apiDbClient.opportunity.findMany({
+            take: items,
+            skip: page * items,
+            include: {
+                ...OpportunityRepository.#getRecordInclusion(),
+                MainProtocol: true,
+                Chain: true,
+                Protocols: true,
+                Tokens: true,
+            },
+            ...args,
+        });
+    }
+    static async countMany(query) {
+        const args = OpportunityRepository.#transformQueryToPrismaFilters(query);
+        return await apiDbClient.opportunity.count(args);
+    }
+    static async getAllIdsForDynamicOpp() {
+        return await apiDbClient.opportunity.findMany({
+            where: { type: { notIn: ["ERC20_SNAPSHOT", "JSON_AIRDROP"] } },
+            select: { id: true },
+        });
+    }
+    /**
+     * Updates Apr, Tvl and DailyRewards record
+     * @param opportunityId
+     * @param apr
+     * @param tvl
+     * @returns
+     */
+    static async updateRecords(opportunityId, apr, tvl, dailyRewards) {
+        const aprRecord = await apiDbClient.aprRecord.create({
+            data: {
+                id: AprService.hashId(opportunityId, apr.timestamp),
+                timestamp: apr.timestamp,
+                cumulated: apr.cumulated,
+                Opportunity: { connect: { id: opportunityId } },
+                AprBreakdown: { createMany: { data: apr.breakdowns } },
+            },
+        });
+        const tvlRecord = await apiDbClient.tVLRecord.create({
+            data: {
+                id: TvlService.hashId(opportunityId, tvl.timestamp),
+                timestamp: tvl.timestamp,
+                Opportunity: { connect: { id: opportunityId } },
+                total: tvl.total,
+                TvlBreakdown: { createMany: { data: tvl.breakdowns } },
+            },
+            include: { TvlBreakdown: true },
+        });
+        const dailyRewardsRecord = await apiDbClient.dailyRewardsRecord.create({
+            data: {
+                id: RewardService.hashDailyRewardsRecordId(opportunityId, dailyRewards.timestamp),
+                timestamp: dailyRewards.timestamp,
+                Opportunity: { connect: { id: opportunityId } },
+                total: dailyRewards.total,
+                DailyRewardsBreakdown: { createMany: { data: dailyRewards.breakdowns } },
+            },
+            include: { DailyRewardsBreakdown: true },
+        });
+        const opportunity = await apiDbClient.opportunity.update({
+            where: { id: opportunityId },
+            data: { apr: apr.cumulated, tvl: tvl.total, dailyRewards: dailyRewards.total },
+        });
+        return {
+            aprRecord,
+            tvlRecord,
+            dailyRewardsRecord,
+            opportunity,
+        };
+    }
+    static async updateStatus(id, status) {
+        return await apiDbClient.opportunity.update({ where: { id }, data: { status } });
+    }
+    static async updateApr(id, apr) {
+        return await apiDbClient.opportunity.update({ where: { id }, data: { apr } });
+    }
+}

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

@@ -1,5 +1,4 @@
 import { type CreateCampaignModel } from "../campaign";
-import { type Status } from "../../../../database/api/.generated";
 import type { ChainId } from "@sdk";
 import type { CreateOpportunityModel, GetOpportunitiesQueryEntity, LightOpportunityFromDB, OpportunityMetadata, OpportunityUnique } from "./opportunity.model";
 import { OpportunityRepository } from "./opportunity.repository";
@@ -18,20 +17,6 @@ export declare abstract class OpportunityService {
      */
     static getMetadata(campaign: CreateCampaignModel): Promise<OpportunityMetadata>;
     static updateMetadata(chain: ChainId): Promise<void>;
-    static updateStatus(opportunityId: string, newStatus: Status): Promise<{
-        name: string;
-        type: import("../../../../database/api/.generated").$Enums.CampaignType;
-        id: string;
-        status: import("../../../../database/api/.generated").$Enums.Status;
-        tags: string[];
-        identifier: string;
-        chainId: number;
-        action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
-        mainProtocolId: string | null;
-        tvl: number;
-        apr: number;
-        dailyRewards: number;
-    }>;
     static getUniqueWithCampaignsOrThrow(opportunityId: string | OpportunityUnique): Promise<({
         aprRecord: {
             cumulated: number;