@enzymefinance/testutils 4.0.0 → 4.0.3

package/src/scaffolding/extensions/external-positions/uniswap-v3-liquidity.ts

@@ -1,284 +0,0 @@
-import type { AddressLike, Call, Contract } from '@enzymefinance/ethers';
-import { contract, extractEvent, resolveAddress } from '@enzymefinance/ethers';
-import type { SignerWithAddress } from '@enzymefinance/hardhat';
-import type { ComptrollerLib, ExternalPositionManager } from '@enzymefinance/protocol';
-import {
-  callOnExternalPositionArgs,
-  ExternalPositionManagerActionId,
-  ExternalPositionType,
-  UniswapV3LiquidityPositionActionId,
-  uniswapV3LiquidityPositionAddLiquidityArgs,
-  uniswapV3LiquidityPositionCollectArgs,
-  UniswapV3LiquidityPositionLib,
-  uniswapV3LiquidityPositionMintArgs,
-  uniswapV3LiquidityPositionPurgeArgs,
-  uniswapV3LiquidityPositionRemoveLiquidityArgs,
-} from '@enzymefinance/protocol';
-import type { BigNumber, BigNumberish, BytesLike } from 'ethers';
-
-import { createExternalPosition } from './actions';
-
-export enum UniswapV3FeeAmount {
-  LOW = 500,
-  MEDIUM = 3000,
-  HIGH = 10000,
-}
-
-export const uniswapV3LiquidityPositionGetMinTick = (tickSpacing: number) =>
-  Math.ceil(-887272 / tickSpacing) * tickSpacing;
-export const uniswapV3LiquidityPositionGetMaxTick = (tickSpacing: number) =>
-  Math.floor(887272 / tickSpacing) * tickSpacing;
-
-export interface IUniswapV3NonFungibleTokenManager extends Contract<IUniswapV3NonFungibleTokenManager> {
-  positions: Call<
-    (tokenId: BigNumberish) => {
-      nonce: BigNumber;
-      operator: string;
-      token0: string;
-      token1: string;
-      fee: BigNumber;
-      tickLower: BigNumber;
-      tickUpper: BigNumber;
-      liquidity: BigNumber;
-      feeGrowthInside0LastX128: BigNumber;
-      feeGrowthInside1LastX128: BigNumber;
-      tokensOwed0: BigNumber;
-      tokensOwed1: BigNumber;
-    },
-    Contract<any>
-  >;
-}
-
-export const IUniswapV3NonFungibleTokenManager = contract<IUniswapV3NonFungibleTokenManager>()`
-  function positions(uint256 tokenId) view returns (uint96 nonce, address operator, address token0, address token1, uint24 fee, int24 tickLower, int24 tickUpper, uint128 liquidity, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128, uint128 tokensOwed0, uint128 tokensOwed1)
-`;
-
-export async function createUniswapV3LiquidityPosition({
-  signer,
-  comptrollerProxy,
-  externalPositionManager,
-  callOnExternalPositionData = '0x',
-}: {
-  signer: SignerWithAddress;
-  comptrollerProxy: ComptrollerLib;
-  externalPositionManager: ExternalPositionManager;
-  callOnExternalPositionData?: BytesLike;
-}) {
-  const { externalPositionProxy: externalPositionProxyContract, receipt } = await createExternalPosition({
-    callOnExternalPositionData,
-    comptrollerProxy,
-    externalPositionManager,
-    externalPositionTypeId: ExternalPositionType.UniswapV3LiquidityPosition,
-    signer,
-  });
-
-  return { externalPositionProxyAddress: externalPositionProxyContract.address, receipt };
-}
-
-export async function uniswapV3LiquidityPositionAddLiquidity({
-  signer,
-  comptrollerProxy,
-  externalPositionManager,
-  externalPositionProxy,
-  nftId,
-  amount0Desired,
-  amount1Desired,
-  amount0Min = 0,
-  amount1Min = 0,
-}: {
-  signer: SignerWithAddress;
-  comptrollerProxy: ComptrollerLib;
-  externalPositionManager: ExternalPositionManager;
-  externalPositionProxy: AddressLike;
-  nftId: BigNumberish;
-  amount0Desired: BigNumberish;
-  amount1Desired: BigNumberish;
-  amount0Min?: BigNumberish;
-  amount1Min?: BigNumberish;
-}) {
-  const actionArgs = uniswapV3LiquidityPositionAddLiquidityArgs({
-    amount0Desired,
-    amount0Min,
-    amount1Desired,
-    amount1Min,
-    nftId,
-  });
-
-  const callArgs = callOnExternalPositionArgs({
-    actionArgs,
-    actionId: UniswapV3LiquidityPositionActionId.AddLiquidity,
-    externalPositionProxy,
-  });
-
-  return comptrollerProxy
-    .connect(signer)
-    .callOnExtension(externalPositionManager, ExternalPositionManagerActionId.CallOnExternalPosition, callArgs);
-}
-
-export async function uniswapV3LiquidityPositionCollect({
-  signer,
-  comptrollerProxy,
-  externalPositionManager,
-  externalPositionProxy,
-  nftId,
-}: {
-  signer: SignerWithAddress;
-  comptrollerProxy: ComptrollerLib;
-  externalPositionManager: ExternalPositionManager;
-  externalPositionProxy: AddressLike;
-  nftId: BigNumberish;
-}) {
-  const actionArgs = uniswapV3LiquidityPositionCollectArgs({
-    nftId,
-  });
-
-  const callArgs = callOnExternalPositionArgs({
-    actionArgs,
-    actionId: UniswapV3LiquidityPositionActionId.Collect,
-    externalPositionProxy,
-  });
-
-  return comptrollerProxy
-    .connect(signer)
-    .callOnExtension(externalPositionManager, ExternalPositionManagerActionId.CallOnExternalPosition, callArgs);
-}
-
-export async function uniswapV3LiquidityPositionMint({
-  signer,
-  comptrollerProxy,
-  externalPositionManager,
-  externalPositionProxy,
-  token0,
-  token1,
-  fee,
-  tickLower,
-  tickUpper,
-  amount0Desired,
-  amount1Desired,
-  amount0Min = 0,
-  amount1Min = 0,
-}: {
-  signer: SignerWithAddress;
-  comptrollerProxy: ComptrollerLib;
-  externalPositionManager: ExternalPositionManager;
-  externalPositionProxy: AddressLike;
-  token0: AddressLike;
-  token1: AddressLike;
-  fee: BigNumberish;
-  tickLower: BigNumberish;
-  tickUpper: BigNumberish;
-  amount0Desired: BigNumberish;
-  amount1Desired: BigNumberish;
-  amount0Min?: BigNumberish;
-  amount1Min?: BigNumberish;
-}) {
-  const actionArgs = uniswapV3LiquidityPositionMintArgs({
-    amount0Desired,
-    amount0Min,
-    amount1Desired,
-    amount1Min,
-    fee,
-    tickLower,
-    tickUpper,
-    token0,
-    token1,
-  });
-
-  const callArgs = callOnExternalPositionArgs({
-    actionArgs,
-    actionId: UniswapV3LiquidityPositionActionId.Mint,
-    externalPositionProxy,
-  });
-
-  const receipt = await comptrollerProxy
-    .connect(signer)
-    .callOnExtension(externalPositionManager, ExternalPositionManagerActionId.CallOnExternalPosition, callArgs);
-
-  const externalPosition = new UniswapV3LiquidityPositionLib(externalPositionProxy, provider);
-  const nftId = extractEvent(receipt, externalPosition.abi.getEvent('NFTPositionAdded'))[0].args.tokenId;
-
-  return { nftId, receipt };
-}
-
-export async function uniswapV3LiquidityPositionPurge({
-  signer,
-  comptrollerProxy,
-  externalPositionManager,
-  externalPositionProxy,
-  nftId,
-  liquidity,
-  amount0Min = 0,
-  amount1Min = 0,
-}: {
-  signer: SignerWithAddress;
-  comptrollerProxy: ComptrollerLib;
-  externalPositionManager: ExternalPositionManager;
-  externalPositionProxy: AddressLike;
-  nftId: BigNumberish;
-  liquidity: BigNumberish;
-  amount0Min?: BigNumberish;
-  amount1Min?: BigNumberish;
-}) {
-  const actionArgs = uniswapV3LiquidityPositionPurgeArgs({
-    amount0Min,
-    amount1Min,
-    liquidity,
-    nftId,
-  });
-
-  const callArgs = callOnExternalPositionArgs({
-    actionArgs,
-    actionId: UniswapV3LiquidityPositionActionId.Purge,
-    externalPositionProxy,
-  });
-
-  return comptrollerProxy
-    .connect(signer)
-    .callOnExtension(externalPositionManager, ExternalPositionManagerActionId.CallOnExternalPosition, callArgs);
-}
-
-export async function uniswapV3LiquidityPositionRemoveLiquidity({
-  signer,
-  comptrollerProxy,
-  externalPositionManager,
-  externalPositionProxy,
-  nftId,
-  liquidity,
-  amount0Min = 0,
-  amount1Min = 0,
-}: {
-  signer: SignerWithAddress;
-  comptrollerProxy: ComptrollerLib;
-  externalPositionManager: ExternalPositionManager;
-  externalPositionProxy: AddressLike;
-  nftId: BigNumberish;
-  liquidity: BigNumberish;
-  amount0Min?: BigNumberish;
-  amount1Min?: BigNumberish;
-}) {
-  const actionArgs = uniswapV3LiquidityPositionRemoveLiquidityArgs({
-    amount0Min,
-    amount1Min,
-    liquidity,
-    nftId,
-  });
-
-  const callArgs = callOnExternalPositionArgs({
-    actionArgs,
-    actionId: UniswapV3LiquidityPositionActionId.RemoveLiquidity,
-    externalPositionProxy,
-  });
-
-  return comptrollerProxy
-    .connect(signer)
-    .callOnExtension(externalPositionManager, ExternalPositionManagerActionId.CallOnExternalPosition, callArgs);
-}
-
-export function uniswapV3OrderTokenPair({ tokenA, tokenB }: { tokenA: AddressLike; tokenB: AddressLike }) {
-  const tokenAAddress = resolveAddress(tokenA);
-  const tokenBAddress = resolveAddress(tokenB);
-
-  return tokenAAddress < tokenBAddress
-    ? { token0: tokenAAddress, token1: tokenBAddress }
-    : { token0: tokenBAddress, token1: tokenAAddress };
-}

package/src/scaffolding/extensions/fees.ts

@@ -1,70 +0,0 @@
-import type { SignerWithAddress } from '@enzymefinance/hardhat';
-import { FeeHook, feeManagerConfigArgs, FeeSettlementType, IFee } from '@enzymefinance/protocol';
-import { constants, utils } from 'ethers';
-
-export async function generateFeeManagerConfigWithMockFees({ deployer }: { deployer: SignerWithAddress }) {
-  const fees = await generateMockFees({
-    deployer,
-  });
-
-  const feeManagerSettingsData = [utils.randomBytes(10), '0x', utils.randomBytes(2)];
-
-  return feeManagerConfigArgs({
-    fees: Object.values(fees),
-    settings: feeManagerSettingsData,
-  });
-}
-
-export async function generateMockFees({ deployer }: { deployer: SignerWithAddress }) {
-  // Create mock fees
-  const mockContinuousFeeSettleOnly = await IFee.mock(deployer);
-  const mockContinuousFeeWithGavAndUpdates = await IFee.mock(deployer);
-  const mockPostBuySharesFee = await IFee.mock(deployer);
-
-  // Initialize mock fee return values
-  await Promise.all([
-    // Continuous fee the mimics ManagementFee
-    mockContinuousFeeSettleOnly.getRecipientForFund.returns(constants.AddressZero),
-    mockContinuousFeeSettleOnly.settle.returns(FeeSettlementType.None, constants.AddressZero, 0),
-    mockContinuousFeeSettleOnly.payout.returns(false),
-    mockContinuousFeeSettleOnly.addFundSettings.returns(undefined),
-    mockContinuousFeeSettleOnly.activateForFund.returns(undefined),
-    mockContinuousFeeSettleOnly.update.returns(undefined),
-    mockContinuousFeeSettleOnly.settlesOnHook.returns(false, false),
-    mockContinuousFeeSettleOnly.settlesOnHook.given(FeeHook.Continuous).returns(true, false),
-    mockContinuousFeeSettleOnly.settlesOnHook.given(FeeHook.PreBuyShares).returns(true, false),
-    mockContinuousFeeSettleOnly.settlesOnHook.given(FeeHook.PreRedeemShares).returns(true, false),
-    mockContinuousFeeSettleOnly.updatesOnHook.returns(false, false),
-    // Continuous fee the mimics PerformanceFee
-    mockContinuousFeeWithGavAndUpdates.getRecipientForFund.returns(constants.AddressZero),
-    mockContinuousFeeWithGavAndUpdates.settle.returns(FeeSettlementType.None, constants.AddressZero, 0),
-    mockContinuousFeeWithGavAndUpdates.payout.returns(false),
-    mockContinuousFeeWithGavAndUpdates.addFundSettings.returns(undefined),
-    mockContinuousFeeWithGavAndUpdates.activateForFund.returns(undefined),
-    mockContinuousFeeWithGavAndUpdates.update.returns(undefined),
-    mockContinuousFeeWithGavAndUpdates.settlesOnHook.returns(false, false),
-    mockContinuousFeeWithGavAndUpdates.settlesOnHook.given(FeeHook.Continuous).returns(true, true),
-    mockContinuousFeeWithGavAndUpdates.settlesOnHook.given(FeeHook.PreBuyShares).returns(true, true),
-    mockContinuousFeeWithGavAndUpdates.settlesOnHook.given(FeeHook.PreRedeemShares).returns(true, true),
-    mockContinuousFeeWithGavAndUpdates.updatesOnHook.returns(false, false),
-    mockContinuousFeeWithGavAndUpdates.updatesOnHook.given(FeeHook.Continuous).returns(true, true),
-    mockContinuousFeeWithGavAndUpdates.updatesOnHook.given(FeeHook.PostBuyShares).returns(true, true),
-    mockContinuousFeeWithGavAndUpdates.updatesOnHook.given(FeeHook.PreRedeemShares).returns(true, true),
-    // PostBuyShares fee
-    mockPostBuySharesFee.getRecipientForFund.returns(constants.AddressZero),
-    mockPostBuySharesFee.settle.returns(FeeSettlementType.None, constants.AddressZero, 0),
-    mockPostBuySharesFee.payout.returns(false),
-    mockPostBuySharesFee.addFundSettings.returns(undefined),
-    mockPostBuySharesFee.activateForFund.returns(undefined),
-    mockPostBuySharesFee.update.returns(undefined),
-    mockPostBuySharesFee.settlesOnHook.returns(false, false),
-    mockPostBuySharesFee.settlesOnHook.given(FeeHook.PostBuyShares).returns(true, false),
-    mockPostBuySharesFee.updatesOnHook.returns(false, false),
-  ]);
-
-  return {
-    mockContinuousFeeSettleOnly,
-    mockContinuousFeeWithGavAndUpdates,
-    mockPostBuySharesFee,
-  };
-}

package/src/scaffolding/extensions/index.ts

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

package/src/scaffolding/extensions/integrations/aave.ts

@@ -1,78 +0,0 @@
-import type { SignerWithAddress } from '@enzymefinance/hardhat';
-import type { AaveAdapter, ComptrollerLib, IntegrationManager, StandardToken } from '@enzymefinance/protocol';
-import {
-  aaveLendArgs,
-  aaveRedeemArgs,
-  callOnIntegrationArgs,
-  IntegrationManagerActionId,
-  lendSelector,
-  redeemSelector,
-} from '@enzymefinance/protocol';
-import type { BigNumberish } from 'ethers';
-import { utils } from 'ethers';
-
-export async function aaveLend({
-  comptrollerProxy,
-  integrationManager,
-  fundOwner,
-  aaveAdapter,
-  aToken,
-  amount = utils.parseEther('1'),
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  aaveAdapter: AaveAdapter;
-  aToken: StandardToken;
-  amount?: BigNumberish;
-}) {
-  const lendArgs = aaveLendArgs({
-    aToken,
-    amount,
-  });
-
-  const callArgs = callOnIntegrationArgs({
-    adapter: aaveAdapter,
-    encodedCallArgs: lendArgs,
-    selector: lendSelector,
-  });
-
-  const lendTx = comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-
-  return lendTx;
-}
-
-export async function aaveRedeem({
-  comptrollerProxy,
-  integrationManager,
-  fundOwner,
-  aaveAdapter,
-  aToken,
-  amount = utils.parseEther('1'),
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  aaveAdapter: AaveAdapter;
-  aToken: StandardToken;
-  amount?: BigNumberish;
-}) {
-  const redeemArgs = aaveRedeemArgs({
-    aToken,
-    amount,
-  });
-
-  const callArgs = callOnIntegrationArgs({
-    adapter: aaveAdapter,
-    encodedCallArgs: redeemArgs,
-    selector: redeemSelector,
-  });
-
-  const redeemTx = comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-
-  return redeemTx;
-}

package/src/scaffolding/extensions/integrations/compound.ts

@@ -1,255 +0,0 @@
-import type { AddressLike, Contract, Send } from '@enzymefinance/ethers';
-import { contract, resolveAddress } from '@enzymefinance/ethers';
-import type { SignerWithAddress } from '@enzymefinance/hardhat';
-import type {
-  CompoundAdapter,
-  CompoundPriceFeed,
-  ComptrollerLib,
-  ICERC20,
-  IntegrationManager,
-  VaultLib,
-} from '@enzymefinance/protocol';
-import {
-  callOnIntegrationArgs,
-  claimRewardsSelector,
-  compoundArgs,
-  compoundClaimRewardsArgs,
-  IntegrationManagerActionId,
-  lendSelector,
-  redeemSelector,
-  StandardToken,
-} from '@enzymefinance/protocol';
-import type { BigNumberish } from 'ethers';
-import { BigNumber, utils } from 'ethers';
-
-import { getAssetBalances } from '../../common';
-
-export interface ICompoundComptroller extends Contract<ICompoundComptroller> {
-  claimComp: Send<(_account: AddressLike) => void>;
-}
-
-export const ICompoundComptroller = contract<ICompoundComptroller>()`
-  function claimComp(address)
-`;
-
-export async function assertCompoundLend({
-  tokenWhale,
-  comptrollerProxy,
-  vaultProxy,
-  integrationManager,
-  fundOwner,
-  compoundAdapter,
-  tokenAmount = utils.parseEther('1'),
-  cToken,
-  compoundPriceFeed,
-}: {
-  tokenWhale: SignerWithAddress;
-  comptrollerProxy: ComptrollerLib;
-  vaultProxy: VaultLib;
-  integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  compoundAdapter: CompoundAdapter;
-  tokenAmount?: BigNumber;
-  cToken: ICERC20;
-  compoundPriceFeed: CompoundPriceFeed;
-}) {
-  const token = new StandardToken(await compoundPriceFeed.getTokenFromCToken.args(cToken).call(), tokenWhale);
-  await token.connect(tokenWhale).transfer(vaultProxy, tokenAmount);
-  const rateBefore = await cToken.exchangeRateStored.call();
-
-  // Exchange rate stored can have a small deviation from exchangeRateStored
-  const minIncomingCTokenAmount = tokenAmount
-    .mul(utils.parseEther('1'))
-    .div(rateBefore)
-    .mul(BigNumber.from('999'))
-    .div(BigNumber.from('1000'));
-
-  const [preTxIncomingAssetBalance, preTxOutgoingAssetBalance] = await getAssetBalances({
-    account: vaultProxy,
-    assets: [cToken as any, token],
-  });
-
-  const lendReceipt = await compoundLend({
-    cToken,
-    cTokenAmount: minIncomingCTokenAmount,
-    compoundAdapter,
-    comptrollerProxy,
-    fundOwner,
-    integrationManager,
-    tokenAmount,
-  });
-
-  // Get exchange rate after tx (the rate is updated right after)
-  const rate = await cToken.exchangeRateStored();
-  const [postTxIncomingAssetBalance, postTxOutgoingAssetBalance] = await getAssetBalances({
-    account: vaultProxy,
-    assets: [cToken as any, token],
-  });
-
-  const expectedCTokenAmount = tokenAmount.mul(utils.parseEther('1')).div(rate);
-  expect(postTxIncomingAssetBalance).toEqBigNumber(preTxIncomingAssetBalance.add(expectedCTokenAmount));
-  expect(postTxOutgoingAssetBalance).toEqBigNumber(preTxOutgoingAssetBalance.sub(tokenAmount));
-
-  return lendReceipt;
-}
-
-export async function assertCompoundRedeem({
-  comptrollerProxy,
-  vaultProxy,
-  integrationManager,
-  fundOwner,
-  compoundAdapter,
-  cToken,
-  compoundPriceFeed,
-}: {
-  comptrollerProxy: ComptrollerLib;
-  vaultProxy: VaultLib;
-  integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  compoundAdapter: CompoundAdapter;
-  cToken: ICERC20;
-  compoundPriceFeed: CompoundPriceFeed;
-}) {
-  const cTokenAmount = utils.parseUnits('1', await cToken.decimals());
-  await cToken.transfer(vaultProxy, cTokenAmount);
-
-  const token = new StandardToken(await compoundPriceFeed.getTokenFromCToken.args(cToken).call(), provider);
-  const [preTxIncomingAssetBalance, preTxOutgoingAssetBalance] = await getAssetBalances({
-    account: vaultProxy,
-    assets: [token, cToken as any],
-  });
-
-  const rateBefore = await cToken.exchangeRateStored();
-  const minIncomingTokenAmount = cTokenAmount.mul(rateBefore).div(utils.parseEther('1'));
-
-  const redeemReceipt = await compoundRedeem({
-    cToken,
-    cTokenAmount,
-    compoundAdapter,
-    comptrollerProxy,
-    fundOwner,
-    integrationManager,
-    tokenAmount: minIncomingTokenAmount,
-    vaultProxy,
-  });
-
-  const [postTxIncomingAssetBalance, postTxOutgoingAssetBalance] = await getAssetBalances({
-    account: vaultProxy,
-    assets: [token, cToken as any],
-  });
-
-  // Get exchange rate after tx (the rate is updated right after)
-  const rate = await cToken.exchangeRateStored();
-  const expectedTokenAmount = cTokenAmount.mul(rate).div(utils.parseEther('1'));
-
-  expect(postTxIncomingAssetBalance).toEqBigNumber(preTxIncomingAssetBalance.add(expectedTokenAmount));
-  expect(postTxOutgoingAssetBalance).toEqBigNumber(preTxOutgoingAssetBalance.sub(cTokenAmount));
-
-  return redeemReceipt;
-}
-
-export async function compoundClaim({
-  comptrollerProxy,
-  integrationManager,
-  fundOwner,
-  compoundAdapter,
-  compoundComptroller,
-  cTokens,
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  compoundAdapter: CompoundAdapter;
-  compoundComptroller: AddressLike;
-  cTokens: AddressLike[];
-}) {
-  const claimArgs = compoundClaimRewardsArgs({
-    cTokens,
-    compoundComptroller,
-  });
-
-  const callArgs = callOnIntegrationArgs({
-    adapter: compoundAdapter,
-    encodedCallArgs: claimArgs,
-    selector: claimRewardsSelector,
-  });
-
-  const claimRewardsTx = comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-
-  return claimRewardsTx;
-}
-
-export async function compoundLend({
-  comptrollerProxy,
-  integrationManager,
-  fundOwner,
-  compoundAdapter,
-  cToken,
-  tokenAmount = utils.parseEther('1'),
-  cTokenAmount = utils.parseEther('1'),
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  compoundAdapter: CompoundAdapter;
-  cToken: AddressLike;
-  tokenAmount?: BigNumberish;
-  cTokenAmount?: BigNumberish;
-}) {
-  const lendArgs = compoundArgs({
-    cToken,
-    minIncomingAssetAmount: cTokenAmount,
-    outgoingAssetAmount: tokenAmount,
-  });
-
-  const callArgs = callOnIntegrationArgs({
-    adapter: compoundAdapter,
-    encodedCallArgs: lendArgs,
-    selector: lendSelector,
-  });
-
-  const lendTx = comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-
-  return lendTx;
-}
-
-export async function compoundRedeem({
-  comptrollerProxy,
-  integrationManager,
-  fundOwner,
-  compoundAdapter,
-  cToken,
-  tokenAmount = utils.parseEther('1'),
-  cTokenAmount = utils.parseEther('1'),
-}: {
-  comptrollerProxy: ComptrollerLib;
-  vaultProxy: VaultLib;
-  integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  compoundAdapter: CompoundAdapter;
-  cToken: AddressLike;
-  tokenAmount?: BigNumberish;
-  cTokenAmount?: BigNumberish;
-}) {
-  const redeemArgs = compoundArgs({
-    cToken: resolveAddress(cToken),
-    minIncomingAssetAmount: tokenAmount,
-    outgoingAssetAmount: cTokenAmount,
-  });
-
-  const callArgs = callOnIntegrationArgs({
-    adapter: compoundAdapter,
-    encodedCallArgs: redeemArgs,
-    selector: redeemSelector,
-  });
-
-  const redeemTx = comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-
-  return redeemTx;
-}