@merkl/api 0.10.117 → 0.10.119

package/dist/database/engine/.generated/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "prisma-client-0a7328d289178dfc3d2435a7d4d2e9f0cf2b4f4f86b7c7360ef7632323998bb4",
+  "name": "prisma-client-7f45b7454b156a79bbbccc40cd019348cf13c70ba7b3318a1b8b2228a4c67099",
   "main": "index.js",
   "types": "index.d.ts",
   "browser": "index-browser.js",

package/dist/database/engine/.generated/schema.prisma

@@ -2,7 +2,7 @@ generator client {
   provider        = "prisma-client-js"
   binaryTargets   = ["native", "linux-arm64-openssl-1.1.x", "linux-musl-arm64-openssl-3.0.x"]
   output          = ".generated/"
-  previewFeatures = ["fullTextSearch"]
+  previewFeatures = ["fullTextSearchPostgres", "relationJoins"]
 }
 
 datasource db {
@@ -186,8 +186,6 @@ model ERC20Holders {
   @@id([chainId, token])
 }
 
-// TO DROP
-
 model Tokens {
   chainId  Int
   address  String @db.Char(42)
@@ -197,6 +195,14 @@ model Tokens {
   @@id([chainId, address])
 }
 
+model StateSave {
+  id          String
+  blockNumber Int
+  state       Json
+
+  @@id([id, blockNumber])
+}
+
 model CampaignCreators {
   address String @db.Char(42)
   tags    String @default("")

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

@@ -1054,6 +1054,7 @@ declare const eden: {
                 fetch?: RequestInit | undefined;
             } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                 200: {
+                    tags: string[];
                     address: string;
                 } | null;
             }>>;
@@ -1304,6 +1305,31 @@ declare const eden: {
                     };
                 }>>;
             };
+            tags: {
+                get: (options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        tags: string[];
+                        address: string;
+                    }[];
+                }>>;
+            };
+            sync: {
+                post: (body: unknown, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: void;
+                }>>;
+            };
         };
         roots: {
             timestamps: {
@@ -1331,11 +1357,10 @@ declare const eden: {
                     fetch?: RequestInit | undefined;
                 } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                     200: {
-                        [chainId: number]: {
-                            live: string;
-                            lastTree: string;
-                        };
-                    };
+                        live: string;
+                        tree: string;
+                        lastTree: string;
+                    }[];
                 }>>;
             };
         };
@@ -3042,6 +3067,25 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 };
             };
         };
+    } & {
+        users: {
+            tags: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: {
+                            tags: string[];
+                            address: string;
+                        }[];
+                    };
+                };
+            };
+        };
     } & {
         users: {
             ":address": {
@@ -3052,6 +3096,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     headers: unknown;
                     response: {
                         200: {
+                            tags: string[];
                             address: string;
                         } | null;
                     };
@@ -3298,6 +3343,22 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 };
             };
         };
+    } & {
+        users: {
+            sync: {
+                post: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: void;
+                    };
+                };
+            };
+        };
     } & {
         users: {
             ":address": {
@@ -3358,11 +3419,10 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     headers: unknown;
                     response: {
                         200: {
-                            [chainId: number]: {
-                                live: string;
-                                lastTree: string;
-                            };
-                        };
+                            live: string;
+                            tree: string;
+                            lastTree: string;
+                        }[];
                     };
                 };
             };
@@ -4918,6 +4978,7 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                 fetch?: RequestInit | undefined;
             } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                 200: {
+                    tags: string[];
                     address: string;
                 } | null;
             }>>;
@@ -5168,6 +5229,31 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     };
                 }>>;
             };
+            tags: {
+                get: (options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: {
+                        tags: string[];
+                        address: string;
+                    }[];
+                }>>;
+            };
+            sync: {
+                post: (body: unknown, options: {
+                    headers: {
+                        authorization: string;
+                    };
+                    query?: Record<string, unknown> | undefined;
+                    fetch?: RequestInit | undefined;
+                }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                    200: void;
+                }>>;
+            };
         };
         roots: {
             timestamps: {
@@ -5195,11 +5281,10 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     fetch?: RequestInit | undefined;
                 } | undefined) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
                     200: {
-                        [chainId: number]: {
-                            live: string;
-                            lastTree: string;
-                        };
-                    };
+                        live: string;
+                        tree: string;
+                        lastTree: string;
+                    }[];
                 }>>;
             };
         };

package/dist/src/index.d.ts

@@ -1324,6 +1324,25 @@ declare const app: Elysia<"", false, {
                 };
             };
         };
+    } & {
+        users: {
+            tags: {
+                get: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: {
+                            tags: string[];
+                            address: string;
+                        }[];
+                    };
+                };
+            };
+        };
     } & {
         users: {
             ":address": {
@@ -1334,6 +1353,7 @@ declare const app: Elysia<"", false, {
                     headers: unknown;
                     response: {
                         200: {
+                            tags: string[];
                             address: string;
                         } | null;
                     };
@@ -1580,6 +1600,22 @@ declare const app: Elysia<"", false, {
                 };
             };
         };
+    } & {
+        users: {
+            sync: {
+                post: {
+                    body: unknown;
+                    params: Record<never, string>;
+                    query: unknown;
+                    headers: {
+                        authorization: string;
+                    };
+                    response: {
+                        200: void;
+                    };
+                };
+            };
+        };
     } & {
         users: {
             ":address": {
@@ -1640,11 +1676,10 @@ declare const app: Elysia<"", false, {
                     headers: unknown;
                     response: {
                         200: {
-                            [chainId: number]: {
-                                live: string;
-                                lastTree: string;
-                            };
-                        };
+                            live: string;
+                            tree: string;
+                            lastTree: string;
+                        }[];
                     };
                 };
             };

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

@@ -1,14 +1,14 @@
 import type { Pricer } from "../../../../../utils/pricer";
 import type { Campaign, 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 dataRawAave;
     call: string;
     target: keyof callKeysAave;
-    metaData?: any;
+    metaData?: keyof callKeysAave;
 };
-export type callKeysAave = callKeys & {
+export type callKeysAave = mandatoryCallKeys & {
     underlying: string;
     symbolUnderlyingToken: string;
 };
@@ -25,6 +25,6 @@ export declare class AaveProcessor extends GenericProcessor<callKeysAave, dataRa
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(index: number, type: tokenType, typeInfo: dataRawAave, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeAave>;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawAave, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeAave>;
 }
 export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/AssetProcessor.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 dataRawAsset;
     call: string;
     target: keyof callKeysAsset;
-    metaData?: any;
+    metaData?: keyof callKeysAsset;
     optional?: boolean;
 };
-type callKeysAsset = callKeys & {
+type callKeysAsset = mandatoryCallKeys & {
     underlying: string;
     exchangeRate: string;
     symbolUnderlyingToken: string;

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

@@ -2,14 +2,14 @@ import type { Pricer } from "../../../../../utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import type { BigNumber } from "ethers";
 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 dataRawAura;
     call: string;
     target: keyof callKeysAura;
-    metaData?: any;
+    metaData?: keyof callKeysAura;
 };
-type callKeysAura = callKeys & {
+type callKeysAura = mandatoryCallKeys & {
     balancerPool: string;
     vault: string;
     auraOperator: string;

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

@@ -2,14 +2,14 @@ import type { Pricer } from "../../../../../utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import type { BigNumber } from "ethers";
 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 dataRawBG;
     call: string;
     target: keyof callKeysBG;
-    metaData?: any;
+    metaData?: keyof callKeysBG;
 };
-type callKeysBG = callKeys & {
+type callKeysBG = mandatoryCallKeys & {
     gyroscopeToken: string;
     balanceUnderlyingPoolTokens: string;
     totalSupplyUnderlyingPoolTokens: string;

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

@@ -2,14 +2,14 @@ import type { Pricer } from "../../../../../utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import { BigNumber } from "ethers";
 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 dataRawBP;
     call: string;
     target: keyof callKeysBP;
-    metaData?: any;
+    metaData?: keyof callKeysBP;
 };
-type callKeysBP = callKeys & {
+type callKeysBP = mandatoryCallKeys & {
     tokenAddress: string;
     poolId: string;
     vault: string;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/BeefyProcessor.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 dataRawBeefy;
     call: string;
     target: keyof callKeysBeefy;
-    metaData?: any;
+    metaData?: keyof callKeysBeefy;
 };
-type callKeysBeefy = callKeys & {
+type callKeysBeefy = mandatoryCallKeys & {
     underlying: string;
     pricePerShare: string;
     token0: string;
@@ -43,6 +43,6 @@ export declare class BeefyProcessor extends GenericProcessor<callKeysBeefy, data
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(index: number, type: tokenType, typeInfo: dataRawBeefy, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBeefy>;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawBeefy, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBeefy>;
 }
 export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/CompoundProcessor.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 dataRawCompound;
     call: string;
     target: keyof callKeysCompound;
-    metaData?: any;
+    metaData?: keyof callKeysCompound;
 };
-type callKeysCompound = callKeys & {
+type callKeysCompound = mandatoryCallKeys & {
     tokenAddress: string;
     totalBorrow: string;
     balanceBaseToken: string;
@@ -39,6 +39,6 @@ export declare class CompoundProcessor extends GenericProcessor<callKeysCompound
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(index: number, type: tokenType, typeInfo: dataRawCompound, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeCompound>;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawCompound, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeCompound>;
 }
 export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/EnzymeProcessor.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 dataRawEnzyme;
     call: string;
     target: keyof callKeysEnzyme;
-    metaData?: any;
+    metaData?: keyof callKeysEnzyme;
 };
-type callKeysEnzyme = callKeys & {
+type callKeysEnzyme = mandatoryCallKeys & {
     factory: string;
     underlying: string;
     exchangeRate: string;
@@ -33,8 +33,8 @@ export declare class EnzymeProcessor extends GenericProcessor<callKeysEnzyme, da
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(index: number, type: tokenType, typeInfo: dataRawEnzyme, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeEnzyme>;
-    processingRound2(typeInfo: callKeys): void;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawEnzyme, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeEnzyme>;
+    processingRound2(typeInfo: dataRawEnzyme): void;
     computeRound3(index: number, type: tokenType, typeInfo: dataRawEnzyme, calls: string[]): tokenTypeStruct;
 }
 export {};

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

@@ -1,19 +1,20 @@
 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 dataRawEuler;
     call: string;
     target: keyof callKeysEuler;
-    metaData?: any;
+    metaData?: keyof callKeysEuler;
 };
-type callKeysEuler = callKeys & {
+type callKeysEuler = mandatoryCallKeys & {
     vault: string;
     underlying: string;
     symbolUnderlyingToken: string;
     decimalsUnderlyingToken: string;
     targetTotalAsset: string;
+    totalAssets: string;
 };
 type dataRawEuler = callKeysEuler & {};
 type dataTypeEuler = dataType & {
@@ -32,6 +33,6 @@ export declare class EulerBorrowProcessor extends GenericProcessor<callKeysEuler
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(index: number, type: tokenType, typeInfo: dataRawEuler, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeEuler>;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawEuler, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeEuler>;
 }
 export {};

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

@@ -1,19 +1,20 @@
 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 dataRawEuler;
     call: string;
     target: keyof callKeysEuler;
-    metaData?: any;
+    metaData?: keyof callKeysEuler;
 };
-type callKeysEuler = callKeys & {
+type callKeysEuler = mandatoryCallKeys & {
     vault: string;
     underlying: string;
     symbolUnderlyingToken: string;
     decimalsUnderlyingToken: string;
     targetTotalAsset: string;
+    totalAssets: string;
 };
 type dataRawEuler = callKeysEuler & {};
 type dataTypeEuler = dataType & {

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/FluidProcessor.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 dataRawFluid;
     call: string;
     target: keyof callKeysFluid;
-    metaData?: any;
+    metaData?: keyof callKeysFluid;
 };
-type callKeysFluid = callKeys & {
+type callKeysFluid = mandatoryCallKeys & {
     underlying: string;
     exchangeRate: string;
     symbolUnderlyingToken: string;
@@ -33,7 +33,7 @@ export declare class FluidProcessor extends GenericProcessor<callKeysFluid, data
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(index: number, type: tokenType, typeInfo: dataRawFluid, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeFluid>;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawFluid, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeFluid>;
     processingRound3(typeInfo: dataRawFluid): void;
 }
 export {};

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

@@ -1,14 +1,14 @@
 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 dataRawFrax;
     call: string;
     target: keyof callKeysFrax;
-    metaData?: any;
+    metaData?: keyof callKeysFrax;
 };
-type callKeysFrax = callKeys & {
+type callKeysFrax = mandatoryCallKeys & {
     underlying: string;
     sharePrice: string;
     symbolUnderlyingToken: string;
@@ -28,6 +28,6 @@ export declare class FraxProcessor extends GenericProcessor<callKeysFrax, dataRa
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(index: number, type: tokenType, typeInfo: dataRawFrax, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeFrax>;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawFrax, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeFrax>;
 }
 export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/GearboxProcessor.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 dataRawGearbox;
     call: string;
     target: keyof callKeysGearbox;
-    metaData?: any;
+    metaData?: keyof callKeysGearbox;
 };
-type callKeysGearbox = callKeys & {
+type callKeysGearbox = mandatoryCallKeys & {
     stakingToken: string;
     balanceStakingToken: string;
     underlyingToken: string;
@@ -35,6 +35,6 @@ export declare class GearboxProcessor extends GenericProcessor<callKeysGearbox,
         round3: callType[];
         round4: callType[];
     };
-    processingRound5(index: number, type: tokenType, typeInfo: dataRawGearbox, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeGearbox>;
+    processingRound5(_index: number, type: tokenType, typeInfo: dataRawGearbox, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeGearbox>;
 }
 export {};

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

@@ -15,8 +15,10 @@ export type callType = {
     metaData?: any;
     optional?: boolean;
 };
-export type callKeys = {
+export type callKeys = mandatoryCallKeys & {
     [key: string]: string;
+};
+export type mandatoryCallKeys = {
     tokenAddress: string;
     blacklistedSupply: string;
     totalSupply: string;