@merkl/api 0.10.158 → 0.10.160

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

@@ -1,63 +0,0 @@
-import { Redis } from "../../cache";
-import param from "../../types/parameters";
-import { ANGLE_NETWORKS, Campaign, ChainId, isSupportedChain, registry, } from "@sdk";
-import { t } from "elysia";
-import { UnsupportedNetwork } from "../../utils/error";
-export const query = t.Object({
-    chainIds: t.Optional(t.Union([t.String(), t.Array(t.String())])),
-    types: t.Optional(t.Union([t.Numeric(), t.Array(t.Numeric()), t.String(), t.Array(t.String())])),
-    live: t.Optional(t.BooleanString()),
-    creatorTag: t.Optional(t.String()),
-});
-export const response = t.Record(t.Union(ANGLE_NETWORKS.merkl.map(chain => t.Literal(`${chain}`))), t.Optional(t.Record(t.String({ title: "id" }), t.Record(t.String({ title: "CampaignId" }), t.Object({
-    chainId: param.Chain.type,
-    campaignId: t.String(),
-    tags: t.Optional(t.Array(t.String())),
-    creator: t.String(),
-    rewardToken: t.String(),
-    mainParameter: t.String(),
-    campaignParameters: t.Object({}),
-    campaignType: param.Type.type,
-})))));
-export default (app) => app.get("", async ({ query, set }) => {
-    const rawChainIds = query.chainIds;
-    let chainIds;
-    if (!rawChainIds) {
-        chainIds = Object.keys(ChainId)
-            .map(k => Number.parseInt(k))
-            .filter(k => isSupportedChain(k, "merkl"));
-    }
-    else if (typeof rawChainIds === "string") {
-        chainIds = [Number.parseInt(rawChainIds)];
-    }
-    else {
-        chainIds = rawChainIds.map(chainId => Number.parseInt(chainId));
-    }
-    for (const chainId of chainIds) {
-        if (!!chainId &&
-            (!isSupportedChain(chainId, "merkl") ||
-                !registry(chainId)?.Merkl?.DistributionCreator ||
-                !registry(chainId)?.Merkl?.Distributor ||
-                !registry(chainId)?.Merkl?.CoreMerkl)) {
-            throw new UnsupportedNetwork(chainId);
-        }
-    }
-    const cacheKeys = chainIds.map(chainId => `Campaigns_${chainId}`);
-    const dynamicData = (await Redis.getMany(cacheKeys)).reduce((prev, chainData, index) => {
-        if (!!chainData) {
-            prev[chainIds[index]] = Object.keys(chainData).reduce((prev, curr) => {
-                if (Number.parseInt(curr.split("_")[0]) === Campaign.ERC20) {
-                    prev[curr] = chainData[curr];
-                }
-                return prev;
-            }, {});
-        }
-        return prev;
-    }, {});
-    return dynamicData;
-}, {
-    query: t.Object({
-        chainIds: t.Optional(t.Union([t.String(), t.Array(t.String())])),
-    }),
-    tags: ["Campaigns"],
-});

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

@@ -1,53 +0,0 @@
-import { type Elysia } from "elysia";
-export declare const query: import("@sinclair/typebox").TObject<{
-    chainId: import("@sinclair/typebox").TNumber;
-    timestamp: import("@sinclair/typebox").TNumber;
-}>;
-export declare const response: import("@sinclair/typebox").TObject<{
-    chainId: import("@sinclair/typebox").TUnion<import("elysia").TSchema[]>;
-    epoch: import("@sinclair/typebox").TNumber;
-    root: import("@sinclair/typebox").TString;
-    timestamp: 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: {
-                timestamp: number;
-                chainId: number;
-            };
-            headers: unknown;
-            response: {
-                200: {
-                    timestamp: number;
-                    chainId: number;
-                    root: string;
-                    epoch: number;
-                } | null;
-            };
-        };
-    };
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-}, {
-    derive: {};
-    resolve: {};
-    schema: {};
-}>;
-export default _default;

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

@@ -1,47 +0,0 @@
-import param from "../../types/parameters";
-import { engineDbClient } from "../../utils/prisma";
-import { t } from "elysia";
-import checkQueryChainIdValidity from "../../hooks/checkQueryChainIdValidity";
-export const query = t.Object({
-    chainId: t.Numeric(),
-    timestamp: t.Numeric(),
-});
-export const response = t.Object({
-    chainId: param.Chain.type,
-    epoch: t.Number(),
-    root: t.String(),
-    timestamp: t.Number(),
-});
-export default (app) => app.use(checkQueryChainIdValidity()).get("", async ({ query }) => {
-    const chainId = query.chainId;
-    // Query all campaigns
-    let root = await engineDbClient.merklRoots.findFirst({
-        orderBy: {
-            timestamp: "desc",
-        },
-        where: {
-            chainId: chainId,
-            timestamp: {
-                lte: query.timestamp,
-            },
-        },
-    });
-    if (!root) {
-        // Find the root with the lowest timestamp
-        root = await engineDbClient.merklRoots.findFirst({
-            orderBy: {
-                timestamp: "asc",
-            },
-            where: {
-                chainId: chainId,
-            },
-        });
-    }
-    return root;
-}, {
-    transform({ query }) {
-        query.chainId = !query.chainId ? undefined : Number.parseInt(query.chainId);
-    },
-    query,
-    tags: ["Merkl"],
-});