@merkl/api 0.9.15

package/dist/src/routes/v1/tokens.js

@@ -0,0 +1,17 @@
+import { getTokensListWithCache } from "@/libs/getTokensList";
+import { t } from "elysia";
+export const response = t.Record(t.String({ title: "ChainId" }), t.Record(t.String({ title: "TokenAddress" }), t.Object({
+    address: t.String(),
+    name: t.String(),
+    decimals: t.Number(),
+    symbol: t.String(),
+    hasPermit: t.Boolean(),
+    useInSwap: t.Optional(t.Boolean()),
+    logoURI: t.String(),
+})));
+export default (app) => app.get("/tokens", async () => {
+    return await getTokensListWithCache();
+}, {
+    query: t.Object({}),
+    tags: ["Onchain"],
+});

package/dist/src/routes/v2/merkl.d.ts

@@ -0,0 +1,55 @@
+import type Elysia from "elysia";
+export declare const query: import("@sinclair/typebox").TObject<{
+    AMMs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>]>>;
+    "AMMs[0]": import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    "AMMs[]": import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>]>>;
+    chainIds: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>]>>;
+    "chainIds[0]": import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    "chainIds[]": import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>]>>;
+    user: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    onlyLive: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    merkl: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                user?: string | undefined;
+                chainIds?: number | number[] | undefined;
+                AMMs?: string | string[] | undefined;
+                onlyLive?: string | undefined;
+                "AMMs[]"?: string | string[] | undefined;
+                "AMMs[0]"?: string | undefined;
+                "chainIds[]"?: number | number[] | undefined;
+                "chainIds[0]"?: number | undefined;
+            };
+            headers: unknown;
+            response: {
+                [x: string]: any;
+                200: any;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;

package/dist/src/routes/v2/merkl.js

@@ -0,0 +1,13 @@
+import { t } from "elysia";
+import { merklRoute } from "../v3/merkl";
+export const query = t.Object({
+    AMMs: t.Optional(t.Union([t.String(), t.Array(t.String())])),
+    "AMMs[0]": t.Optional(t.String()),
+    "AMMs[]": t.Optional(t.Union([t.String(), t.Array(t.String())])),
+    chainIds: t.Optional(t.Union([t.Numeric(), t.Array(t.Numeric())])),
+    "chainIds[0]": t.Optional(t.Numeric()),
+    "chainIds[]": t.Optional(t.Union([t.Numeric(), t.Array(t.Numeric())])),
+    user: t.Optional(t.String()),
+    onlyLive: t.Optional(t.String()),
+});
+export default (app) => app.get("/merkl", merklRoute, { query, tags: ["Merkl"] });

package/dist/src/routes/v2/router.d.ts

@@ -0,0 +1,46 @@
+import Elysia from "elysia";
+export declare const v2: Elysia<"/v2", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    v2: {
+        merkl: {
+            get: {
+                body: unknown;
+                params: {};
+                query: {
+                    user?: string | undefined;
+                    chainIds?: number | number[] | undefined;
+                    AMMs?: string | string[] | undefined;
+                    onlyLive?: string | undefined;
+                    "AMMs[]"?: string | string[] | undefined;
+                    "AMMs[0]"?: string | undefined;
+                    "chainIds[]"?: number | number[] | undefined;
+                    "chainIds[0]"?: number | undefined;
+                };
+                headers: unknown;
+                response: {
+                    [x: string]: any;
+                    200: any;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

package/dist/src/routes/v2/router.js

@@ -0,0 +1,3 @@
+import Elysia from "elysia";
+import merkl from "./merkl";
+export const v2 = new Elysia({ tags: ["v2"], prefix: "/v2" }).use(merkl);

package/dist/src/routes/v3/app.d.ts

@@ -0,0 +1,48 @@
+import type Elysia from "elysia";
+/**
+ * @deprecated - can be removed once old apps are not in used anymore
+ */
+export declare const response: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+    rate: import("@sinclair/typebox").TNumber;
+    token: import("@sinclair/typebox").TString;
+}>>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    app: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {};
+            headers: unknown;
+            response: {
+                200: {
+                    tokens: any;
+                    prices: {
+                        rate: number;
+                        token: string;
+                    }[];
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;

package/dist/src/routes/v3/app.js

@@ -0,0 +1,38 @@
+import { getTokensListWithCache } from "@/libs/getTokensList";
+import { CacheService } from "@/modules/v4/cache";
+import { TTLPresets } from "@/modules/v4/cache/cache.model";
+import { TokenService } from "@/modules/v4/token/token.service";
+import { Pricer } from "@/utils/pricer";
+import { t } from "elysia";
+/**
+ * @deprecated - can be removed once old apps are not in used anymore
+ */
+export const response = t.Array(t.Object({ rate: t.Number(), token: t.String() }));
+export default (app) => app.get("/app", async () => {
+    return await CacheService.wrap(TTLPresets.MIN_5, async () => {
+        const json = {
+            tokens: await getTokensListWithCache(),
+            prices: await (await Pricer.load()).getArray(),
+        };
+        const v3Tokens = await TokenService.findMany({});
+        for (const token of v3Tokens) {
+            if (!json.tokens[token.chainId]) {
+                json.tokens[token.chainId] = {};
+            }
+            if (!json.tokens[token.chainId][token.address] && token.icon?.length > 0) {
+                json.tokens[token.chainId][token.address] = {
+                    address: token.address,
+                    chainId: token.chainId,
+                    decimals: token.decimals,
+                    name: token.name,
+                    symbol: token.symbol,
+                    logoURI: token.icon,
+                };
+            }
+        }
+        return json;
+    });
+}, {
+    query: t.Object({}),
+    tags: ["Onchain"],
+});

package/dist/src/routes/v3/blacklist.d.ts

@@ -0,0 +1,45 @@
+import type Elysia from "elysia";
+export declare const query: import("@sinclair/typebox").TObject<{
+    user: import("@sinclair/typebox").TString;
+}>;
+export declare const response: import("@sinclair/typebox").TObject<{
+    isBlacklisted: import("@sinclair/typebox").TBoolean;
+}>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    blacklist: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                user: string;
+            };
+            headers: unknown;
+            response: {
+                200: {
+                    isBlacklisted: boolean;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;

package/dist/src/routes/v3/blacklist.js

@@ -0,0 +1,19 @@
+import { BlacklistService } from "@/modules/v4/blacklist";
+import { t } from "elysia";
+import checkQueryAddressValidity from "../../hooks/checkQueryAddressValidity";
+// @dev DEPRECATED - conversion to v4 done
+export const query = t.Object({
+    user: t.String(),
+});
+export const response = t.Object({
+    isBlacklisted: t.Boolean(),
+});
+export default (app) => app.use(checkQueryAddressValidity()).get("/blacklist", async ({ query }) => {
+    return { isBlacklisted: await BlacklistService.isBlacklisted(query.user) };
+}, {
+    query,
+    response: {
+        200: response,
+    },
+    tags: ["Merkl"],
+});

package/dist/src/routes/v3/campaign/delay.d.ts

@@ -0,0 +1,49 @@
+import { type Elysia } from "elysia";
+/**
+ * @deprecated - to remove in favor of new status page
+ */
+export declare const query: import("@sinclair/typebox").TObject<{
+    onlyLive: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;
+export declare const response: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TNumber>>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    index: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                onlyLive?: boolean | undefined;
+            };
+            headers: unknown;
+            response: {
+                [x: string]: any;
+                200: any;
+                readonly 400: {
+                    message?: string | undefined;
+                    error: string;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;

package/dist/src/routes/v3/campaign/delay.js

@@ -0,0 +1,81 @@
+import { Redis } from "@/cache";
+import { staticCampaignWithCache } from "@/libs/staticCampaigns";
+import { engineDbClient } from "@db";
+import { ChainId, isSupportedChain } from "@sdk";
+import { t } from "elysia";
+import moment from "moment";
+/**
+ * @deprecated - to remove in favor of new status page
+ */
+export const query = t.Object({
+    onlyLive: t.Optional(t.Boolean()),
+});
+export const response = t.Record(t.String({ title: "ChainId" }), t.Record(t.String({ title: "CampaignId" }), t.Number()));
+export default (app) => app.get("", async ({ query }) => {
+    return await computeDelayWithCache(!!query.onlyLive);
+}, {
+    transform({ query }) {
+        if (!query.onlyLive)
+            query.onlyLive = true;
+        else
+            query.onlyLive = query.onlyLive === "true"; // To Patch uncorrect Elysia types (Elysia provide boolean instead of string from queryParams)!
+    },
+    query,
+    response: {
+        400: t.Object({
+            error: t.String(),
+            message: t.Optional(t.String()),
+        }),
+    },
+    tags: ["Campaigns"],
+});
+const computeDelay = async (onlyLive) => {
+    const chainIds = Object.keys(ChainId)
+        .map(k => Number.parseInt(k))
+        .filter(k => isSupportedChain(k, "merkl"));
+    const res = {};
+    const timeNow = moment().unix();
+    const cacheData = await Redis.getManyWithArgs("MerklChainData", chainIds);
+    const lastUpdateTimestampList = await engineDbClient.leaves.groupBy({
+        _max: {
+            lastProcessedTimestamp: true,
+        },
+        where: {
+            chainId: {
+                in: chainIds,
+            },
+            root: { in: cacheData.map(data => data?.merkleRoot).filter(r => !!r) },
+        },
+        by: ["chainId", "campaignId"],
+    });
+    const lastObjectTimestampObject = lastUpdateTimestampList.reduce((acc, { chainId, campaignId, _max }) => {
+        if (_max.lastProcessedTimestamp) {
+            acc[chainId] = acc[chainId] || {};
+            acc[chainId][campaignId] = _max.lastProcessedTimestamp;
+        }
+        return acc;
+    }, {});
+    // Iterate through each chainId and its associated campaigns
+    for (const chainId of chainIds) {
+        const campaigns = await staticCampaignWithCache(chainId);
+        for (const campaign of campaigns) {
+            const { campaignId, startTimestamp, endTimestamp, campaignType, mainParameter } = campaign;
+            // Skip non-live campaigns if onlyLive is true
+            if (onlyLive && (startTimestamp > timeNow || endTimestamp < timeNow))
+                continue;
+            const lastProcessedTimestamp = lastObjectTimestampObject[chainId]?.[campaignId] || 0;
+            res[chainId] = res[chainId] || {};
+            const delay = Math.min(endTimestamp, timeNow) - Math.max(lastProcessedTimestamp, startTimestamp);
+            res[chainId][campaignId] = {
+                lastProcessedTimestamp,
+                startTimestamp,
+                endTimestamp,
+                delay,
+                campaignType,
+                mainParameter,
+            };
+        }
+    }
+    return res;
+};
+const computeDelayWithCache = async (onlyLive) => await Redis.getOrSet("Delays", computeDelay, onlyLive);

package/dist/src/routes/v3/campaignClaims.d.ts

@@ -0,0 +1,48 @@
+import type Elysia from "elysia";
+/**
+ * @deprecated
+ * This whole file is deprecated but is still used by Pancakeswap to populate their db so we can't remove it yet.
+ */
+export declare const query: import("@sinclair/typebox").TObject<{
+    campaignId: import("@sinclair/typebox").TString;
+    chainId: import("@sinclair/typebox").TNumber;
+    byReason: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    campaignClaims: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                byReason?: boolean | undefined;
+                campaignId: string;
+                chainId: number;
+            };
+            headers: unknown;
+            response: {
+                200: unknown;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;

package/dist/src/routes/v3/campaignClaims.js

@@ -0,0 +1,29 @@
+import checkQueryChainIdValidity from "@/hooks/checkQueryChainIdValidity";
+import { engineDbClient } from "@db";
+import { Prisma } from "@db/engine";
+import { t } from "elysia";
+/**
+ * @deprecated
+ * This whole file is deprecated but is still used by Pancakeswap to populate their db so we can't remove it yet.
+ */
+export const query = t.Object({
+    campaignId: t.String(),
+    chainId: t.Numeric(),
+    byReason: t.Optional(t.BooleanString()),
+});
+const CLAIMS_OVER_TIME = (chainId, campaignId) => Prisma.sql `
+    SELECT timestamp, recipient, reason, claimed
+    FROM "ClaimsOverTime"
+    WHERE
+        "chainId"=${chainId} AND
+        "campaignId"=${campaignId} 
+    ORDER BY timestamp ASC
+    `;
+export default (app) => app.use(checkQueryChainIdValidity()).get("/campaignClaims", async ({ query }) => {
+    const campaignId = query.campaignId;
+    const chainId = query.chainId;
+    return await engineDbClient.$queryRaw(CLAIMS_OVER_TIME(chainId, campaignId));
+}, {
+    query,
+    tags: ["Campaigns"],
+});

package/dist/src/routes/v3/campaignUnclaimed.d.ts

@@ -0,0 +1,47 @@
+import { type Elysia } from "elysia";
+/**
+ * @deprecated - conversion to v4 done
+ */
+export declare const query: import("@sinclair/typebox").TObject<{
+    campaignIds: import("@sinclair/typebox").TString;
+    chainId: import("@sinclair/typebox").TNumber;
+}>;
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    campaignUnclaimed: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                chainId: number;
+                campaignIds: string;
+            };
+            headers: unknown;
+            response: {
+                200: {
+                    [x: string]: string;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;

package/dist/src/routes/v3/campaignUnclaimed.js

@@ -0,0 +1,28 @@
+import { RewardService } from "@/modules/v4/reward";
+import { t } from "elysia";
+import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
+/**
+ * @deprecated - conversion to v4 done
+ */
+export const query = t.Object({
+    campaignIds: t.String(),
+    chainId: t.Numeric(),
+});
+export default (app) => app.use(checkQueryChainIdValidity()).get("/campaignUnclaimed", async ({ query }) => {
+    const campaignIds = query.campaignIds;
+    let campaigns = [];
+    if (campaignIds.includes(",")) {
+        campaigns = campaignIds.split(",");
+    }
+    else {
+        campaigns = [campaignIds];
+    }
+    const chainId = query.chainId;
+    return await RewardService.getUnclaimed({
+        chainId,
+        campaignIds: campaigns,
+    });
+}, {
+    query,
+    tags: ["Campaigns"],
+});

package/dist/src/routes/v3/campaigns.d.ts

@@ -0,0 +1,58 @@
+import type Elysia from "elysia";
+export declare const query: import("@sinclair/typebox").TObject<{
+    chainIds: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>]>>;
+    types: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>, import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>]>>;
+    live: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+    creatorTag: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    hideTestTokens: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export declare const response: import("@sinclair/typebox").TObject<{}>;
+/**
+ * @deprecated - conversion to v4 done
+ *
+ * @dev there was a significant loss of information with the v4 conversion
+ * So some issues are expected
+ *
+ * v3 was returning a whole bunch of dynamic data when the v4 only has tvl and apr
+ */
+declare const _default: (app: Elysia) => Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    campaigns: {
+        get: {
+            body: unknown;
+            params: {};
+            query: {
+                types?: string | number | string[] | number[] | undefined;
+                chainIds?: string | string[] | undefined;
+                creatorTag?: string | undefined;
+                live?: boolean | undefined;
+                hideTestTokens?: string | undefined;
+            };
+            headers: unknown;
+            response: {
+                [x: string]: any;
+                200: any;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export default _default;