@merkl/api 0.16.21 → 0.16.23

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

@@ -2670,6 +2670,21 @@ declare const eden: {
                     200: void;
                 }>>;
             }) & {
+                computedUntil: ((params: {
+                    campaignId: string | number;
+                }) => {
+                    put: (body: {
+                        computedUntil: number;
+                    }, options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: void;
+                    }>>;
+                }) & {};
                 overlaps: {
                     get: (options: {
                         headers: {
@@ -5847,6 +5862,21 @@ declare const eden: {
                     200: void;
                 }>>;
             }) & {
+                computedUntil: ((params: {
+                    campaignId: string | number;
+                }) => {
+                    put: (body: {
+                        computedUntil: number;
+                    }, options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: void;
+                    }>>;
+                }) & {};
                 overlaps: {
                     get: (options: {
                         headers: {
@@ -10318,6 +10348,28 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     };
                 };
             };
+        } & {
+            engine: {
+                computedUntil: {
+                    ":campaignId": {
+                        put: {
+                            body: {
+                                computedUntil: number;
+                            };
+                            params: {
+                                campaignId: string;
+                            };
+                            query: unknown;
+                            headers: {
+                                authorization: string;
+                            };
+                            response: {
+                                200: void;
+                            };
+                        };
+                    };
+                };
+            };
         } & {
             engine: {
                 overlaps: {
@@ -14567,6 +14619,21 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     200: void;
                 }>>;
             }) & {
+                computedUntil: ((params: {
+                    campaignId: string | number;
+                }) => {
+                    put: (body: {
+                        computedUntil: number;
+                    }, options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: void;
+                    }>>;
+                }) & {};
                 overlaps: {
                     get: (options: {
                         headers: {
@@ -17744,6 +17811,21 @@ export declare const MerklApi: (domain: string | import("elysia").default<"", fa
                     200: void;
                 }>>;
             }) & {
+                computedUntil: ((params: {
+                    campaignId: string | number;
+                }) => {
+                    put: (body: {
+                        computedUntil: number;
+                    }, options: {
+                        headers: {
+                            authorization: string;
+                        };
+                        query?: Record<string, unknown> | undefined;
+                        fetch?: RequestInit | undefined;
+                    }) => Promise<import("@elysiajs/eden").Treaty.TreatyResponse<{
+                        200: void;
+                    }>>;
+                }) & {};
                 overlaps: {
                     get: (options: {
                         headers: {

package/dist/src/index.d.ts

@@ -3266,6 +3266,28 @@ declare const app: Elysia<"", false, {
                     };
                 };
             };
+        } & {
+            engine: {
+                computedUntil: {
+                    ":campaignId": {
+                        put: {
+                            body: {
+                                computedUntil: number;
+                            };
+                            params: {
+                                campaignId: string;
+                            };
+                            query: unknown;
+                            headers: {
+                                authorization: string;
+                            };
+                            response: {
+                                200: void;
+                            };
+                        };
+                    };
+                };
+            };
         } & {
             engine: {
                 overlaps: {

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

@@ -1,8 +1,8 @@
-import type { Pricer } from "../../../../../utils/pricer";
+import type { Pricer } from "../../../../utils/pricer";
 import { type CallDto, type Campaign, type CampaignParameters } from "@sdk";
-import type { ERC20SupportedCampaignType } from "../../ERC20DynamicData";
-import { type tokenType, type tokenTypeStruct } from "../helpers/tokenType";
-export declare enum roundType {
+import type { ERC20SupportedCampaignType } from "../ERC20DynamicData";
+import { type tokenType, type tokenTypeStruct } from "./helpers/tokenType";
+export declare enum Round {
     one = "round1",
     two = "round2",
     three = "round3",
@@ -15,9 +15,6 @@ export type callType = {
     metaData?: any;
     optional?: boolean;
 };
-export type callKeys = mandatoryCallKeys & {
-    [key: string]: string;
-};
 export type mandatoryCallKeys = {
     type: tokenType;
     protocol: string;
@@ -26,6 +23,9 @@ export type mandatoryCallKeys = {
     totalSupply: string;
     whitelistedSupply: string;
 };
+export type callKeys = mandatoryCallKeys & {
+    [key: string]: string;
+};
 export type dataRaw = {
     protocol: string;
     tokenAddress: string;
@@ -44,6 +44,13 @@ export type dataType = {
     priceTargetToken: number;
     whitelistedSupplyTargetToken: number;
 };
+/**
+ * Generic Processor to compute dynamic data of ERC20 tokens
+ *
+ * @params Input - Sets of value that will be passed from rounds to rounds in order to query the blockchain
+ * @params DataRaw - Raw data output from the view function calls
+ * @params Output - Final output of the processor
+ */
 export declare class GenericProcessor<Input extends callKeys, DataRaw extends dataRaw, Output extends dataType> {
     rounds: {
         round1: callType[];
@@ -52,16 +59,16 @@ export declare class GenericProcessor<Input extends callKeys, DataRaw extends da
         round4: callType[];
     };
     debug: boolean;
-    processingRound1(typeInfo: DataRaw): void;
-    processingRound2(typeInfo: DataRaw, campaign?: CampaignParameters<ERC20SupportedCampaignType>): void;
-    processingRound3(typeInfo: DataRaw): void;
-    processingRound4(typeInfo: DataRaw): void;
+    processingRound1(_typeInfo: DataRaw): void;
+    processingRound2(_typeInfo: DataRaw, _campaign?: CampaignParameters<ERC20SupportedCampaignType>): void;
+    processingRound3(_typeInfo: DataRaw): void;
+    processingRound4(_typeInfo: DataRaw): void;
     handleWhiteListBlacklistRound5(typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): {
         whitelistedSupplyTargetToken: number;
         totalSupply: any;
         blacklistedSupply: number;
     };
-    processingRound5(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<Output>;
+    processingRound5(_index: number, type: tokenType, typeInfo: DataRaw, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<Output>;
     computeRound1(type: tokenType, typeInfo: DataRaw): tokenTypeStruct;
     computeRound2(index: number, type: tokenType, typeInfo: DataRaw, calls: string[], campaign?: CampaignParameters<ERC20SupportedCampaignType>): tokenTypeStruct;
     computeRound3(index: number, type: tokenType, typeInfo: DataRaw, calls: string[]): tokenTypeStruct;
@@ -71,7 +78,7 @@ export declare class GenericProcessor<Input extends callKeys, DataRaw extends da
     generateBlackListCall(type: tokenType, typeInfo: DataRaw, campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>): CallDto[];
     decodeListedSupply(index: number, decimals: number, list: string[], calls: string[]): string;
     decodeRound(round: callType[], index: number, calls: string[], type: tokenType, data: DataRaw): void;
-    decodePreviousRound(round: roundType, calls: string[], data: DataRaw, type: tokenType, index: number): void;
+    decodePreviousRound(round: Round, calls: string[], data: DataRaw, type: tokenType, index: number): void;
     encodeRound(round: callType[], callInfo: Input, type: tokenType): CallDto[];
-    encodeNextRound(round: roundType, type: tokenType, data: DataRaw): CallDto[];
+    encodeNextRound(round: Round, type: tokenType, data: DataRaw): CallDto[];
 }

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor/GenericProcessor.js → GenericProcessor.js}

@@ -1,16 +1,23 @@
-import { decodeCall } from "../../../../../utils/decodeCalls";
-import { createCall } from "../../../../../utils/encodeCalls";
-import { generateCardName } from "../../../../../utils/generateCardName";
-import { generateIcons } from "../../../../../utils/generateIcons";
+import { decodeCall } from "../../../../utils/decodeCalls";
+import { createCall } from "../../../../utils/encodeCalls";
+import { generateCardName } from "../../../../utils/generateCardName";
+import { generateIcons } from "../../../../utils/generateIcons";
 import { BN2Number } from "@sdk";
-import { tokenTypeToProtocol } from "../helpers/tokenType";
-export var roundType;
-(function (roundType) {
-    roundType["one"] = "round1";
-    roundType["two"] = "round2";
-    roundType["three"] = "round3";
-    roundType["four"] = "round4";
-})(roundType || (roundType = {}));
+import { tokenTypeToProtocol } from "./helpers/tokenType";
+export var Round;
+(function (Round) {
+    Round["one"] = "round1";
+    Round["two"] = "round2";
+    Round["three"] = "round3";
+    Round["four"] = "round4";
+})(Round || (Round = {}));
+/**
+ * Generic Processor to compute dynamic data of ERC20 tokens
+ *
+ * @params Input - Sets of value that will be passed from rounds to rounds in order to query the blockchain
+ * @params DataRaw - Raw data output from the view function calls
+ * @params Output - Final output of the processor
+ */
 export class GenericProcessor {
     rounds = {
         round1: [],
@@ -19,10 +26,10 @@ export class GenericProcessor {
         round4: [{ key: "totalSupply", call: "totalSupply", target: "tokenAddress" }],
     };
     debug = false;
-    processingRound1(typeInfo) { }
-    processingRound2(typeInfo, campaign) { }
-    processingRound3(typeInfo) { }
-    processingRound4(typeInfo) { }
+    processingRound1(_typeInfo) { }
+    processingRound2(_typeInfo, _campaign) { }
+    processingRound3(_typeInfo) { }
+    processingRound4(_typeInfo) { }
     handleWhiteListBlacklistRound5(typeInfo, campaign) {
         const totalSupply = BN2Number(typeInfo.totalSupply, campaign.campaignParameters.decimalsTargetToken);
         const whitelistedSupply = Number(typeInfo.whitelistedSupply);
@@ -35,7 +42,7 @@ export class GenericProcessor {
             blacklistedSupply,
         };
     }
-    async processingRound5(index, type, typeInfo, calls, campaign, pricer) {
+    async processingRound5(_index, type, typeInfo, _calls, campaign, pricer) {
         const { whitelistedSupplyTargetToken, totalSupply, blacklistedSupply } = this.handleWhiteListBlacklistRound5(typeInfo, campaign);
         const priceTargetToken = (await pricer.get({ symbol: campaign.campaignParameters.symbolTargetToken })) ?? 0;
         const tvl = whitelistedSupplyTargetToken * priceTargetToken;
@@ -56,57 +63,57 @@ export class GenericProcessor {
         if (this.debug) {
             console.log("Round 1", {
                 type: type,
-                calls: this.encodeNextRound(roundType.one, type, typeInfo),
+                calls: this.encodeNextRound(Round.one, type, typeInfo),
                 typeInfo,
             });
         }
         return {
             type: type,
-            calls: this.encodeNextRound(roundType.one, type, typeInfo),
+            calls: this.encodeNextRound(Round.one, type, typeInfo),
             typeInfo,
         };
     }
     computeRound2(index, type, typeInfo, calls, campaign) {
-        this.decodePreviousRound(roundType.one, calls, typeInfo, type, index);
+        this.decodePreviousRound(Round.one, calls, typeInfo, type, index);
         this.processingRound2(typeInfo, campaign);
         if (this.debug) {
             console.log("Round 2", {
                 type: type,
-                calls: this.encodeNextRound(roundType.two, type, typeInfo),
+                calls: this.encodeNextRound(Round.two, type, typeInfo),
                 typeInfo,
             });
         }
         return {
             type: type,
-            calls: this.encodeNextRound(roundType.two, type, typeInfo),
+            calls: this.encodeNextRound(Round.two, type, typeInfo),
             typeInfo,
         };
     }
     computeRound3(index, type, typeInfo, calls) {
-        this.decodePreviousRound(roundType.two, calls, typeInfo, type, index);
+        this.decodePreviousRound(Round.two, calls, typeInfo, type, index);
         this.processingRound3(typeInfo);
         if (this.debug) {
             console.log("Round 3", {
                 type: type,
-                calls: this.encodeNextRound(roundType.three, type, typeInfo),
+                calls: this.encodeNextRound(Round.three, type, typeInfo),
                 typeInfo,
             });
         }
         return {
             type: type,
-            calls: this.encodeNextRound(roundType.three, type, typeInfo),
+            calls: this.encodeNextRound(Round.three, type, typeInfo),
             typeInfo,
         };
     }
     computeRound4(index, type, typeInfo, calls, campaign) {
         const blacklistedLiquidityCalls = this.generateBlackListCall(type, typeInfo, campaign);
         const whitelistedLiquidityCalls = this.generateWhitelistCall(type, typeInfo, campaign);
-        this.decodePreviousRound(roundType.three, calls, typeInfo, type, index);
+        this.decodePreviousRound(Round.three, calls, typeInfo, type, index);
         this.processingRound4(typeInfo);
         if (this.debug) {
             console.log("Round 4", {
                 type: type,
-                calls: this.encodeNextRound(roundType.four, type, typeInfo),
+                calls: this.encodeNextRound(Round.four, type, typeInfo),
                 typeInfo,
             });
         }
@@ -114,7 +121,7 @@ export class GenericProcessor {
             type: type,
             calls: whitelistedLiquidityCalls
                 .concat(blacklistedLiquidityCalls)
-                .concat(this.encodeNextRound(roundType.four, type, typeInfo)),
+                .concat(this.encodeNextRound(Round.four, type, typeInfo)),
             typeInfo: {
                 ...typeInfo,
             },
@@ -125,7 +132,7 @@ export class GenericProcessor {
         index = index + campaign.campaignParameters.whitelist.length;
         typeInfo.blacklistedSupply = this.decodeListedSupply(index, campaign.campaignParameters.decimalsTargetToken, campaign.campaignParameters.blacklist, calls);
         index = index + campaign.campaignParameters.blacklist.length;
-        this.decodePreviousRound(roundType.four, calls, typeInfo, type, index);
+        this.decodePreviousRound(Round.four, calls, typeInfo, type, index);
         const outputInfo = (await this.processingRound5(index, type, typeInfo, calls, campaign, pricer));
         if (this.debug) {
             console.log("Round 5", {
@@ -184,7 +191,7 @@ export class GenericProcessor {
                     index++;
                     data[key] = value;
                 }
-                catch (error) {
+                catch {
                     index++;
                 }
             }
@@ -196,16 +203,16 @@ export class GenericProcessor {
         });
     }
     decodePreviousRound(round, calls, data, type, index) {
-        if (round === roundType.one) {
+        if (round === Round.one) {
             this.decodeRound(this.rounds.round1, index, calls, type, data);
         }
-        if (round === roundType.two) {
+        if (round === Round.two) {
             this.decodeRound(this.rounds.round2, index, calls, type, data);
         }
-        if (round === roundType.three) {
+        if (round === Round.three) {
             this.decodeRound(this.rounds.round3, index, calls, type, data);
         }
-        if (round === roundType.four) {
+        if (round === Round.four) {
             this.decodeRound(this.rounds.round4, index, calls, type, data);
         }
     }
@@ -231,16 +238,16 @@ export class GenericProcessor {
             return acc;
         }, {});
         let calls = [];
-        if (round === roundType.one) {
+        if (round === Round.one) {
             calls = this.encodeRound(this.rounds.round1, callInfo, type);
         }
-        if (round === roundType.two) {
+        if (round === Round.two) {
             calls = this.encodeRound(this.rounds.round2, callInfo, type);
         }
-        if (round === roundType.three) {
+        if (round === Round.three) {
             calls = this.encodeRound(this.rounds.round3, callInfo, type);
         }
-        if (round === roundType.four) {
+        if (round === Round.four) {
             calls = this.encodeRound(this.rounds.round4, callInfo, type);
         }
         return calls;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/AaveProcessor.d.ts

@@ -1,7 +1,7 @@
 import type { Pricer } from "../../../../../utils/pricer";
 import type { Campaign, CampaignParameters } from "@sdk";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
 import type { tokenType } from "../helpers/tokenType";
-import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
 type callType = {
     key: keyof dataRawAave;
     call: string;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/AaveProcessor.js

@@ -1,5 +1,5 @@
 import { generateCardName } from "../../../../../utils/generateCardName";
-import { GenericProcessor } from "./GenericProcessor";
+import { GenericProcessor } from "../GenericProcessor";
 export class AaveProcessor extends GenericProcessor {
     rounds = {
         round1: [{ key: "underlying", call: "underlying", target: "tokenAddress" }],

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/AnglesLiquid.d.ts

@@ -1,7 +1,7 @@
 import type { Pricer } from "../../../../../utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
 import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
-import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
 type callType = {
     key: keyof dataRawAnglesLiquid;
     call: string;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/AnglesLiquid.js

@@ -1,6 +1,6 @@
 import { generateCardName } from "../../../../../utils/generateCardName";
 import { BN2Number } from "@sdk";
-import { GenericProcessor } from "./GenericProcessor";
+import { GenericProcessor } from "../GenericProcessor";
 export class AnglesLiquidProcessor extends GenericProcessor {
     rounds = {
         round1: [],

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/AssetProcessor.d.ts

@@ -1,7 +1,7 @@
 import type { Pricer } from "../../../../../utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
 import { tokenType } from "../helpers/tokenType";
-import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
 type callType = {
     key: keyof dataRawAsset;
     call: string;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/AssetProcessor.js

@@ -1,7 +1,7 @@
 import { generateCardName } from "../../../../../utils/generateCardName";
 import { BN2Number } from "@sdk";
+import { GenericProcessor } from "../GenericProcessor";
 import { tokenType } from "../helpers/tokenType";
-import { GenericProcessor } from "./GenericProcessor";
 export class AssetProcessor extends GenericProcessor {
     rounds = {
         round1: [

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/AuraProcessor.d.ts

@@ -1,8 +1,8 @@
 import type { Pricer } from "../../../../../utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import type { BigNumber } from "ethers";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
 import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
-import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
 type callType = {
     key: keyof dataRawAura;
     call: string;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/AuraProcessor.js

@@ -3,7 +3,7 @@ import { createCall } from "../../../../../utils/encodeCalls";
 import { generateCardName } from "../../../../../utils/generateCardName";
 import { BN2Number } from "@sdk";
 import { utils } from "ethers";
-import { GenericProcessor, roundType } from "./GenericProcessor";
+import { GenericProcessor, Round } from "../GenericProcessor";
 export class AuraProcessor extends GenericProcessor {
     rounds = {
         round1: [
@@ -92,9 +92,9 @@ export class AuraProcessor extends GenericProcessor {
     computeRound4(index, type, typeInfo, calls, campaign) {
         // This is to enforce type checking
         const blacklistedLiquidityCalls = this.generateBlackListCall(type, typeInfo, campaign);
-        this.decodePreviousRound(roundType.three, calls, typeInfo, type, index);
+        this.decodePreviousRound(Round.three, calls, typeInfo, type, index);
         this.processingRound4(typeInfo);
-        const poolCalls = this.encodeNextRound(roundType.four, type, typeInfo);
+        const poolCalls = this.encodeNextRound(Round.four, type, typeInfo);
         for (const poolToken of typeInfo.poolTokens) {
             poolCalls.push(createCall(poolToken.token, "symbol"));
             poolCalls.push(createCall(poolToken.token, "decimals"));

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/BalancerGaugeProcessor.d.ts

@@ -1,8 +1,8 @@
 import type { Pricer } from "../../../../../utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import type { BigNumber } from "ethers";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
 import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
-import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
 type callType = {
     key: keyof dataRawBG;
     call: string;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/BalancerGaugeProcessor.js

@@ -2,7 +2,7 @@ import { decodeCall } from "../../../../../utils/decodeCalls";
 import { createCall } from "../../../../../utils/encodeCalls";
 import { generateCardName } from "../../../../../utils/generateCardName";
 import { BN2Number } from "@sdk";
-import { GenericProcessor, roundType } from "./GenericProcessor";
+import { GenericProcessor, Round } from "../GenericProcessor";
 export class BalancerGaugeProcessor extends GenericProcessor {
     rounds = {
         round1: [{ key: "gyroscopeToken", call: "lp_token", target: "tokenAddress" }],
@@ -65,7 +65,7 @@ export class BalancerGaugeProcessor extends GenericProcessor {
     computeRound4(index, type, typeInfo, calls, campaign) {
         // This is to enforce type checking
         const blacklistedLiquidityCalls = this.generateBlackListCall(type, typeInfo, campaign);
-        this.decodePreviousRound(roundType.three, calls, typeInfo, type, index);
+        this.decodePreviousRound(Round.three, calls, typeInfo, type, index);
         this.processingRound4(typeInfo);
         const poolCalls = [createCall(typeInfo.tokenAddress, "totalSupply")];
         for (const poolToken of typeInfo.poolTokens) {

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/BalancerPoolProcessor.d.ts

@@ -1,8 +1,8 @@
 import type { Pricer } from "../../../../../utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import { BigNumber } from "ethers";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
 import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
-import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
 type callType = {
     key: keyof dataRawBP;
     call: string;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/BalancerPoolProcessor.js

@@ -4,7 +4,7 @@ import { generateCardName } from "../../../../../utils/generateCardName";
 import { BN2Number } from "@sdk";
 import { BigNumber } from "ethers";
 import { utils } from "ethers";
-import { GenericProcessor, roundType } from "./GenericProcessor";
+import { GenericProcessor, Round } from "../GenericProcessor";
 export class BalancerPoolProcessor extends GenericProcessor {
     rounds = {
         round1: [],
@@ -77,9 +77,9 @@ export class BalancerPoolProcessor extends GenericProcessor {
     computeRound4(index, type, typeInfo, calls, campaign) {
         // This is to enforce type checking
         const blacklistedLiquidityCalls = this.generateBlackListCall(type, typeInfo, campaign);
-        this.decodePreviousRound(roundType.three, calls, typeInfo, type, index);
+        this.decodePreviousRound(Round.three, calls, typeInfo, type, index);
         this.processingRound4(typeInfo);
-        const poolCalls = this.encodeNextRound(roundType.four, type, typeInfo);
+        const poolCalls = this.encodeNextRound(Round.four, type, typeInfo);
         for (const poolToken of typeInfo.poolTokens) {
             poolCalls.push(createCall(poolToken.token, "symbol"));
             poolCalls.push(createCall(poolToken.token, "decimals"));

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/BalancerV3PoolProcessor.d.ts

@@ -1,8 +1,8 @@
 import type { Pricer } from "../../../../../utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
 import type { BigNumber } from "ethers";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
 import type { tokenType, tokenTypeStruct } from "../helpers/tokenType";
-import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
 type callType = {
     key: keyof dataRawBalancerV3;
     call: string;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/BalancerV3PoolProcessor.js

@@ -1,6 +1,6 @@
 import { generateCardName } from "../../../../../utils/generateCardName";
 import { BN2Number } from "@sdk";
-import { GenericProcessor } from "./GenericProcessor";
+import { GenericProcessor } from "../GenericProcessor";
 const matchSingleNumber = (input) => {
     const regex = /^\d+$/;
     return regex.test(input);

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/BeefyProcessor.d.ts

@@ -1,7 +1,7 @@
 import type { Pricer } from "../../../../../utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
 import type { tokenType } from "../helpers/tokenType";
-import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
 type callType = {
     key: keyof dataRawBeefy;
     call: string;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/BeefyProcessor.js

@@ -1,6 +1,6 @@
 import { generateCardName } from "../../../../../utils/generateCardName";
 import { BN2Number } from "@sdk";
-import { GenericProcessor } from "./GenericProcessor";
+import { GenericProcessor } from "../GenericProcessor";
 export class BeefyProcessor extends GenericProcessor {
     rounds = {
         round1: [

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/CompoundProcessor.d.ts

@@ -1,7 +1,7 @@
 import type { Pricer } from "../../../../../utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
 import type { tokenType } from "../helpers/tokenType";
-import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
 type callType = {
     key: keyof dataRawCompound;
     call: string;

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/CompoundProcessor.js

@@ -1,6 +1,6 @@
 import { generateCardName } from "../../../../../utils/generateCardName";
 import { BN2Number } from "@sdk";
-import { GenericProcessor } from "./GenericProcessor";
+import { GenericProcessor } from "../GenericProcessor";
 export class CompoundProcessor extends GenericProcessor {
     rounds = {
         round1: [{ key: "baseToken", call: "baseToken", target: "tokenAddress" }],

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/{processor → implementations}/ERC4626Processor.d.ts

@@ -1,7 +1,7 @@
 import type { Pricer } from "../../../../../utils/pricer";
 import { type Campaign, type CampaignParameters } from "@sdk";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
 import type { tokenType } from "../helpers/tokenType";
-import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
 type callType = {
     key: keyof dataRawERC4626;
     call: string;