@merkl/api 0.10.129 → 0.10.131

package/dist/src/errors/BadRequest.error.js

@@ -0,0 +1,7 @@
+import { HttpError } from "./HttpError";
+export class BadRequestError extends HttpError {
+    constructor(message = "Bad Request", legalValues) {
+        super(message, 400, { legalValues });
+        this.name = "BadRequestError";
+    }
+}

package/dist/src/errors/Conflict.error.js

@@ -0,0 +1,7 @@
+import { HttpError } from "./HttpError";
+export class ConflictError extends HttpError {
+    constructor(message = "Conflict") {
+        super(message, 409);
+        this.name = "ConflictError";
+    }
+}

package/dist/src/errors/HttpError.js

@@ -0,0 +1,11 @@
+export class HttpError extends Error {
+    code;
+    httpCode;
+    info;
+    constructor(message = "Internal Server Error", httpCode = 500, info) {
+        super(message);
+        this.code = "HttpError";
+        this.httpCode = httpCode;
+        this.info = info;
+    }
+}

package/dist/src/errors/NotFound.error.js

@@ -0,0 +1,7 @@
+import { HttpError } from "./HttpError";
+export class NotFoundError extends HttpError {
+    constructor(message = "Not Found") {
+        super(message, 404);
+        this.name = "NotFoundError";
+    }
+}

package/dist/src/errors/Opportunity.error.js

@@ -0,0 +1,11 @@
+export class OpportunityError extends Error {
+    code;
+    httpCode;
+    info;
+    constructor(message, name, info) {
+        super(message);
+        this.code = "OpportunityError";
+        this.name = name;
+        this.info = info;
+    }
+}

package/dist/src/errors/Unauthorized.error.js

@@ -0,0 +1,7 @@
+import { HttpError } from "./HttpError";
+export class UnauthorizedError extends HttpError {
+    constructor(message = "Unauthorized") {
+        super(message, 401);
+        this.name = "UnauthorizedError";
+    }
+}

package/dist/src/errors/index.js

@@ -0,0 +1,5 @@
+export * from "./HttpError";
+export * from "./Unauthorized.error";
+export * from "./NotFound.error";
+export * from "./BadRequest.error";
+export * from "./Conflict.error";

package/dist/src/guards/BackOffice.guard.js

@@ -0,0 +1,10 @@
+import { UnauthorizedError } from "../errors";
+import { t } from "elysia";
+export const AuthorizationHeadersDto = t.Object({
+    authorization: t.String(),
+});
+export async function BackOfficeGuard({ headers }) {
+    if (headers.authorization !== `Bearer ${process.env.BACKOFFICE_SECRET}`) {
+        throw new UnauthorizedError();
+    }
+}

package/dist/src/guards/Engine.guard.js

@@ -0,0 +1,10 @@
+import { UnauthorizedError } from "../errors";
+import { t } from "elysia";
+export const AuthorizationHeadersDto = t.Object({
+    authorization: t.String(),
+});
+export async function EngineGuard({ headers }) {
+    if (headers.authorization !== `Bearer ${process.env.ENGINE_SECRET}`) {
+        throw new UnauthorizedError();
+    }
+}

package/dist/src/guards/TokenAuth.guard.js

@@ -0,0 +1,10 @@
+import { UnauthorizedError } from "../errors";
+import { t } from "elysia";
+export const AuthorizationHeadersDto = t.Object({
+    authorization: t.String(),
+});
+export async function TokenAuthGuard({ headers }) {
+    if (headers.authorization !== `Bearer ${process.env.API_SECRET}`) {
+        throw new UnauthorizedError();
+    }
+}

package/dist/src/hooks/checkQueryAddressValidity.js

@@ -0,0 +1,7 @@
+import { throwOnInvalidAddress } from "../utils/throw";
+export default function checkQueryAddressValidity(queryKey = "user") {
+    return (app) => app.onBeforeHandle(({ query }) => {
+        const address = query?.[queryKey];
+        query[queryKey] = throwOnInvalidAddress(address ?? "");
+    });
+}

package/dist/src/hooks/checkQueryChainIdValidity.js

@@ -0,0 +1,7 @@
+import { throwOnUnsupportedChainId } from "../utils/throw";
+export default function checkQueryChainIdValidity(queryKey = "chainId") {
+    return (app) => app.onBeforeHandle(({ query }) => {
+        const chainId = query?.[queryKey];
+        chainId !== undefined && throwOnUnsupportedChainId(chainId);
+    });
+}

package/dist/src/index.js

@@ -0,0 +1,79 @@
+import { cors } from "@elysiajs/cors";
+import { swagger } from "@elysiajs/swagger";
+import axios from "axios";
+import { Elysia } from "elysia";
+import { autoroutes } from "elysia-autoroutes";
+import { redisClient } from "./cache/redis";
+import { v4 } from "./modules/v4/router";
+import { errorHandler } from "./utils/error";
+import { log } from "./utils/logger";
+import { apiDbClient, engineDbClient } from "./utils/prisma";
+// Axios with bun workaround
+axios.defaults.headers.common["Accept-Encoding"] = "gzip";
+const PORT = process.env.PORT || 3000;
+const app = new Elysia({
+    normalize: false,
+    serve: {
+        maxRequestBodySize: 1024 * 1024 * 1024, // 1GB
+    },
+})
+    .use(swagger({
+    documentation: {
+        info: {
+            contact: {
+                email: "contact@angle.money",
+                name: "Angle Labs",
+            },
+            description: "API to access data related to merkl campaigns, built and maintained by Angle Labs. This API is provided as is, without any warranty of any kind.",
+            license: {
+                name: "UNLICENSED",
+            },
+            title: "Merkl API",
+            version: "1.0.1",
+        },
+    },
+    exclude: [/v4\/(?!users\/[^/]+\/rewards$).*/, /v1\/.*/, /v2\/.*/],
+}))
+    .use(cors())
+    .get("/", () => "Merkl API")
+    .use(swagger({
+    path: "/docs",
+    documentation: {
+        info: {
+            contact: {
+                email: "contact@angle.money",
+                name: "Angle Labs",
+            },
+            description: "API to access data related to merkl campaigns, built and maintained by Angle Labs. This API is provided as is, without any warranty of any kind.",
+            license: {
+                name: "UNLICENSED",
+            },
+            title: "Merkl API v4 (in development)",
+            version: "1.0.1",
+        },
+        tags: [
+            {
+                name: "Participate",
+                description: "Interact with opportunities on-chain",
+            },
+        ],
+    },
+    exclude: [/v1\/.*/, /v2\/.*/, /v3\/.*/, /docs.*/, "/"],
+}))
+    .use(v4)
+    .use(autoroutes({
+    routesDir: `${import.meta.dir}/routes`,
+    generateTags: false,
+}))
+    .use(errorHandler())
+    .listen(PORT, ({ hostname, port }) => {
+    log.info(`🌐  Api started (${hostname}:${port})`);
+});
+// ─── Signal Handling ─────────────────────────────────────────────────────────
+process.on("SIGTERM", () => {
+    engineDbClient.$disconnect();
+    apiDbClient.$disconnect();
+    redisClient.disconnect();
+    process.exit();
+});
+export { app };

package/dist/src/internal/controllers/endingCampaigns.js

@@ -0,0 +1,41 @@
+import { engineDbClient } from "../../utils/prisma";
+import { t } from "elysia";
+import { Pricer } from "../../utils/pricer";
+import { NON_RENEWED_CAMPAIGNS } from "../../utils/queries/endingCampaigns";
+const ONE_DAY = 24 * 60 * 60;
+export const endingCampaignsController = (app) => app.get("/v3/internal/endingCampaigns", async ({ query, set }) => {
+    let minEndDate = query.minEndDate;
+    let maxEndDate = query.maxEndDate;
+    let minStartDate = query.minStartDate;
+    const now = Math.floor(Date.now() / 1000);
+    if (!minStartDate) {
+        minStartDate = 0;
+    }
+    if (!minEndDate) {
+        minEndDate = now - ONE_DAY;
+    }
+    if (!maxEndDate) {
+        maxEndDate = now + ONE_DAY;
+    }
+    const endingCampaigns = await engineDbClient.$queryRaw(NON_RENEWED_CAMPAIGNS(maxEndDate, minStartDate, minEndDate));
+    const pricer = await Pricer.load();
+    for (const e of endingCampaigns) {
+        const price = await pricer.get({
+            symbol: e.symbol,
+        });
+        if (!price) {
+            e.usdValue = 0;
+            continue;
+        }
+        e.usdValue = price * e.amount;
+        e.hoursLeft = Math.floor((e.endTimestamp - now) / 3600);
+    }
+    return endingCampaigns.sort((a, b) => b.hoursLeft - a.hoursLeft);
+}, {
+    query: t.Object({
+        maxEndDate: t.Optional(t.Numeric()),
+        minEndDate: t.Optional(t.Numeric()),
+        minStartDate: t.Optional(t.Numeric()),
+        nonRenewedOnly: t.Optional(t.String()),
+    }),
+});

package/dist/src/internal/controllers/unclaimed.js

@@ -0,0 +1,36 @@
+import { engineDbClient } from "../../utils/prisma";
+import { t } from "elysia";
+import { InvalidParameter } from "../../utils/error";
+import { Pricer } from "../../utils/pricer";
+import { UNCLAIMED_BEFORE } from "../../utils/queries/unclaimed";
+export const unclaimedController = (app) => app.get("/v3/internal/unclaimed", async ({ query, set }) => {
+    let timestamp = query.timestamp;
+    const months = query.months;
+    if (!timestamp && !months)
+        throw new InvalidParameter("Missing timestamp or months");
+    if (!!timestamp && !!months)
+        throw new InvalidParameter("Cannot provide both timestamp and months");
+    if (!!months) {
+        timestamp = Math.floor(Date.now() / 1000) - months * 30 * 24 * 60 * 60;
+    }
+    if (!timestamp)
+        throw new InvalidParameter("Missing timestamp");
+    const unclaimed = await engineDbClient.$queryRaw(UNCLAIMED_BEFORE(timestamp));
+    const pricer = await Pricer.load();
+    for (const u of unclaimed) {
+        const price = await pricer.get({
+            symbol: u.symbol,
+        });
+        if (!price) {
+            u.usdValue = 0;
+            continue;
+        }
+        u.usdValue = price * u.unclaimed;
+    }
+    return unclaimed.sort((a, b) => b.usdValue - a.usdValue);
+}, {
+    query: t.Object({
+        months: t.Optional(t.Numeric()),
+        timestamp: t.Optional(t.Numeric()),
+    }),
+});

package/dist/src/internal/index.js

@@ -0,0 +1,30 @@
+import { redisClient } from "../cache/redis";
+import { log } from "../utils/logger";
+import { engineDbClient } from "../utils/prisma";
+import { swagger } from "@elysiajs/swagger";
+import axios from "axios";
+import { Elysia } from "elysia";
+import { endingCampaignsController } from "./controllers/endingCampaigns";
+import { unclaimedController } from "./controllers/unclaimed";
+// Axios with bun workaround
+axios.defaults.headers.common["Accept-Encoding"] = "gzip";
+const PORT = process.env.PORT || 3000;
+const app = new Elysia()
+    .use(swagger())
+    .get("/", () => "Merkl Internal API")
+    .use(unclaimedController) // /v3/internal/unclaimed
+    .use(endingCampaignsController) // /v3/internal/endingCampaigns
+    .onError(ctx => {
+    console.error(ctx.error.message);
+    console.error(ctx.error.stack);
+    return (ctx.set.status = "Internal Server Error");
+})
+    .listen(PORT, ({ hostname, port }) => {
+    log.info(`⚙️ Internal started (${hostname}:${port})`);
+});
+// ─── Signal Handling ─────────────────────────────────────────────────────────
+process.on("SIGTERM", () => {
+    engineDbClient.$disconnect();
+    redisClient.disconnect();
+    process.exit();
+});

package/dist/src/libs/campaigns/campaignTypes/AjnaDynamicData.js

@@ -0,0 +1,111 @@
+import { batchMulticallCallWithRetry } from "../../../utils/generic";
+import { providers } from "../../../utils/providers";
+import { AjnaSubCampaignType, BN2Number, ERC20Pool__factory, NETWORK_LABELS, PoolInfoUtilsInterface, YEAR, } from "@sdk";
+import { POOL_INFO_UTILS } from "@sdk";
+import axios from "axios";
+import { log } from "../../../utils/logger";
+import { Pricer } from "../../../utils/pricer";
+export async function AjnaDynamicData(chainId, campaigns) {
+    const pricer = await Pricer.load();
+    const calls = [];
+    for (const campaign of campaigns) {
+        if (campaign.campaignParameters.subCampaignType === AjnaSubCampaignType.lend) {
+            calls.push({
+                allowFailure: true,
+                callData: PoolInfoUtilsInterface.encodeFunctionData("poolPricesInfo", [campaign.campaignParameters.poolId]),
+                target: POOL_INFO_UTILS[campaign.computeChainId],
+            });
+        }
+    }
+    return {
+        cached: false,
+        call: {
+            callData: calls,
+            handler: () => { },
+            reducer: async (result) => {
+                const dynamicData = [];
+                const resIndexes = await batchMulticallCallWithRetry(chainId, {
+                    calls,
+                });
+                let index = 0;
+                for (const campaign of campaigns) {
+                    const res = await axios.get(`https://ajna-api.blockanalitica.com/v4/${NETWORK_LABELS[chainId].toLowerCase()}/pools/${campaign.campaignParameters.poolId.toLowerCase()}`);
+                    try {
+                        let totalSupplyTargetToken = 0;
+                        let totalComputedTargetToken = 0;
+                        let blacklistedSupply = 0;
+                        let blacklistedPosition;
+                        if (campaign.campaignParameters.subCampaignType === AjnaSubCampaignType.lend) {
+                            totalSupplyTargetToken = res?.data.results?.quote_token_balance;
+                            const htpIndex = PoolInfoUtilsInterface.decodeFunctionResult("poolPricesInfo", resIndexes[index].returnData)[3];
+                            const lupIndex = PoolInfoUtilsInterface.decodeFunctionResult("poolPricesInfo", resIndexes[index].returnData)[5];
+                            const threshold = BN2Number(lupIndex, 0) === 0 ? lupIndex : lupIndex.gt(htpIndex) ? lupIndex.add(22) : htpIndex.add(22);
+                            const InterestEarningSupplyRes = await ERC20Pool__factory.connect(campaign.campaignParameters.poolId, providers[campaign.computeChainId]).depositUpToIndex(threshold);
+                            totalComputedTargetToken = BN2Number(InterestEarningSupplyRes, 18);
+                            index++;
+                        }
+                        else {
+                            totalSupplyTargetToken = res?.data.results?.debt;
+                        }
+                        totalComputedTargetToken =
+                            campaign.campaignSubType === AjnaSubCampaignType.lend ? totalComputedTargetToken : totalSupplyTargetToken;
+                        if (campaign.campaignParameters.blacklist.length !== 0 && totalComputedTargetToken !== 0) {
+                            for (const blacklisted of campaign.campaignParameters.blacklist) {
+                                const res = await axios.get(`https://ajna-api.blockanalitica.com/v4/${NETWORK_LABELS[chainId].toLowerCase()}/wallets/${blacklisted}/pools/?days_ago=1&order=-debt&p_size=50`);
+                                let nextRoute = null;
+                                if (!!res.data.next) {
+                                    nextRoute = `https://${res.data.next.slice(res.data.next.indexOf(":") + 1)}`;
+                                }
+                                blacklistedPosition = res.data.results.find((position) => position.pool_address === campaign.campaignParameters.poolId);
+                                blacklistedSupply = !blacklistedPosition
+                                    ? 0
+                                    : campaign.campaignSubType === AjnaSubCampaignType.lend
+                                        ? Number(blacklistedPosition.supply)
+                                        : Number(blacklistedPosition.debt);
+                                while (nextRoute !== null && blacklistedSupply !== 0) {
+                                    const res = await axios.get(nextRoute);
+                                    blacklistedPosition = res.data.results.find((position) => position.pool_address === campaign.campaignParameters.poolId);
+                                    blacklistedSupply = !blacklistedPosition
+                                        ? 0
+                                        : campaign.campaignSubType === AjnaSubCampaignType.lend
+                                            ? Number(blacklistedPosition.supply)
+                                            : Number(blacklistedPosition.debt);
+                                    if (!!res.data.next) {
+                                        nextRoute = `https://${res.data.next.slice(res.data.next.indexOf(":") + 1)}`;
+                                    }
+                                    else {
+                                        nextRoute = null;
+                                    }
+                                }
+                            }
+                        }
+                        totalComputedTargetToken -= blacklistedSupply;
+                        const priceRewardToken = (await pricer.get({
+                            address: campaign.rewardToken,
+                            chainId,
+                            symbol: campaign.campaignParameters.symbolRewardToken,
+                        })) ?? 0;
+                        dynamicData.push({
+                            ...campaign,
+                            apr: (priceRewardToken *
+                                BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) *
+                                YEAR *
+                                100) /
+                                campaign.campaignParameters.duration /
+                                (totalComputedTargetToken * res?.data.results?.quote_token_underlying_price),
+                            totalSupplyTargetToken,
+                            tvl: res?.data.results?.tvl,
+                            computedtotalSupply: totalComputedTargetToken,
+                        });
+                    }
+                    catch (e) {
+                        log.error("Failed to fetch Ajna data", e);
+                        // In this case we return just the staticData
+                        dynamicData.push({ ...campaign });
+                    }
+                }
+                return dynamicData;
+            },
+        },
+    };
+}

package/dist/src/libs/campaigns/campaignTypes/BadgerDynamicData.js

@@ -0,0 +1,93 @@
+import { BN2Number, SortedCdpsInterface, YEAR, } from "@sdk";
+import { log } from "../../../utils/logger";
+import { Pricer } from "../../../utils/pricer";
+import { CDPMANAGER_ADDRESS, EBTC_ADDRESS, SORTEDCDPS_ADDRESS } from "../../../constants";
+import { batchMulticallCallWithRetry } from "../../../utils/generic";
+import { CdpManagerInterface } from "../../../../libs/sdk/src/merkl/interface";
+export async function BadgerDynamicData(chainId, campaigns) {
+    const pricer = await Pricer.load();
+    const calls = [];
+    calls.push({
+        allowFailure: false,
+        callData: CdpManagerInterface.encodeFunctionData("getSystemDebt"),
+        target: CDPMANAGER_ADDRESS,
+    });
+    return {
+        cached: false,
+        call: {
+            callData: calls,
+            handler: () => { },
+            reducer: async (result) => {
+                const dynamicData = [];
+                for (const campaign of campaigns) {
+                    try {
+                        // Blacklist management
+                        let blacklistSupply = 0;
+                        let calls = [];
+                        for (const blacklisted of [
+                            "0xFBC472DdbE6DaE23fc0771518d1791D06a52cf4D",
+                            "0x690C74AF48BE029e763E61b4aDeB10E06119D3ba",
+                            "0xD0A7A8B98957b9CD3cFB9c0425AbE44551158e9e",
+                            "0x68682e8857D24A5Bb71fCd5C6Dc5867731226B62",
+                        ]) {
+                            calls.push({
+                                allowFailure: false,
+                                callData: SortedCdpsInterface.encodeFunctionData("getCdpsOf", [blacklisted]),
+                                target: SORTEDCDPS_ADDRESS,
+                            });
+                        }
+                        const resCdps = await batchMulticallCallWithRetry(chainId, {
+                            calls,
+                        });
+                        calls = [];
+                        for (const res of resCdps) {
+                            const cdp = SortedCdpsInterface.decodeFunctionResult("getCdpsOf", res.returnData)[0];
+                            if (cdp.length !== 0) {
+                                calls.push({
+                                    allowFailure: false,
+                                    callData: CdpManagerInterface.encodeFunctionData("Cdps", cdp),
+                                    target: CDPMANAGER_ADDRESS,
+                                });
+                            }
+                        }
+                        const resBlacklist = await batchMulticallCallWithRetry(chainId, {
+                            calls,
+                        });
+                        for (const res of resBlacklist) {
+                            const cdpBlacklistedSupply = CdpManagerInterface.decodeFunctionResult("Cdps", res.returnData)[0];
+                            blacklistSupply += BN2Number(cdpBlacklistedSupply, campaign.campaignParameters.decimalsTargetToken);
+                        }
+                        const totalSupplyTargetToken = BN2Number(CdpManagerInterface.decodeFunctionResult("getSystemDebt", result[0])[0], campaign.campaignParameters.decimalsTargetToken) - blacklistSupply;
+                        const priceRewardToken = (await pricer.get({
+                            address: campaign.rewardToken,
+                            chainId,
+                            symbol: campaign.campaignParameters.symbolRewardToken,
+                        })) ?? 0;
+                        const priceTargetToken = (await pricer.get({
+                            address: EBTC_ADDRESS,
+                            chainId,
+                            symbol: campaign.campaignParameters.symbolTargetToken,
+                        })) ?? 0;
+                        dynamicData.push({
+                            ...campaign,
+                            apr: (priceRewardToken *
+                                BN2Number(campaign.amount, campaign.campaignParameters.decimalsRewardToken) *
+                                YEAR *
+                                100) /
+                                campaign.campaignParameters.duration /
+                                (totalSupplyTargetToken * priceTargetToken),
+                            totalSupplyTargetToken,
+                            tvl: totalSupplyTargetToken * priceTargetToken,
+                        });
+                    }
+                    catch (e) {
+                        log.error("Failed to fetch Dolomite data", e);
+                        // In this case we return just the staticData
+                        dynamicData.push({ ...campaign });
+                    }
+                }
+                return dynamicData;
+            },
+        },
+    };
+}