@merkl/api 1.0.78 → 1.0.80

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/EulerBorrowProcessor.d.ts

@@ -0,0 +1,36 @@
+import { type Campaign, type CampaignParameters } from "@angleprotocol/sdk/ts";
+import type { Erc20SubType } from "../../../../engine/implementations/Erc20/subTypes";
+import type { Pricer } from "../../../../utils/pricer";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+type callType = {
+    key: keyof dataRawEuler;
+    call: string;
+    target: keyof callKeysEuler;
+    metaData?: keyof callKeysEuler;
+};
+type callKeysEuler = mandatoryCallKeys & {
+    addressVault: string;
+    totalAssets: string;
+};
+type dataRawEuler = callKeysEuler & {
+    symbolUnderlyingToken: string;
+};
+type dataTypeEuler = dataType & {
+    addressVault: string;
+    asset: string;
+    symbolAsset: string;
+    decimalsAsset: number;
+    totalSupply: number;
+    totalBorrows: string;
+};
+export declare class EulerBorrowProcessor extends GenericProcessor<callKeysEuler, dataRawEuler, dataTypeEuler> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawEuler, campaign: CampaignParameters<Campaign.EULER>): void;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawEuler, _calls: string[], campaign: CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeEuler>;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/EulerLendProcessor.d.ts

@@ -0,0 +1,35 @@
+import { type Campaign, type CampaignParameters } from "@angleprotocol/sdk/ts";
+import type { Erc20SubType } from "../../../../engine/implementations/Erc20/subTypes";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+type callType = {
+    key: keyof dataRawEuler;
+    call: string;
+    target: keyof callKeysEuler;
+    metaData?: keyof callKeysEuler;
+};
+type callKeysEuler = mandatoryCallKeys & {
+    addressVault: string;
+    totalAssets: string;
+};
+type dataRawEuler = callKeysEuler & {
+    symbolUnderlyingToken: string;
+};
+type dataTypeEuler = dataType & {
+    addressVault: string;
+    asset: string;
+    symbolAsset: string;
+    decimalsAsset: number;
+    totalSupply: number;
+    totalAssets: string;
+};
+export declare class EulerLendProcessor extends GenericProcessor<callKeysEuler, dataRawEuler, dataTypeEuler> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawEuler, campaign: CampaignParameters<Campaign.EULER>): void;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawEuler, _calls: string[], campaign: CampaignParameters<Campaign.EULER>): Promise<dataTypeEuler>;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/FluidProcessor.d.ts

@@ -0,0 +1,39 @@
+import { type Campaign, type CampaignParameters } from "@angleprotocol/sdk/ts";
+import type { Erc20SubType } from "../../../../engine/implementations/Erc20/subTypes";
+import type { Pricer } from "../../../../utils/pricer";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+type callType = {
+    key: keyof dataRawFluid;
+    call: string;
+    target: keyof callKeysFluid;
+    metaData?: keyof callKeysFluid;
+};
+type callKeysFluid = mandatoryCallKeys & {
+    underlying: string;
+    exchangeRate: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+    amount: string;
+    toAssets: string;
+};
+type dataRawFluid = callKeysFluid & {};
+type dataTypeFluid = dataType & {
+    underlying: string;
+    exchangeRate: number;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+    totalSupply: number;
+    amount: string;
+    toAssets: string;
+};
+export declare class FluidProcessor extends GenericProcessor<callKeysFluid, dataRawFluid, dataTypeFluid> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawFluid, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeFluid>;
+    processingRound3(typeInfo: dataRawFluid): void;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/FraxProcessor.d.ts

@@ -0,0 +1,33 @@
+import { type Campaign, type CampaignParameters } from "@angleprotocol/sdk/ts";
+import { Erc20SubType } from "../../../../engine/implementations/Erc20/subTypes";
+import type { Pricer } from "../../../../utils/pricer";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+type callType = {
+    key: keyof dataRawFrax;
+    call: string;
+    target: keyof callKeysFrax;
+    metaData?: keyof callKeysFrax;
+};
+type callKeysFrax = mandatoryCallKeys & {
+    underlying: string;
+    sharePrice: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+};
+type dataRawFrax = callKeysFrax & {};
+type dataTypeFrax = dataType & {
+    underlying: string;
+    sharePrice: number;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+};
+export declare class FraxProcessor extends GenericProcessor<callKeysFrax, dataRawFrax, dataTypeFrax> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawFrax, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeFrax>;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/GammaALMProcessor.d.ts

@@ -0,0 +1,30 @@
+import { type Campaign, type CampaignParameters } from "@angleprotocol/sdk/ts";
+import type { Erc20SubType } from "../../../../engine/implementations/Erc20/subTypes";
+import type { Pricer } from "../../../../utils/pricer";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+type callType = {
+    key: keyof dataRawGamma;
+    call: string;
+    target: keyof callKeysGamma;
+    metaData?: any;
+};
+type callKeysGamma = mandatoryCallKeys & {
+    tokenPrice: string;
+    name: string;
+};
+type dataRawGamma = callKeysGamma & {
+    underlyingProtocol: string;
+};
+type dataTypeGamma = dataType & {
+    tokenPrice: string;
+};
+export declare class GammaALMProcessor extends GenericProcessor<callKeysGamma, dataRawGamma, dataTypeGamma> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawGamma, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, _pricer: Pricer): Promise<dataTypeGamma>;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/GammaProcessor.d.ts

@@ -0,0 +1,43 @@
+import { type Campaign, type CampaignParameters } from "@angleprotocol/sdk/ts";
+import type { Erc20SubType } from "../../../../engine/implementations/Erc20/subTypes";
+import type { Pricer } from "../../../../utils/pricer";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+type callType = {
+    key: keyof dataRawGamma;
+    call: string;
+    target: keyof callKeysGamma;
+    metaData?: keyof callKeysGamma;
+};
+type callKeysGamma = mandatoryCallKeys & {
+    token0: string;
+    token1: string;
+    CFMMPrice: string;
+    cfmm: string;
+};
+type dataRawGamma = callKeysGamma & {
+    tokensRaw: string[];
+    tokenBalances: string[];
+    symbolToken0: string;
+    symbolToken1: string;
+    decimalsToken0: string;
+    decimalsToken1: string;
+    balanceToken0: string;
+    balanceToken1: string;
+};
+type dataTypeGamma = dataType & {};
+export declare class GammaProcessor extends GenericProcessor<callKeysGamma, dataRawGamma, dataTypeGamma> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawGamma): void;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawGamma, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeGamma>;
+    computeRound1(type: Erc20SubType, typeInfo: dataRawGamma): import("../tokenTypeStruct").tokenTypeStruct;
+    computeRound2(index: number, type: Erc20SubType, typeInfo: dataRawGamma, calls: string[]): import("../tokenTypeStruct").tokenTypeStruct;
+    computeRound3(index: number, type: Erc20SubType, typeInfo: dataRawGamma, calls: string[]): import("../tokenTypeStruct").tokenTypeStruct;
+    computeRound4(index: number, type: Erc20SubType, typeInfo: dataRawGamma, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): import("../tokenTypeStruct").tokenTypeStruct;
+    computeRound5(index: number, type: Erc20SubType, typeInfo: dataRawGamma, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<import("../tokenTypeStruct").tokenTypeStruct>;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/GearboxProcessor.d.ts

@@ -0,0 +1,44 @@
+import { type Campaign, type CampaignParameters } from "@angleprotocol/sdk/ts";
+import type { Erc20SubType } from "../../../../engine/implementations/Erc20/subTypes";
+import type { Pricer } from "../../../../utils/pricer";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+type callType = {
+    key: keyof dataRawGearbox;
+    call: string;
+    target: keyof callKeysGearbox;
+    metaData?: keyof callKeysGearbox;
+    optional?: boolean;
+};
+type callKeysGearbox = mandatoryCallKeys & {
+    stakingToken: string;
+    balanceStakingToken: string;
+    underlyingToken: string;
+    totalSupplyStakingToken: string;
+    decimalsStakingToken: string;
+    totalAssets: string;
+    decimalsUnderlyingToken: string;
+    symbolUnderlyingToken: string;
+};
+type dataRawGearbox = callKeysGearbox & {
+    isTrade: boolean;
+};
+type dataTypeGearbox = dataType & {
+    stakingToken: string;
+    balanceStakingToken: number;
+    underlyingToken: string;
+    totalSupplyStakingToken: number;
+    decimalsStakingToken: string;
+    totalAssets: number;
+    percentageOfSupplyUnderlyingPoolTokens: number;
+};
+export declare class GearboxProcessor extends GenericProcessor<callKeysGearbox, dataRawGearbox, dataTypeGearbox> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawGearbox): Promise<void>;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawGearbox, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeGearbox>;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/HanjiVaultProcessor.d.ts

@@ -0,0 +1,43 @@
+import { type Campaign, type CampaignParameters } from "@angleprotocol/sdk/ts";
+import type { Erc20SubType } from "../../../../engine/implementations/Erc20/subTypes";
+import type { Pricer } from "../../../../utils/pricer";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+type callType = {
+    key: keyof dataRawHanjiN;
+    call: string;
+    target: keyof callKeysHanjiN;
+    metaData?: keyof callKeysHanjiN | string;
+    optional?: boolean;
+};
+type callKeysHanjiN = mandatoryCallKeys & {
+    owner: string;
+    [key: `token${number}`]: string;
+    [key: `symbolToken${number}`]: string;
+    [key: `decimalsToken${number}`]: string;
+    [key: `balanceToken${number}`]: string;
+    [key: `${number}`]: string;
+    name: string;
+    helper: string;
+    tvl: string;
+};
+type dataRawHanjiN = callKeysHanjiN & {
+    numberTokens: number;
+};
+type dataTypeHanjiN = dataType & {
+    numberTokens: number;
+    tvl: number;
+};
+export declare class HanjiVaultProcessor extends GenericProcessor<callKeysHanjiN, dataRawHanjiN, dataTypeHanjiN> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawHanjiN): void;
+    processingRound3(typeInfo: dataRawHanjiN): void;
+    computeRound3(index: number, type: Erc20SubType, typeInfo: dataRawHanjiN, calls: string[]): import("../tokenTypeStruct").tokenTypeStruct;
+    computeRound4(index: number, type: Erc20SubType, typeInfo: dataRawHanjiN, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>): import("../tokenTypeStruct").tokenTypeStruct;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawHanjiN, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeHanjiN>;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/HoldStationProcessor.d.ts

@@ -0,0 +1,29 @@
+import { type Campaign, type CampaignParameters } from "@angleprotocol/sdk/ts";
+import type { Erc20SubType } from "../../../../engine/implementations/Erc20/subTypes";
+import type { Pricer } from "../../../../utils/pricer";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+type callType = {
+    key: keyof dataRawHS;
+    call: string;
+    target: keyof callKeysHS;
+    metaData?: keyof callKeysHS;
+};
+type callKeysHS = mandatoryCallKeys & {
+    tvl: string;
+    underlying: string;
+};
+type dataRawHS = callKeysHS & {
+    decimalsUnderlying: string;
+    symbolUnderlyingToken: string;
+};
+type dataTypeHS = dataType & {};
+export declare class HoldStationProcessor extends GenericProcessor<callKeysHS, dataRawHS, dataTypeHS> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawHS, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeHS>;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/HourglassProcessor.d.ts

@@ -0,0 +1,36 @@
+import { type Campaign, type CampaignParameters } from "@angleprotocol/sdk/ts";
+import { BigNumber } from "ethers";
+import type { Erc20SubType } from "../../../../engine/implementations/Erc20/subTypes";
+import type { Pricer } from "../../../../utils/pricer";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+type callType = {
+    key: keyof dataRawHourglass;
+    call: string;
+    target: keyof callKeysHourglass;
+    metaData?: keyof callKeysHourglass;
+};
+export type callKeysHourglass = mandatoryCallKeys & {
+    depositor: string;
+    underlying: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlying: string;
+    balanceOfUnderlying: string;
+};
+type dataRawHourglass = callKeysHourglass & {};
+type dataTypeHourglass = dataType & {
+    underlying: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlying: number;
+    priceTargetToken: number;
+    balanceOfUnderlying: BigNumber;
+};
+export declare class HourglassProcessor extends GenericProcessor<callKeysHourglass, dataRawHourglass, dataTypeHourglass> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawHourglass, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeHourglass>;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/MaverickBPProcessor.d.ts

@@ -0,0 +1,50 @@
+import { type Campaign, type CampaignParameters } from "@angleprotocol/sdk/ts";
+import type { Erc20SubType } from "../../../../engine/implementations/Erc20/subTypes";
+import type { Pricer } from "../../../../utils/pricer";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+type callType = {
+    key: keyof dataRawMaverickBP;
+    call: string;
+    target: keyof callKeysMaverickBP;
+    metaData?: keyof callKeysMaverickBP;
+};
+type callKeysMaverickBP = mandatoryCallKeys & {
+    boostedPositionInformation: string;
+    token0: string;
+    token1: string;
+    lensAddress: string;
+};
+type dataRawMaverickBP = callKeysMaverickBP & {
+    amount0: string;
+    amount1: string;
+    decimalsToken0: string;
+    decimalsToken1: string;
+    bpInfoReturnData: {
+        [key: string]: string | number;
+    };
+    symbolToken0: string;
+    symbolToken1: string;
+};
+type dataTypeMaverickBP = dataType & {
+    amount0: number;
+    amount1: number;
+    decimalsToken0: number;
+    decimalsToken1: number;
+    lensAddress: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    token0: string;
+    token1: string;
+};
+export declare class MaverickBPProcessor extends GenericProcessor<callKeysMaverickBP, dataRawMaverickBP, dataTypeMaverickBP> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound1(typeInfo: dataRawMaverickBP): void;
+    processingRound2(typeInfo: dataRawMaverickBP): void;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawMaverickBP, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeMaverickBP>;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/MetamorphoProcessor.d.ts

@@ -0,0 +1,33 @@
+import { type Campaign, type CampaignParameters } from "@angleprotocol/sdk/ts";
+import type { Pricer } from "../../../../utils/pricer";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+import type { Erc20SubType } from "../../../../engine/implementations/Erc20/subTypes";
+type callType = {
+    key: keyof dataRawMetamorpho;
+    call: string;
+    target: keyof callKeysMetamorpho;
+    metaData?: keyof callKeysMetamorpho;
+};
+type callKeysMetamorpho = mandatoryCallKeys & {
+    underlying: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+    totalAssets: string;
+};
+type dataRawMetamorpho = callKeysMetamorpho & {};
+type dataTypeMetamorpho = dataType & {
+    underlying: string;
+    symbolUnderlyingToken: string;
+    priceTargetToken: number;
+};
+export declare class MetamorphoProcessor extends GenericProcessor<callKeysMetamorpho, dataRawMetamorpho, dataTypeMetamorpho> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawMetamorpho, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeMetamorpho>;
+    computeRound3(index: number, type: Erc20SubType, typeInfo: dataRawMetamorpho, calls: string[]): import("../tokenTypeStruct").tokenTypeStruct;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/NoLinkVaultProcessor.d.ts

@@ -0,0 +1,38 @@
+import { type Campaign, type CampaignParameters } from "@angleprotocol/sdk/ts";
+import { Erc20SubType } from "../../../../engine/implementations/Erc20/subTypes";
+import type { Pricer } from "../../../../utils/pricer";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+type callType = {
+    key: keyof dataRawNoLinkVault;
+    call: string;
+    target: keyof callKeysNoLinkVault;
+    metaData?: keyof callKeysNoLinkVault;
+};
+type callKeysNoLinkVault = mandatoryCallKeys & {
+    rateAccountant: string;
+    base: string;
+    baseSymbol: string;
+};
+type dataRawNoLinkVault = callKeysNoLinkVault & {
+    rate: string;
+};
+type dataTypeNoLinkVault = dataType & {
+    rate: number;
+    baseSymbol: string;
+};
+export declare class NoLinkVaultProcessor extends GenericProcessor<callKeysNoLinkVault, dataRawNoLinkVault, dataTypeNoLinkVault> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound1(typeInfo: dataRawNoLinkVault): void;
+    processingRound5(index: number, type: Erc20SubType, typeInfo: dataRawNoLinkVault, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeNoLinkVault>;
+    computeRound1(type: Erc20SubType, typeInfo: dataRawNoLinkVault): import("../tokenTypeStruct").tokenTypeStruct;
+    computeRound2(index: number, type: Erc20SubType, typeInfo: dataRawNoLinkVault, calls: string[]): import("../tokenTypeStruct").tokenTypeStruct;
+    computeRound3(index: number, type: Erc20SubType, typeInfo: dataRawNoLinkVault, calls: string[]): import("../tokenTypeStruct").tokenTypeStruct;
+    computeRound4(index: number, type: Erc20SubType, typeInfo: dataRawNoLinkVault, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): import("../tokenTypeStruct").tokenTypeStruct;
+    computeRound5(index: number, type: Erc20SubType, typeInfo: dataRawNoLinkVault, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<import("../tokenTypeStruct").tokenTypeStruct>;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/PendleProcessor.d.ts

@@ -0,0 +1,29 @@
+import type { Campaign, CampaignParameters } from "@angleprotocol/sdk/ts";
+import type { Erc20SubType } from "../../../../engine/implementations/Erc20/subTypes";
+import type { Pricer } from "../../../../utils/pricer";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+type callType = {
+    key: keyof dataRawPendle;
+    call: string;
+    target: keyof callKeysPendle;
+    metaData?: keyof callKeysPendle;
+};
+type callKeysPendle = mandatoryCallKeys & {
+    SYToken: string;
+    underlying: string;
+    symbolUnderlyingToken: string;
+};
+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: Erc20SubType, typeInfo: dataRawPendle, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypePendle>;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/PendleYTProcessor.d.ts

@@ -0,0 +1,29 @@
+import type { Campaign, CampaignParameters } from "@angleprotocol/sdk/ts";
+import type { Erc20SubType } from "../../../../engine/implementations/Erc20/subTypes";
+import type { Pricer } from "../../../../utils/pricer";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+type callType = {
+    key: keyof dataRawPendleYT;
+    call: string;
+    target: keyof callKeysPendleYT;
+    metaData?: keyof callKeysPendleYT;
+};
+type callKeysPendleYT = mandatoryCallKeys & {
+    SYToken: string;
+    underlying: string;
+    symbolUnderlyingToken: string;
+};
+type dataRawPendleYT = callKeysPendleYT & {
+    readTokensRaw: string[];
+};
+type dataTypePendleYT = dataType & {};
+export declare class PendleYTProcessor extends GenericProcessor<callKeysPendleYT, dataRawPendleYT, dataTypePendleYT> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawPendleYT, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, _pricer: Pricer): Promise<dataTypePendleYT>;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/RadiantProcessor.d.ts

@@ -0,0 +1,32 @@
+import { type Campaign, type CampaignParameters } from "@angleprotocol/sdk/ts";
+import type { Erc20SubType } from "../../../../engine/implementations/Erc20/subTypes";
+import type { Pricer } from "../../../../utils/pricer";
+import { GenericProcessor, type dataType, type mandatoryCallKeys } from "../GenericProcessor";
+type callType = {
+    key: keyof dataRawRadiant;
+    call: string;
+    target: keyof callKeysRadiant;
+    metaData?: keyof callKeysRadiant;
+};
+type callKeysRadiant = mandatoryCallKeys & {
+    underlyingToken: string;
+    priceBN: string;
+    symbolUnderlyingToken: string;
+};
+type dataRawRadiant = callKeysRadiant & {};
+type dataTypeRadiant = dataType & {
+    priceTargetToken: number;
+    underlyingToken: string;
+    symbolUnderlyingToken: string;
+};
+export declare class RadiantProcessor extends GenericProcessor<callKeysRadiant, dataRawRadiant, dataTypeRadiant> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawRadiant, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, _pricer: Pricer): Promise<dataTypeRadiant>;
+    computeRound3(index: number, type: Erc20SubType, typeInfo: dataRawRadiant, calls: string[]): import("../tokenTypeStruct").tokenTypeStruct;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/RfxProcessor.d.ts

@@ -0,0 +1,40 @@
+import { type Campaign, type CampaignParameters } from "@angleprotocol/sdk/ts";
+import type { Erc20SubType } from "../../../../engine/implementations/Erc20/subTypes";
+import type { Pricer } from "../../../../utils/pricer";
+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 & {
+    symbolShortToken: string;
+    symbolLongToken: string;
+};
+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: Erc20SubType, typeInfo: dataRawTemplate, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeRfx>;
+}
+export {};