@merkl/api 0.9.15

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

@@ -0,0 +1,99 @@
+import type { GetTransactionsQueryModel } from "@/modules/v4/accounting";
+export declare class AccountingRepository {
+    static findMany(query: GetTransactionsQueryModel): Promise<{
+        id: string;
+        datetime: Date;
+        chainId: number;
+        timestamp: number;
+        recipient: string;
+        fromTokenId: string;
+        toTokenId: string;
+        multisig: string;
+        amountIn: string;
+        amountOut: string;
+    }[]>;
+    static getByTokenForDumper(fromTokenId: string): Promise<{
+        id: string;
+        datetime: Date;
+        chainId: number;
+        timestamp: number;
+        recipient: string;
+        fromTokenId: string;
+        toTokenId: string;
+        multisig: string;
+        amountIn: string;
+        amountOut: string;
+    }[]>;
+    static getForMonthForRecipient(recipient: string, toTokenId: string, month: number, year: number): Promise<{
+        id: string;
+        datetime: Date;
+        chainId: number;
+        timestamp: number;
+        recipient: string;
+        fromTokenId: string;
+        toTokenId: string;
+        multisig: string;
+        amountIn: string;
+        amountOut: string;
+    }[]>;
+    static getForMultisigBetweenDates(startDate: Date, endDate: Date): Promise<{
+        id: string;
+        datetime: Date;
+        chainId: number;
+        timestamp: number;
+        recipient: string;
+        fromTokenId: string;
+        toTokenId: string;
+        multisig: string;
+        amountIn: string;
+        amountOut: string;
+    }[]>;
+    static getForMultisig(): Promise<{
+        id: string;
+        datetime: Date;
+        chainId: number;
+        timestamp: number;
+        recipient: string;
+        fromTokenId: string;
+        toTokenId: string;
+        multisig: string;
+        amountIn: string;
+        amountOut: string;
+    }[]>;
+    static getForMultisigByChain(chainId: number): Promise<{
+        id: string;
+        datetime: Date;
+        chainId: number;
+        timestamp: number;
+        recipient: string;
+        fromTokenId: string;
+        toTokenId: string;
+        multisig: string;
+        amountIn: string;
+        amountOut: string;
+    }[]>;
+    static getForMultisigByChainBetweenDates(chainId: number, startDate: Date, endDate: Date): Promise<{
+        id: string;
+        datetime: Date;
+        chainId: number;
+        timestamp: number;
+        recipient: string;
+        fromTokenId: string;
+        toTokenId: string;
+        multisig: string;
+        amountIn: string;
+        amountOut: string;
+    }[]>;
+    static getForDumperBetweenDates(fromTokenId: string, startDate: Date, endDate: Date): Promise<{
+        id: string;
+        datetime: Date;
+        chainId: number;
+        timestamp: number;
+        recipient: string;
+        fromTokenId: string;
+        toTokenId: string;
+        multisig: string;
+        amountIn: string;
+        amountOut: string;
+    }[]>;
+}

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

@@ -0,0 +1,100 @@
+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: {
+                    recipient: {
+                        equals: apiDbClient.dump.fields.multisig,
+                    },
+                },
+            },
+        });
+    }
+    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: {
+                recipient: {
+                    equals: apiDbClient.dump.fields.multisig,
+                },
+                datetime: {
+                    gte: startDate,
+                    lt: endDate,
+                },
+            },
+        });
+    }
+    static async getForMultisig() {
+        return await apiDbClient.dump.findMany({
+            where: {
+                recipient: {
+                    equals: apiDbClient.dump.fields.multisig,
+                },
+            },
+        });
+    }
+    static async getForMultisigByChain(chainId) {
+        return await apiDbClient.dump.findMany({
+            where: {
+                chainId,
+                recipient: {
+                    equals: apiDbClient.dump.fields.multisig,
+                },
+            },
+        });
+    }
+    static async getForMultisigByChainBetweenDates(chainId, startDate, endDate) {
+        return await apiDbClient.dump.findMany({
+            where: {
+                chainId,
+                datetime: {
+                    gte: startDate,
+                    lte: endDate,
+                },
+                recipient: {
+                    equals: apiDbClient.dump.fields.multisig,
+                },
+            },
+        });
+    }
+    static async getForDumperBetweenDates(fromTokenId, startDate, endDate) {
+        return await apiDbClient.dump.findMany({
+            where: {
+                fromTokenId,
+                datetime: {
+                    gte: startDate,
+                    lte: endDate,
+                },
+                NOT: {
+                    recipient: {
+                        equals: apiDbClient.dump.fields.multisig,
+                    },
+                },
+            },
+        });
+    }
+}

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

@@ -0,0 +1,59 @@
+import type { GetTransactionsQueryModel } from "@/modules/v4/accounting";
+import { ChainId } from "@sdk";
+export declare class AccountingService {
+    static hashId(chainId: ChainId, fromTokenId: string, toTokenId: string, timestamp: number): string;
+    static getTokenId(chainId: number, address: string): string;
+    static findMany(query: GetTransactionsQueryModel): Promise<{
+        id: string;
+        datetime: Date;
+        chainId: number;
+        timestamp: number;
+        recipient: string;
+        fromTokenId: string;
+        toTokenId: string;
+        multisig: string;
+        amountIn: string;
+        amountOut: string;
+    }[]>;
+    static getRevenue(): Promise<{
+        totalAmount: number;
+    }>;
+    static getRevenueByChain(chainId: number): Promise<{
+        totalAmount: number;
+    }>;
+    static getAllRevenueBreakdownByChain(): Promise<{
+        total: number;
+        breakdown: {
+            [key: number]: {
+                chainAmount: number;
+                percentage: number;
+            };
+        };
+    }>;
+    static getMonthlyRevenue(year: number, month: number): Promise<{
+        total: number;
+        breakdown: {
+            [key: number]: {
+                chainAmount: number;
+                percentage: number;
+            };
+        };
+        from: string;
+        to: string;
+    }>;
+    static getMonthlyRevenueByChain(chainId: number, year: number, month: number): Promise<{
+        totalAmount: number;
+        from: string;
+        to: string;
+    }>;
+    static getTokenTransaction(tokenAddress: string, chainId: number): Promise<{
+        totalAmount: number;
+        totalAmountUSD: number;
+    }>;
+    static getTokenMonthlyTransaction(tokenAddress: string, chainId: number, year: number, month: number): Promise<{
+        totalAmount: number;
+        totalAmountUSD: number;
+        from: string;
+        to: string;
+    }>;
+}

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

@@ -0,0 +1,107 @@
+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/accounting/index.d.ts

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

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

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

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

@@ -0,0 +1,3 @@
+export declare class AirflowService {
+    static triggerDAGRun(dagId: string, conf: object): Promise<void>;
+}

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

@@ -0,0 +1,20 @@
+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.d.ts

@@ -0,0 +1,41 @@
+import type { Resource } from "@/modules/v4/prisma";
+/**
+ * Apr Record
+ * @description Describes one apr snapshot for an opportunity
+ * @see {@link Resource}
+ */
+export type AprRecord = Resource<"AprRecord", "id" | "opportunityId", {
+    breakdowns: AprBreakdown["model"][];
+}>;
+/**
+ * Apr Breakdown
+ * @description Describes one apr fraction of record
+ * @see {@link Resource}
+ */
+export type AprBreakdown = Resource<"AprBreakdown", "id" | "aprRecordId">;
+export declare const AprBreakdownResourceDto: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TNumber;
+    type: import("@sinclair/typebox").TEnum<{
+        CAMPAIGN: "CAMPAIGN";
+        TOKEN: "TOKEN";
+        PROTOCOL: "PROTOCOL";
+    }>;
+    identifier: import("@sinclair/typebox").TString;
+    value: import("@sinclair/typebox").TNumber;
+    aprRecordId: import("@sinclair/typebox").TString;
+}>;
+export declare const AprRecordResourceDto: import("@sinclair/typebox").TObject<{
+    cumulated: import("@sinclair/typebox").TNumber;
+    timestamp: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TBigInt, import("@sinclair/typebox").TString]>;
+    breakdowns: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TNumber;
+        type: import("@sinclair/typebox").TEnum<{
+            CAMPAIGN: "CAMPAIGN";
+            TOKEN: "TOKEN";
+            PROTOCOL: "PROTOCOL";
+        }>;
+        identifier: import("@sinclair/typebox").TString;
+        value: import("@sinclair/typebox").TNumber;
+        aprRecordId: import("@sinclair/typebox").TString;
+    }>>;
+}>;

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

@@ -0,0 +1,15 @@
+import { AprType } from "@db/api";
+import { t } from "elysia";
+// ─── Dtos ────────────────────────────────────────────────────────────────────
+export const AprBreakdownResourceDto = t.Object({
+    id: t.Number(),
+    type: t.Enum(AprType),
+    identifier: t.String(),
+    value: t.Number(),
+    aprRecordId: t.String(),
+});
+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.d.ts

@@ -0,0 +1,6 @@
+import { type CampaignDynamicData, Campaign as CampaignTypeV3 } from "@sdk";
+import type { AprRecord } from "./apr.model";
+export declare abstract class AprService {
+    static hashId(opportunityId: string, timestamp: bigint): string;
+    static extractFromDynamicData<C extends CampaignTypeV3>(type: C, campaigns: CampaignDynamicData<C>[], timestamp?: bigint): AprRecord["model"];
+}

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

@@ -0,0 +1,49 @@
+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();
+    }
+    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/apr/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./apr.model";
+export * from "./apr.service";

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

@@ -0,0 +1,2 @@
+export * from "./apr.model";
+export * from "./apr.service";

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

@@ -0,0 +1,123 @@
+import Elysia from "elysia";
+export declare const BlacklistController: Elysia<"/blacklists", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {
+    blacklists: {
+        index: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: {
+                        id: string;
+                        chainId: number;
+                        poolAddress: string;
+                        userAddress: string;
+                        arrestTimestamp: bigint;
+                        arrestDetails: import("database/api/.generated/runtime/library").JsonValue;
+                    }[];
+                };
+            };
+        };
+    };
+} & {
+    blacklists: {
+        mapping: {
+            get: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: unknown;
+                };
+            };
+        };
+    };
+} & {
+    blacklists: {
+        check: {
+            ":address": {
+                get: {
+                    body: unknown;
+                    params: {
+                        address: string;
+                    };
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: boolean;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    blacklists: {
+        index: {
+            post: {
+                body: {
+                    reason?: string | undefined;
+                    chainId: number;
+                    poolAddress: string;
+                    userAddress: string;
+                };
+                params: {};
+                query: unknown;
+                headers: {
+                    authorization: string;
+                };
+                response: {
+                    200: {
+                        id: string;
+                        chainId: number;
+                        poolAddress: string;
+                        userAddress: string;
+                        arrestTimestamp: bigint;
+                        arrestDetails: import("database/api/.generated/runtime/library").JsonValue;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    blacklists: {
+        user: {
+            ":address": {
+                delete: {
+                    body: unknown;
+                    params: {
+                        address: string;
+                    };
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: boolean;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;