@merkl/api 0.10.140 → 0.10.142

package/dist/src/eden/index.d.ts

@@ -1040,8 +1040,13 @@ declare const eden: {
                     fetch?: RequestInit | undefined;
                 } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                     200: {
-                        [x: string]: boolean;
-                    };
+                        id: string;
+                        chainId: number;
+                        poolAddress: string;
+                        userAddress: string;
+                        arrestTimestamp: bigint;
+                        arrestDetails: import("database/api/.generated/runtime/library").JsonValue;
+                    }[];
                 }>>;
                 post: (body: {
                     reason?: string | undefined;
@@ -1065,6 +1070,15 @@ declare const eden: {
                     };
                 }>>;
             };
+            mapping: {
+                get: (options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: unknown;
+                }>>;
+            };
             check: ((params: {
                 address: string | number;
             }) => {
@@ -1659,6 +1673,13 @@ declare const eden: {
                     campaignId: string;
                     computedUntil: bigint;
                     processingStarted: bigint;
+                }[] | {
+                    error: string;
+                    details: import("database/api/.generated/runtime/library").JsonValue;
+                    status: import("../../database/api/.generated").$Enums.RunStatus;
+                    campaignId: string;
+                    computedUntil: bigint;
+                    processingStarted: bigint;
                 };
             }>>;
         }) & {
@@ -3014,8 +3035,27 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     headers: unknown;
                     response: {
                         200: {
-                            [x: string]: boolean;
-                        };
+                            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;
                     };
                 };
             };
@@ -3886,6 +3926,13 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                             campaignId: string;
                             computedUntil: bigint;
                             processingStarted: bigint;
+                        }[] | {
+                            error: string;
+                            details: import("database/api/.generated/runtime/library").JsonValue;
+                            status: import("../../database/api/.generated").$Enums.RunStatus;
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
                         };
                     };
                 };
@@ -4940,8 +4987,13 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     fetch?: RequestInit | undefined;
                 } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                     200: {
-                        [x: string]: boolean;
-                    };
+                        id: string;
+                        chainId: number;
+                        poolAddress: string;
+                        userAddress: string;
+                        arrestTimestamp: bigint;
+                        arrestDetails: import("database/api/.generated/runtime/library").JsonValue;
+                    }[];
                 }>>;
                 post: (body: {
                     reason?: string | undefined;
@@ -4965,6 +5017,15 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     };
                 }>>;
             };
+            mapping: {
+                get: (options?: {
+                    headers?: Record<string, unknown> | undefined;
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: unknown;
+                }>>;
+            };
             check: ((params: {
                 address: string | number;
             }) => {
@@ -5559,6 +5620,13 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     campaignId: string;
                     computedUntil: bigint;
                     processingStarted: bigint;
+                }[] | {
+                    error: string;
+                    details: import("database/api/.generated/runtime/library").JsonValue;
+                    status: import("../../database/api/.generated").$Enums.RunStatus;
+                    campaignId: string;
+                    computedUntil: bigint;
+                    processingStarted: bigint;
                 };
             }>>;
         }) & {

package/dist/src/index.d.ts

@@ -1280,8 +1280,27 @@ declare const app: Elysia<"", false, {
                     headers: unknown;
                     response: {
                         200: {
-                            [x: string]: boolean;
-                        };
+                            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;
                     };
                 };
             };
@@ -2152,6 +2171,13 @@ declare const app: Elysia<"", false, {
                             campaignId: string;
                             computedUntil: bigint;
                             processingStarted: bigint;
+                        }[] | {
+                            error: string;
+                            details: import("database/api/.generated/runtime/library").JsonValue;
+                            status: import("../database/api/.generated").$Enums.RunStatus;
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
                         };
                     };
                 };

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

@@ -21,8 +21,27 @@ export declare const BlacklistController: Elysia<"/blacklists", false, {
                 headers: unknown;
                 response: {
                     200: {
-                        [x: string]: boolean;
-                    };
+                        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;
                 };
             };
         };

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

@@ -7,6 +7,7 @@ import { BlacklistService } from "./blacklist.service";
 export const BlacklistController = new Elysia({ prefix: "/blacklists", detail: { tags: ["Blacklists"] } })
     // ─── 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,

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

@@ -1,8 +1,13 @@
 import type { AddBlacklistModel } from "./blacklist.model";
 export declare class BlacklistRepository {
     static findMany(): Promise<{
-        [address: string]: boolean;
-    }>;
+        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<{

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

@@ -1,14 +1,8 @@
 import { apiDbClient } from "../../../utils/prisma";
 import { NULL_ADDRESS } from "@sdk";
-import { utils } from "ethers";
 export class BlacklistRepository {
     static async findMany() {
-        return (await apiDbClient.blacklist.findMany()).reduce((prev, { userAddress, arrestTimestamp }) => {
-            if (!!arrestTimestamp) {
-                prev[utils.getAddress(userAddress)] = true;
-            }
-            return prev;
-        }, {});
+        return await apiDbClient.blacklist.findMany();
     }
     static async check(address) {
         return ((await apiDbClient.blacklist.findMany({

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

@@ -3,8 +3,14 @@ import type { AddBlacklistModel } from ".";
 export declare class BlacklistService {
     static hashId(chainId: ChainId, userAddress: string, poolAddress: string): string;
     static findMany(): Promise<{
-        [address: string]: boolean;
-    }>;
+        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<{

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

@@ -9,6 +9,16 @@ export class BlacklistService {
     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));
     }

package/dist/src/modules/v4/router.d.ts

@@ -1262,8 +1262,27 @@ export declare const v4: Elysia<"/v4", false, {
                     headers: unknown;
                     response: {
                         200: {
-                            [x: string]: boolean;
-                        };
+                            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;
                     };
                 };
             };
@@ -2134,6 +2153,13 @@ export declare const v4: Elysia<"/v4", false, {
                             campaignId: string;
                             computedUntil: bigint;
                             processingStarted: bigint;
+                        }[] | {
+                            error: string;
+                            details: import("database/api/.generated/runtime/library").JsonValue;
+                            status: import("../../../database/api/.generated").$Enums.RunStatus;
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
                         };
                     };
                 };

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

@@ -107,6 +107,13 @@ export declare const StatusController: Elysia<"/campaign-status", false, {
                         campaignId: string;
                         computedUntil: bigint;
                         processingStarted: bigint;
+                    }[] | {
+                        error: string;
+                        details: import("database/api/.generated/runtime/library").JsonValue;
+                        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+                        campaignId: string;
+                        computedUntil: bigint;
+                        processingStarted: bigint;
                     };
                 };
             };

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

@@ -22,7 +22,10 @@ export const StatusController = new Elysia({ prefix: "/campaign-status", detail:
     // ─── Find Many Status ────────────────────────────────────────────────
     .get("/", async ({ query }) => await StatusService.findMany(query), { query: QueryCampaignStatusDto })
     // ─── Get A Status By Id ────────────────────────────────────────────
+    // campaignId will be either a rough campaignId in the engine sense, a campaignId in the api db way, or a distributionChain_campaignId
     .get("/:campaignId", async ({ params }) => {
+    if (!params.campaignId.includes("-") && params.campaignId.startsWith("0x"))
+        return await StatusService.findManyByCampaignId(params.campaignId);
     if (!params.campaignId.includes("-"))
         return await StatusService.findUniqueOrThrow(params.campaignId);
     const [distributionChain, campaignId] = params.campaignId.split("-");

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

@@ -11,6 +11,14 @@ export declare class StatusRepository {
         computedUntil: bigint;
         processingStarted: bigint;
     }[]>;
+    static findManyByCampaignId(campaignId: string): Promise<{
+        error: string;
+        details: Prisma.JsonValue;
+        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+    }[]>;
     static findUniqueOrThrow(campaignId: string): Promise<{
         error: string;
         details: Prisma.JsonValue;

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

@@ -14,6 +14,15 @@ export class StatusRepository {
     static async findMany(query) {
         return await apiDbClient.campaignStatus.findMany(StatusRepository.#formatQuery(query));
     }
+    static async findManyByCampaignId(campaignId) {
+        return await apiDbClient.campaignStatus.findMany({
+            where: {
+                Campaign: {
+                    campaignId: campaignId,
+                },
+            },
+        });
+    }
     static async findUniqueOrThrow(campaignId) {
         return await apiDbClient.campaignStatus.findUniqueOrThrow({
             where: {

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

@@ -9,6 +9,14 @@ export declare class StatusService {
         computedUntil: bigint;
         processingStarted: bigint;
     }[]>;
+    static findManyByCampaignId(campaignId: string): Promise<{
+        error: string;
+        details: import("database/api/.generated/runtime/library").JsonValue;
+        status: import("../../../../database/api/.generated").$Enums.RunStatus;
+        campaignId: string;
+        computedUntil: bigint;
+        processingStarted: bigint;
+    }[]>;
     static findUniqueOrThrow(campaignUnique: CampaignUnique | string): Promise<{
         error: string;
         details: import("database/api/.generated/runtime/library").JsonValue;

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

@@ -7,6 +7,9 @@ export class StatusService {
     static async findMany(query) {
         return await StatusRepository.findMany(query);
     }
+    static async findManyByCampaignId(campaignId) {
+        return await StatusRepository.findManyByCampaignId(campaignId);
+    }
     static async findUniqueOrThrow(campaignUnique) {
         const campaignId = typeof campaignUnique === "string" ? campaignUnique : CampaignService.hashId(campaignUnique);
         return await StatusRepository.findUniqueOrThrow(campaignId);

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

@@ -1288,8 +1288,27 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                     headers: unknown;
                     response: {
                         200: {
-                            [x: string]: boolean;
-                        };
+                            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;
                     };
                 };
             };
@@ -2160,6 +2179,13 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                             campaignId: string;
                             computedUntil: bigint;
                             processingStarted: bigint;
+                        }[] | {
+                            error: string;
+                            details: import("database/api/.generated/runtime/library").JsonValue;
+                            status: import("../../../database/api/.generated").$Enums.RunStatus;
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
                         };
                     };
                 };

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

@@ -1286,8 +1286,27 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                     headers: unknown;
                     response: {
                         200: {
-                            [x: string]: boolean;
-                        };
+                            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;
                     };
                 };
             };
@@ -2158,6 +2177,13 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                             campaignId: string;
                             computedUntil: bigint;
                             processingStarted: bigint;
+                        }[] | {
+                            error: string;
+                            details: import("database/api/.generated/runtime/library").JsonValue;
+                            status: import("../../../database/api/.generated").$Enums.RunStatus;
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
                         };
                     };
                 };

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

@@ -1289,8 +1289,27 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                     headers: unknown;
                     response: {
                         200: {
-                            [x: string]: boolean;
-                        };
+                            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;
                     };
                 };
             };
@@ -2161,6 +2180,13 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                             campaignId: string;
                             computedUntil: bigint;
                             processingStarted: bigint;
+                        }[] | {
+                            error: string;
+                            details: import("database/api/.generated/runtime/library").JsonValue;
+                            status: import("../../../database/api/.generated").$Enums.RunStatus;
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
                         };
                     };
                 };

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

@@ -1280,8 +1280,27 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                     headers: unknown;
                     response: {
                         200: {
-                            [x: string]: boolean;
-                        };
+                            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;
                     };
                 };
             };
@@ -2152,6 +2171,13 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                             campaignId: string;
                             computedUntil: bigint;
                             processingStarted: bigint;
+                        }[] | {
+                            error: string;
+                            details: import("database/api/.generated/runtime/library").JsonValue;
+                            status: import("../../../database/api/.generated").$Enums.RunStatus;
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
                         };
                     };
                 };

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

@@ -1285,8 +1285,27 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                     headers: unknown;
                     response: {
                         200: {
-                            [x: string]: boolean;
-                        };
+                            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;
                     };
                 };
             };
@@ -2157,6 +2176,13 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                             campaignId: string;
                             computedUntil: bigint;
                             processingStarted: bigint;
+                        }[] | {
+                            error: string;
+                            details: import("database/api/.generated/runtime/library").JsonValue;
+                            status: import("../../../database/api/.generated").$Enums.RunStatus;
+                            campaignId: string;
+                            computedUntil: bigint;
+                            processingStarted: bigint;
                         };
                     };
                 };