@merkl/api 0.21.46 → 1.0.0

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

@@ -1,61 +0,0 @@
-import { AuthorizationHeadersDto, BackOfficeGuard } from "@/guards/BackOffice.guard";
-import { throwOnInvalidRequiredAddress, throwOnUnsupportedChainId } from "@/utils/throw";
-import Elysia from "elysia";
-import { ChainDto, DateDto, GetTransactionsQueryModel, RevenuesDto, TokensDateDto, TokensDto, } from "./accounting.model";
-import { AccountingService } from "./accounting.service";
-export const AccountingController = new Elysia({ prefix: "/accounting", detail: { tags: ["Accounting"], hide: true } })
-    .get("/", async ({ query }) => await AccountingService.findMany(query), {
-    query: GetTransactionsQueryModel,
-    headers: AuthorizationHeadersDto,
-    beforeHandle: BackOfficeGuard,
-})
-    .group("/revenues", app => {
-    return app
-        .get("", async () => await AccountingService.getAllRevenueBreakdownByChain(), {
-        headers: AuthorizationHeadersDto,
-        beforeHandle: BackOfficeGuard,
-    })
-        .get("/per-month/:year/:month", async ({ params }) => await AccountingService.getMonthlyRevenue(params.year, params.month), {
-        params: DateDto,
-        headers: AuthorizationHeadersDto,
-        beforeHandle: BackOfficeGuard,
-    })
-        .get("/chains/:chainId", async ({ params }) => await AccountingService.getRevenueByChain(params.chainId), {
-        params: ChainDto,
-        headers: AuthorizationHeadersDto,
-        beforeHandle: async ({ params, headers }) => {
-            BackOfficeGuard({ headers });
-            throwOnUnsupportedChainId(params.chainId);
-        },
-    })
-        .get("/chains/:chainId/per-month/:year/:month", async ({ params }) => await AccountingService.getMonthlyRevenueByChain(params.chainId, params.year, params.month), {
-        params: RevenuesDto,
-        headers: AuthorizationHeadersDto,
-        beforeHandle: async ({ params, headers }) => {
-            BackOfficeGuard({ headers });
-            throwOnUnsupportedChainId(params.chainId);
-        },
-    });
-})
-    // ─── Tokens Group ────────────────────────────────────────────────────
-    .group("/tokens", app => {
-    return app
-        .get("/:chainId/:tokenAddress", async ({ params }) => await AccountingService.getTokenTransaction(params.tokenAddress, params.chainId), {
-        params: TokensDto,
-        headers: AuthorizationHeadersDto,
-        beforeHandle: async ({ params, headers }) => {
-            BackOfficeGuard({ headers });
-            params.tokenAddress = throwOnInvalidRequiredAddress(params.tokenAddress);
-            throwOnUnsupportedChainId(params.chainId);
-        },
-    })
-        .get("/:chainId/:tokenAddress/per-month/:year/:month", async ({ params }) => await AccountingService.getTokenMonthlyTransaction(params.tokenAddress, params.chainId, params.year, params.month), {
-        params: TokensDateDto,
-        headers: AuthorizationHeadersDto,
-        beforeHandle: async ({ params, headers }) => {
-            BackOfficeGuard({ headers });
-            params.tokenAddress = throwOnInvalidRequiredAddress(params.tokenAddress);
-            throwOnUnsupportedChainId(params.chainId);
-        },
-    });
-});

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

@@ -1,32 +0,0 @@
-import { t } from "elysia";
-export const TokensDto = t.Object({
-    chainId: t.Numeric(),
-    tokenAddress: t.String(),
-});
-export const GetTransactionsQueryModel = t.Object({
-    page: t.Optional(t.Numeric()),
-    items: t.Optional(t.Numeric()),
-});
-export const TokensDateDto = t.Object({
-    chainId: t.Numeric(),
-    tokenAddress: t.String(),
-    month: t.Numeric(),
-    year: t.Numeric(),
-});
-export const DateDto = t.Object({
-    month: t.Numeric(),
-    year: t.Numeric(),
-});
-export const ChainDto = t.Object({
-    chainId: t.Numeric(),
-});
-export const RevenuesDto = t.Object({
-    chainId: t.Numeric(),
-    month: t.Numeric(),
-    year: t.Numeric(),
-});
-export const GetRevenuesDto = t.Object({
-    chainId: t.Numeric(),
-    month: t.Numeric(),
-    year: t.Numeric(),
-});

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

@@ -1,154 +0,0 @@
-import { apiDbClient } from "@db";
-export class AccountingRepository {
-    static async findMany(query) {
-        const { page: _page, items: _items } = query;
-        const page = _page ? _page : 0;
-        const items = _items ? _items : 20;
-        return await apiDbClient.dump.findMany({
-            take: items,
-            skip: page * items,
-        });
-    }
-    static async getByTokenForDumper(fromTokenId) {
-        return await apiDbClient.dump.findMany({
-            where: {
-                fromTokenId,
-                NOT: {
-                    OR: [
-                        {
-                            recipient: {
-                                equals: apiDbClient.dump.fields.multisig,
-                            },
-                        },
-                        {
-                            recipient: {
-                                equals: "0xb08AB4332AD871F89da24df4751968A61e58013c",
-                            },
-                        },
-                    ],
-                },
-            },
-        });
-    }
-    static async getForMonthForRecipient(recipient, toTokenId, month, year) {
-        const startDate = new Date(year, month, 0);
-        const endDate = new Date(year, month + 1, 0);
-        return await apiDbClient.dump.findMany({
-            where: {
-                toTokenId,
-                recipient,
-                datetime: {
-                    gte: startDate,
-                    lt: endDate,
-                },
-            },
-        });
-    }
-    static async getForMultisigBetweenDates(startDate, endDate) {
-        return await apiDbClient.dump.findMany({
-            where: {
-                OR: [
-                    {
-                        recipient: {
-                            equals: apiDbClient.dump.fields.multisig,
-                        },
-                    },
-                    {
-                        recipient: {
-                            equals: "0xb08AB4332AD871F89da24df4751968A61e58013c",
-                        },
-                    },
-                ],
-                datetime: {
-                    gte: startDate,
-                    lt: endDate,
-                },
-            },
-        });
-    }
-    static async getForMultisig() {
-        return await apiDbClient.dump.findMany({
-            where: {
-                OR: [
-                    {
-                        recipient: {
-                            equals: apiDbClient.dump.fields.multisig,
-                        },
-                    },
-                    {
-                        recipient: {
-                            equals: "0xb08AB4332AD871F89da24df4751968A61e58013c",
-                        },
-                    },
-                ],
-            },
-        });
-    }
-    static async getForMultisigByChain(chainId) {
-        return await apiDbClient.dump.findMany({
-            where: {
-                chainId,
-                OR: [
-                    {
-                        recipient: {
-                            equals: apiDbClient.dump.fields.multisig,
-                        },
-                    },
-                    {
-                        recipient: {
-                            equals: "0xb08AB4332AD871F89da24df4751968A61e58013c",
-                        },
-                    },
-                ],
-            },
-        });
-    }
-    static async getForMultisigByChainBetweenDates(chainId, startDate, endDate) {
-        return await apiDbClient.dump.findMany({
-            where: {
-                chainId,
-                datetime: {
-                    gte: startDate,
-                    lte: endDate,
-                },
-                OR: [
-                    {
-                        recipient: {
-                            equals: apiDbClient.dump.fields.multisig,
-                        },
-                    },
-                    {
-                        recipient: {
-                            equals: "0xb08AB4332AD871F89da24df4751968A61e58013c",
-                        },
-                    },
-                ],
-            },
-        });
-    }
-    static async getForDumperBetweenDates(fromTokenId, startDate, endDate) {
-        return await apiDbClient.dump.findMany({
-            where: {
-                fromTokenId,
-                datetime: {
-                    gte: startDate,
-                    lte: endDate,
-                },
-                NOT: {
-                    OR: [
-                        {
-                            recipient: {
-                                equals: apiDbClient.dump.fields.multisig,
-                            },
-                        },
-                        {
-                            recipient: {
-                                equals: "0xb08AB4332AD871F89da24df4751968A61e58013c",
-                            },
-                        },
-                    ],
-                },
-            },
-        });
-    }
-}

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

@@ -1,107 +0,0 @@
-import { AccountingRepository } from "@/modules/v4/accounting/accounting.repository";
-import { TokenService } from "@/modules/v4/token/token.service";
-import { ChainId } from "@sdk";
-export class AccountingService {
-    static hashId(chainId, fromTokenId, toTokenId, timestamp) {
-        return Bun.hash(`${chainId}${fromTokenId}${toTokenId}${timestamp}`).toString();
-    }
-    static getTokenId(chainId, address) {
-        return TokenService.hashId({ chainId, address });
-    }
-    static async findMany(query) {
-        return await AccountingRepository.findMany(query);
-    }
-    static async getRevenue() {
-        const data = await AccountingRepository.getForMultisig();
-        let totalAmount = 0;
-        for (const tx of data) {
-            totalAmount += Number(tx.amountIn);
-        }
-        return { totalAmount };
-    }
-    static async getRevenueByChain(chainId) {
-        const data = await AccountingRepository.getForMultisigByChain(chainId);
-        let totalAmount = 0;
-        for (const tx of data) {
-            totalAmount += Number(tx.amountIn);
-        }
-        return { totalAmount };
-    }
-    static async getAllRevenueBreakdownByChain() {
-        const breakdown = {};
-        let consolidatedAmount = 0;
-        for (const chainId of Object.values(ChainId).filter(id => typeof id === "number")) {
-            const data = await AccountingRepository.getForMultisigByChain(chainId);
-            let totalAmount = 0;
-            for (const tx of data) {
-                totalAmount += Number(tx.amountIn);
-            }
-            breakdown[chainId] = { chainAmount: totalAmount, percentage: 0 };
-            consolidatedAmount += totalAmount;
-        }
-        for (const chainId of Object.values(ChainId).filter(id => typeof id === "number")) {
-            const totalAmount = breakdown[chainId].chainAmount;
-            breakdown[chainId] = { chainAmount: totalAmount, percentage: (totalAmount * 100) / consolidatedAmount };
-        }
-        return { total: consolidatedAmount, breakdown };
-    }
-    static async getMonthlyRevenue(year, month) {
-        const startDate = new Date(year, month - 1, 1);
-        const endDate = new Date(year, month, 0, 23, 59, 59);
-        const breakdown = {};
-        let consolidatedAmount = 0;
-        for (const chainId of Object.values(ChainId).filter(id => typeof id === "number")) {
-            const monthlyData = await AccountingRepository.getForMultisigByChainBetweenDates(chainId, startDate, endDate);
-            let totalAmount = 0;
-            for (const tx of monthlyData) {
-                totalAmount += Number(tx.amountIn);
-            }
-            breakdown[chainId] = { chainAmount: totalAmount, percentage: 0 };
-            consolidatedAmount += totalAmount;
-        }
-        for (const chainId of Object.values(ChainId).filter(id => typeof id === "number")) {
-            const totalAmount = breakdown[chainId].chainAmount;
-            breakdown[chainId] = { chainAmount: totalAmount, percentage: (totalAmount * 100) / consolidatedAmount };
-        }
-        return { total: consolidatedAmount, breakdown, from: startDate.toDateString(), to: endDate.toDateString() };
-    }
-    static async getMonthlyRevenueByChain(chainId, year, month) {
-        const startDate = new Date(year, month - 1, 1);
-        const endDate = new Date(year, month, 0, 23, 59, 59);
-        const monthlyData = await AccountingRepository.getForMultisigByChainBetweenDates(chainId, startDate, endDate);
-        let totalAmount = 0;
-        for (const tx of monthlyData) {
-            totalAmount += Number(tx.amountIn);
-        }
-        return { totalAmount, from: startDate.toDateString(), to: endDate.toDateString() };
-    }
-    static async getTokenTransaction(tokenAddress, chainId) {
-        const tokenId = AccountingService.getTokenId(chainId, tokenAddress);
-        const data = await AccountingRepository.getByTokenForDumper(tokenId);
-        let totalAmount = 0;
-        let totalAmountUSD = 0;
-        for (const tx of data) {
-            totalAmount += Number(tx.amountIn);
-            totalAmountUSD += Number(tx.amountOut);
-        }
-        return { totalAmount: totalAmount, totalAmountUSD: totalAmountUSD };
-    }
-    static async getTokenMonthlyTransaction(tokenAddress, chainId, year, month) {
-        const startDate = new Date(year, month - 1, 1);
-        const endDate = new Date(year, month, 0, 23, 59, 59);
-        const tokenId = AccountingService.getTokenId(chainId, tokenAddress);
-        const monthlyData = await AccountingRepository.getForDumperBetweenDates(tokenId, startDate, endDate);
-        let totalAmount = 0;
-        let totalAmountUSD = 0;
-        for (const tx of monthlyData) {
-            totalAmount += Number(tx.amountIn);
-            totalAmountUSD += Number(tx.amountOut);
-        }
-        return {
-            totalAmount: totalAmount,
-            totalAmountUSD: totalAmountUSD,
-            from: startDate.toDateString(),
-            to: endDate.toDateString(),
-        };
-    }
-}

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

@@ -1,20 +0,0 @@
-import { log } from "@/utils/logger";
-import { withRetry } from "@sdk";
-import { GoogleAuth } from "google-auth-library";
-export class AirflowService {
-    static async triggerDAGRun(dagId, conf) {
-        const auth = new GoogleAuth({
-            scopes: "https://www.googleapis.com/auth/cloud-platform",
-        });
-        const client = await auth.getClient();
-        const reqParams = {
-            method: "POST",
-            url: `${process.env.AIRFLOW_URL}/api/v1/dags/${dagId}/dagRuns`,
-            data: {
-                conf,
-            },
-        };
-        await withRetry(async () => await client.request(reqParams), [], 2, 10_000);
-        log.info(`✅ triggered DAG ${dagId}`);
-    }
-}

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

@@ -1,13 +0,0 @@
-import { AprType } from "@db/api";
-import { t } from "elysia";
-// ─── Dtos ────────────────────────────────────────────────────────────────────
-export const AprBreakdownResourceDto = t.Object({
-    identifier: t.String(),
-    type: t.Enum(AprType),
-    value: t.Number(),
-});
-export const AprRecordResourceDto = t.Object({
-    cumulated: t.Number(),
-    timestamp: t.Union([t.BigInt(), t.String()]),
-    breakdowns: t.Array(AprBreakdownResourceDto),
-});

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

@@ -1,52 +0,0 @@
-import { AprType } from "@db/api";
-import { Campaign as CampaignTypeV3 } from "@sdk";
-import moment from "moment";
-export class AprService {
-    static hashId(opportunityId, timestamp) {
-        return Bun.hash(`${opportunityId}${timestamp}`).toString();
-    }
-    /**
-     * @deprecated
-     */
-    static extractFromDynamicData(type, campaigns, timestamp = BigInt(moment().unix())) {
-        const typesWithoutApr = [CampaignTypeV3.INVALID, CampaignTypeV3.JSON_AIRDROP, CampaignTypeV3.ERC20_SNAPSHOT];
-        if (typesWithoutApr.includes(type))
-            return { timestamp, cumulated: 0, breakdowns: [] };
-        let cumulated = campaigns.reduce((sum, campaign) => {
-            const isLive = BigInt(campaign.endTimestamp) > timestamp && BigInt(campaign.startTimestamp) < timestamp;
-            if (!isLive)
-                return sum;
-            return sum + (Number.isNaN(Number(campaign.apr)) ? 0 : Number(campaign.apr));
-        }, 0) ?? 0;
-        cumulated = Number.isNaN(Number(cumulated)) || !Number.isFinite(cumulated) ? 0 : cumulated;
-        const breakdowns = campaigns.map(campaign => {
-            const isLive = BigInt(campaign.endTimestamp) > timestamp && BigInt(campaign.startTimestamp) < timestamp;
-            return {
-                identifier: campaign.campaignId,
-                type: AprType.CAMPAIGN,
-                value: !isLive || Number.isNaN(campaign.apr) || !Number.isFinite(campaign.apr) ? 0 : Number(campaign.apr),
-            };
-        });
-        if (type === CampaignTypeV3.CLAMM) {
-            for (const campaign of campaigns) {
-                const isLive = BigInt(campaign.endTimestamp) > timestamp && BigInt(campaign.startTimestamp) < timestamp;
-                if (campaign.forwarders) {
-                    for (const forwarder of campaign.forwarders) {
-                        breakdowns.push({
-                            identifier: forwarder.label,
-                            type: AprType.PROTOCOL,
-                            value: !isLive || Number.isNaN(forwarder.almAPR) || !Number.isFinite(forwarder.almAPR)
-                                ? 0
-                                : Number(forwarder.almAPR),
-                        });
-                    }
-                }
-            }
-        }
-        return {
-            timestamp,
-            cumulated,
-            breakdowns,
-        };
-    }
-}

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

@@ -1,23 +0,0 @@
-import { JwtCookieDto, VerifyJwtGuard } from "@/guards/VerifyJwt.guard";
-import Elysia from "elysia";
-import { LoginDto } from "./authentication.model";
-import { AuthService } from "./authentication.service";
-const authService = new AuthService();
-export const AuthController = new Elysia({
-    prefix: "/auth",
-    detail: { tags: ["Authentication"] },
-})
-    .post("login", async ({ body, cookie: { jwt } }) => {
-    jwt.value = await authService.login(body);
-    jwt.sameSite = true;
-    jwt.path = "/";
-    jwt.httpOnly = true;
-    jwt.secure = true;
-    jwt.maxAge = 2 * 60 * 60; // 2h
-    return;
-}, { body: LoginDto })
-    .delete("/revoke", async ({ cookie: { jwt } }) => {
-    await authService.revokeToken(jwt.value);
-    jwt.remove();
-    return;
-}, { beforeHandle: VerifyJwtGuard, cookie: JwtCookieDto });

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

@@ -1,6 +0,0 @@
-import { t } from "elysia";
-export const LoginDto = t.Object({
-    address: t.String({ pattern: "^(0x)?[0-9a-fA-F]{40}$" }),
-    message: t.String(),
-    signature: t.String({ pattern: "^(0x)?[0-9a-fA-F]{130}$" }),
-});

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

@@ -1,31 +0,0 @@
-import { UnauthorizedError } from "@/errors";
-import { SignJWT, decodeJwt } from "jose";
-import { http, createPublicClient } from "viem";
-import { mainnet } from "viem/chains";
-import { CacheService } from "../cache/cache.service";
-import { UserService } from "../user/user.service";
-export class AuthService {
-    #publicClient = createPublicClient({ chain: mainnet, transport: http() });
-    #encodedJwtSecret = new TextEncoder().encode(process.env.JWT_SECRET);
-    async login(message) {
-        if (!this.#publicClient.verifyMessage(message))
-            throw new UnauthorizedError("Failed to verify the message signature.");
-        let user = await UserService.findUnique(message.address);
-        if (!user)
-            user = await UserService.create({ address: message.address, tags: [] });
-        return await this.generateJwt(user);
-    }
-    async generateJwt(user) {
-        return await new SignJWT({ creator: user.creatorId })
-            .setProtectedHeader({ alg: "HS256" })
-            .setExpirationTime("2h")
-            .setAudience(user.address)
-            .setIssuer("merkl")
-            .setSubject("studio")
-            .setJti(Bun.randomUUIDv7())
-            .sign(this.#encodedJwtSecret);
-    }
-    async revokeToken(jwt) {
-        return await CacheService.sAdd("token:revoked", decodeJwt(jwt).jti);
-    }
-}

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

@@ -1,42 +0,0 @@
-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 }) => {
-        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 }) => {
-        BackOfficeGuard({ headers });
-        params.address = throwOnInvalidRequiredAddress(params.address);
-    },
-    detail: { hide: true },
-});

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

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

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

@@ -1,31 +0,0 @@
-import { TTLPresets } from "@/modules/v4/cache/cache.model";
-import { CacheService } from "@/modules/v4/cache/cache.service";
-import { utils } from "ethers";
-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/boost/boost.controller.js

@@ -1,15 +0,0 @@
-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 },
-});