@merkl/api 0.10.80 → 0.10.82

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

@@ -74,7 +74,7 @@ export declare abstract class RewardService {
      * @param reward straight from db
      * @returns a Reward model
      */
-    static format(reward: Awaited<ReturnType<typeof RewardRepository.getByRecipient>>[number]): {
+    static format(rewards: Awaited<ReturnType<typeof RewardRepository.getByRecipient>>): {
         token: {
             id: string;
             name: string | null;
@@ -148,10 +148,10 @@ export declare abstract class RewardService {
         root: string;
         recipient: string;
         proofs: string[];
-    };
+    }[];
     static createManyBreakdown(data: CreateManyBreakdownModel): Promise<import("../../../../database/api/.generated").Prisma.BatchPayload>;
-    static getByRecipient(recipient: string, roots: string[], withToken?: boolean): Promise<{
-        token: {
+    static getByRecipient(recipient: string, roots: string[], withToken?: boolean): Promise<({
+        RewardToken: {
             id: string;
             name: string | null;
             chainId: number;
@@ -162,69 +162,77 @@ export declare abstract class RewardService {
             verified: boolean;
             price: number | null;
         };
-        breakdowns: {
-            campaignId: string;
-            opportunity: {
-                Chain: {
-                    id: number;
-                    name: string;
-                    icon: string;
-                };
-                Tokens: {
+        Breakdown: ({
+            Campaign: {
+                identifier: string;
+                campaignId: string;
+                Opportunity: {
+                    Chain: {
+                        id: number;
+                        name: string;
+                        icon: string;
+                    };
+                    Tokens: {
+                        id: string;
+                        name: string | null;
+                        chainId: number;
+                        address: string;
+                        decimals: number;
+                        symbol: string;
+                        icon: string;
+                        verified: boolean;
+                        price: number | null;
+                    }[];
+                    Protocols: {
+                        id: string;
+                        tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
+                        name: string;
+                        description: string;
+                        url: string;
+                        icon: string;
+                    }[];
+                    MainProtocol: {
+                        id: string;
+                        tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
+                        name: string;
+                        description: string;
+                        url: string;
+                        icon: string;
+                    } | null;
+                } & {
                     id: string;
-                    name: string | null;
                     chainId: number;
-                    address: string;
-                    decimals: number;
-                    symbol: string;
-                    icon: string;
-                    verified: boolean;
-                    price: number | null;
-                }[];
-                Protocols: {
-                    id: string;
-                    tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
-                    name: string;
-                    description: string;
-                    url: string;
-                    icon: string;
-                }[];
-                MainProtocol: {
-                    id: string;
-                    tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
+                    type: import("../../../../database/api/.generated").$Enums.CampaignType;
+                    identifier: string;
                     name: string;
-                    description: string;
-                    url: string;
-                    icon: string;
-                } | null;
-            } & {
-                id: string;
-                chainId: number;
-                type: import("../../../../database/api/.generated").$Enums.CampaignType;
-                identifier: string;
-                name: string;
-                status: import("../../../../database/api/.generated").$Enums.Status;
-                action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
-                mainProtocolId: string | null;
-                tvl: number;
-                apr: number;
-                dailyRewards: number;
-                tags: string[];
+                    status: import("../../../../database/api/.generated").$Enums.Status;
+                    action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
+                    mainProtocolId: string | null;
+                    tvl: number;
+                    apr: number;
+                    dailyRewards: number;
+                    tags: string[];
+                };
             };
+        } & {
+            id: number;
+            protocolId: string | null;
             reason: string;
             amount: string;
             claimed: string;
             pending: string;
             auxiliaryData1: string | null;
             auxiliaryData2: string | null;
-        }[];
-        claimed: bigint;
-        amount: bigint;
-        pending: bigint;
+            rewardId: string;
+            campaignId: string;
+        })[];
+    } & {
+        id: string;
         root: string;
         recipient: string;
+        rewardTokenId: string;
         proofs: string[];
-    }[]>;
+    })[]>;
     /**
      * Groups a breakdown array by their corresponding opportunities
      * @param breakdowns with campaignIds
@@ -247,7 +255,7 @@ export declare abstract class RewardService {
      */
     static splitRewardsBreakdownByOpportunity(rewards: Awaited<ReturnType<typeof RewardService.getUserRewardsByChain>>): (Omit<{
         chain: Chain;
-        rewards: Awaited<ReturnType<(typeof RewardService)["getByRecipient"]>>;
+        rewards: Awaited<ReturnType<(typeof RewardService)["format"]>>;
     }, "rewards"> & {
         rewards: (Omit<{
             token: {
@@ -337,7 +345,7 @@ export declare abstract class RewardService {
     })[];
     static removeOpportunityFromRewardBreakdown(rewards: Awaited<ReturnType<typeof RewardService.getUserRewardsByChain>>): (Omit<{
         chain: Chain;
-        rewards: Awaited<ReturnType<(typeof RewardService)["getByRecipient"]>>;
+        rewards: Awaited<ReturnType<(typeof RewardService)["format"]>>;
     }, "rewards"> & {
         rewards: (Omit<{
             token: {
@@ -425,8 +433,9 @@ export declare abstract class RewardService {
             }[];
         })[];
     })[];
-    static checkLastClaim(chainId: number, user: string, roots: CacheKeys["CurrentRoot"]["returns"], rewards: Awaited<ReturnType<typeof RewardService.getByRecipient>>): Promise<{
-        token: {
+    static findManyRootsOnChain(chainId: ChainId): Promise<any>;
+    static checkLastClaim(chainId: number, user: string, roots: CacheKeys["CurrentRoot"]["returns"], rewards: Awaited<ReturnType<typeof RewardService.getByRecipient>>): Promise<({
+        RewardToken: {
             id: string;
             name: string | null;
             chainId: number;
@@ -437,72 +446,80 @@ export declare abstract class RewardService {
             verified: boolean;
             price: number | null;
         };
-        breakdowns: {
-            campaignId: string;
-            opportunity: {
-                Chain: {
-                    id: number;
-                    name: string;
-                    icon: string;
-                };
-                Tokens: {
+        Breakdown: ({
+            Campaign: {
+                identifier: string;
+                campaignId: string;
+                Opportunity: {
+                    Chain: {
+                        id: number;
+                        name: string;
+                        icon: string;
+                    };
+                    Tokens: {
+                        id: string;
+                        name: string | null;
+                        chainId: number;
+                        address: string;
+                        decimals: number;
+                        symbol: string;
+                        icon: string;
+                        verified: boolean;
+                        price: number | null;
+                    }[];
+                    Protocols: {
+                        id: string;
+                        tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
+                        name: string;
+                        description: string;
+                        url: string;
+                        icon: string;
+                    }[];
+                    MainProtocol: {
+                        id: string;
+                        tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
+                        name: string;
+                        description: string;
+                        url: string;
+                        icon: string;
+                    } | null;
+                } & {
                     id: string;
-                    name: string | null;
                     chainId: number;
-                    address: string;
-                    decimals: number;
-                    symbol: string;
-                    icon: string;
-                    verified: boolean;
-                    price: number | null;
-                }[];
-                Protocols: {
-                    id: string;
-                    tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
-                    name: string;
-                    description: string;
-                    url: string;
-                    icon: string;
-                }[];
-                MainProtocol: {
-                    id: string;
-                    tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
+                    type: import("../../../../database/api/.generated").$Enums.CampaignType;
+                    identifier: string;
                     name: string;
-                    description: string;
-                    url: string;
-                    icon: string;
-                } | null;
-            } & {
-                id: string;
-                chainId: number;
-                type: import("../../../../database/api/.generated").$Enums.CampaignType;
-                identifier: string;
-                name: string;
-                status: import("../../../../database/api/.generated").$Enums.Status;
-                action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
-                mainProtocolId: string | null;
-                tvl: number;
-                apr: number;
-                dailyRewards: number;
-                tags: string[];
+                    status: import("../../../../database/api/.generated").$Enums.Status;
+                    action: import("../../../../database/api/.generated").$Enums.OpportunityAction;
+                    mainProtocolId: string | null;
+                    tvl: number;
+                    apr: number;
+                    dailyRewards: number;
+                    tags: string[];
+                };
             };
+        } & {
+            id: number;
+            protocolId: string | null;
             reason: string;
             amount: string;
             claimed: string;
             pending: string;
             auxiliaryData1: string | null;
             auxiliaryData2: string | null;
-        }[];
-        claimed: bigint;
-        amount: bigint;
-        pending: bigint;
+            rewardId: string;
+            campaignId: string;
+        })[];
+    } & {
+        id: string;
         root: string;
         recipient: string;
+        rewardTokenId: string;
         proofs: string[];
-    }[]>;
+    })[]>;
     static getUserRewardsByChain(user: string, withToken: boolean, chainFilter?: ChainId[]): Promise<{
         chain: Chain;
-        rewards: Awaited<ReturnType<(typeof RewardService)["getByRecipient"]>>;
+        rewards: Awaited<ReturnType<(typeof RewardService)["format"]>>;
     }[]>;
     static updatePendings(data: UpdatePendingModel): Promise<boolean>;
     static count(): Promise<Record<string, {

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

@@ -62,7 +62,6 @@ export declare const v4: Elysia<"/v4", false, {
                         200: {
                             aprRecord: {
                                 cumulated: number;
-                                cummulated: number;
                                 timestamp: bigint;
                                 breakdowns: {
                                     id: number;
@@ -150,7 +149,6 @@ export declare const v4: Elysia<"/v4", false, {
                             200: {
                                 aprRecord: {
                                     cumulated: number;
-                                    cummulated: number;
                                     timestamp: bigint;
                                     breakdowns: {
                                         id: number;
@@ -248,7 +246,6 @@ export declare const v4: Elysia<"/v4", false, {
                         200: ({
                             aprRecord: {
                                 cumulated: number;
-                                cummulated: number;
                                 timestamp: bigint;
                                 breakdowns: {
                                     id: number;
@@ -1166,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: {
@@ -1276,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: {
@@ -1732,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: {