@merkl/api 1.0.78 → 1.0.80

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

@@ -0,0 +1,35 @@
+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 dataRawAsset;
+    call: string;
+    target: keyof callKeysAsset;
+    metaData?: keyof callKeysAsset;
+    optional?: boolean;
+};
+type callKeysAsset = mandatoryCallKeys & {
+    underlying: string;
+    exchangeRate: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+};
+type dataRawAsset = callKeysAsset & {};
+type dataTypeAsset = dataType & {
+    underlying: string;
+    exchangeRate: number;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+};
+export declare class AssetProcessor extends GenericProcessor<callKeysAsset, dataRawAsset, dataTypeAsset> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawAsset): void;
+    processingRound5(index: number, type: Erc20SubType, typeInfo: dataRawAsset, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeAsset>;
+}
+export {};

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

@@ -0,0 +1,107 @@
+import { type Campaign, type CampaignParameters } from "@angleprotocol/sdk/ts";
+import type { 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 dataRawAura;
+    call: string;
+    target: keyof callKeysAura;
+    metaData?: keyof callKeysAura;
+};
+type callKeysAura = mandatoryCallKeys & {
+    balancerPool: string;
+    vault: string;
+    auraOperator: string;
+    poolId: string;
+    totalSupplyBalancerPool: string;
+    gaugeContract: string;
+    auraStaker: string;
+    totalSupplyGauge: string;
+    pid: string;
+    gaugeBalance: string;
+    auraBalance: string;
+    vaultBalance: string;
+};
+type dataRawAura = callKeysAura & {
+    poolTokensRaw: Array<string[] | BigNumber[]>;
+    poolTokens: Array<{
+        token: string;
+        balance: string;
+        amountInPool: number;
+        symbol: string;
+        decimals: number;
+        price: number;
+    }>;
+};
+type dataTypeAura = dataType & {
+    balancerPool: string;
+    vault: string;
+    auraOperator: string;
+    poolId: string;
+    totalSupplyBalancerPool: number;
+    gaugeContract: string;
+    auraStaker: string;
+    totalSupplyGauge: number;
+    pid: string;
+    gaugeBalance: number;
+    auraBalance: number;
+    poolTokensRaw: Array<string[] | BigNumber[]>;
+    poolTokens: Array<{
+        token: string;
+        balance: string;
+        amountInPool: number;
+        symbol: string;
+        decimals: number;
+        price: number;
+    }>;
+};
+export declare class AuraProcessor extends GenericProcessor<callKeysAura, dataRawAura, dataTypeAura> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound4(typeInfo: dataRawAura): void;
+    processingRound5(index: number, type: Erc20SubType, typeInfo: dataRawAura, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeAura>;
+    computeRound4(index: number, type: Erc20SubType, typeInfo: dataRawAura, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): {
+        type: Erc20SubType;
+        calls: import("@angleprotocol/sdk/ts").CallDto[];
+        typeInfo: {
+            type: Erc20SubType;
+            protocol: string;
+            tokenAddress: string;
+            blacklistedSupply: string;
+            totalSupply: string;
+            whitelistedSupply: string;
+            lockNFT: string;
+            eip712DomainName: string;
+            stakingName: string;
+            stakingSymbol: string;
+            isStaking: string;
+            balancerPool: string;
+            vault: string;
+            auraOperator: string;
+            poolId: string;
+            totalSupplyBalancerPool: string;
+            gaugeContract: string;
+            auraStaker: string;
+            totalSupplyGauge: string;
+            pid: string;
+            gaugeBalance: string;
+            auraBalance: string;
+            vaultBalance: string;
+            poolTokensRaw: Array<string[] | BigNumber[]>;
+            poolTokens: Array<{
+                token: string;
+                balance: string;
+                amountInPool: number;
+                symbol: string;
+                decimals: number;
+                price: number;
+            }>;
+        };
+    };
+}
+export {};

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

@@ -0,0 +1,85 @@
+import { type Campaign, type CampaignParameters } from "@angleprotocol/sdk/ts";
+import type { 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 dataRawBG;
+    call: string;
+    target: keyof callKeysBG;
+    metaData?: keyof callKeysBG;
+};
+type callKeysBG = mandatoryCallKeys & {
+    gyroscopeToken: string;
+    balanceUnderlyingPoolTokens: string;
+    totalSupplyUnderlyingPoolTokens: string;
+    poolId: string;
+    vault: string;
+    vaultBalance: string;
+    poolHolder: string;
+};
+type dataRawBG = callKeysBG & {
+    poolTokensRaw: Array<string[] | BigNumber[]>;
+    poolTokens: Array<{
+        token: string;
+        balance: string;
+    }>;
+    poolHolder: string;
+    poolHolderBalance: string;
+};
+type dataTypeBG = dataType & {
+    gyroscopeToken: string;
+    balanceUnderlyingPoolTokens: string;
+    totalSupplyUnderlyingPoolTokens: string;
+    poolId: string;
+    vault: string;
+    poolTokensRaw: Array<string[] | BigNumber[]>;
+    poolTokens: Array<{
+        token: string;
+        balance: string;
+    }>;
+    vaultBalance: string;
+    poolHolderBalance: string;
+};
+export declare class BEXRewardGaugeProcessor extends GenericProcessor<callKeysBG, dataRawBG, dataTypeBG> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawBG): void;
+    processingRound4(typeInfo: dataRawBG): void;
+    processingRound5(index: number, type: Erc20SubType, typeInfo: dataRawBG, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBG>;
+    computeRound4(index: number, type: Erc20SubType, typeInfo: dataRawBG, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): {
+        type: Erc20SubType;
+        calls: import("@angleprotocol/sdk/ts").CallDto[];
+        typeInfo: {
+            type: Erc20SubType;
+            protocol: string;
+            tokenAddress: string;
+            blacklistedSupply: string;
+            totalSupply: string;
+            whitelistedSupply: string;
+            lockNFT: string;
+            eip712DomainName: string;
+            stakingName: string;
+            stakingSymbol: string;
+            isStaking: string;
+            gyroscopeToken: string;
+            balanceUnderlyingPoolTokens: string;
+            totalSupplyUnderlyingPoolTokens: string;
+            poolId: string;
+            vault: string;
+            vaultBalance: string;
+            poolHolder: string;
+            poolTokensRaw: Array<string[] | BigNumber[]>;
+            poolTokens: Array<{
+                token: string;
+                balance: string;
+            }>;
+            poolHolderBalance: string;
+        };
+    };
+}
+export {};

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

@@ -0,0 +1,75 @@
+import { type Campaign, type CampaignParameters } from "@angleprotocol/sdk/ts";
+import type { 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 dataRawBG;
+    call: string;
+    target: keyof callKeysBG;
+    metaData?: keyof callKeysBG;
+};
+type callKeysBG = mandatoryCallKeys & {
+    gyroscopeToken: string;
+    balanceUnderlyingPoolTokens: string;
+    totalSupplyUnderlyingPoolTokens: string;
+    poolId: string;
+    vault: string;
+};
+type dataRawBG = callKeysBG & {
+    poolTokensRaw: Array<string[] | BigNumber[]>;
+    poolTokens: Array<{
+        token: string;
+        balance: string;
+    }>;
+};
+type dataTypeBG = dataType & {
+    gyroscopeToken: string;
+    balanceUnderlyingPoolTokens: string;
+    totalSupplyUnderlyingPoolTokens: string;
+    poolId: string;
+    vault: string;
+    poolTokensRaw: Array<string[] | BigNumber[]>;
+    poolTokens: Array<{
+        token: string;
+        balance: string;
+    }>;
+};
+export declare class BalancerGaugeProcessor extends GenericProcessor<callKeysBG, dataRawBG, dataTypeBG> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound4(typeInfo: dataRawBG): void;
+    processingRound5(index: number, type: Erc20SubType, typeInfo: dataRawBG, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBG>;
+    computeRound4(index: number, type: Erc20SubType, typeInfo: dataRawBG, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): {
+        type: Erc20SubType;
+        calls: import("@angleprotocol/sdk/ts").CallDto[];
+        typeInfo: {
+            type: Erc20SubType;
+            protocol: string;
+            tokenAddress: string;
+            blacklistedSupply: string;
+            totalSupply: string;
+            whitelistedSupply: string;
+            lockNFT: string;
+            eip712DomainName: string;
+            stakingName: string;
+            stakingSymbol: string;
+            isStaking: string;
+            gyroscopeToken: string;
+            balanceUnderlyingPoolTokens: string;
+            totalSupplyUnderlyingPoolTokens: string;
+            poolId: string;
+            vault: string;
+            poolTokensRaw: Array<string[] | BigNumber[]>;
+            poolTokens: Array<{
+                token: string;
+                balance: string;
+            }>;
+        };
+    };
+}
+export {};

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

@@ -0,0 +1,88 @@
+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 dataRawBP;
+    call: string;
+    target: keyof callKeysBP;
+    metaData?: keyof callKeysBP;
+};
+type callKeysBP = mandatoryCallKeys & {
+    tokenAddress: string;
+    poolId: string;
+    vault: string;
+    totalSupply: string;
+    vaultBalance: string;
+    blacklistedSupply: string;
+};
+type dataRawBP = callKeysBP & {
+    poolTokensRaw: Array<string[] | BigNumber[]>;
+    poolTokens: Array<{
+        token: string;
+        balance: string;
+        amountInPool: number;
+        symbol: string;
+        decimals: number;
+        price: number;
+    }>;
+};
+type dataTypeBP = dataType & {
+    tokenAddress: string;
+    poolId: string;
+    vault: string;
+    poolTokens: Array<{
+        token: string;
+        amountInPool: number;
+        symbol: string;
+        decimals: number;
+        price: number;
+    }>;
+    totalSupply: number;
+    blacklistedSupply: number;
+    tvl: number;
+    priceTargetToken: number;
+    cardName: string;
+    vaultBalance: number;
+};
+export declare class BalancerPoolProcessor extends GenericProcessor<callKeysBP, dataRawBP, dataTypeBP> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(index: number, type: Erc20SubType, typeInfo: dataRawBP, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBP>;
+    processingRound4(typeInfo: dataRawBP): void;
+    computeRound4(index: number, type: Erc20SubType, typeInfo: dataRawBP, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): {
+        type: Erc20SubType;
+        calls: import("@angleprotocol/sdk/ts").CallDto[];
+        typeInfo: {
+            type: Erc20SubType;
+            protocol: string;
+            tokenAddress: string;
+            blacklistedSupply: string;
+            totalSupply: string;
+            whitelistedSupply: string;
+            lockNFT: string;
+            eip712DomainName: string;
+            stakingName: string;
+            stakingSymbol: string;
+            isStaking: string;
+            poolId: string;
+            vault: string;
+            vaultBalance: string;
+            poolTokensRaw: Array<string[] | BigNumber[]>;
+            poolTokens: Array<{
+                token: string;
+                balance: string;
+                amountInPool: number;
+                symbol: string;
+                decimals: number;
+                price: number;
+            }>;
+        };
+    };
+}
+export {};

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

@@ -0,0 +1,44 @@
+import { type Campaign, type CampaignParameters } from "@angleprotocol/sdk/ts";
+import type { 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 dataRawBalancerV3;
+    call: string;
+    target: keyof callKeysBalancerV3;
+    metaData?: keyof callKeysBalancerV3 | string;
+    optional?: boolean;
+};
+type callKeysBalancerV3 = mandatoryCallKeys & {
+    [key: `token${number}`]: string;
+    [key: `symbolToken${number}`]: string;
+    [key: `decimalsToken${number}`]: string;
+    [key: `${number}`]: string;
+    name: string;
+};
+type dataRawBalancerV3 = callKeysBalancerV3 & {
+    numberTokens: number;
+    [key: `balanceToken${number}`]: BigNumber;
+    tokenInfo: {
+        tokens: string[];
+        tokenInfo: string[][];
+        balancesRaw: BigNumber[];
+        lastBalancesLiveScaled18: BigNumber[];
+    };
+};
+type dataTypeBalancerV3 = dataType & {
+    numberTokens: number;
+};
+export declare class BalancerV3PoolProcessor extends GenericProcessor<callKeysBalancerV3, dataRawBalancerV3, dataTypeBalancerV3> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawBalancerV3): void;
+    computeRound3(index: number, type: Erc20SubType, typeInfo: dataRawBalancerV3, calls: string[]): import("../tokenTypeStruct").tokenTypeStruct;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawBalancerV3, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBalancerV3>;
+}
+export {};

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

@@ -0,0 +1,48 @@
+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 & {
+    underlying: string;
+    pricePerShare: string;
+    token0: string;
+    token1: string;
+    totalSupplyUnderlying: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    decimalsToken0: string;
+    decimalsToken1: string;
+    balanceToken0: string;
+    balanceToken1: string;
+};
+type dataRawBeefy = callKeysBeefy & {};
+type dataTypeBeefy = dataType & {
+    underlying: string;
+    pricePerShare: number;
+    token0: string;
+    token1: string;
+    totalSupplyUnderlying: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    decimalsToken0: string;
+    decimalsToken1: string;
+    balanceToken0: string;
+    balanceToken1: string;
+    priceTargetToken: number;
+};
+export declare class BeefyProcessor 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/BunniV2Processor.d.ts

@@ -0,0 +1,45 @@
+import type { PoolStateStructOutput } from "@angleprotocol/sdk/generated/BunniV2Hub";
+import { type Campaign, type CampaignParameters, type UniswapV4PoolKey } 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 dataRawBunniV2;
+    call: string;
+    target: keyof callKeysBunniV2;
+    metaData?: keyof callKeysBunniV2;
+};
+type callKeysBunniV2 = mandatoryCallKeys & {
+    decimalsToken0: string;
+    decimalsToken1: string;
+    hub: string;
+    poolId: string;
+    poolKey: string;
+    poolState: string;
+    symbolToken0: string;
+    symbolToken1: string;
+    token0: string;
+    token1: string;
+    totalSupply: string;
+};
+type dataRawBunniV2 = callKeysBunniV2 & {
+    poolId: string;
+    poolKey: UniswapV4PoolKey;
+    poolState: PoolStateStructOutput;
+};
+type dataTypeBunniV2 = dataType & {
+    poolId: string;
+    balance0: string;
+    balance1: string;
+};
+export declare class BunniV2Processor extends GenericProcessor<callKeysBunniV2, dataRawBunniV2, dataTypeBunniV2> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound2(typeInfo: dataRawBunniV2): void;
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawBunniV2, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBunniV2>;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/CompoundProcessor.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 dataRawCompound;
+    call: string;
+    target: keyof callKeysCompound;
+    metaData?: keyof callKeysCompound;
+};
+type callKeysCompound = mandatoryCallKeys & {
+    tokenAddress: string;
+    totalBorrow: string;
+    balanceBaseToken: string;
+    symbolBaseToken: string;
+    decimalsBaseToken: string;
+    baseToken: string;
+    totalSupply: string;
+    blacklistedSupply: string;
+};
+type dataRawCompound = callKeysCompound & {};
+type dataTypeCompound = dataType & {
+    tokenAddress: string;
+    totalBorrow: number;
+    balanceBaseToken: number;
+    symbolBaseToken: string;
+    decimalsBaseToken: string;
+    baseToken: string;
+    totalSupply: number;
+    tvl: number;
+    priceTargetToken: number;
+    cardName: string;
+    blacklistedSupply: number;
+};
+export declare class CompoundProcessor extends GenericProcessor<callKeysCompound, dataRawCompound, dataTypeCompound> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawCompound, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeCompound>;
+}
+export {};

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

@@ -0,0 +1,34 @@
+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 dataRawERC4626;
+    call: string;
+    target: keyof callKeysERC4626;
+    metaData?: any;
+};
+type callKeysERC4626 = mandatoryCallKeys & {
+    asset: string;
+    decimalsAsset: string;
+    name: string;
+    symbolAsset: string;
+    totalAssets: string;
+};
+type dataRawERC4626 = callKeysERC4626 & {};
+type dataTypeERC4626 = dataType & {
+    asset: string;
+    decimalsAsset: string;
+    symbolAsset: string;
+    totalAssets: string;
+};
+export declare class ERC4626Processor extends GenericProcessor<callKeysERC4626, dataRawERC4626, dataTypeERC4626> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawERC4626, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeERC4626>;
+}
+export {};

package/dist/src/engine/deprecated/erc20SubTypeProcessors/implementations/EnzymeProcessor.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 dataRawEnzyme;
+    call: string;
+    target: keyof callKeysEnzyme;
+    metaData?: keyof callKeysEnzyme;
+};
+type callKeysEnzyme = mandatoryCallKeys & {
+    factory: string;
+    underlying: string;
+    exchangeRate: string;
+    symbolUnderlyingToken: string;
+    fundValueCalculator: string;
+    dispatcher: string;
+};
+type dataRawEnzyme = callKeysEnzyme & {
+    exchangeRateRaw: Array<string>;
+};
+type dataTypeEnzyme = dataType & {
+    factory: string;
+    underlying: string;
+    exchangeRate: number;
+    symbolUnderlyingToken: string;
+    fundValueCalculator: string;
+};
+export declare class EnzymeProcessor extends GenericProcessor<callKeysEnzyme, dataRawEnzyme, dataTypeEnzyme> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    processingRound5(_index: number, type: Erc20SubType, typeInfo: dataRawEnzyme, _calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeEnzyme>;
+    processingRound2(typeInfo: dataRawEnzyme): void;
+    computeRound3(index: number, type: Erc20SubType, typeInfo: dataRawEnzyme, calls: string[]): import("../tokenTypeStruct").tokenTypeStruct;
+}
+export {};

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