@merkl/api 0.10.118 → 0.10.120

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/constants.d.ts

@@ -25,6 +25,7 @@ export declare const MERKL_BLACKLIST: string[];
 export declare const EBTC_ADDRESS = "0x661c70333AA1850CcDBAe82776Bb436A0fCfeEfB";
 export declare const CDPMANAGER_ADDRESS = "0xc4cbaE499bb4Ca41E78f52F07f5d98c375711774";
 export declare const SORTEDCDPS_ADDRESS = "0x591AcB5AE192c147948c12651a0a5f24f0529BE3";
+export declare const RFX_DATASTORE = "0x895124783008C6c68eFcccac24c482Fdf30439B2";
 export declare const DOPEX_OPTION_MARKET: {
     [market: string]: string;
 };

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/helpers/tokenType.d.ts

@@ -47,7 +47,8 @@ export declare enum tokenType {
     baseswap = "baseswap",
     zkswap = "zkswap",
     pendle = "pendle",
-    ironcladStaking = "ironcladStaking"
+    ironcladStaking = "ironcladStaking",
+    rfx = "rfx"
 }
 export declare const tokenTypeToProtocol: {
     [key in tokenType]: {

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;

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/RfxProcessor.d.ts

@@ -0,0 +1,37 @@
+import type { Pricer } from "../../../../../utils/pricer";
+import { type Campaign, type CampaignParameters } from "@sdk";
+import type { tokenType } from "../helpers/tokenType";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawTemplate;
+    call: string;
+    target: keyof callKeysRfx;
+    metaData?: keyof callKeysRfx;
+};
+type callKeysRfx = mandatoryCallKeys & {
+    shortToken: string;
+    longToken: string;
+    symbolShortToken: string;
+    symbolLongToken: string;
+    decimalsToken: string;
+    decimalsShortToken: string;
+    decimalsLongToken: string;
+    balanceShortToken: string;
+    balanceLongToken: string;
+    RFX_DATASTORE: string;
+    metaDataShort: string;
+    metaDataLong: string;
+};
+type dataRawTemplate = callKeysRfx & {};
+type dataTypeRfx = dataType & {};
+export declare class RfxProcessor extends GenericProcessor<callKeysRfx, dataRawTemplate, dataTypeRfx> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound1(typeInfo: dataRawTemplate): void;
+    processingRound5(index: number, type: tokenType, typeInfo: dataRawTemplate, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeRfx>;
+}
+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 {};