@merkl/api 0.10.81 → 0.10.82

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

@@ -1163,7 +1163,7 @@ export declare const v4: Elysia<"/v4", false, {
                             response: {
                                 200: (Omit<{
                                     chain: import("../../../database/api/.generated").Chain;
-                                    rewards: Awaited<ReturnType<typeof import("./reward").RewardService["getByRecipient"]>>;
+                                    rewards: Awaited<ReturnType<typeof import("./reward").RewardService["format"]>>;
                                 }, "rewards"> & {
                                     rewards: (Omit<{
                                         token: {
@@ -1273,7 +1273,7 @@ export declare const v4: Elysia<"/v4", false, {
                         response: {
                             200: (Omit<{
                                 chain: import("../../../database/api/.generated").Chain;
-                                rewards: Awaited<ReturnType<typeof import("./reward").RewardService["getByRecipient"]>>;
+                                rewards: Awaited<ReturnType<typeof import("./reward").RewardService["format"]>>;
                             }, "rewards"> & {
                                 rewards: (Omit<{
                                     token: {
@@ -1729,127 +1729,34 @@ export declare const v4: Elysia<"/v4", false, {
     };
 } & {
     v4: {
-        campaignStatus: {
-            engine: {
-                post: {
-                    body: {
-                        status: {
-                            value: "SUCCESS";
-                            computedUntil: number;
-                        } | {
-                            value: "PROCESSING";
-                        } | {
-                            error: string;
-                            details: string;
-                            value: "SKIPPED";
-                        } | {
-                            error: string;
-                            details: string;
-                            value: "FAILED";
-                        };
-                        campaignId: string;
-                        distributionChain: number;
-                    };
-                    params: Record<never, string>;
-                    query: unknown;
-                    headers: {
-                        authorization: string;
-                    };
-                    response: {
-                        200: void;
-                    };
-                };
-            };
-        };
-    } & {
-        campaignStatus: {
-            index: {
-                get: {
-                    body: unknown;
-                    params: Record<never, string>;
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        200: {
-                            campaignId: string;
-                            computedUntil: bigint;
-                            processingStarted: bigint;
-                            status: import("../../../database/api/.generated").$Enums.RunStatus;
-                            error: string;
-                            details: import("../../../database/api/.generated").Prisma.JsonValue;
-                        }[];
-                    };
-                };
-            };
-        };
-    } & {
-        campaignStatus: {
-            unique: {
-                get: {
-                    body: unknown;
-                    params: Record<never, string>;
-                    query: {
-                        identifier: string;
-                        distributionChain: number;
-                    };
-                    headers: unknown;
-                    response: {
-                        200: {
-                            campaignId: string;
-                            computedUntil: bigint;
-                            processingStarted: bigint;
-                            status: import("../../../database/api/.generated").$Enums.RunStatus;
-                            error: string;
-                            details: import("../../../database/api/.generated").Prisma.JsonValue;
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        campaignStatus: {
-            computeChain: {
+        dynamicData: {
+            chainId: {
                 ":chainId": {
-                    get: {
-                        body: unknown;
-                        params: {
-                            chainId: number;
-                        };
-                        query: unknown;
-                        headers: unknown;
-                        response: {
-                            200: {
-                                campaignId: string;
-                                computedUntil: bigint;
-                                processingStarted: bigint;
-                                status: import("../../../database/api/.generated").$Enums.RunStatus;
-                                error: string;
-                                details: import("../../../database/api/.generated").Prisma.JsonValue;
-                            }[];
+                    token: {
+                        ":tokenAddress": {
+                            get: {
+                                body: unknown;
+                                params: {
+                                    chainId: string;
+                                    tokenAddress: string;
+                                };
+                                query: unknown;
+                                headers: unknown;
+                                response: {
+                                    200: {
+                                        tvl: number;
+                                        totalSupply: number;
+                                        cardName: string;
+                                        blacklistedSupply: number;
+                                        priceTargetToken: number;
+                                    };
+                                };
+                            };
                         };
                     };
                 };
             };
         };
-    } & {
-        campaignStatus: {
-            overlaps: {
-                get: {
-                    body: unknown;
-                    params: Record<never, string>;
-                    query: {
-                        identifier: string;
-                        distributionChain: number;
-                    };
-                    headers: {
-                        authorization: string;
-                    };
-                    response: {
-                        200: boolean;
-                    };
-                };
-            };
-        };
     };
 }, {
     derive: {};

package/dist/src/modules/v4/testdynamicData/dynamicData.controller.d.ts

@@ -0,0 +1,50 @@
+import Elysia from "elysia";
+export declare const DynamicDataController: Elysia<"/dynamicData", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+}, {
+    dynamicData: {
+        chainId: {
+            ":chainId": {
+                token: {
+                    ":tokenAddress": {
+                        get: {
+                            body: unknown;
+                            params: {
+                                chainId: string;
+                                tokenAddress: string;
+                            };
+                            query: unknown;
+                            headers: unknown;
+                            response: {
+                                200: {
+                                    tvl: number;
+                                    totalSupply: number;
+                                    cardName: string;
+                                    blacklistedSupply: number;
+                                    priceTargetToken: number;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

package/dist/src/modules/v4/testdynamicData/dynamicData.model.d.ts

@@ -0,0 +1,5 @@
+export declare const DynamicDataSourceIdentifier: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TString;
+    tokenAddress: import("@sinclair/typebox").TString;
+}>;
+export type PriceSourceIdentifierModel = typeof DynamicDataSourceIdentifier.static;

package/dist/src/modules/v4/testdynamicData/dynamicData.service.d.ts

@@ -0,0 +1,12 @@
+type output = {
+    tvl: number;
+    totalSupply: number;
+    cardName: string;
+    blacklistedSupply: number;
+    priceTargetToken: number;
+};
+export declare class DynamicDataService {
+    /** Fetches a single price */
+    static queryERC20DynamicData(chainId: string, tokenAddress: string): Promise<output>;
+}
+export {};

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

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

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

@@ -1,4 +1,4 @@
-import type { ChainId } from "@sdk";
+import { type ChainId } from "@sdk";
 import type { GetTokenQueryModel, Token, TokenModel } from "./token.model";
 export declare abstract class TokenRepository {
     #private;

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

@@ -64,7 +64,7 @@ export declare const UserController: Elysia<"/users", false, {
                         response: {
                             200: (Omit<{
                                 chain: import("../../../../database/api/.generated").Chain;
-                                rewards: Awaited<ReturnType<(typeof RewardService)["getByRecipient"]>>;
+                                rewards: Awaited<ReturnType<(typeof RewardService)["format"]>>;
                             }, "rewards"> & {
                                 rewards: (Omit<{
                                     token: {
@@ -174,7 +174,7 @@ export declare const UserController: Elysia<"/users", false, {
                     response: {
                         200: (Omit<{
                             chain: import("../../../../database/api/.generated").Chain;
-                            rewards: Awaited<ReturnType<(typeof RewardService)["getByRecipient"]>>;
+                            rewards: Awaited<ReturnType<(typeof RewardService)["format"]>>;
                         }, "rewards"> & {
                             rewards: (Omit<{
                                 token: {

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

@@ -1189,7 +1189,7 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                             response: {
                                 200: (Omit<{
                                     chain: import("../../../database/api/.generated").Chain;
-                                    rewards: Awaited<ReturnType<typeof import("../../modules/v4/reward").RewardService["getByRecipient"]>>;
+                                    rewards: Awaited<ReturnType<typeof import("../../modules/v4/reward").RewardService["format"]>>;
                                 }, "rewards"> & {
                                     rewards: (Omit<{
                                         token: {
@@ -1299,7 +1299,7 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                         response: {
                             200: (Omit<{
                                 chain: import("../../../database/api/.generated").Chain;
-                                rewards: Awaited<ReturnType<typeof import("../../modules/v4/reward").RewardService["getByRecipient"]>>;
+                                rewards: Awaited<ReturnType<typeof import("../../modules/v4/reward").RewardService["format"]>>;
                             }, "rewards"> & {
                                 rewards: (Omit<{
                                     token: {
@@ -1755,127 +1755,34 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
     };
 } & {
     v4: {
-        campaignStatus: {
-            engine: {
-                post: {
-                    body: {
-                        status: {
-                            value: "SUCCESS";
-                            computedUntil: number;
-                        } | {
-                            value: "PROCESSING";
-                        } | {
-                            error: string;
-                            details: string;
-                            value: "SKIPPED";
-                        } | {
-                            error: string;
-                            details: string;
-                            value: "FAILED";
-                        };
-                        campaignId: string;
-                        distributionChain: number;
-                    };
-                    params: Record<never, string>;
-                    query: unknown;
-                    headers: {
-                        authorization: string;
-                    };
-                    response: {
-                        200: void;
-                    };
-                };
-            };
-        };
-    } & {
-        campaignStatus: {
-            index: {
-                get: {
-                    body: unknown;
-                    params: Record<never, string>;
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        200: {
-                            campaignId: string;
-                            computedUntil: bigint;
-                            processingStarted: bigint;
-                            status: import("../../../database/api/.generated").$Enums.RunStatus;
-                            error: string;
-                            details: import("../../../database/api/.generated").Prisma.JsonValue;
-                        }[];
-                    };
-                };
-            };
-        };
-    } & {
-        campaignStatus: {
-            unique: {
-                get: {
-                    body: unknown;
-                    params: Record<never, string>;
-                    query: {
-                        identifier: string;
-                        distributionChain: number;
-                    };
-                    headers: unknown;
-                    response: {
-                        200: {
-                            campaignId: string;
-                            computedUntil: bigint;
-                            processingStarted: bigint;
-                            status: import("../../../database/api/.generated").$Enums.RunStatus;
-                            error: string;
-                            details: import("../../../database/api/.generated").Prisma.JsonValue;
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        campaignStatus: {
-            computeChain: {
+        dynamicData: {
+            chainId: {
                 ":chainId": {
-                    get: {
-                        body: unknown;
-                        params: {
-                            chainId: number;
-                        };
-                        query: unknown;
-                        headers: unknown;
-                        response: {
-                            200: {
-                                campaignId: string;
-                                computedUntil: bigint;
-                                processingStarted: bigint;
-                                status: import("../../../database/api/.generated").$Enums.RunStatus;
-                                error: string;
-                                details: import("../../../database/api/.generated").Prisma.JsonValue;
-                            }[];
+                    token: {
+                        ":tokenAddress": {
+                            get: {
+                                body: unknown;
+                                params: {
+                                    chainId: string;
+                                    tokenAddress: string;
+                                };
+                                query: unknown;
+                                headers: unknown;
+                                response: {
+                                    200: {
+                                        tvl: number;
+                                        totalSupply: number;
+                                        cardName: string;
+                                        blacklistedSupply: number;
+                                        priceTargetToken: number;
+                                    };
+                                };
+                            };
                         };
                     };
                 };
             };
         };
-    } & {
-        campaignStatus: {
-            overlaps: {
-                get: {
-                    body: unknown;
-                    params: Record<never, string>;
-                    query: {
-                        identifier: string;
-                        distributionChain: number;
-                    };
-                    headers: {
-                        authorization: string;
-                    };
-                    response: {
-                        200: boolean;
-                    };
-                };
-            };
-        };
     };
 } & {
     index: {

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

@@ -1187,7 +1187,7 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                             response: {
                                 200: (Omit<{
                                     chain: import("../../../database/api/.generated").Chain;
-                                    rewards: Awaited<ReturnType<typeof import("../../modules/v4/reward").RewardService["getByRecipient"]>>;
+                                    rewards: Awaited<ReturnType<typeof import("../../modules/v4/reward").RewardService["format"]>>;
                                 }, "rewards"> & {
                                     rewards: (Omit<{
                                         token: {
@@ -1297,7 +1297,7 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                         response: {
                             200: (Omit<{
                                 chain: import("../../../database/api/.generated").Chain;
-                                rewards: Awaited<ReturnType<typeof import("../../modules/v4/reward").RewardService["getByRecipient"]>>;
+                                rewards: Awaited<ReturnType<typeof import("../../modules/v4/reward").RewardService["format"]>>;
                             }, "rewards"> & {
                                 rewards: (Omit<{
                                     token: {
@@ -1753,127 +1753,34 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
     };
 } & {
     v4: {
-        campaignStatus: {
-            engine: {
-                post: {
-                    body: {
-                        status: {
-                            value: "SUCCESS";
-                            computedUntil: number;
-                        } | {
-                            value: "PROCESSING";
-                        } | {
-                            error: string;
-                            details: string;
-                            value: "SKIPPED";
-                        } | {
-                            error: string;
-                            details: string;
-                            value: "FAILED";
-                        };
-                        campaignId: string;
-                        distributionChain: number;
-                    };
-                    params: Record<never, string>;
-                    query: unknown;
-                    headers: {
-                        authorization: string;
-                    };
-                    response: {
-                        200: void;
-                    };
-                };
-            };
-        };
-    } & {
-        campaignStatus: {
-            index: {
-                get: {
-                    body: unknown;
-                    params: Record<never, string>;
-                    query: unknown;
-                    headers: unknown;
-                    response: {
-                        200: {
-                            campaignId: string;
-                            computedUntil: bigint;
-                            processingStarted: bigint;
-                            status: import("../../../database/api/.generated").$Enums.RunStatus;
-                            error: string;
-                            details: import("../../../database/api/.generated").Prisma.JsonValue;
-                        }[];
-                    };
-                };
-            };
-        };
-    } & {
-        campaignStatus: {
-            unique: {
-                get: {
-                    body: unknown;
-                    params: Record<never, string>;
-                    query: {
-                        identifier: string;
-                        distributionChain: number;
-                    };
-                    headers: unknown;
-                    response: {
-                        200: {
-                            campaignId: string;
-                            computedUntil: bigint;
-                            processingStarted: bigint;
-                            status: import("../../../database/api/.generated").$Enums.RunStatus;
-                            error: string;
-                            details: import("../../../database/api/.generated").Prisma.JsonValue;
-                        };
-                    };
-                };
-            };
-        };
-    } & {
-        campaignStatus: {
-            computeChain: {
+        dynamicData: {
+            chainId: {
                 ":chainId": {
-                    get: {
-                        body: unknown;
-                        params: {
-                            chainId: number;
-                        };
-                        query: unknown;
-                        headers: unknown;
-                        response: {
-                            200: {
-                                campaignId: string;
-                                computedUntil: bigint;
-                                processingStarted: bigint;
-                                status: import("../../../database/api/.generated").$Enums.RunStatus;
-                                error: string;
-                                details: import("../../../database/api/.generated").Prisma.JsonValue;
-                            }[];
+                    token: {
+                        ":tokenAddress": {
+                            get: {
+                                body: unknown;
+                                params: {
+                                    chainId: string;
+                                    tokenAddress: string;
+                                };
+                                query: unknown;
+                                headers: unknown;
+                                response: {
+                                    200: {
+                                        tvl: number;
+                                        totalSupply: number;
+                                        cardName: string;
+                                        blacklistedSupply: number;
+                                        priceTargetToken: number;
+                                    };
+                                };
+                            };
                         };
                     };
                 };
             };
         };
-    } & {
-        campaignStatus: {
-            overlaps: {
-                get: {
-                    body: unknown;
-                    params: Record<never, string>;
-                    query: {
-                        identifier: string;
-                        distributionChain: number;
-                    };
-                    headers: {
-                        authorization: string;
-                    };
-                    response: {
-                        200: boolean;
-                    };
-                };
-            };
-        };
     };
 } & {
     index: {