@enzymefinance/testutils 4.0.0-next.6 → 4.0.1

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

@@ -1,290 +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,
-  encodeArgs,
-  ExternalPositionManagerActionId,
-  ExternalPositionType,
-  UniswapV3LiquidityPositionActionId,
-  uniswapV3LiquidityPositionAddLiquidityArgs,
-  uniswapV3LiquidityPositionCollectArgs,
-  uniswapV3LiquidityPositionInitArgs,
-  UniswapV3LiquidityPositionLib,
-  uniswapV3LiquidityPositionMintArgs,
-  uniswapV3LiquidityPositionPurgeArgs,
-  uniswapV3LiquidityPositionRemoveLiquidityArgs,
-  VaultLib,
-} from '@enzymefinance/protocol';
-import type { BigNumber, BigNumberish } from 'ethers';
-
-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,
-  token0,
-  token1,
-}: {
-  signer: SignerWithAddress;
-  comptrollerProxy: ComptrollerLib;
-  externalPositionManager: ExternalPositionManager;
-  token0: AddressLike;
-  token1: AddressLike;
-}) {
-  const initArgs = uniswapV3LiquidityPositionInitArgs({
-    token0,
-    token1,
-  });
-
-  const receipt = await comptrollerProxy
-    .connect(signer)
-    .callOnExtension(
-      externalPositionManager,
-      ExternalPositionManagerActionId.CreateExternalPosition,
-      encodeArgs(['uint256', 'bytes'], [ExternalPositionType.UniswapV3LiquidityPosition, initArgs]),
-    );
-
-  const vaultProxy = new VaultLib(await comptrollerProxy.getVaultProxy(), signer);
-  const externalPositions = await vaultProxy.getActiveExternalPositions.call();
-  const externalPositionProxyAddress = externalPositions[externalPositions.length - 1];
-
-  return { externalPositionProxyAddress, 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,
-  fee,
-  tickLower,
-  tickUpper,
-  amount0Desired,
-  amount1Desired,
-  amount0Min = 0,
-  amount1Min = 0,
-}: {
-  signer: SignerWithAddress;
-  comptrollerProxy: ComptrollerLib;
-  externalPositionManager: ExternalPositionManager;
-  externalPositionProxy: 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,
-  });
-
-  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,94 +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, ComptrollerLib, IntegrationManager, VaultLib } from '@enzymefinance/protocol';
-import {
-  callOnIntegrationArgs,
-  compoundArgs,
-  IntegrationManagerActionId,
-  lendSelector,
-  redeemSelector,
-} from '@enzymefinance/protocol';
-import type { BigNumberish } from 'ethers';
-import { utils } from 'ethers';
-
-export interface ICompoundComptroller extends Contract<ICompoundComptroller> {
-  claimComp: Send<(_account: AddressLike) => void>;
-}
-
-export const ICompoundComptroller = contract<ICompoundComptroller>()`
-  function claimComp(address)
-`;
-
-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;
-}