@merkl/api 0.9.15

package/dist/src/modules/v4/liquidity/implementations/EulerPositionFetcher.js

@@ -0,0 +1,40 @@
+import { BN2Number, Campaign, ChainInteractionService, ERC20Interface } from "@sdk";
+const campaignType = Campaign.EULER;
+export class EulerPositionFetcher {
+    fetchPositions = async (chainId, user, opportunities) => {
+        opportunities = opportunities.filter(o => o.type === Campaign[campaignType] && o.tokens?.length > 0 && o.chainId === chainId);
+        const calls = [];
+        for (const opportunity of opportunities) {
+            // Call per opportunity
+            for (const token of opportunity.tokens) {
+                calls.push({
+                    allowFailure: true,
+                    callData: ERC20Interface.encodeFunctionData("balanceOf", [user]),
+                    target: token.address,
+                });
+            }
+        }
+        const res = await ChainInteractionService(chainId).fetchState(calls);
+        const result = [];
+        for (const [index, opportunity] of opportunities.entries()) {
+            // Decoding calls per opportunity
+            for (const [subIndex, token] of opportunity.tokens.entries()) {
+                const balance = ERC20Interface.decodeFunctionResult("balanceOf", res[index + subIndex].returnData)[0].toString();
+                if (BigInt(balance) > 0n) {
+                    const position = {
+                        flags: {},
+                        opportunity,
+                        tokens: [
+                            {
+                                token,
+                                breakdown: [{ type: "balance", value: BN2Number(balance, token.decimals) }],
+                            },
+                        ],
+                    };
+                    result.push(position);
+                }
+            }
+        }
+        return result;
+    };
+}

package/dist/src/modules/v4/liquidity/liquidity.controller.d.ts

@@ -0,0 +1,39 @@
+import { Elysia } from "elysia";
+export declare const LiquidityController: Elysia<"/liquidity", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    liquidity: {
+        index: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    address: string;
+                    chainId: number;
+                };
+                headers: unknown;
+                response: {
+                    200: import("./liquidity.model").PositionT[];
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

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

@@ -0,0 +1,16 @@
+import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "@/utils/throw";
+import { Elysia } from "elysia";
+import { PositionsInputDto } from "./liquidity.model";
+import { LiquidityService } from "./liquidity.service";
+// ─── Positions Controller ──────────────────────────────────────────────
+export const LiquidityController = new Elysia({ prefix: "/liquidity", detail: { tags: ["Positions"], hide: true } })
+    // ─── Get User Positions on a Chain ───────────────────────────────────
+    .get("/", async ({ query }) => {
+    return await LiquidityService.fetchPositions(query);
+}, {
+    query: PositionsInputDto,
+    beforeHandle: ({ query }) => {
+        throwOnUnsupportedChainId(query.chainId);
+        query.address = throwOnInvalidRequiredAddress(query.address);
+    },
+});

package/dist/src/modules/v4/liquidity/liquidity.model.d.ts

@@ -0,0 +1,25 @@
+import type { MerklChainId } from "@sdk";
+import type { Opportunity } from "../opportunity";
+export type PositionT = {
+    flags: {
+        range?: string;
+        id?: string;
+        link?: string;
+    };
+    opportunity: Opportunity["model"];
+    tokens: {
+        token: Opportunity["model"]["tokens"][0];
+        breakdown: {
+            type: string;
+            value: number;
+        }[];
+    }[];
+};
+export interface PositionFetcher {
+    fetchPositions(chainId: MerklChainId, user: string, opportunity: Opportunity["model"][]): Promise<PositionT[]>;
+}
+export declare const PositionsInputDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    address: import("@sinclair/typebox").TString;
+}>;
+export type PositionsInputModel = typeof PositionsInputDto.static;

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

@@ -0,0 +1,5 @@
+import { t } from "elysia";
+export const PositionsInputDto = t.Object({
+    chainId: t.Numeric(),
+    address: t.String(),
+});

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

@@ -0,0 +1,14 @@
+import type { MerklChainId } from "@sdk";
+export declare class LiquidityRepository {
+    static findManyDolomitePositions(chainId: MerklChainId, user: string): Promise<{
+        balance: string;
+        token: {
+            id: string;
+            marketId: string;
+            symbol: string;
+            decimals: string;
+            borrowLiquidity: string;
+            supplyLiquidity: string;
+        };
+    }[]>;
+}

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

@@ -0,0 +1,6 @@
+import axios from "axios";
+export class LiquidityRepository {
+    static async findManyDolomitePositions(chainId, user) {
+        return (await axios.get(`https://api.dolomite.io/balances/${chainId}/users/${user}`)).data.Result;
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { PositionT, PositionsInputModel } from "./liquidity.model";
+export declare class LiquidityService {
+    #private;
+    static fetchPositions(query: PositionsInputModel): Promise<PositionT[]>;
+}

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

@@ -0,0 +1,34 @@
+import { MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT } from "@/constants";
+import { Campaign, withTimeout } from "@sdk";
+import { OpportunityService } from "../opportunity";
+import { AjnaPositionFetcher } from "./implementations/AjnaPositionFetcher";
+import { BadgerPositionFetcher } from "./implementations/BadgerPositionFetcher";
+import { ClammPositionFetcher } from "./implementations/ClammPositionFetcher";
+import { DolomitePositionFetcher } from "./implementations/DolomitePositionFetcher";
+import { ERC20PositionFetcher } from "./implementations/ERC20PositionFetcher";
+import { EulerPositionFetcher } from "./implementations/EulerPositionFetcher";
+export class LiquidityService {
+    static #fetchers = {
+        [Campaign.ERC20]: new ERC20PositionFetcher(),
+        [Campaign.EULER]: new EulerPositionFetcher(),
+        [Campaign.AJNA]: new AjnaPositionFetcher(),
+        [Campaign.BADGER]: new BadgerPositionFetcher(),
+        [Campaign.CLAMM]: new ClammPositionFetcher(),
+        [Campaign.DOLOMITE]: new DolomitePositionFetcher(),
+    };
+    static async fetchPositions(query) {
+        const opportunities = await OpportunityService.findLiveWithCampaigns(query.chainId, 1);
+        const promises = [];
+        for (const campaignType of Object.keys(Campaign)) {
+            const fetcher = LiquidityService.#fetchers[Number.parseInt(campaignType)];
+            if (fetcher) {
+                promises.push(withTimeout(fetcher.fetchPositions(query.chainId, query.address, opportunities.filter(o => !!o)), MERKL_USER_POSITION_FETCHING_GLOBAL_TIMEOUT));
+            }
+        }
+        const settledPromises = await Promise.allSettled(promises);
+        for (const errors of settledPromises.filter(p => p.status === "rejected")) {
+            console.error(errors.reason);
+        }
+        return settledPromises.filter(p => p.status === "fulfilled").flatMap(p => p.value);
+    }
+}

package/dist/src/modules/v4/merklRoot/index.d.ts

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

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

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

package/dist/src/modules/v4/merklRoot/merklRoot.controller.d.ts

@@ -0,0 +1,93 @@
+import Elysia from "elysia";
+export declare const MerklRootController: Elysia<"/roots", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    roots: {
+        index: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    chainId: number;
+                    fromTimestamp: string;
+                    toTimestamp: string;
+                };
+                headers: unknown;
+                response: {
+                    200: {
+                        chainId: number;
+                        timestamp: bigint;
+                        root: string;
+                        epoch: number;
+                    }[];
+                };
+            };
+        };
+    };
+} & {
+    roots: {
+        live: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: {
+                        [x: number]: {
+                            live: string;
+                            tree: string;
+                            lastTree: string;
+                            endOfDisputePeriod: number;
+                            disputer: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+} & {
+    roots: {
+        engine: {
+            post: {
+                body: {
+                    chainId: number;
+                    timestamp: number;
+                    root: string;
+                    epoch: number;
+                };
+                params: {};
+                query: unknown;
+                headers: {
+                    authorization: string;
+                };
+                response: {
+                    200: {
+                        chainId: number;
+                        timestamp: bigint;
+                        root: string;
+                        epoch: number;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

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

@@ -0,0 +1,31 @@
+import { AuthorizationHeadersDto, EngineGuard } from "@/guards/Engine.guard";
+import { throwOnUnsupportedChainId } from "@/utils/throw";
+import Elysia from "elysia";
+import { CreateRootDto, 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("/", async ({ query }) => await MerklRootService.rootForTimestamp(query), {
+    query: RootByTimestampsDto,
+    beforeHandle: async ({ query }) => {
+        throwOnUnsupportedChainId(query.chainId);
+    },
+    detail: {
+        description: "Returns the last merkl roots recorded before the provided timestamps",
+    },
+})
+    // ─── Get all live Merkl Roots ─────────────────────────────────────────
+    .get("/live", async () => await MerklRootService.fetchAll())
+    // ─── Create a Merkl Root Entry ────────────────────────────────────────
+    .post("/engine", async ({ body }) => {
+    return await MerklRootService.create(body);
+}, {
+    headers: AuthorizationHeadersDto,
+    body: CreateRootDto,
+    beforeHandle: ({ headers, body }) => {
+        EngineGuard({ headers });
+        throwOnUnsupportedChainId(body.chainId);
+    },
+    detail: { hide: true },
+});

package/dist/src/modules/v4/merklRoot/merklRoot.model.d.ts

@@ -0,0 +1,13 @@
+export declare const RootByTimestampsDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    fromTimestamp: import("@sinclair/typebox").TString;
+    toTimestamp: import("@sinclair/typebox").TString;
+}>;
+export declare const CreateRootDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    root: import("@sinclair/typebox").TString;
+    timestamp: import("@sinclair/typebox").TNumber;
+    epoch: import("@sinclair/typebox").TNumber;
+}>;
+export type RootByTimestampModel = typeof RootByTimestampsDto.static;
+export type CreateRootModel = typeof CreateRootDto.static;

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

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

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

@@ -0,0 +1,29 @@
+import { type ChainId } from "@sdk";
+import type { CreateRootModel, RootByTimestampModel } from "./merklRoot.model";
+export declare class MerklRootRepository {
+    static firstRoot(chainId: ChainId): Promise<{
+        chainId: number;
+        timestamp: bigint;
+        root: string;
+        epoch: number;
+    } | null>;
+    static rootForTimestamp(x: RootByTimestampModel): Promise<{
+        chainId: number;
+        timestamp: bigint;
+        root: string;
+        epoch: number;
+    }[]>;
+    static fetch(chainId: ChainId): Promise<{
+        live: any;
+        tree: any;
+        lastTree: any;
+        endOfDisputePeriod: any;
+        disputer: any;
+    }>;
+    static create(x: CreateRootModel): Promise<{
+        chainId: number;
+        timestamp: bigint;
+        root: string;
+        epoch: number;
+    }>;
+}

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

@@ -0,0 +1,35 @@
+import { apiDbClient } from "@db";
+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, tree, lastTree, endOfDisputePeriod, disputer } = await DistributorService(chainId).fetchUpdateData();
+        return { live, tree, lastTree, endOfDisputePeriod, disputer };
+    }
+    static async create(x) {
+        return await apiDbClient.merklRoot.create({
+            data: x,
+        });
+    }
+}

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

@@ -0,0 +1,46 @@
+import type { ChainId } from "@sdk";
+import type { CreateRootModel, RootByTimestampModel } from "./merklRoot.model";
+export declare class MerklRootService {
+    static firstRoot(chainId: ChainId): Promise<{
+        chainId: number;
+        timestamp: bigint;
+        root: string;
+        epoch: number;
+    } | null>;
+    static rootForTimestamp(x: RootByTimestampModel): Promise<{
+        chainId: number;
+        timestamp: bigint;
+        root: string;
+        epoch: number;
+    }[]>;
+    /**
+     * Fetch roots for the provided chain
+     * @param chainId to fetch roots for
+     * @returns object with live and last tree roots
+     */
+    static fetch(chainId: ChainId): Promise<{
+        live: any;
+        tree: any;
+        lastTree: any;
+        endOfDisputePeriod: any;
+        disputer: any;
+    }>;
+    /**
+     * 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 fetchAll(chainIds?: ChainId[]): Promise<Record<number, {
+        live: string;
+        tree: string;
+        lastTree: string;
+        endOfDisputePeriod: number;
+        disputer: string;
+    }>>;
+    static create(x: CreateRootModel): Promise<{
+        chainId: number;
+        timestamp: bigint;
+        root: string;
+        epoch: number;
+    }>;
+}

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

@@ -0,0 +1,44 @@
+import { CacheService } from "../cache";
+import { TTLPresets } from "../cache/cache.model";
+import { ChainService } from "../chain/chain.service";
+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")
+                .reduce((acc, promise, index) => {
+                acc[ids[index]] = promise.value;
+                return acc;
+            }, {});
+            return roots;
+        });
+    }
+    static async create(x) {
+        return await MerklRootRepository.create(x);
+    }
+}

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

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

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

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