@merkl/api 0.10.81 → 0.10.82

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/AaveProcessor.d.ts

@@ -0,0 +1,30 @@
+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";
+type callType = {
+    key: keyof dataRawAave;
+    call: string;
+    target: keyof callKeysAave;
+    metaData?: any;
+};
+export type callKeysAave = callKeys & {
+    underlying: string;
+    symbolUnderlyingToken: string;
+};
+type dataRawAave = callKeysAave & {};
+type dataTypeAave = dataType & {
+    underlying: string;
+    symbolUnderlyingToken: string;
+    priceTargetToken: number;
+};
+export declare class AaveProcessor extends GenericProcessor<callKeysAave, dataRawAave, dataTypeAave> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    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

@@ -0,0 +1,35 @@
+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";
+type callType = {
+    key: keyof dataRawAsset;
+    call: string;
+    target: keyof callKeysAsset;
+    metaData?: any;
+    optional?: boolean;
+};
+type callKeysAsset = callKeys & {
+    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: tokenType, typeInfo: dataRawAsset, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeAsset>;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/AuraProcessor.d.ts

@@ -0,0 +1,61 @@
+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";
+type callType = {
+    key: keyof dataRawAura;
+    call: string;
+    target: keyof callKeysAura;
+    metaData?: any;
+};
+type callKeysAura = callKeys & {
+    balancerPool: string;
+    vault: string;
+    auraOperator: string;
+    poolId: string;
+    totalSupplyBalancerPool: string;
+    gaugeContract: string;
+    auraStaker: string;
+    totalSupplyGauge: string;
+    pid: string;
+    gaugeBalance: string;
+    auraBalance: string;
+};
+type dataRawAura = callKeysAura & {
+    poolTokensRaw: Array<string[] | BigNumber[]>;
+    poolTokens: Array<{
+        token: string;
+        balance: string;
+    }>;
+};
+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;
+    }>;
+};
+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: tokenType, typeInfo: dataRawAura, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeAura>;
+    computeRound4(index: number, type: tokenType, typeInfo: dataRawAura, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/BalancerGaugeProcessor.d.ts

@@ -0,0 +1,49 @@
+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";
+type callType = {
+    key: keyof dataRawBG;
+    call: string;
+    target: keyof callKeysBG;
+    metaData?: any;
+};
+type callKeysBG = callKeys & {
+    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: tokenType, typeInfo: dataRawBG, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBG>;
+    computeRound4(index: number, type: tokenType, typeInfo: dataRawBG, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/BalancerPoolProcessor.d.ts

@@ -0,0 +1,53 @@
+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";
+type callType = {
+    key: keyof dataRawBP;
+    call: string;
+    target: keyof callKeysBP;
+    metaData?: any;
+};
+type callKeysBP = callKeys & {
+    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;
+    }>;
+};
+type dataTypeBP = dataType & {
+    tokenAddress: string;
+    poolId: string;
+    vault: string;
+    poolTokens: Array<{
+        token: string;
+        balance: string;
+    }>;
+    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: tokenType, typeInfo: dataRawBP, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeBP>;
+    processingRound4(typeInfo: dataRawBP): void;
+    computeRound4(index: number, type: tokenType, typeInfo: dataRawBP, calls: string[], campaign: CampaignParameters<Campaign.ERC20>): tokenTypeStruct;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/BeefyProcessor.d.ts

@@ -0,0 +1,48 @@
+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";
+type callType = {
+    key: keyof dataRawBeefy;
+    call: string;
+    target: keyof callKeysBeefy;
+    metaData?: any;
+};
+type callKeysBeefy = callKeys & {
+    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: 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

@@ -0,0 +1,44 @@
+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";
+type callType = {
+    key: keyof dataRawCompound;
+    call: string;
+    target: keyof callKeysCompound;
+    metaData?: any;
+};
+type callKeysCompound = callKeys & {
+    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: 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

@@ -0,0 +1,40 @@
+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";
+type callType = {
+    key: keyof dataRawEnzyme;
+    call: string;
+    target: keyof callKeysEnzyme;
+    metaData?: any;
+};
+type callKeysEnzyme = callKeys & {
+    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: tokenType, typeInfo: dataRawEnzyme, calls: string[], campaign: CampaignParameters<Campaign.ERC20> | CampaignParameters<Campaign.EULER>, pricer: Pricer): Promise<dataTypeEnzyme>;
+    processingRound2(typeInfo: callKeys): void;
+    computeRound3(index: number, type: tokenType, typeInfo: dataRawEnzyme, calls: string[]): tokenTypeStruct;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/EulerBorrowProcessor.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 callKeys, type dataType } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawEuler;
+    call: string;
+    target: keyof callKeysEuler;
+    metaData?: any;
+};
+type callKeysEuler = callKeys & {
+    vault: string;
+    underlying: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+    targetTotalAsset: string;
+};
+type dataRawEuler = callKeysEuler & {};
+type dataTypeEuler = dataType & {
+    vault: string;
+    underlying: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+    totalSupply: number;
+    targetTotalAsset: string;
+    totalAssets: string;
+};
+export declare class EulerBorrowProcessor extends GenericProcessor<callKeysEuler, dataRawEuler, dataTypeEuler> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    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

@@ -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 callKeys, type dataType } from "./GenericProcessor";
+type callType = {
+    key: keyof dataRawEuler;
+    call: string;
+    target: keyof callKeysEuler;
+    metaData?: any;
+};
+type callKeysEuler = callKeys & {
+    vault: string;
+    underlying: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+    targetTotalAsset: string;
+};
+type dataRawEuler = callKeysEuler & {};
+type dataTypeEuler = dataType & {
+    vault: string;
+    underlying: string;
+    symbolUnderlyingToken: string;
+    decimalsUnderlyingToken: string;
+    totalSupply: number;
+    targetTotalAsset: string;
+    totalAssets: string;
+};
+export declare class EulerLendProcessor extends GenericProcessor<callKeysEuler, dataRawEuler, dataTypeEuler> {
+    rounds: {
+        round1: callType[];
+        round2: callType[];
+        round3: callType[];
+        round4: callType[];
+    };
+    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/FluidProcessor.d.ts

@@ -0,0 +1,39 @@
+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";
+type callType = {
+    key: keyof dataRawFluid;
+    call: string;
+    target: keyof callKeysFluid;
+    metaData?: any;
+};
+type callKeysFluid = callKeys & {
+    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: 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

@@ -0,0 +1,33 @@
+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";
+type callType = {
+    key: keyof dataRawFrax;
+    call: string;
+    target: keyof callKeysFrax;
+    metaData?: any;
+};
+type callKeysFrax = callKeys & {
+    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: 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

@@ -0,0 +1,40 @@
+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";
+type callType = {
+    key: keyof dataRawGearbox;
+    call: string;
+    target: keyof callKeysGearbox;
+    metaData?: any;
+};
+type callKeysGearbox = callKeys & {
+    stakingToken: string;
+    balanceStakingToken: string;
+    underlyingToken: string;
+    totalSupplyStakingToken: string;
+    decimalsStakingToken: string;
+    totalAssets: string;
+    decimalsUnderlyingToken: string;
+    symbolUnderlyingToken: string;
+};
+type dataRawGearbox = callKeysGearbox & {};
+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[];
+    };
+    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/MetamorphoProcessor.d.ts

@@ -0,0 +1,31 @@
+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";
+type callType = {
+    key: keyof dataRawMetamorpho;
+    call: string;
+    target: keyof callKeysMetamorpho;
+    metaData?: any;
+};
+type callKeysMetamorpho = callKeys & {
+    underlying: string;
+    symbolUnderlyingToken: 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: 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

@@ -0,0 +1,27 @@
+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";
+type callType = {
+    key: keyof dataRawTemplate;
+    call: string;
+    target: keyof callKeysTemplate;
+    metaData?: any;
+};
+type callKeysTemplate = callKeys & {
+    readTokensRaw: string[];
+    SYToken: string;
+    symbolUnderlyingToken: string;
+};
+type dataRawTemplate = callKeysTemplate & {};
+type dataTypeTemplate = dataType & {};
+export declare class PendleProcessor extends GenericProcessor<callKeysTemplate, dataRawTemplate, dataTypeTemplate> {
+    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>;
+}
+export {};

package/dist/src/libs/campaigns/campaignTypes/ERC20SubTypes/processor/RadiantProcessor.d.ts

@@ -0,0 +1,32 @@
+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";
+type callType = {
+    key: keyof dataRawRadiant;
+    call: string;
+    target: keyof callKeysRadiant;
+    metaData?: any;
+};
+type callKeysRadiant = callKeys & {
+    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: 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/SpliceProcessor.d.ts

@@ -0,0 +1,16 @@
+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";
+type callKeysSplice = callKeys & {
+    priceTargetToken: string;
+};
+type dataRawSplice = callKeysSplice & {};
+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>;
+    computeRound3(index: number, type: tokenType, typeInfo: dataRawSplice, calls: string[]): tokenTypeStruct;
+}
+export {};