@merkl/api 0.9.15

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

@@ -0,0 +1,42 @@
+import { AuthorizationHeadersDto, BackOfficeGuard } from "@/guards/BackOffice.guard";
+import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "@/utils/throw";
+import { NULL_ADDRESS } from "@sdk";
+import Elysia from "elysia";
+import { AddBlacklistDto, CheckBlacklistDto, RemoveBlacklistDto } from "./blacklist.model";
+import { BlacklistService } from "./blacklist.service";
+export const BlacklistController = new Elysia({ prefix: "/blacklists", detail: { tags: ["Blacklists"], hide: true } })
+    // ─── Get Entire Blacklist ────────────────────────────────────────────
+    .get("/", async () => await BlacklistService.findMany())
+    .get("/mapping", async () => await BlacklistService.findMapping())
+    // ─── Check If An Address Is Blacklisted ──────────────────────────────
+    .get("/check/:address", async ({ params }) => await BlacklistService.isBlacklisted(params.address), {
+    params: CheckBlacklistDto,
+    beforeHandle: ({ params }) => {
+        params.address = throwOnInvalidRequiredAddress(params.address);
+    },
+})
+    // ─── Add User To Blacklist ───────────────────────────────────────────
+    .post("/", async ({ body }) => await BlacklistService.add({
+    ...body,
+    id: BlacklistService.hashId(body.chainId, body.userAddress, body.poolAddress),
+}), {
+    body: AddBlacklistDto,
+    headers: AuthorizationHeadersDto,
+    beforeHandle: async ({ body, headers }) => {
+        await BackOfficeGuard({ headers });
+        body.userAddress = throwOnInvalidRequiredAddress(body.userAddress);
+        body.poolAddress = throwOnInvalidRequiredAddress(body.poolAddress ?? NULL_ADDRESS);
+        throwOnUnsupportedChainId(body.chainId);
+    },
+    detail: { hide: true },
+})
+    // ─── Remove A User From Blacklist ────────────────────────────────────
+    .delete("/user/:address", async ({ params }) => await BlacklistService.remove(params.address), {
+    params: RemoveBlacklistDto,
+    headers: AuthorizationHeadersDto,
+    beforeHandle: async ({ headers, params }) => {
+        await BackOfficeGuard({ headers });
+        params.address = throwOnInvalidRequiredAddress(params.address);
+    },
+    detail: { hide: true },
+});

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

@@ -0,0 +1,15 @@
+export declare const AddBlacklistDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    userAddress: import("@sinclair/typebox").TString;
+    poolAddress: import("@sinclair/typebox").TString;
+    reason: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export declare const CheckBlacklistDto: import("@sinclair/typebox").TObject<{
+    address: import("@sinclair/typebox").TString;
+}>;
+export declare const RemoveBlacklistDto: import("@sinclair/typebox").TObject<{
+    address: import("@sinclair/typebox").TString;
+}>;
+export type AddBlacklistModel = typeof AddBlacklistDto.static & {
+    id: string;
+};

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

@@ -0,0 +1,13 @@
+import { t } from "elysia";
+export const AddBlacklistDto = t.Object({
+    chainId: t.Numeric(),
+    userAddress: t.String(),
+    poolAddress: t.String(),
+    reason: t.Optional(t.String()),
+});
+export const CheckBlacklistDto = t.Object({
+    address: t.String(),
+});
+export const RemoveBlacklistDto = t.Object({
+    address: t.String(),
+});

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

@@ -0,0 +1,21 @@
+import type { AddBlacklistModel } from "./blacklist.model";
+export declare class BlacklistRepository {
+    static findMany(): Promise<{
+        id: string;
+        chainId: number;
+        poolAddress: string;
+        userAddress: string;
+        arrestTimestamp: bigint;
+        arrestDetails: import("database/api/.generated/runtime/library").JsonValue;
+    }[]>;
+    static check(address: string): Promise<boolean>;
+    static remove(address: string): Promise<boolean>;
+    static add(x: AddBlacklistModel): Promise<{
+        id: string;
+        chainId: number;
+        poolAddress: string;
+        userAddress: string;
+        arrestTimestamp: bigint;
+        arrestDetails: import("database/api/.generated/runtime/library").JsonValue;
+    }>;
+}

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

@@ -0,0 +1,50 @@
+import { apiDbClient } from "@db";
+import { NULL_ADDRESS } from "@sdk";
+export class BlacklistRepository {
+    static async findMany() {
+        return await apiDbClient.blacklist.findMany();
+    }
+    static async check(address) {
+        return ((await apiDbClient.blacklist.findMany({
+            where: {
+                userAddress: address,
+            },
+        })).findIndex(x => !!x.arrestTimestamp) !== -1);
+    }
+    static async remove(address) {
+        const points = await apiDbClient.blacklist.findMany({ where: { userAddress: address } });
+        if (points?.filter(x => !!x.arrestTimestamp).length === 0) {
+            throw new Error(`Address ${address} is not blacklisted`);
+        }
+        for (const point of points) {
+            await apiDbClient.blacklist.update({
+                data: {
+                    arrestTimestamp: 0,
+                },
+                where: {
+                    chainId_userAddress_poolAddress: {
+                        chainId: point.chainId,
+                        userAddress: point.userAddress,
+                        poolAddress: point.poolAddress,
+                    },
+                },
+            });
+        }
+        return true;
+    }
+    static async add(x) {
+        if (!!(await apiDbClient.blacklist.findUnique({ where: { id: x.id } }))) {
+            await apiDbClient.blacklist.delete({ where: { id: x.id } });
+        }
+        return await apiDbClient.blacklist.create({
+            data: {
+                id: x.id,
+                User: { connectOrCreate: { where: { address: x.userAddress }, create: { address: x.userAddress } } },
+                Chain: { connect: { id: x.chainId } },
+                poolAddress: x.poolAddress ?? NULL_ADDRESS,
+                arrestTimestamp: Date.now(),
+                arrestDetails: !x.reason ? {} : { reason: x.reason },
+            },
+        });
+    }
+}

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

@@ -0,0 +1,24 @@
+import type { ChainId } from "@sdk";
+import type { AddBlacklistModel } from ".";
+export declare class BlacklistService {
+    static hashId(chainId: ChainId, userAddress: string, poolAddress: string): string;
+    static findMany(): Promise<{
+        id: string;
+        chainId: number;
+        poolAddress: string;
+        userAddress: string;
+        arrestTimestamp: bigint;
+        arrestDetails: import("database/api/.generated/runtime/library").JsonValue;
+    }[]>;
+    static findMapping(): Promise<unknown>;
+    static isBlacklisted(address: string): Promise<boolean>;
+    static remove(address: string): Promise<boolean>;
+    static add(x: AddBlacklistModel): Promise<{
+        id: string;
+        chainId: number;
+        poolAddress: string;
+        userAddress: string;
+        arrestTimestamp: bigint;
+        arrestDetails: import("database/api/.generated/runtime/library").JsonValue;
+    }>;
+}

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

@@ -0,0 +1,31 @@
+import { utils } from "ethers";
+import { CacheService } from "../cache";
+import { TTLPresets } from "../cache/cache.model";
+import { BlacklistRepository } from "./blacklist.repository";
+export class BlacklistService {
+    static hashId(chainId, userAddress, poolAddress) {
+        return Bun.hash(`${chainId}${userAddress}${poolAddress}`).toString();
+    }
+    static async findMany() {
+        return await CacheService.wrap(TTLPresets.MIN_5, BlacklistRepository.findMany);
+    }
+    static async findMapping() {
+        return await CacheService.wrap(TTLPresets.MIN_5, () => BlacklistRepository.findMany().then(r => {
+            return r.reduce((prev, { userAddress, arrestTimestamp }) => {
+                if (!!arrestTimestamp) {
+                    prev[utils.getAddress(userAddress)] = true;
+                }
+                return prev;
+            }, {});
+        }));
+    }
+    static async isBlacklisted(address) {
+        return BlacklistRepository.check(utils.getAddress(address));
+    }
+    static async remove(address) {
+        return await BlacklistRepository.remove(address);
+    }
+    static async add(x) {
+        return await BlacklistRepository.add(x);
+    }
+}

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

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

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

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

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

@@ -0,0 +1,88 @@
+import Elysia from "elysia";
+export declare const BoostController: Elysia<"/boosts", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    boosts: {
+        euler: {
+            post: {
+                body: {
+                    addresses: string[];
+                } | {
+                    address: string;
+                    score: string;
+                }[];
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: {
+                        address: string;
+                        boost: string;
+                    }[];
+                };
+            };
+        };
+    };
+} & {
+    boosts: {
+        euler: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: {
+                        address: string;
+                        boost: string;
+                    }[];
+                };
+            };
+        };
+    };
+} & {
+    boosts: {
+        openblock: {
+            zksync: {
+                post: {
+                    body: {
+                        addresses: string[];
+                    } | {
+                        address: string;
+                        score: string;
+                    }[];
+                    params: {};
+                    query: {
+                        target: string;
+                        protocol: string;
+                    };
+                    headers: unknown;
+                    response: {
+                        200: {
+                            address: string;
+                            boost: string;
+                        }[];
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

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

@@ -0,0 +1,15 @@
+import Elysia from "elysia";
+import { getEulerBoostBody, getZksyncBoost } from "./boost.model";
+import { BoostService } from "./boost.service";
+export const BoostController = new Elysia({ prefix: "/boosts", detail: { tags: ["Boosts"], hide: true } })
+    // ─── Get Euler Boost ─────────────────────────────────────────────────
+    .post("/euler", async () => BoostService.getEulerBoost(), {
+    body: getEulerBoostBody,
+    detail: { hide: true },
+})
+    .get("/euler", async () => BoostService.getEulerBoost())
+    .post("/openblock/zksync", async ({ query, body }) => BoostService.getOpenBlockBoost(query, body), {
+    query: getZksyncBoost,
+    body: getEulerBoostBody,
+    detail: { hide: true },
+});

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

@@ -0,0 +1,12 @@
+export declare const getEulerBoostBody: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+    addresses: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+}>, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+    address: import("@sinclair/typebox").TString;
+    score: import("@sinclair/typebox").TString;
+}>>]>;
+export declare const getZksyncBoost: import("@sinclair/typebox").TObject<{
+    protocol: import("@sinclair/typebox").TString;
+    target: import("@sinclair/typebox").TString;
+}>;
+export type getZksyncBoostModel = typeof getZksyncBoost.static;
+export type getEulerBoostBodyModel = typeof getEulerBoostBody.static;

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

@@ -0,0 +1,14 @@
+import { t } from "elysia";
+export const getEulerBoostBody = t.Union([
+    t.Object({
+        addresses: t.Array(t.String()),
+    }),
+    t.Array(t.Object({
+        address: t.String(),
+        score: t.String(),
+    })),
+]);
+export const getZksyncBoost = t.Object({
+    protocol: t.String(),
+    target: t.String(),
+});

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

@@ -0,0 +1,11 @@
+import type { getEulerBoostBodyModel, getZksyncBoostModel } from "./boost.model";
+export declare class BoostService {
+    static getEulerBoost(): Promise<{
+        address: string;
+        boost: string;
+    }[]>;
+    static getOpenBlockBoost(query: getZksyncBoostModel, body: getEulerBoostBodyModel): Promise<{
+        address: string;
+        boost: string;
+    }[]>;
+}

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

@@ -0,0 +1,20 @@
+import axios from "axios";
+export class BoostService {
+    static async getEulerBoost() {
+        return (await axios.get("https://points.euler.finance/integrations/merkl/usd0multipliers")).data.map(({ address, score }) => ({ address, boost: score }));
+    }
+    static async getOpenBlockBoost(query, body) {
+        const protocol = query.protocol;
+        const target = query.target;
+        const url = `https://www.data-openblocklabs.com/zksync/boosts/${protocol}/${target}`;
+        const response = await axios.post(url, body, {
+            headers: {
+                "Content-Type": "application/json",
+            },
+        });
+        if (response.data.length === 0) {
+            throw new Error("No data found");
+        }
+        return response.data.map(({ address, boost }) => ({ address, boost: boost.toString() }));
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from "./boost.controller";
+export * from "./boost.service";

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

@@ -0,0 +1,2 @@
+export * from "./boost.controller";
+export * from "./boost.service";

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

@@ -0,0 +1,10 @@
+export declare const mimeTypes: readonly ["audio/aac", "application/x-abiword", "image/apng", "application/x-freearc", "image/avif", "video/x-msvideo", "application/vnd.amazon.ebook", "application/octet-stream", "image/bmp", "application/x-bzip", "application/x-bzip2", "application/x-cdf", "application/x-csh", "text/css", "text/csv", "application/msword", "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "application/vnd.ms-fontobject", "application/epub+zip", "application/gzip", "application/x-gzip", "image/gif", "text/html", "image/vnd.microsoft.icon", "text/calendar", "application/java-archive", "image/jpeg", "text/javascript", "application/json", "application/ld+json", "audio/midi", "audio/x-midi", "text/javascript", "audio/mpeg", "video/mp4", "video/mpeg", "application/vnd.apple.installer+xml", "application/vnd.oasis.opendocument.presentation", "application/vnd.oasis.opendocument.spreadsheet", "application/vnd.oasis.opendocument.text", "audio/ogg", "video/ogg", "application/ogg", "audio/ogg", "font/otf", "image/png", "application/pdf", "application/x-httpd-php", "application/vnd.ms-powerpoint", "application/vnd.openxmlformats-officedocument.presentationml.presentation", "application/vnd.rar", "application/rtf", "application/x-sh", "image/svg+xml", "application/x-tar", "image/tiff", "video/mp2t", "font/ttf", "text/plain", "application/vnd.visio", "audio/wav", "audio/webm", "video/webm", "image/webp", "font/woff", "font/woff2", "application/xhtml+xml", "application/vnd.ms-excel", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "application/xml", "text/xml", "application/atom+xml", "application/xml", "application/vnd.mozilla.xul+xml", "application/zip", "application/x-zip-compressed", "audio/video", "video/3gpp", "audio/3gpp", "audio/video", "video/3gpp2", "audio/3gpp2", "application/x-7z-compressed"];
+export type MimeType = (typeof mimeTypes)[number];
+export type UploadOptions<T> = {
+    type?: MimeType;
+    compression?: boolean;
+    overwrite?: boolean;
+    isPublic?: boolean;
+    transform?: (obj: T) => string;
+    separator?: string;
+};

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

@@ -0,0 +1,85 @@
+export const mimeTypes = [
+    "audio/aac",
+    "application/x-abiword",
+    "image/apng",
+    "application/x-freearc",
+    "image/avif",
+    "video/x-msvideo",
+    "application/vnd.amazon.ebook",
+    "application/octet-stream",
+    "image/bmp",
+    "application/x-bzip",
+    "application/x-bzip2",
+    "application/x-cdf",
+    "application/x-csh",
+    "text/css",
+    "text/csv",
+    "application/msword",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "application/vnd.ms-fontobject",
+    "application/epub+zip",
+    "application/gzip",
+    "application/x-gzip",
+    "image/gif",
+    "text/html",
+    "image/vnd.microsoft.icon",
+    "text/calendar",
+    "application/java-archive",
+    "image/jpeg",
+    "text/javascript",
+    "application/json",
+    "application/ld+json",
+    "audio/midi",
+    "audio/x-midi",
+    "text/javascript",
+    "audio/mpeg",
+    "video/mp4",
+    "video/mpeg",
+    "application/vnd.apple.installer+xml",
+    "application/vnd.oasis.opendocument.presentation",
+    "application/vnd.oasis.opendocument.spreadsheet",
+    "application/vnd.oasis.opendocument.text",
+    "audio/ogg",
+    "video/ogg",
+    "application/ogg",
+    "audio/ogg",
+    "font/otf",
+    "image/png",
+    "application/pdf",
+    "application/x-httpd-php",
+    "application/vnd.ms-powerpoint",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    "application/vnd.rar",
+    "application/rtf",
+    "application/x-sh",
+    "image/svg+xml",
+    "application/x-tar",
+    "image/tiff",
+    "video/mp2t",
+    "font/ttf",
+    "text/plain",
+    "application/vnd.visio",
+    "audio/wav",
+    "audio/webm",
+    "video/webm",
+    "image/webp",
+    "font/woff",
+    "font/woff2",
+    "application/xhtml+xml",
+    "application/vnd.ms-excel",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "application/xml",
+    "text/xml",
+    "application/atom+xml",
+    "application/xml",
+    "application/vnd.mozilla.xul+xml",
+    "application/zip",
+    "application/x-zip-compressed",
+    "audio/video",
+    "video/3gpp",
+    "audio/3gpp",
+    "audio/video",
+    "video/3gpp2",
+    "audio/3gpp2",
+    "application/x-7z-compressed",
+];

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

@@ -0,0 +1,11 @@
+import type { UploadOptions } from "./bucket.model";
+export declare class BucketService {
+    #private;
+    defaultUploadOptions: UploadOptions<unknown>;
+    constructor(bucket: string, projectId: string);
+    pushArray<T>(filename: string, arr: T[], options?: UploadOptions<T>): Promise<number>;
+    push(filename: string, text: string, options?: Omit<UploadOptions<never>, "transform" | "separator">): Promise<number>;
+    pushRaw(filename: string, data: Uint8Array, options?: Omit<UploadOptions<never>, "transform" | "separator">): Promise<number>;
+    pullArray<T>(filename: string, callback: (elem: string) => T, separator?: string): Promise<T[]>;
+    pull(filename: string): Promise<string>;
+}