@merkl/api 0.21.46 → 1.0.0

package/dist/src/engine/tvl/logStates.js

@@ -1,106 +0,0 @@
-import { BucketService } from "@/modules/v4/bucket/bucket.service";
-import { engineDbClient } from "@db";
-import { BN2Number, Campaign as CampaignType, ChainInteractionService, } from "@sdk";
-// TODO: handle multiple main composed campaigns
-export function getIdPerCampaignType(campaignType, campaign) {
-    switch (campaignType) {
-        case CampaignType.ERC20LOGPROCESSOR:
-        case CampaignType.ERC20REBASELOGPROCESSOR:
-            campaign = campaign;
-            return `ERC20LogProcessor_${campaign.computeChainId}_${campaign.campaignParameters.targetToken}`;
-        case CampaignType.EVENT_BASED:
-            campaign = campaign;
-            return `EventBasedProcessor_${campaign.computeChainId}_${campaign.campaignId}`;
-        case CampaignType.LOCKER:
-            campaign = campaign;
-            return `LOCKER_${campaign.campaignParameters.lockerContract}`;
-    }
-}
-/**
- * Compute TVL
- * @dev important: using the most recent state save with current prices
- *      it's only an estimate
- */
-// TODO: handle multiple main composed campaigns
-export async function computeEventBasedPoolRewardsFromMostRecentStateSave(chainId, campaignType, campaign) {
-    let stateSave;
-    let blockNumber;
-    let states = {};
-    try {
-        const currentBlock = await ChainInteractionService(chainId).getBlockNumber();
-        const mostRecentStateSave = await engineDbClient.stateSave.findFirst({
-            where: {
-                id: getIdPerCampaignType(campaignType, campaign),
-                blockNumber: {
-                    lte: currentBlock,
-                },
-            },
-            orderBy: {
-                blockNumber: "desc",
-            },
-        });
-        stateSave = mostRecentStateSave.state;
-        blockNumber = mostRecentStateSave?.blockNumber;
-        states = stateSave.states;
-        // const globalState = stateSave.globalState as { tick: number; liquidity: string };
-    }
-    catch { }
-    const { fileName, bucketName } = states;
-    // Bucket service
-    let distributedRewards = 0;
-    if (!fileName || !bucketName) {
-        return { distributedRewards, blockNumber: blockNumber };
-    }
-    try {
-        const bucket = new BucketService("merkl-production-states", "merkl-production");
-        const storedStates = JSON.parse(await bucket.pull(fileName));
-        for (const [_, { value, params: _params }] of Object.entries(storedStates)) {
-            distributedRewards += BN2Number(value.allTimeValue, 18);
-        }
-        distributedRewards = Math.max(distributedRewards, 1);
-    }
-    catch { }
-    return { distributedRewards, blockNumber: blockNumber };
-}
-export async function computeLockerAmountFromMostRecentStateSave(chainId, campaignType, campaign) {
-    let stateSave;
-    let blockNumber;
-    let states = {};
-    try {
-        const currentBlock = await ChainInteractionService(chainId).getBlockNumber();
-        const mostRecentStateSave = await engineDbClient.stateSave.findFirst({
-            where: {
-                id: getIdPerCampaignType(campaignType, campaign),
-                blockNumber: {
-                    lte: currentBlock,
-                },
-            },
-            orderBy: {
-                blockNumber: "desc",
-            },
-        });
-        stateSave = mostRecentStateSave.state;
-        blockNumber = mostRecentStateSave?.blockNumber;
-        states = stateSave.states;
-        // const globalState = stateSave.globalState as { tick: number; liquidity: string };
-    }
-    catch { }
-    const { fileName, bucketName } = states;
-    // Bucket service
-    let lockedAmount = 0;
-    if (!fileName || !bucketName) {
-        return { lockedAmount, blockNumber: blockNumber };
-    }
-    try {
-        const bucket = new BucketService("merkl-production-states", "merkl-production");
-        const storedStates = JSON.parse(await bucket.pull(fileName));
-        for (const [_, { value, params: _params }] of Object.entries(storedStates)) {
-            for (const slot of Object.values(value.slots)) {
-                lockedAmount += BN2Number(slot.lockedAmount, 18);
-            }
-        }
-        lockedAmount = Math.max(lockedAmount, 1);
-    }
-    catch { }
-    return { lockedAmount, blockNumber: blockNumber };
-}

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

@@ -1,7 +0,0 @@
-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

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

package/dist/src/errors/HttpError.js

@@ -1,17 +0,0 @@
-import { t } from "elysia";
-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;
-    }
-}
-export const HttpErrorDto = t.Object({
-    code: t.String({ default: "Internal Server Error" }),
-    httpCode: t.Number({ default: 500 }),
-    info: t.String(),
-});

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

@@ -1,7 +0,0 @@
-import { HttpError } from "./HttpError";
-export class InvalidParameter extends HttpError {
-    constructor(message = "Invalid Parameter") {
-        super(message, 400);
-        this.name = "InvalidParameterError";
-    }
-}

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

@@ -1,12 +0,0 @@
-import { t } from "elysia";
-import { HttpError } from "./HttpError";
-export class NotFoundError extends HttpError {
-    constructor(message = "Not Found") {
-        super(message, 404);
-        this.name = "NotFoundError";
-    }
-}
-export const NotFoundErrorDto = t.Object({
-    name: t.String({ default: "NotFoundError" }),
-    message: t.String({ default: "Not Found" }),
-});

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

@@ -1,11 +0,0 @@
-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/UnableToFindPrice.error.js

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

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

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

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

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

package/dist/src/errors/index.js

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

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

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

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

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

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

@@ -1,10 +0,0 @@
-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/guards/VerifyJwt.guard.js

@@ -1,13 +0,0 @@
-import { UnauthorizedError } from "@/errors";
-import { CacheService } from "@/modules/v4/cache/cache.service";
-import { t } from "elysia";
-import { jwtVerify } from "jose";
-export const JwtCookieDto = t.Cookie({
-    jwt: t.String(),
-});
-const JWT_SECRET = new TextEncoder().encode(process.env.JWT_SECRET);
-export async function VerifyJwtGuard({ cookie }) {
-    const decodedJwt = await jwtVerify(cookie.jwt.value, JWT_SECRET);
-    if (!decodedJwt.payload.jti || (await CacheService.sIsMember("token:revoked", decodedJwt.payload.jti)))
-        throw new UnauthorizedError("Failed to verify JWT.");
-}

package/dist/src/hooks/checkQueryAddressValidity.js

@@ -1,7 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,113 +0,0 @@
-import { cors } from "@elysiajs/cors";
-import { swagger } from "@elysiajs/swagger";
-import axios from "axios";
-import { Elysia } from "elysia";
-import { apiDbClient, engineDbClient } from "../database";
-import { redisClient } from "./cache/redis";
-import { v4 } from "./modules/v4/router";
-import { v1 } from "./routes/v1/router";
-import { v2 } from "./routes/v2/router";
-import { v3 } from "./routes/v3/router";
-import { errorHandler } from "./utils/error";
-import { log } from "./utils/logger";
-if (!process.env.JWT_SECRET)
-    throw new Error("Environment variable JWT_SECRET is missing.");
-// 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
-        idleTimeout: 0,
-    },
-})
-    .use(swagger({
-    scalarConfig: {
-        theme: "kepler",
-        darkMode: true,
-        favicon: "https://app.merkl.xyz/images/merkl-favicon.ico",
-    },
-    documentation: {
-        info: {
-            contact: {
-                email: "contact@merkl.money",
-                name: "Angle Labs",
-            },
-            description: "The official 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\/.*/, "/"],
-}))
-    .use(swagger({
-    path: "/docs",
-    scalarConfig: {
-        theme: "kepler",
-        darkMode: true,
-        favicon: "https://app.merkl.xyz/images/merkl-favicon.ico",
-    },
-    documentation: {
-        tags: [
-            {
-                name: "Opportunities",
-                description: "An opportunity represents a collection of campaigns.",
-            },
-            {
-                name: "Campaigns",
-                description: "Campaigns are designed to incentivize participation in a protocol by offering rewards to users for specific behaviors or actions.",
-            },
-            {
-                name: "Protocols",
-                description: "Endpoints related to protocols integrated by Merkl.",
-            },
-            {
-                name: "Chains",
-                description: "Endpoints related to chains integrated by Merkl.",
-            },
-            {
-                name: "Users",
-                description: "Endpoints related to Merkl users.",
-            },
-        ],
-        info: {
-            contact: {
-                email: "contact@merkl.money",
-                name: "Angle Labs",
-            },
-            description: "The official 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: [/engine\/*/, /v1\/.*/, /v2\/.*/, /v3\/.*/, /swagger\/*/],
-}))
-    .use(cors())
-    .get("/", () => "Merkl API: docs available at /docs", {
-    detail: {
-        hide: true,
-    },
-})
-    .use(v1)
-    .use(v2)
-    .use(v4)
-    .use(v3)
-    .use(errorHandler())
-    .listen({ port: PORT, idleTimeout: 40 }, server => {
-    log.info(`🌐  Api started (${server.hostname || "localhost"}:${server.port})`);
-});
-// ─── Signal Handling ─────────────────────────────────────────────────────────
-process.on("SIGTERM", () => {
-    engineDbClient.$disconnect();
-    apiDbClient.$disconnect();
-    redisClient.disconnect();
-    process.exit();
-});
-export { app };

package/dist/src/jobs/dynamic-data.js

@@ -1,159 +0,0 @@
-// @ts-nocheck
-/**
-  @deprecated Used only for the v3/campaigns route
- */
-import { Redis } from "@/cache";
-import { campaignTVLBuilderFactory } from "@/engine/tvl/factory";
-import { campaignsToOldFormat } from "@/libs/deprecated-merklv3";
-import { merklChainData } from "@/libs/merklChainData";
-import { staticCampaignWithCache } from "@/libs/staticCampaigns";
-import { OpportunityConvertorService } from "@/modules/v4/opportunity/opportunity.converter";
-import { log } from "@/utils/logger";
-import { ALL_CAMPAIGNS_FOR_CHAIN_AFTER } from "@/utils/queries/allCampaigns";
-import { engineDbClient } from "@db";
-import { Campaign, ChainId, NETWORK_LABELS } from "@sdk";
-import moment from "moment";
-// ─── Required Env Variables ──────────────────────────────────────────────────
-const chainId = Number(process.env.CHAIN_ID);
-if (!chainId)
-    throw new Error("Environment variable CHAIN_ID is required.");
-const highCampaignsChains = [ChainId.ARBITRUM, ChainId.POLYGON, ChainId.BLAST, ChainId.BASE];
-export const main = async () => {
-    if (chainId === ChainId.MAINNET) {
-        await OpportunityConvertorService.logKeyAndTTLV3Opportunities(false, false, undefined, undefined);
-        await OpportunityConvertorService.setV3Opportunities(false, false, undefined, undefined);
-        log.info("✅ opportunity v3 cache updated successfully");
-        await OpportunityConvertorService.logKeyAndTTLV3Opportunities(false, true, undefined, undefined);
-        await OpportunityConvertorService.setV3Opportunities(false, true, undefined, undefined);
-        log.info("✅ opportunity v3 test cache updated successfully");
-    }
-    let success = true;
-    try {
-        await Redis.safeSet(`MerklChainData_${chainId}`, await merklChainData(chainId));
-    }
-    catch (error) {
-        log.error(`❌ update merklChainData cache failed for ${NETWORK_LABELS[chainId]}`, error);
-        success = false;
-    }
-    log.local(`🔁 updating ${NETWORK_LABELS[chainId]} Campaigns cache`);
-    let campaignsAfter = moment().subtract(3, "months").unix();
-    if (highCampaignsChains.includes(chainId)) {
-        campaignsAfter = moment().subtract(1, "months").unix();
-    }
-    const TWO_WEEKS_AGO = moment().subtract(2, "weeks").unix();
-    try {
-        const dynamicData = {};
-        let staticData = (await engineDbClient.$queryRaw(ALL_CAMPAIGNS_FOR_CHAIN_AFTER(chainId, campaignsAfter)));
-        log.local(`Data length before filtering: ${staticData.length}`);
-        const mainParameters = {};
-        staticData = staticData.filter(campaign => {
-            if (campaign.endTimestamp < TWO_WEEKS_AGO && campaign.campaignType === Campaign.CLAMM) {
-                campaign.campaignParameters.forwarders = [];
-            }
-            mainParameters[campaign.mainParameter] = true;
-            return true;
-        });
-        log.local(`Data length after filtering: ${staticData.length}`);
-        if (!!staticData) {
-            // Build list of existing campaign types for this chain
-            const campaignTypes = !staticData
-                ? []
-                : staticData
-                    .map(campaign => campaign.campaignType)
-                    .reduce((prev, campaignType) => {
-                    if (!prev.includes(campaignType))
-                        prev.push(campaignType);
-                    return prev;
-                }, []);
-            // Fetch dynamic data for all these types
-            const promisesPerType = campaignTypes.map(async (campaignType) => {
-                const campaigns = staticData.filter(campaign => campaign.campaignType === campaignType);
-                if (campaignTVLBuilderFactory(campaignType).deprecated) {
-                    await campaignTVLBuilderFactory(campaignType)
-                        .build(chainId, campaigns)
-                        .then(r => {
-                        for (const d of r) {
-                            if (!!d) {
-                                // Main Parameter OVERRIDING
-                                if (d.campaignType === Campaign.SILO && d.campaignParameters.whitelist?.length === 1) {
-                                    d.mainParameter = `${d.mainParameter}-${d.campaignParameters.whitelist[0]}`;
-                                }
-                                if (!dynamicData[`${d.campaignType}_${d.mainParameter}`])
-                                    dynamicData[`${d.campaignType}_${d.mainParameter}`] = {};
-                                dynamicData[`${d.campaignType}_${d.mainParameter}`][d.campaignId] = d;
-                            }
-                        }
-                    });
-                }
-                else {
-                    for (const d of campaigns) {
-                        if (!!d) {
-                            // Main Parameter OVERRIDING
-                            if (d.campaignType === Campaign.SILO && d.campaignParameters.whitelist?.length === 1) {
-                                d.mainParameter = `${d.mainParameter}-${d.campaignParameters.whitelist[0]}`;
-                            }
-                            if (!dynamicData[`${d.campaignType}_${d.mainParameter}`])
-                                dynamicData[`${d.campaignType}_${d.mainParameter}`] = {};
-                            dynamicData[`${d.campaignType}_${d.mainParameter}`][d.campaignId] = d;
-                        }
-                    }
-                }
-            });
-            await Promise.all(promisesPerType);
-        }
-        if (!!dynamicData && Object.keys(dynamicData).length > 0) {
-            await Redis.safeSet(`Campaigns_${chainId}`, dynamicData);
-            // Set live or future campaigns
-            const liveDynamicData = {};
-            for (const [type_mainParameter, value] of Object.entries(dynamicData)) {
-                for (const [campaignId, data] of Object.entries(value)) {
-                    if (data.endTimestamp > moment().unix()) {
-                        if (!liveDynamicData[type_mainParameter]) {
-                            liveDynamicData[type_mainParameter] = {};
-                        }
-                        liveDynamicData[type_mainParameter][campaignId] = data;
-                    }
-                }
-            }
-            await Redis.safeSet(`LiveCampaigns_${chainId}`, liveDynamicData);
-            const merklChainData = await Redis.get("MerklChainData", chainId);
-            await Redis.safeSet(`CampaignsOldFormat_${chainId}`, campaignsToOldFormat(dynamicData, merklChainData));
-            await Redis.safeSet(`LiveCampaignsOldFormat_${chainId}`, campaignsToOldFormat(liveDynamicData, merklChainData));
-            log.info(`✅ ${NETWORK_LABELS[chainId]} caches updated successfully`);
-        }
-        else {
-            if (chainId === ChainId.CORE || chainId === ChainId.THUNDERCORE) {
-                log.info(`⚠️ no campaigns found for ${NETWORK_LABELS[chainId]}, setting empty cache`);
-                for (const key of [
-                    "Campaigns",
-                    "LiveCampaigns",
-                    "CampaignsOldFormat",
-                    "LiveCampaignsOldFormat",
-                ]) {
-                    await Redis.safeSet(`${key}_${chainId}`, {});
-                }
-                log.info(`✅ ${NETWORK_LABELS[chainId]} caches updated - empty cache`);
-            }
-        }
-    }
-    catch (error) {
-        log.error(`❌ update Campaigns cache failed for ${NETWORK_LABELS[chainId]}`, error);
-        success = false;
-    }
-    // This is independant of campaigns cache update, so not in the if condition
-    try {
-        await staticCampaignWithCache(chainId);
-    }
-    catch (error) {
-        log.error(`❌ update Campaigns cache failed for ${NETWORK_LABELS[chainId]}`, error);
-    }
-    return { success };
-};
-try {
-    await main();
-    process.exit(0);
-}
-catch (err) {
-    console.error(err);
-    process.exit(1);
-}