@merkl/api 0.10.117 → 0.10.119

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/MetamorphoProcessor.d.ts

@@ -1,14 +1,14 @@
 import type { Pricer } from "../../../../../utils/pricer";
 import type { Campaign, CampaignParameters } from "@sdk";
 import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
-import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
 type callType = {
     key: keyof dataRawMetamorpho;
     call: string;
     target: keyof callKeysMetamorpho;
-    metaData?: any;
+    metaData?: keyof callKeysMetamorpho;
 };
-type callKeysMetamorpho = callKeys & {
+type callKeysMetamorpho = mandatoryCallKeys & {
     underlying: string;
     symbolUnderlyingToken: string;
 };
@@ -25,7 +25,7 @@ export declare class MetamorphoProcessor extends GenericProcessor<callKeysMetamo
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(index: number, type: tokenType, typeInfo: dataRawMetamorpho, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeMetamorpho>;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawMetamorpho, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, _pricer: Pricer): Promise<dataTypeMetamorpho>;
     computeRound3(index: number, type: tokenType, typeInfo: dataRawMetamorpho, calls: string[]): tokenTypeStruct;
 }
 export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/PendleProcessor.d.ts

@@ -1,27 +1,29 @@
 import type { Pricer } from "../../../../../utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import type { tokenType } from "../helpers/tokenType";
-import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
 type callType = {
-    key: keyof dataRawTemplate;
+    key: keyof dataRawPendle;
     call: string;
-    target: keyof callKeysTemplate;
-    metaData?: any;
+    target: keyof callKeysPendle;
+    metaData?: keyof callKeysPendle;
 };
-type callKeysTemplate = callKeys & {
-    readTokensRaw: string[];
+type callKeysPendle = mandatoryCallKeys & {
     SYToken: string;
+    underlying: string;
     symbolUnderlyingToken: string;
 };
-type dataRawTemplate = callKeysTemplate & {};
-type dataTypeTemplate = dataType & {};
-export declare class PendleProcessor extends GenericProcessor<callKeysTemplate, dataRawTemplate, dataTypeTemplate> {
+type dataRawPendle = callKeysPendle & {
+    readTokensRaw: string[];
+};
+type dataTypePendle = dataType & {};
+export declare class PendleProcessor extends GenericProcessor<callKeysPendle, dataRawPendle, dataTypePendle> {
     rounds: {
         round1: callType[];
         round2: callType[];
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(index: number, type: tokenType, typeInfo: dataRawTemplate, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeTemplate>;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawPendle, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypePendle>;
 }
 export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/RadiantProcessor.d.ts

@@ -1,14 +1,14 @@
 import type { Pricer } from "../../../../../utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
-import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
 type callType = {
     key: keyof dataRawRadiant;
     call: string;
     target: keyof callKeysRadiant;
-    metaData?: any;
+    metaData?: keyof callKeysRadiant;
 };
-type callKeysRadiant = callKeys & {
+type callKeysRadiant = mandatoryCallKeys & {
     underlyingToken: string;
     priceBN: string;
     symbolUnderlyingToken: string;
@@ -26,7 +26,7 @@ export declare class RadiantProcessor extends GenericProcessor<callKeysRadiant,
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(index: number, type: tokenType, typeInfo: dataRawRadiant, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeRadiant>;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawRadiant, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, _pricer: Pricer): Promise<dataTypeRadiant>;
     computeRound3(index: number, type: tokenType, typeInfo: dataRawRadiant, calls: string[]): tokenTypeStruct;
 }
 export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/SpliceProcessor.d.ts

@@ -1,8 +1,8 @@
 import type { Pricer } from "../../../../../utils/pricer";
 import type { Campaign, CampaignParameters } from "@sdk";
 import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
-import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
-type callKeysSplice = callKeys & {
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
+type callKeysSplice = mandatoryCallKeys & {
     priceTargetToken: string;
 };
 type dataRawSplice = callKeysSplice & {};
@@ -10,7 +10,7 @@ type dataTypeSplice = dataType & {
     priceTargetToken: number;
 };
 export declare class SpliceProcessor extends GenericProcessor<callKeysSplice, dataRawSplice, dataTypeSplice> {
-    processingRound5(index: number, type: tokenType, typeInfo: dataRawSplice, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeSplice>;
+    processingRound5(_index: number, _type: tokenType, typeInfo: dataRawSplice, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, _pricer: Pricer): Promise<dataTypeSplice>;
     computeRound3(index: number, type: tokenType, typeInfo: dataRawSplice, calls: string[]): tokenTypeStruct;
 }
 export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/SturdySiloProcessor.d.ts

@@ -1,14 +1,14 @@
 import type { Pricer } from "../../../../../utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import type { tokenType } from "../helpers/tokenType";
-import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
 type callType = {
     key: keyof dataRawSturdySilo;
     call: string;
     target: keyof callKeysSturdySilo;
-    metaData?: any;
+    metaData?: keyof callKeysSturdySilo;
 };
-type callKeysSturdySilo = callKeys & {
+type callKeysSturdySilo = mandatoryCallKeys & {
     underlying: string;
     sharePrice: string;
     collateralContract: string;
@@ -34,6 +34,6 @@ export declare class SturdySiloProcessor extends GenericProcessor<callKeysSturdy
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(index: number, type: tokenType, typeInfo: dataRawSturdySilo, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeSturdySilo>;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawSturdySilo, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeSturdySilo>;
 }
 export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/TemplateProcessor.d.ts

@@ -1,14 +1,14 @@
 import type { Pricer } from "../../../../../utils/pricer";
 import type { Campaign, CampaignParameters } from "@sdk";
 import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
-import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
 type callType = {
     key: keyof dataRawTemplate;
     call: string;
     target: keyof callKeysTemplate;
-    metaData?: any;
+    metaData?: keyof callKeysTemplate;
 };
-type callKeysTemplate = callKeys & {};
+type callKeysTemplate = mandatoryCallKeys & {};
 type dataRawTemplate = callKeysTemplate & {};
 type dataTypeTemplate = dataType & {};
 export declare class TemplateProcessor extends GenericProcessor<callKeysTemplate, dataRawTemplate, dataTypeTemplate> {

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/TorosProcessor.d.ts

@@ -1,15 +1,16 @@
 import type { Pricer } from "../../../../../utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import type { tokenType } from "../helpers/tokenType";
-import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
 type callType = {
     key: keyof dataRawToros;
     call: string;
     target: keyof callKeysToros;
     metaData?: any;
 };
-type callKeysToros = callKeys & {
+type callKeysToros = mandatoryCallKeys & {
     tokenPrice: string;
+    name: string;
 };
 type dataRawToros = callKeysToros & {};
 type dataTypeToros = dataType & {
@@ -24,6 +25,6 @@ export declare class TorosProcessor extends GenericProcessor<callKeysToros, data
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(index: number, type: tokenType, typeInfo: dataRawToros, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeToros>;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawToros, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, _pricer: Pricer): Promise<dataTypeToros>;
 }
 export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/UniswapProcessor.d.ts

@@ -1,14 +1,14 @@
 import type { Pricer } from "../../../../../utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import type { tokenType } from "../helpers/tokenType";
-import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
 type callType = {
     key: keyof dataRawUni;
     call: string;
     target: keyof callKeysUni;
-    metaData?: any;
+    metaData?: keyof callKeysUni;
 };
-type callKeysUni = callKeys & {
+type callKeysUni = mandatoryCallKeys & {
     token0: string;
     token1: string;
     symbolToken0: string;
@@ -37,6 +37,6 @@ export declare class UniswapProcessor extends GenericProcessor<callKeysUni, data
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(index: number, type: tokenType, typeInfo: dataRawUni, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeUni>;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawUni, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeUni>;
 }
 export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/curveProcessor.d.ts

@@ -1,15 +1,15 @@
 import type { Pricer } from "../../../../../utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import { tokenType } from "../helpers/tokenType";
-import { GenericProcessor, type callKeys, type dataType } from "./GenericProcessor";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
 type callType = {
     key: keyof dataRawCurve;
     call: string;
     target: keyof callKeysCurve;
-    metaData?: any;
+    metaData?: keyof callKeysCurve;
     optional?: boolean;
 };
-type callKeysCurve = callKeys & {
+type callKeysCurve = mandatoryCallKeys & {
     lp_price: string;
     token0: string;
     token1: string;
@@ -42,6 +42,6 @@ export declare class CurveProcessor extends GenericProcessor<callKeysCurve, data
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(index: number, type: tokenType, typeInfo: dataRawCurve, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeCurve>;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawCurve, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeCurve>;
 }
 export {};

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

@@ -43,11 +43,10 @@ export declare const MerklRootController: Elysia<"/roots", false, {
                 headers: unknown;
                 response: {
                     200: {
-                        [chainId: number]: {
-                            live: string;
-                            lastTree: string;
-                        };
-                    };
+                        live: string;
+                        tree: string;
+                        lastTree: string;
+                    }[];
                 };
             };
         };

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

@@ -26,9 +26,8 @@ export declare class MerklRootService {
      * @returns record of chains to object with live and last tree roots
      */
     static fetchAll(chainIds?: ChainId[]): Promise<{
-        [chainId: number]: {
-            live: string;
-            lastTree: string;
-        };
-    }>;
+        live: string;
+        tree: string;
+        lastTree: string;
+    }[]>;
 }

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

@@ -1306,6 +1306,25 @@ export declare const v4: Elysia<"/v4", false, {
                 };
             };
         };
+    } & {
+        users: {
+            tags: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: {
+                            tags: string[];
+                            address: string;
+                        }[];
+                    };
+                };
+            };
+        };
     } & {
         users: {
             ":address": {
@@ -1316,6 +1335,7 @@ export declare const v4: Elysia<"/v4", false, {
                     headers: unknown;
                     response: {
                         200: {
+                            tags: string[];
                             address: string;
                         } | null;
                     };
@@ -1562,6 +1582,22 @@ export declare const v4: Elysia<"/v4", false, {
                 };
             };
         };
+    } & {
+        users: {
+            sync: {
+                post: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: void;
+                    };
+                };
+            };
+        };
     } & {
         users: {
             ":address": {
@@ -1622,11 +1658,10 @@ export declare const v4: Elysia<"/v4", false, {
                     headers: unknown;
                     response: {
                         200: {
-                            [chainId: number]: {
-                                live: string;
-                                lastTree: string;
-                            };
-                        };
+                            live: string;
+                            tree: string;
+                            lastTree: string;
+                        }[];
                     };
                 };
             };

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

@@ -33,6 +33,25 @@ export declare const UserController: Elysia<"/users", false, {
             };
         };
     };
+} & {
+    users: {
+        tags: {
+            get: {
+                body: unknown;
+                params: Record<never, string>;
+                query: unknown;
+                headers: {
+                    authorization: string;
+                };
+                response: {
+                    200: {
+                        tags: string[];
+                        address: string;
+                    }[];
+                };
+            };
+        };
+    };
 } & {
     users: {
         ":address": {
@@ -43,6 +62,7 @@ export declare const UserController: Elysia<"/users", false, {
                 headers: unknown;
                 response: {
                     200: {
+                        tags: string[];
                         address: string;
                     } | null;
                 };
@@ -289,6 +309,22 @@ export declare const UserController: Elysia<"/users", false, {
             };
         };
     };
+} & {
+    users: {
+        sync: {
+            post: {
+                body: unknown;
+                params: Record<never, string>;
+                query: unknown;
+                headers: {
+                    authorization: string;
+                };
+                response: {
+                    200: void;
+                };
+            };
+        };
+    };
 } & {
     users: {
         ":address": {

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

@@ -1,12 +1,17 @@
 import type { GetManyUserModel, UserModel } from "./user.model";
 export declare abstract class UserRepository {
     static findUnique(address: string): Promise<{
+        tags: string[];
         address: string;
     } | null>;
     static findMany(query: GetManyUserModel): Promise<{
         tags: string[];
         address: string;
     }[]>;
+    static findManyWithTags(): Promise<{
+        tags: string[];
+        address: string;
+    }[]>;
     static create(user: UserModel): Promise<{
         tags: string[];
         address: string;

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

@@ -1,9 +1,14 @@
 import type { GetManyUserModel, UserModel } from "./user.model";
 export declare abstract class UserService {
-    static get(address: string): Promise<{
+    static findUnique(address: string): Promise<{
+        tags: string[];
         address: string;
     } | null>;
-    static getMany(query: GetManyUserModel): Promise<{
+    static findMany(query: GetManyUserModel): Promise<{
+        tags: string[];
+        address: string;
+    }[]>;
+    static findManyWithTags(): Promise<{
         tags: string[];
         address: string;
     }[]>;
@@ -16,4 +21,5 @@ export declare abstract class UserService {
         tags: string[];
         address: string;
     }>;
+    static syncTags(): Promise<void>;
 }

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

@@ -1332,6 +1332,25 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                 };
             };
         };
+    } & {
+        users: {
+            tags: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: {
+                            tags: string[];
+                            address: string;
+                        }[];
+                    };
+                };
+            };
+        };
     } & {
         users: {
             ":address": {
@@ -1342,6 +1361,7 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                     headers: unknown;
                     response: {
                         200: {
+                            tags: string[];
                             address: string;
                         } | null;
                     };
@@ -1588,6 +1608,22 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                 };
             };
         };
+    } & {
+        users: {
+            sync: {
+                post: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: void;
+                    };
+                };
+            };
+        };
     } & {
         users: {
             ":address": {
@@ -1648,11 +1684,10 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                     headers: unknown;
                     response: {
                         200: {
-                            [chainId: number]: {
-                                live: string;
-                                lastTree: string;
-                            };
-                        };
+                            live: string;
+                            tree: string;
+                            lastTree: string;
+                        }[];
                     };
                 };
             };

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

@@ -1330,6 +1330,25 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                 };
             };
         };
+    } & {
+        users: {
+            tags: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: {
+                            tags: string[];
+                            address: string;
+                        }[];
+                    };
+                };
+            };
+        };
     } & {
         users: {
             ":address": {
@@ -1340,6 +1359,7 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                     headers: unknown;
                     response: {
                         200: {
+                            tags: string[];
                             address: string;
                         } | null;
                     };
@@ -1586,6 +1606,22 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                 };
             };
         };
+    } & {
+        users: {
+            sync: {
+                post: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: void;
+                    };
+                };
+            };
+        };
     } & {
         users: {
             ":address": {
@@ -1646,11 +1682,10 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                     headers: unknown;
                     response: {
                         200: {
-                            [chainId: number]: {
-                                live: string;
-                                lastTree: string;
-                            };
-                        };
+                            live: string;
+                            tree: string;
+                            lastTree: string;
+                        }[];
                     };
                 };
             };

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

@@ -1333,6 +1333,25 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                 };
             };
         };
+    } & {
+        users: {
+            tags: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: {
+                            tags: string[];
+                            address: string;
+                        }[];
+                    };
+                };
+            };
+        };
     } & {
         users: {
             ":address": {
@@ -1343,6 +1362,7 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                     headers: unknown;
                     response: {
                         200: {
+                            tags: string[];
                             address: string;
                         } | null;
                     };
@@ -1589,6 +1609,22 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                 };
             };
         };
+    } & {
+        users: {
+            sync: {
+                post: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: void;
+                    };
+                };
+            };
+        };
     } & {
         users: {
             ":address": {
@@ -1649,11 +1685,10 @@ declare const _default: (app: App) => import("elysia").default<"", false, {
                     headers: unknown;
                     response: {
                         200: {
-                            [chainId: number]: {
-                                live: string;
-                                lastTree: string;
-                            };
-                        };
+                            live: string;
+                            tree: string;
+                            lastTree: string;
+                        }[];
                     };
                 };
             };