@merkl/api 1.0.78 → 1.0.80

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

@@ -0,0 +1,34 @@
+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 dataRawSatlayer;
+    call: string;
+    target: keyof callKeysSatlayer;
+    metaData?: keyof callKeysSatlayer;
+};
+export type callKeysSatlayer = mandatoryCallKeys & {
+    owner: string;
+    symbol: string;
+    symbolUnderlyingToken: string;
+    underlying: string;
+};
+type dataRawSatlayer = callKeysSatlayer & {};
+type dataTypeSatlayer = dataType & {
+    owner: string;
+    symbol: string;
+    underlying: string;
+    symbolUnderlyingToken: string;
+    priceTargetToken: number;
+};
+export declare class SatlayerProcessor extends GenericProcessor<callKeysSatlayer, dataRawSatlayer, dataTypeSatlayer> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawSatlayer, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeSatlayer>;
+}
+export {};

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

@@ -0,0 +1,31 @@
+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 dataRawSpectra;
+    call: string;
+    target: keyof callKeysSpectra;
+    metaData?: any;
+};
+type callKeysSpectra = mandatoryCallKeys & {
+    tokenPrice: string;
+    name: string;
+    minter: string;
+};
+type dataRawSpectra = callKeysSpectra & {
+    curvePool: string;
+};
+type dataTypeSpectra = dataType & {
+    tokenPrice: string;
+};
+export declare class SpectraProcessor extends GenericProcessor<callKeysSpectra, dataRawSpectra, dataTypeSpectra> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawSpectra, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, _pricer: Pricer): Promise<dataTypeSpectra>;
+}
+export {};

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

@@ -0,0 +1,31 @@
+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 dataRawSpectra;
+    call: string;
+    target: keyof callKeysSpectra;
+    metaData?: any;
+};
+type callKeysSpectra = mandatoryCallKeys & {
+    tokenPrice: string;
+    name: string;
+    principalToken: string;
+};
+type dataRawSpectra = callKeysSpectra & {
+    principalToken: string;
+};
+type dataTypeSpectra = dataType & {
+    tokenPrice: string;
+};
+export declare class SpectraYTProcessor extends GenericProcessor<callKeysSpectra, dataRawSpectra, dataTypeSpectra> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawSpectra, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, _pricer: Pricer): Promise<dataTypeSpectra>;
+}
+export {};

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

@@ -0,0 +1,16 @@
+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 callKeysSplice = mandatoryCallKeys & {
+    priceTargetToken: string;
+};
+type dataRawSplice = callKeysSplice & {};
+type dataTypeSplice = dataType & {
+    priceTargetToken: number;
+};
+export declare class SpliceProcessor extends GenericProcessor<callKeysSplice, dataRawSplice, dataTypeSplice> {
+    processingRound5(_index: number, _type: Erc20SubType, typeInfo: dataRawSplice, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, _pricer: Pricer): Promise<dataTypeSplice>;
+    computeRound3(index: number, type: Erc20SubType, typeInfo: dataRawSplice, calls: string[]): import("../tokenTypeStruct").tokenTypeStruct;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/StabilityProcessor.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 dataRawStability;
+    call: string;
+    target: keyof callKeysStability;
+    metaData?: keyof callKeysStability;
+};
+export type callKeysStability = mandatoryCallKeys & {
+    price: string;
+    name: string;
+};
+type dataRawStability = callKeysStability & {};
+type dataTypeStability = dataType & {
+    price: string;
+    name: string;
+};
+export declare class StabilityProcessor extends GenericProcessor<callKeysStability, dataRawStability, dataTypeStability> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawStability, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeStability>;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/SturdySiloProcessor.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 dataRawSturdySilo;
+    call: string;
+    target: keyof callKeysSturdySilo;
+    metaData?: keyof callKeysSturdySilo;
+};
+type callKeysSturdySilo = mandatoryCallKeys & {
+    underlying: string;
+    sharePrice: string;
+    collateralContract: string;
+    collateral: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+    symbolCollateral: string;
+};
+type dataRawSturdySilo = callKeysSturdySilo & {};
+type dataTypeSturdySilo = dataType & {
+    underlying: string;
+    sharePrice: number;
+    collateral: string;
+    collateralContract: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+    symbolCollateral: string;
+};
+export declare class SturdySiloProcessor extends GenericProcessor<callKeysSturdySilo, dataRawSturdySilo, dataTypeSturdySilo> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawSturdySilo, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeSturdySilo>;
+}
+export {};

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

@@ -0,0 +1,52 @@
+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 dataRawTempest;
+    call: string;
+    target: keyof callKeysTempest;
+    metaData?: keyof callKeysTempest;
+};
+type callKeysTempest = mandatoryCallKeys & {
+    addressToken0: string;
+    addressToken1: string;
+    addressesReturnData: string;
+};
+type dataRawTempest = callKeysTempest & {
+    addressToken0: string;
+    addressToken1: string;
+    addressesReturnData: {
+        [key: string]: string | number;
+    };
+    amount0Idle: string;
+    amount0Invested: string;
+    amount1Idle: string;
+    amount1Invested: string;
+    amountInQueue?: string;
+    decimalsToken0: string;
+    decimalsToken1: string;
+    positionsReturnData: {
+        [key: string]: string | number;
+    };
+    symbolToken0: string;
+    symbolToken1: string;
+};
+type dataTypeTempest = dataType & {
+    addressToken0: string;
+    addressToken1: string;
+    symbolToken0: string;
+    symbolToken1: string;
+};
+export declare class TempestVaultProcessor extends GenericProcessor<callKeysTempest, dataRawTempest, dataTypeTempest> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawTempest): void;
+    computeRound3(index: number, type: Erc20SubType, typeInfo: dataRawTempest, calls: string[]): import("../tokenTypeStruct").tokenTypeStruct;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawTempest, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeTempest>;
+}
+export {};

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

@@ -0,0 +1,32 @@
+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 dataRawTemplate;
+    call: string;
+    target: keyof callKeysTemplate;
+    metaData?: keyof callKeysTemplate;
+};
+type callKeysTemplate = mandatoryCallKeys & {};
+type dataRawTemplate = callKeysTemplate & {};
+type dataTypeTemplate = dataType & {};
+export declare class TemplateProcessor extends GenericProcessor<callKeysTemplate, dataRawTemplate, dataTypeTemplate> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound1(typeInfo: dataRawTemplate): void;
+    processingRound2(typeInfo: dataRawTemplate): void;
+    processingRound3(typeInfo: dataRawTemplate): void;
+    processingRound4(typeInfo: dataRawTemplate): void;
+    processingRound5(index: number, type: Erc20SubType, typeInfo: dataRawTemplate, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeTemplate>;
+    computeRound1(type: Erc20SubType, typeInfo: dataRawTemplate): import("../tokenTypeStruct").tokenTypeStruct;
+    computeRound2(index: number, type: Erc20SubType, typeInfo: dataRawTemplate, calls: string[]): import("../tokenTypeStruct").tokenTypeStruct;
+    computeRound3(index: number, type: Erc20SubType, typeInfo: dataRawTemplate, calls: string[]): import("../tokenTypeStruct").tokenTypeStruct;
+    computeRound4(index: number, type: Erc20SubType, typeInfo: dataRawTemplate, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): import("../tokenTypeStruct").tokenTypeStruct;
+    computeRound5(index: number, type: Erc20SubType, typeInfo: dataRawTemplate, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<import("../tokenTypeStruct").tokenTypeStruct>;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/TorosProcessor.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 dataRawToros;
+    call: string;
+    target: keyof callKeysToros;
+    metaData?: any;
+};
+type callKeysToros = mandatoryCallKeys & {
+    tokenPrice: string;
+    name: string;
+};
+type dataRawToros = callKeysToros & {};
+type dataTypeToros = dataType & {
+    tokenPrice: string;
+    priceTargetToken: number;
+    symbolUnderlyingToken: string;
+};
+export declare class TorosProcessor extends GenericProcessor<callKeysToros, dataRawToros, dataTypeToros> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawToros, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, _pricer: Pricer): Promise<dataTypeToros>;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/UniswapProcessor.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 dataRawUni;
+    call: string;
+    target: keyof callKeysUni;
+    metaData?: keyof callKeysUni;
+};
+type callKeysUni = mandatoryCallKeys & {
+    token0: string;
+    token1: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    decimalsToken0: string;
+    decimalsToken1: string;
+    balanceToken0: string;
+    balanceToken1: string;
+};
+type dataRawUni = callKeysUni & {};
+type dataTypeUni = dataType & {
+    token0: string;
+    token1: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    decimalsToken0: number;
+    decimalsToken1: number;
+    balanceToken0: number;
+    balanceToken1: number;
+    priceTargetToken: number;
+};
+export declare class UniswapProcessor extends GenericProcessor<callKeysUni, dataRawUni, dataTypeUni> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawUni): void;
+    computeRound3(index: number, type: Erc20SubType, typeInfo: dataRawUni, calls: string[]): import("../tokenTypeStruct").tokenTypeStruct;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawUni, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeUni>;
+}
+export {};

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

@@ -0,0 +1,28 @@
+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 dataRawVicuna;
+    call: string;
+    target: keyof callKeysVicuna;
+    metaData?: any;
+};
+type callKeysVicuna = mandatoryCallKeys & {
+    tokenPrice: string;
+    name: string;
+};
+type dataRawVicuna = callKeysVicuna & {};
+type dataTypeVicuna = dataType & {
+    tokenPrice: string;
+};
+export declare class VicunaProcessor extends GenericProcessor<callKeysVicuna, dataRawVicuna, dataTypeVicuna> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawVicuna, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, _pricer: Pricer): Promise<dataTypeVicuna>;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/WoofiProcessor.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 dataRawBeefy;
+    call: string;
+    target: keyof callKeysBeefy;
+    metaData?: keyof callKeysBeefy;
+};
+type callKeysBeefy = mandatoryCallKeys & {
+    decimalsToken: string;
+    underlying: string;
+    pricePerShare: string;
+    totalSupplyUnderlying: string;
+    symbolUnderlyingToken: string;
+};
+type dataRawBeefy = callKeysBeefy & {};
+type dataTypeBeefy = dataType & {
+    underlying: string;
+    pricePerShare: number;
+};
+export declare class WoofiProcessor extends GenericProcessor<callKeysBeefy, dataRawBeefy, dataTypeBeefy> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(index: number, type: Erc20SubType, typeInfo: dataRawBeefy, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBeefy>;
+}
+export {};

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

@@ -0,0 +1,53 @@
+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 dataRawzkSwapThreePool;
+    call: string;
+    target: keyof callKeysZkswapThreePool;
+    metaData?: keyof callKeysZkswapThreePool;
+};
+type callKeysZkswapThreePool = mandatoryCallKeys & {
+    balances: string;
+    coins: string;
+    minter: string;
+    pool: string;
+    token0Address: string;
+    token0Index: string;
+    token1Address: string;
+    token1Index: string;
+    token2Address: string;
+    token2Index: string;
+};
+type dataRawzkSwapThreePool = callKeysZkswapThreePool & {
+    balance0: string;
+    balance1: string;
+    balance2: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    symbolToken2: string;
+    decimalsToken0: string;
+    decimalsToken1: string;
+    decimalsToken2: string;
+};
+type dataTypeZkSwapThreePool = dataType & {
+    pool: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    symbolToken2: string;
+    token0Address: string;
+    token1Address: string;
+    token2Address: string;
+};
+export declare class ZkSwapThreePoolProcessor extends GenericProcessor<callKeysZkswapThreePool, dataRawzkSwapThreePool, dataTypeZkSwapThreePool> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawzkSwapThreePool): void;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawzkSwapThreePool, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeZkSwapThreePool>;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/curveNPoolProcessor.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 dataRawCurveN;
+    call: string;
+    target: keyof callKeysCurveN;
+    metaData?: keyof callKeysCurveN | string;
+    optional?: boolean;
+};
+type callKeysCurveN = mandatoryCallKeys & {
+    [key: `token${number}`]: string;
+    [key: `symbolToken${number}`]: string;
+    [key: `decimalsToken${number}`]: string;
+    [key: `balanceToken${number}`]: string;
+    [key: `${number}`]: string;
+    name: string;
+};
+type dataRawCurveN = callKeysCurveN & {
+    numberTokens: number;
+};
+type dataTypeCurveN = dataType & {
+    numberTokens: number;
+};
+export declare class CurveNPoolProcessor extends GenericProcessor<callKeysCurveN, dataRawCurveN, dataTypeCurveN> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawCurveN): void;
+    processingRound3(typeInfo: dataRawCurveN): void;
+    computeRound3(index: number, type: Erc20SubType, typeInfo: dataRawCurveN, calls: string[]): import("../tokenTypeStruct").tokenTypeStruct;
+    computeRound4(index: number, type: Erc20SubType, typeInfo: dataRawCurveN, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>): import("../tokenTypeStruct").tokenTypeStruct;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawCurveN, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeCurveN>;
+}
+export {};

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

@@ -0,0 +1,49 @@
+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 dataRawCurve;
+    call: string;
+    target: keyof callKeysCurve;
+    metaData?: keyof callKeysCurve;
+    optional?: boolean;
+};
+type callKeysCurve = mandatoryCallKeys & {
+    lp_price: string;
+    token0: string;
+    token1: string;
+    token2: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    symbolToken2: string;
+};
+type dataRawCurve = callKeysCurve & {
+    poolTokens: {
+        [key: string]: string;
+    };
+    numberTokens: number;
+};
+type dataTypeCurve = dataType & {
+    numberTokens: number;
+    lp_price: number;
+    token0: string;
+    token1: string;
+    token2: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    symbolToken2: string;
+    poolTokens: {
+        [key: string]: string;
+    };
+};
+export declare class CurveProcessor extends GenericProcessor<callKeysCurve, dataRawCurve, dataTypeCurve> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawCurve, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeCurve>;
+}
+export {};

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

@@ -0,0 +1,4 @@
+import { Erc20SubType } from "../../../../engine/implementations/Erc20/subTypes";
+import { GenericProcessor } from "../GenericProcessor";
+import type { callKeys, dataRaw, dataType } from "../GenericProcessor";
+export declare const processorMapping: Record<Erc20SubType, typeof GenericProcessor<callKeys, dataRaw, dataType>>;

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

@@ -0,0 +1,54 @@
+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 dataRawStakedCurve;
+    call: string;
+    target: keyof callKeysStakedCurve;
+    metaData?: keyof callKeysStakedCurve;
+    optional?: boolean;
+};
+type callKeysStakedCurve = mandatoryCallKeys & {
+    lp_price: string;
+    token0: string;
+    token1: string;
+    token2: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    symbolToken2: string;
+    underlying: string;
+    amount: string;
+};
+type dataRawStakedCurve = callKeysStakedCurve & {
+    poolTokens: {
+        [key: string]: string;
+    };
+    toAssets: string;
+    symbolUnderlyingToken: string;
+};
+type dataTypeStakedCurve = dataType & {
+    lp_price: number;
+    token0: string;
+    token1: string;
+    token2: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    underlying: string;
+    symbolToken2: string;
+    symbolUnderlyingToken: string;
+    poolTokens: {
+        [key: string]: string;
+    };
+};
+export declare class StakedCurveProcessor extends GenericProcessor<callKeysStakedCurve, dataRawStakedCurve, dataTypeStakedCurve> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound3(typeInfo: dataRawStakedCurve): void;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawStakedCurve, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeStakedCurve>;
+}
+export {};

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

@@ -0,0 +1,38 @@
+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 dataRawxU308;
+    call: string;
+    target: keyof callKeysxU308;
+    metaData?: keyof callKeysxU308;
+};
+type callKeysxU308 = mandatoryCallKeys & {
+    pool: string;
+    sqrtPriceX96: string;
+    _token0: string;
+    _token1: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    decimalsToken0: string;
+    decimalsToken1: string;
+    balanceToken0: string;
+    balanceToken1: string;
+    totalAssets: string;
+};
+type dataRawxU308 = callKeysxU308 & {};
+type dataTypexU308 = dataType & {
+    pool: string;
+};
+export declare class xU308Processor extends GenericProcessor<callKeysxU308, dataRawxU308, dataTypexU308> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawxU308): void;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawxU308, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, _pricer: Pricer): Promise<dataTypexU308>;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/subtypesPrices.d.ts

@@ -0,0 +1,5 @@
+import type { Campaign, CampaignParameters } from "@angleprotocol/sdk/ts";
+import { Erc20SubType } from "../../../engine/implementations/Erc20/subTypes";
+import type { Pricer } from "../../../utils/pricer";
+import type { tokenTypeStruct } from "./tokenTypeStruct";
+export declare function getTokenPricesInfo(index: number, type: Erc20SubType, typeInfo: any, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.ERC20LOGPROCESSOR> | CampaignParameters<Campaign.ERC20REBASELOGPROCESSOR> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<tokenTypeStruct>;