@enzymefinance/testutils 3.0.0

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# @enzymefinance/testutils
+
+## 3.0.0
+### Major Changes
+
+- 65ce0f49: Publishing testutils alongside protocol package.
+
+### Patch Changes
+
+- Updated dependencies [65ce0f49]
+  - @enzymefinance/protocol@3.0.0

package/dist/declarations/src/assertions.d.ts

@@ -0,0 +1,4 @@
+import { ContractReceipt } from '@enzymefinance/ethers';
+import { utils } from 'ethers';
+export declare function assertEvent<TResult = any>(receipt: ContractReceipt<any>, event: string | utils.EventFragment, match?: TResult): NonNullable<TResult>;
+export declare function assertNoEvent(receipt: ContractReceipt<any>, event: string | utils.EventFragment): void;

package/dist/declarations/src/deployment.d.ts

@@ -0,0 +1,81 @@
+import { Contract } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import { Dispatcher, VaultLib, FundDeployer, PolicyManager, AavePriceFeed, AlphaHomoraV1PriceFeed, ChainlinkPriceFeed, CompoundPriceFeed, CurvePriceFeed, IdlePriceFeed, LidoStethPriceFeed, RevertingPriceFeed, StakehoundEthPriceFeed, SynthetixPriceFeed, WdgldPriceFeed, YearnVaultV2PriceFeed, AggregatedDerivativePriceFeed, ValueInterpreter, UniswapV2PoolPriceFeed, IntegrationManager, AaveAdapter, AlphaHomoraV1Adapter, CurveLiquidityAaveAdapter, CurveLiquidityEursAdapter, CurveLiquiditySethAdapter, CurveLiquidityStethAdapter, IdleAdapter, ParaSwapV4Adapter, SynthetixAdapter, YearnVaultV2Adapter, ZeroExV2Adapter, CompoundAdapter, UniswapV2Adapter, TrackedAssetsAdapter, UniswapV3Adapter, CurveExchangeAdapter, KyberAdapter, FeeManager, ComptrollerLib, EntranceRateBurnFee, EntranceRateDirectFee, ManagementFee, PerformanceFee, AuthUserExecutedSharesRequestorLib, AuthUserExecutedSharesRequestorFactory, FundActionsWrapper, AdapterBlacklist, AdapterWhitelist, AssetBlacklist, AssetWhitelist, BuySharesCallerWhitelist, MaxConcentration, MinMaxInvestment, InvestorWhitelist, GuaranteedRedemption } from '@enzymefinance/protocol';
+import { DeploymentConfig } from '../../../deploy/utils/config';
+export declare function getNamedSigner(name: string): Promise<SignerWithAddress>;
+export declare function getUnnamedSigners(): Promise<SignerWithAddress[]>;
+export declare function deployProtocolFixture(): Promise<{
+    readonly deployer: SignerWithAddress;
+    readonly deployment: {
+        readonly dispatcher: Dispatcher;
+        readonly vaultLib: VaultLib;
+        readonly fundDeployer: FundDeployer;
+        readonly policyManager: PolicyManager;
+        readonly aavePriceFeed: AavePriceFeed;
+        readonly alphaHomoraV1PriceFeed: AlphaHomoraV1PriceFeed;
+        readonly chainlinkPriceFeed: ChainlinkPriceFeed;
+        readonly compoundPriceFeed: CompoundPriceFeed;
+        readonly curvePriceFeed: CurvePriceFeed;
+        readonly idlePriceFeed: IdlePriceFeed;
+        readonly lidoStethPriceFeed: LidoStethPriceFeed;
+        readonly revertingPriceFeed: RevertingPriceFeed;
+        readonly synthetixPriceFeed: SynthetixPriceFeed;
+        readonly stakehoundEthPriceFeed: StakehoundEthPriceFeed;
+        readonly wdgldPriceFeed: WdgldPriceFeed;
+        readonly yearnVaultV2PriceFeed: YearnVaultV2PriceFeed;
+        readonly aggregatedDerivativePriceFeed: AggregatedDerivativePriceFeed;
+        readonly valueInterpreter: ValueInterpreter;
+        readonly uniswapV2PoolPriceFeed: UniswapV2PoolPriceFeed;
+        readonly integrationManager: IntegrationManager;
+        readonly curveLiquidityAaveAdapter: CurveLiquidityAaveAdapter;
+        readonly curveLiquidityEursAdapter: CurveLiquidityEursAdapter;
+        readonly curveLiquiditySethAdapter: CurveLiquiditySethAdapter;
+        readonly curveLiquidityStethAdapter: CurveLiquidityStethAdapter;
+        readonly aaveAdapter: AaveAdapter;
+        readonly alphaHomoraV1Adapter: AlphaHomoraV1Adapter;
+        readonly idleAdapter: IdleAdapter;
+        readonly paraSwapV4Adapter: ParaSwapV4Adapter;
+        readonly synthetixAdapter: SynthetixAdapter;
+        readonly yearnVaultV2Adapter: YearnVaultV2Adapter;
+        readonly zeroExV2Adapter: ZeroExV2Adapter;
+        readonly compoundAdapter: CompoundAdapter;
+        readonly uniswapV2Adapter: UniswapV2Adapter;
+        readonly trackedAssetsAdapter: TrackedAssetsAdapter;
+        readonly uniswapV3Adapter: UniswapV3Adapter;
+        readonly curveExchangeAdapter: CurveExchangeAdapter;
+        readonly kyberAdapter: KyberAdapter;
+        readonly feeManager: FeeManager;
+        readonly comptrollerLib: ComptrollerLib;
+        readonly entranceRateBurnFee: EntranceRateBurnFee;
+        readonly entranceRateDirectFee: EntranceRateDirectFee;
+        readonly managementFee: ManagementFee;
+        readonly performanceFee: PerformanceFee;
+        readonly authUserExecutedSharesRequestorLib: AuthUserExecutedSharesRequestorLib;
+        readonly authUserExecutedSharesRequestorFactory: AuthUserExecutedSharesRequestorFactory;
+        readonly fundActionsWrapper: FundActionsWrapper;
+        readonly adapterBlacklist: AdapterBlacklist;
+        readonly adapterWhitelist: AdapterWhitelist;
+        readonly assetBlacklist: AssetBlacklist;
+        readonly assetWhitelist: AssetWhitelist;
+        readonly buySharesCallerWhitelist: BuySharesCallerWhitelist;
+        readonly maxConcentration: MaxConcentration;
+        readonly minMaxInvestment: MinMaxInvestment;
+        readonly investorWhitelist: InvestorWhitelist;
+        readonly guaranteedRedemption: GuaranteedRedemption;
+    };
+    readonly accounts: SignerWithAddress[];
+    readonly config: DeploymentConfig;
+}>;
+declare type Resolve<T extends () => any> = ReturnType<T> extends Promise<infer U> ? U : ReturnType<T>;
+declare type ContractMap = Record<string, Contract>;
+export interface DeploymentFixtureWithoutConfig<T extends ContractMap> {
+    deployer: SignerWithAddress;
+    deployment: T;
+    accounts: SignerWithAddress[];
+}
+export interface DeploymentFixtureWithConfig<T extends ContractMap> extends DeploymentFixtureWithoutConfig<T> {
+    config: DeploymentConfig;
+}
+export declare type ProtocolDeployment = Resolve<typeof deployProtocolFixture>;
+export declare function defaultTestDeployment(_: any): Promise<any>;
+export {};

package/dist/declarations/src/helpers.d.ts

@@ -0,0 +1,2 @@
+import { ContractReceipt } from '@enzymefinance/ethers';
+export declare function transactionTimestamp(receipt: ContractReceipt<any>): Promise<number>;

package/dist/declarations/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from './deployment';
+export * from './scaffolding';
+export * from './assertions';
+export * from './helpers';
+export * from './whales';

package/dist/declarations/src/scaffolding/assets.d.ts

@@ -0,0 +1,12 @@
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import { ComptrollerLib, IntegrationManager, StandardToken, TrackedAssetsAdapter, VaultLib } from '@enzymefinance/protocol';
+import { BigNumberish } from 'ethers';
+export declare function addNewAssetsToFund({ fundOwner, comptrollerProxy, vaultProxy, integrationManager, trackedAssetsAdapter, assets, amounts, }: {
+    fundOwner: SignerWithAddress;
+    comptrollerProxy: ComptrollerLib;
+    vaultProxy: VaultLib;
+    integrationManager: IntegrationManager;
+    trackedAssetsAdapter: TrackedAssetsAdapter;
+    assets: StandardToken[];
+    amounts?: BigNumberish[];
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: import("@enzymefinance/ethers").AddressLike, _actionId: BigNumberish, _callArgs: import("ethers").BytesLike], void, ComptrollerLib>>>;

package/dist/declarations/src/scaffolding/chainlink.d.ts

@@ -0,0 +1,3 @@
+import { BigNumberish } from 'ethers';
+import { MockChainlinkPriceSource } from '@enzymefinance/protocol';
+export declare function updateChainlinkAggregator(aggregator: MockChainlinkPriceSource, price?: BigNumberish): Promise<void>;

package/dist/declarations/src/scaffolding/common.d.ts

@@ -0,0 +1,6 @@
+import { AddressLike } from '@enzymefinance/ethers';
+import { StandardToken } from '@enzymefinance/protocol';
+export declare function getAssetBalances({ account, assets }: {
+    account: AddressLike;
+    assets: StandardToken[];
+}): Promise<import("ethers").BigNumber[]>;

package/dist/declarations/src/scaffolding/core.d.ts

@@ -0,0 +1,19 @@
+import { AddressLike } from '@enzymefinance/ethers';
+import { ChainlinkPriceFeed, Dispatcher, FeeManager, FundDeployer, IntegrationManager, PolicyManager, SynthetixPriceFeed, ValueInterpreter, VaultLib } from '@enzymefinance/protocol';
+import { BytesLike, Signer } from 'ethers';
+export declare function createFundDeployer({ deployer, chainlinkPriceFeed, dispatcher, feeManager, integrationManager, policyManager, synthetixAddressResolverAddress, synthetixPriceFeed, valueInterpreter, vaultLib, vaultCallContracts, vaultCallSelectors, setOnDispatcher, setReleaseStatusLive, }: {
+    deployer: Signer;
+    chainlinkPriceFeed: ChainlinkPriceFeed;
+    dispatcher: Dispatcher;
+    feeManager: FeeManager;
+    integrationManager: IntegrationManager;
+    policyManager: PolicyManager;
+    synthetixAddressResolverAddress: AddressLike;
+    synthetixPriceFeed: SynthetixPriceFeed;
+    valueInterpreter: ValueInterpreter;
+    vaultLib: VaultLib;
+    vaultCallContracts?: AddressLike[];
+    vaultCallSelectors?: BytesLike[];
+    setOnDispatcher?: boolean;
+    setReleaseStatusLive?: boolean;
+}): Promise<FundDeployer>;

package/dist/declarations/src/scaffolding/extensions/common.d.ts

@@ -0,0 +1,11 @@
+import { AddressLike } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import { ComptrollerLib } from '@enzymefinance/protocol';
+import { BigNumberish, BytesLike } from 'ethers';
+export declare function callOnExtension({ comptrollerProxy, extension, actionId, callArgs, signer, }: {
+    comptrollerProxy: ComptrollerLib;
+    extension: AddressLike;
+    actionId: BigNumberish;
+    callArgs?: BytesLike;
+    signer?: SignerWithAddress;
+}): Promise<any>;

package/dist/declarations/src/scaffolding/extensions/fees.d.ts

@@ -0,0 +1,14 @@
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import { FeeManager, IFee } from '@enzymefinance/protocol';
+export declare function generateFeeManagerConfigWithMockFees({ deployer, feeManager, }: {
+    deployer: SignerWithAddress;
+    feeManager: FeeManager;
+}): Promise<string>;
+export declare function generateRegisteredMockFees({ deployer, feeManager, }: {
+    deployer: SignerWithAddress;
+    feeManager: FeeManager;
+}): Promise<{
+    mockContinuousFeeSettleOnly: import("@enzymefinance/ethers").MockContract<IFee>;
+    mockContinuousFeeWithGavAndUpdates: import("@enzymefinance/ethers").MockContract<IFee>;
+    mockPostBuySharesFee: import("@enzymefinance/ethers").MockContract<IFee>;
+}>;

package/dist/declarations/src/scaffolding/extensions/index.d.ts

@@ -0,0 +1,4 @@
+export * from './common';
+export * from './fees';
+export * from './integrations';
+export * from './policies';

package/dist/declarations/src/scaffolding/extensions/integrations/aave.d.ts

@@ -0,0 +1,19 @@
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import { AaveAdapter, ComptrollerLib, IntegrationManager, StandardToken } from '@enzymefinance/protocol';
+import { BigNumberish, utils } from 'ethers';
+export declare function aaveLend({ comptrollerProxy, integrationManager, fundOwner, aaveAdapter, aToken, amount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    aaveAdapter: AaveAdapter;
+    aToken: StandardToken;
+    amount?: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: import("@enzymefinance/ethers").AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function aaveRedeem({ comptrollerProxy, integrationManager, fundOwner, aaveAdapter, aToken, amount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    aaveAdapter: AaveAdapter;
+    aToken: StandardToken;
+    amount?: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: import("@enzymefinance/ethers").AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;

package/dist/declarations/src/scaffolding/extensions/integrations/alpha.d.ts

@@ -0,0 +1,36 @@
+import { Call, Contract } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import { AlphaHomoraV1Adapter, ComptrollerLib, IntegrationManager } from '@enzymefinance/protocol';
+import { BigNumber, BigNumberish, providers, utils } from 'ethers';
+export interface AlphaHomoraV1BankConfig extends Contract<AlphaHomoraV1BankConfig> {
+    getReservePoolBps: Call<() => BigNumber, Contract<any>>;
+}
+export declare const AlphaHomoraV1BankConfig: import("@enzymefinance/ethers").ContractFactory<AlphaHomoraV1BankConfig, never>;
+export interface AlphaHomoraV1Bank extends Contract<AlphaHomoraV1Bank> {
+    config: Call<() => string, Contract<any>>;
+    glbDebtVal: Call<() => BigNumber, Contract<any>>;
+    pendingInterest: Call<(msgValue: BigNumberish) => BigNumber, Contract<any>>;
+    reservePool: Call<() => BigNumber, Contract<any>>;
+    totalEth: Call<() => BigNumber, Contract<any>>;
+}
+export declare const AlphaHomoraV1Bank: import("@enzymefinance/ethers").ContractFactory<AlphaHomoraV1Bank, never>;
+export declare function alphaHomoraV1Lend({ comptrollerProxy, integrationManager, fundOwner, alphaHomoraV1Adapter, wethAmount, minibethAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    alphaHomoraV1Adapter: AlphaHomoraV1Adapter;
+    wethAmount?: BigNumberish;
+    minibethAmount?: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: import("@enzymefinance/ethers").AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function alphaHomoraV1Redeem({ comptrollerProxy, integrationManager, fundOwner, alphaHomoraV1Adapter, ibethAmount, minWethAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    alphaHomoraV1Adapter: AlphaHomoraV1Adapter;
+    ibethAmount?: BigNumberish;
+    minWethAmount?: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: import("@enzymefinance/ethers").AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function calcAlphaBankLiveTotalEth({ provider, alphaHomoraBank, }: {
+    provider: providers.Provider;
+    alphaHomoraBank: AlphaHomoraV1Bank;
+}): Promise<import("@ethersproject/bignumber").BigNumber>;

package/dist/declarations/src/scaffolding/extensions/integrations/compound.d.ts

@@ -0,0 +1,27 @@
+import { AddressLike, Contract, Send } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import { CompoundAdapter, ComptrollerLib, ICERC20, IntegrationManager, VaultLib } from '@enzymefinance/protocol';
+import { BigNumberish, utils } from 'ethers';
+export interface ICompoundComptroller extends Contract<ICompoundComptroller> {
+    claimComp: Send<(_account: AddressLike) => void>;
+}
+export declare const ICompoundComptroller: import("@enzymefinance/ethers").ContractFactory<ICompoundComptroller, never>;
+export declare function compoundLend({ comptrollerProxy, integrationManager, fundOwner, compoundAdapter, cToken, tokenAmount, cTokenAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    compoundAdapter: CompoundAdapter;
+    cToken: ICERC20;
+    tokenAmount?: BigNumberish;
+    cTokenAmount?: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function compoundRedeem({ comptrollerProxy, integrationManager, fundOwner, compoundAdapter, cToken, tokenAmount, cTokenAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    vaultProxy: VaultLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    compoundAdapter: CompoundAdapter;
+    cToken: ICERC20;
+    tokenAmount?: BigNumberish;
+    cTokenAmount?: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;

package/dist/declarations/src/scaffolding/extensions/integrations/curve.d.ts

@@ -0,0 +1,331 @@
+import { AddressLike, Call, Contract, Send } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import { ComptrollerLib, CurveAavePoolAssetIndex, CurveExchangeAdapter, CurveLiquidityAaveAdapter, CurveLiquidityEursAdapter, CurveLiquiditySethAdapter, CurveLiquidityStethAdapter, IntegrationManager, StandardToken } from '@enzymefinance/protocol';
+import { BigNumber, BigNumberish, utils } from 'ethers';
+export interface CurveLiquidityGaugeV2 extends Contract<CurveLiquidityGaugeV2> {
+    claim_rewards: Send<(_addr: AddressLike) => void>;
+    integrate_fraction: Call<(_for: AddressLike) => BigNumber, Contract<any>>;
+}
+export declare const CurveLiquidityGaugeV2: import("@enzymefinance/ethers").ContractFactory<CurveLiquidityGaugeV2, never>;
+export interface CurveSwaps extends Contract<CurveSwaps> {
+    get_best_rate: Call<(_from: AddressLike, to: AddressLike, amount: BigNumberish) => {
+        bestPool: AddressLike;
+        amountReceived: BigNumber;
+    }, CurveSwaps>;
+}
+export declare const CurveSwaps: import("@enzymefinance/ethers").ContractFactory<CurveSwaps, never>;
+export interface CurveMinter extends Contract<CurveMinter> {
+    mint_for: Send<(_gauge_address: AddressLike, _for: AddressLike) => void>;
+}
+export declare const CurveMinter: import("@enzymefinance/ethers").ContractFactory<CurveMinter, never>;
+export declare function curveApproveAssets({ comptrollerProxy, integrationManager, fundOwner, adapter, assets, amounts, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    adapter: AddressLike;
+    assets: AddressLike[];
+    amounts?: BigNumberish[];
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveTakeOrder({ comptrollerProxy, integrationManager, fundOwner, curveExchangeAdapter, pool, outgoingAsset, outgoingAssetAmount, incomingAsset, minIncomingAssetAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveExchangeAdapter: CurveExchangeAdapter;
+    pool: AddressLike;
+    outgoingAsset: StandardToken;
+    outgoingAssetAmount?: BigNumberish;
+    incomingAsset: StandardToken;
+    minIncomingAssetAmount?: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveAaveClaimRewards({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityAaveAdapter, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityAaveAdapter: CurveLiquidityAaveAdapter;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveAaveClaimRewardsAndReinvest({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityAaveAdapter, useFullBalances, minIncomingLiquidityGaugeTokenAmount, intermediaryUnderlyingAssetIndex, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityAaveAdapter: CurveLiquidityAaveAdapter;
+    useFullBalances: boolean;
+    minIncomingLiquidityGaugeTokenAmount?: BigNumberish;
+    intermediaryUnderlyingAssetIndex?: CurveAavePoolAssetIndex;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveAaveClaimRewardsAndSwap({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityAaveAdapter, useFullBalances, incomingAsset, minIncomingAssetAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityAaveAdapter: CurveLiquidityAaveAdapter;
+    useFullBalances: boolean;
+    incomingAsset: AddressLike;
+    minIncomingAssetAmount?: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveAaveLend({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityAaveAdapter, outgoingAaveDaiAmount, outgoingAaveUsdcAmount, outgoingAaveUsdtAmount, minIncomingLPTokenAmount, useUnderlyings, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityAaveAdapter: CurveLiquidityAaveAdapter;
+    outgoingAaveDaiAmount?: BigNumberish;
+    outgoingAaveUsdcAmount?: BigNumberish;
+    outgoingAaveUsdtAmount?: BigNumberish;
+    minIncomingLPTokenAmount?: BigNumberish;
+    useUnderlyings?: boolean;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveAaveLendAndStake({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityAaveAdapter, outgoingAaveDaiAmount, outgoingAaveUsdcAmount, outgoingAaveUsdtAmount, minIncomingLiquidityGaugeTokenAmount, useUnderlyings, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityAaveAdapter: CurveLiquidityAaveAdapter;
+    outgoingAaveDaiAmount?: BigNumberish;
+    outgoingAaveUsdcAmount?: BigNumberish;
+    outgoingAaveUsdtAmount?: BigNumberish;
+    minIncomingLiquidityGaugeTokenAmount?: BigNumberish;
+    useUnderlyings?: boolean;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveAaveRedeem({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityAaveAdapter, outgoingLPTokenAmount, minIncomingAaveDaiAmount, minIncomingAaveUsdcAmount, minIncomingAaveUsdtAmount, receiveSingleAsset, useUnderlyings, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityAaveAdapter: CurveLiquidityAaveAdapter;
+    outgoingLPTokenAmount: BigNumberish;
+    minIncomingAaveDaiAmount?: BigNumberish;
+    minIncomingAaveUsdcAmount?: BigNumberish;
+    minIncomingAaveUsdtAmount?: BigNumberish;
+    receiveSingleAsset?: boolean;
+    useUnderlyings?: boolean;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveAaveStake({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityAaveAdapter, outgoingLPTokenAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityAaveAdapter: CurveLiquidityAaveAdapter;
+    outgoingLPTokenAmount: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveAaveUnstakeAndRedeem({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityAaveAdapter, outgoingLiquidityGaugeTokenAmount, minIncomingAaveDaiAmount, minIncomingAaveUsdcAmount, minIncomingAaveUsdtAmount, receiveSingleAsset, useUnderlyings, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityAaveAdapter: CurveLiquidityAaveAdapter;
+    outgoingLiquidityGaugeTokenAmount: BigNumberish;
+    minIncomingAaveDaiAmount?: BigNumberish;
+    minIncomingAaveUsdcAmount?: BigNumberish;
+    minIncomingAaveUsdtAmount?: BigNumberish;
+    receiveSingleAsset?: boolean;
+    useUnderlyings?: boolean;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveAaveUnstake({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityAaveAdapter, outgoingLiquidityGaugeTokenAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityAaveAdapter: CurveLiquidityAaveAdapter;
+    outgoingLiquidityGaugeTokenAmount: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveEursClaimRewards({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityEursAdapter, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityEursAdapter: CurveLiquidityEursAdapter;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveEursLend({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityEursAdapter, outgoingEursAmount, outgoingSeurAmount, minIncomingLPTokenAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityEursAdapter: CurveLiquidityEursAdapter;
+    outgoingEursAmount: BigNumberish;
+    outgoingSeurAmount: BigNumberish;
+    minIncomingLPTokenAmount: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveEursLendAndStake({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityEursAdapter, outgoingEursAmount, outgoingSeurAmount, minIncomingLiquidityGaugeTokenAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityEursAdapter: CurveLiquidityEursAdapter;
+    outgoingEursAmount: BigNumberish;
+    outgoingSeurAmount: BigNumberish;
+    minIncomingLiquidityGaugeTokenAmount: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveEursRedeem({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityEursAdapter, outgoingLPTokenAmount, minIncomingEursAmount, minIncomingSeurAmount, receiveSingleAsset, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityEursAdapter: CurveLiquidityEursAdapter;
+    outgoingLPTokenAmount: BigNumberish;
+    minIncomingEursAmount: BigNumberish;
+    minIncomingSeurAmount: BigNumberish;
+    receiveSingleAsset: boolean;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveEursStake({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityEursAdapter, outgoingLPTokenAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityEursAdapter: CurveLiquidityEursAdapter;
+    outgoingLPTokenAmount: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveEursUnstakeAndRedeem({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityEursAdapter, outgoingLiquidityGaugeTokenAmount, minIncomingEursAmount, minIncomingSeurAmount, receiveSingleAsset, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityEursAdapter: CurveLiquidityEursAdapter;
+    outgoingLiquidityGaugeTokenAmount: BigNumberish;
+    minIncomingEursAmount: BigNumberish;
+    minIncomingSeurAmount: BigNumberish;
+    receiveSingleAsset: boolean;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveEursUnstake({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityEursAdapter, outgoingLiquidityGaugeTokenAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityEursAdapter: CurveLiquidityEursAdapter;
+    outgoingLiquidityGaugeTokenAmount: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveSethClaimRewards({ comptrollerProxy, integrationManager, fundOwner, curveLiquiditySethAdapter, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquiditySethAdapter: CurveLiquiditySethAdapter;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveSethClaimRewardsAndReinvest({ comptrollerProxy, integrationManager, fundOwner, curveLiquiditySethAdapter, useFullBalances, minIncomingLiquidityGaugeTokenAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquiditySethAdapter: CurveLiquiditySethAdapter;
+    useFullBalances: boolean;
+    minIncomingLiquidityGaugeTokenAmount?: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveSethClaimRewardsAndSwap({ comptrollerProxy, integrationManager, fundOwner, curveLiquiditySethAdapter, useFullBalances, incomingAsset, minIncomingAssetAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquiditySethAdapter: CurveLiquiditySethAdapter;
+    useFullBalances: boolean;
+    incomingAsset: AddressLike;
+    minIncomingAssetAmount?: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveSethLend({ comptrollerProxy, integrationManager, fundOwner, curveLiquiditySethAdapter, outgoingWethAmount, outgoingSethAmount, minIncomingLPTokenAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquiditySethAdapter: CurveLiquiditySethAdapter;
+    outgoingWethAmount: BigNumberish;
+    outgoingSethAmount: BigNumberish;
+    minIncomingLPTokenAmount: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveSethLendAndStake({ comptrollerProxy, integrationManager, fundOwner, curveLiquiditySethAdapter, outgoingWethAmount, outgoingSethAmount, minIncomingLiquidityGaugeTokenAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquiditySethAdapter: CurveLiquiditySethAdapter;
+    outgoingWethAmount: BigNumberish;
+    outgoingSethAmount: BigNumberish;
+    minIncomingLiquidityGaugeTokenAmount: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveSethRedeem({ comptrollerProxy, integrationManager, fundOwner, curveLiquiditySethAdapter, outgoingLPTokenAmount, minIncomingWethAmount, minIncomingSethAmount, receiveSingleAsset, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquiditySethAdapter: CurveLiquiditySethAdapter;
+    outgoingLPTokenAmount: BigNumberish;
+    minIncomingWethAmount: BigNumberish;
+    minIncomingSethAmount: BigNumberish;
+    receiveSingleAsset: boolean;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveSethStake({ comptrollerProxy, integrationManager, fundOwner, curveLiquiditySethAdapter, outgoingLPTokenAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquiditySethAdapter: CurveLiquiditySethAdapter;
+    outgoingLPTokenAmount: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveSethUnstakeAndRedeem({ comptrollerProxy, integrationManager, fundOwner, curveLiquiditySethAdapter, outgoingLiquidityGaugeTokenAmount, minIncomingWethAmount, minIncomingSethAmount, receiveSingleAsset, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquiditySethAdapter: CurveLiquiditySethAdapter;
+    outgoingLiquidityGaugeTokenAmount: BigNumberish;
+    minIncomingWethAmount: BigNumberish;
+    minIncomingSethAmount: BigNumberish;
+    receiveSingleAsset: boolean;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveSethUnstake({ comptrollerProxy, integrationManager, fundOwner, curveLiquiditySethAdapter, outgoingLiquidityGaugeTokenAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquiditySethAdapter: CurveLiquiditySethAdapter;
+    outgoingLiquidityGaugeTokenAmount: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveStethClaimRewards({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityStethAdapter, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityStethAdapter: CurveLiquidityStethAdapter;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveStethClaimRewardsAndReinvest({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityStethAdapter, useFullBalances, minIncomingLiquidityGaugeTokenAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityStethAdapter: CurveLiquidityStethAdapter;
+    useFullBalances: boolean;
+    minIncomingLiquidityGaugeTokenAmount?: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveStethClaimRewardsAndSwap({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityStethAdapter, useFullBalances, incomingAsset, minIncomingAssetAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityStethAdapter: CurveLiquidityStethAdapter;
+    useFullBalances: boolean;
+    incomingAsset: AddressLike;
+    minIncomingAssetAmount?: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveStethLend({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityStethAdapter, outgoingWethAmount, outgoingStethAmount, minIncomingLPTokenAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityStethAdapter: CurveLiquidityStethAdapter;
+    outgoingWethAmount: BigNumberish;
+    outgoingStethAmount: BigNumberish;
+    minIncomingLPTokenAmount: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveStethLendAndStake({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityStethAdapter, outgoingWethAmount, outgoingStethAmount, minIncomingLiquidityGaugeTokenAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityStethAdapter: CurveLiquidityStethAdapter;
+    outgoingWethAmount: BigNumberish;
+    outgoingStethAmount: BigNumberish;
+    minIncomingLiquidityGaugeTokenAmount: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveStethRedeem({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityStethAdapter, outgoingLPTokenAmount, minIncomingWethAmount, minIncomingStethAmount, receiveSingleAsset, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityStethAdapter: CurveLiquidityStethAdapter;
+    outgoingLPTokenAmount: BigNumberish;
+    minIncomingWethAmount: BigNumberish;
+    minIncomingStethAmount: BigNumberish;
+    receiveSingleAsset: boolean;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveStethStake({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityStethAdapter, outgoingLPTokenAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityStethAdapter: CurveLiquidityStethAdapter;
+    outgoingLPTokenAmount: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveStethUnstakeAndRedeem({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityStethAdapter, outgoingLiquidityGaugeTokenAmount, minIncomingWethAmount, minIncomingStethAmount, receiveSingleAsset, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityStethAdapter: CurveLiquidityStethAdapter;
+    outgoingLiquidityGaugeTokenAmount: BigNumberish;
+    minIncomingWethAmount: BigNumberish;
+    minIncomingStethAmount: BigNumberish;
+    receiveSingleAsset: boolean;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;
+export declare function curveStethUnstake({ comptrollerProxy, integrationManager, fundOwner, curveLiquidityStethAdapter, outgoingLiquidityGaugeTokenAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    curveLiquidityStethAdapter: CurveLiquidityStethAdapter;
+    outgoingLiquidityGaugeTokenAmount: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;