@enzymefinance/testutils 4.0.0-next.2 → 4.0.0-next.7

package/src/scaffolding/extensions/external-positions/actions.ts

@@ -1,16 +1,16 @@
-import { AddressLike, extractEvent } from '@enzymefinance/ethers';
-import { SignerWithAddress } from '@enzymefinance/hardhat';
+import type { AddressLike } from '@enzymefinance/ethers';
+import { extractEvent } from '@enzymefinance/ethers';
+import type { SignerWithAddress } from '@enzymefinance/hardhat';
+import type { ComptrollerLib, ExternalPositionManager } from '@enzymefinance/protocol';
 import {
   callOnExternalPositionArgs,
-  ComptrollerLib,
   encodeArgs,
-  ExternalPositionManager,
   ExternalPositionManagerActionId,
   externalPositionReactivateArgs,
   externalPositionRemoveArgs,
   IExternalPositionProxy,
 } from '@enzymefinance/protocol';
-import { BigNumberish, BytesLike } from 'ethers';
+import type { BigNumberish, BytesLike } from 'ethers';
 
 export async function callOnExternalPosition({
   signer,
@@ -28,9 +28,9 @@ export async function callOnExternalPosition({
   actionArgs: BytesLike;
 }) {
   const callArgs = callOnExternalPositionArgs({
-    externalPositionProxy,
-    actionId,
     actionArgs,
+    actionId,
+    externalPositionProxy,
   });
 
   return comptrollerProxy
@@ -44,26 +44,31 @@ export async function createExternalPosition({
   externalPositionManager,
   externalPositionTypeId,
   initializationData = '0x',
+  callOnExternalPositionData = '0x',
 }: {
   signer: SignerWithAddress;
   comptrollerProxy: ComptrollerLib;
   externalPositionManager: ExternalPositionManager;
   externalPositionTypeId: BigNumberish;
   initializationData?: BytesLike;
+  callOnExternalPositionData?: BytesLike;
 }) {
   const receipt = await comptrollerProxy
     .connect(signer)
     .callOnExtension(
       externalPositionManager,
       ExternalPositionManagerActionId.CreateExternalPosition,
-      encodeArgs(['uint256', 'bytes'], [externalPositionTypeId, initializationData]),
+      encodeArgs(
+        ['uint256', 'bytes', 'bytes'],
+        [externalPositionTypeId, initializationData, callOnExternalPositionData],
+      ),
     );
 
   const event = extractEvent(receipt, externalPositionManager.abi.getEvent('ExternalPositionDeployedForFund'));
 
   const externalPositionProxy = new IExternalPositionProxy(event[0].args.externalPosition, signer);
 
-  return { receipt, externalPositionProxy };
+  return { externalPositionProxy, receipt };
 }
 
 export async function reactivateExternalPosition({

package/src/scaffolding/extensions/external-positions/compound.ts

@@ -1,15 +1,14 @@
-import { AddressLike } from '@enzymefinance/ethers';
-import { SignerWithAddress } from '@enzymefinance/hardhat';
+import type { AddressLike } from '@enzymefinance/ethers';
+import type { SignerWithAddress } from '@enzymefinance/hardhat';
+import type { ComptrollerLib, ExternalPositionManager, VaultLib } from '@enzymefinance/protocol';
 import {
-  ComptrollerLib,
-  encodeArgs,
-  ExternalPositionManager,
-  VaultLib,
-  compoundExternalPositionActionArgs,
   CompoundDebtPositionActionId,
+  compoundExternalPositionActionArgs,
+  encodeArgs,
   ExternalPositionType,
 } from '@enzymefinance/protocol';
-import { BigNumberish } from 'ethers';
+import type { BigNumberish } from 'ethers';
+
 import { callOnExternalPosition, createExternalPosition } from './actions';
 
 export async function compoundDebtPositionAddCollateral({
@@ -30,18 +29,18 @@ export async function compoundDebtPositionAddCollateral({
   externalPositionProxy: AddressLike;
 }) {
   const actionArgs = compoundExternalPositionActionArgs({
-    assets,
     amounts,
+    assets,
     data: encodeArgs(['address[]'], [cTokens]),
   });
 
   return callOnExternalPosition({
-    signer: fundOwner,
+    actionArgs,
+    actionId: CompoundDebtPositionActionId.AddCollateralAssets,
     comptrollerProxy,
     externalPositionManager,
     externalPositionProxy,
-    actionId: CompoundDebtPositionActionId.AddCollateralAssets,
-    actionArgs,
+    signer: fundOwner,
   });
 }
 
@@ -64,18 +63,18 @@ export async function compoundDebtPositionBorrow({
   cTokens: AddressLike[];
 }) {
   const actionArgs = compoundExternalPositionActionArgs({
-    assets,
     amounts,
+    assets,
     data: encodeArgs(['address[]'], [cTokens]),
   });
 
   return callOnExternalPosition({
-    signer: fundOwner,
+    actionArgs,
+    actionId: CompoundDebtPositionActionId.BorrowAsset,
     comptrollerProxy,
     externalPositionManager,
     externalPositionProxy,
-    actionId: CompoundDebtPositionActionId.BorrowAsset,
-    actionArgs,
+    signer: fundOwner,
   });
 }
 
@@ -92,18 +91,18 @@ export async function compoundDebtPositionClaimComp({
   externalPositionProxy: AddressLike;
 }) {
   const actionArgs = compoundExternalPositionActionArgs({
-    assets: [],
     amounts: [],
+    assets: [],
     data: '0x',
   });
 
   return callOnExternalPosition({
-    signer: fundOwner,
+    actionArgs,
+    actionId: CompoundDebtPositionActionId.ClaimComp,
     comptrollerProxy,
     externalPositionManager,
     externalPositionProxy,
-    actionId: CompoundDebtPositionActionId.ClaimComp,
-    actionArgs,
+    signer: fundOwner,
   });
 }
 
@@ -125,18 +124,18 @@ export async function compoundDebtPositionRemoveCollateral({
   cTokens: AddressLike[];
 }) {
   const actionArgs = compoundExternalPositionActionArgs({
-    assets,
     amounts,
+    assets,
     data: encodeArgs(['address[]'], [cTokens]),
   });
 
   return callOnExternalPosition({
-    signer: fundOwner,
+    actionArgs,
+    actionId: CompoundDebtPositionActionId.RemoveCollateralAssets,
     comptrollerProxy,
     externalPositionManager,
     externalPositionProxy,
-    actionId: CompoundDebtPositionActionId.RemoveCollateralAssets,
-    actionArgs,
+    signer: fundOwner,
   });
 }
 
@@ -158,18 +157,18 @@ export async function compoundDebtPositionRepayBorrow({
   cTokens: AddressLike[];
 }) {
   const actionArgs = compoundExternalPositionActionArgs({
-    assets,
     amounts,
+    assets,
     data: encodeArgs(['address[]'], [cTokens]),
   });
 
   return callOnExternalPosition({
-    signer: fundOwner,
+    actionArgs,
+    actionId: CompoundDebtPositionActionId.RepayBorrowedAssets,
     comptrollerProxy,
     externalPositionManager,
     externalPositionProxy,
-    actionId: CompoundDebtPositionActionId.RepayBorrowedAssets,
-    actionArgs,
+    signer: fundOwner,
   });
 }
 
@@ -183,9 +182,9 @@ export async function createCompoundDebtPosition({
   externalPositionManager: ExternalPositionManager;
 }) {
   return createExternalPosition({
-    signer,
     comptrollerProxy,
     externalPositionManager,
     externalPositionTypeId: ExternalPositionType.CompoundDebtPosition,
+    signer,
   });
 }

package/src/scaffolding/extensions/external-positions/index.ts

@@ -1,3 +1,4 @@
 export * from './actions';
 export * from './compound';
 export * from './mocks';
+export * from './uniswap-v3-liquidity';

package/src/scaffolding/extensions/external-positions/mocks.ts

@@ -1,19 +1,16 @@
+import type { AddressLike } from '@enzymefinance/ethers';
+import type { SignerWithAddress } from '@enzymefinance/hardhat';
+import type { ComptrollerLib, ExternalPositionFactory, ExternalPositionManager } from '@enzymefinance/protocol';
 import {
-  ComptrollerLib,
-  encodeArgs,
-  ExternalPositionManagerActionId,
-  ExternalPositionFactory,
-  ExternalPositionManager,
   mockGenericExternalPositionActionArgs,
   MockGenericExternalPositionActionId,
   MockGenericExternalPositionLib,
   MockGenericExternalPositionParser,
   VaultLib,
-} from '@enzymefinance/protocol/src';
-import { SignerWithAddress } from '@enzymefinance/hardhat';
-import { AddressLike } from '@enzymefinance/ethers';
-import { BigNumberish } from 'ethers';
-import { callOnExternalPosition } from './actions';
+} from '@enzymefinance/protocol';
+import type { BigNumberish } from 'ethers';
+
+import { callOnExternalPosition, createExternalPosition } from './actions';
 
 export async function createMockExternalPosition({
   comptrollerProxy,
@@ -55,22 +52,21 @@ export async function createMockExternalPosition({
     [mockExternalPositionParser],
   );
 
-  const receipt = await comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(
-      externalPositionManager,
-      ExternalPositionManagerActionId.CreateExternalPosition,
-      encodeArgs(['uint256', 'bytes'], [typeId, '0x']),
-    );
+  const receipt = await createExternalPosition({
+    comptrollerProxy,
+    externalPositionManager,
+    externalPositionTypeId: typeId,
+    signer: fundOwner,
+  });
 
   const externalPositionProxy = (await vaultProxy.getActiveExternalPositions())[0];
 
   return {
-    typeId,
-    mockGenericExternalPositionLib,
-    mockExternalPositionParser,
     externalPositionProxy,
+    mockExternalPositionParser,
+    mockGenericExternalPositionLib,
     receipt,
+    typeId,
   };
 }
 
@@ -90,17 +86,17 @@ export async function mockExternalPositionAddDebtAssets({
   amounts: BigNumberish[];
 }) {
   const actionArgs = mockGenericExternalPositionActionArgs({
-    assets,
     amounts,
+    assets,
   });
 
   return callOnExternalPosition({
-    signer,
+    actionArgs,
+    actionId: MockGenericExternalPositionActionId.AddDebtAssets,
     comptrollerProxy,
     externalPositionManager,
     externalPositionProxy,
-    actionId: MockGenericExternalPositionActionId.AddDebtAssets,
-    actionArgs,
+    signer,
   });
 }
 
@@ -120,17 +116,17 @@ export async function mockExternalPositionAddManagedAssets({
   amounts: BigNumberish[];
 }) {
   const actionArgs = mockGenericExternalPositionActionArgs({
-    assets,
     amounts,
+    assets,
   });
 
   return callOnExternalPosition({
-    signer,
+    actionArgs,
+    actionId: MockGenericExternalPositionActionId.AddManagedAssets,
     comptrollerProxy,
     externalPositionManager,
     externalPositionProxy,
-    actionId: MockGenericExternalPositionActionId.AddManagedAssets,
-    actionArgs,
+    signer,
   });
 }
 
@@ -150,17 +146,17 @@ export async function mockExternalPositionRemoveDebtAssets({
   amounts: BigNumberish[];
 }) {
   const actionArgs = mockGenericExternalPositionActionArgs({
-    assets,
     amounts,
+    assets,
   });
 
   return callOnExternalPosition({
-    signer,
+    actionArgs,
+    actionId: MockGenericExternalPositionActionId.RemoveDebtAssets,
     comptrollerProxy,
     externalPositionManager,
     externalPositionProxy,
-    actionId: MockGenericExternalPositionActionId.RemoveDebtAssets,
-    actionArgs,
+    signer,
   });
 }
 
@@ -180,16 +176,16 @@ export async function mockExternalPositionRemoveManagedAssets({
   amounts: BigNumberish[];
 }) {
   const actionArgs = mockGenericExternalPositionActionArgs({
-    assets,
     amounts,
+    assets,
   });
 
   return callOnExternalPosition({
-    signer,
+    actionArgs,
+    actionId: MockGenericExternalPositionActionId.RemoveManagedAssets,
     comptrollerProxy,
     externalPositionManager,
     externalPositionProxy,
-    actionId: MockGenericExternalPositionActionId.RemoveManagedAssets,
-    actionArgs,
+    signer,
   });
 }

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

@@ -0,0 +1,284 @@
+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,4 +1,4 @@
-import { SignerWithAddress } from '@enzymefinance/hardhat';
+import type { SignerWithAddress } from '@enzymefinance/hardhat';
 import { FeeHook, feeManagerConfigArgs, FeeSettlementType, IFee } from '@enzymefinance/protocol';
 import { constants, utils } from 'ethers';
 

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

@@ -1,17 +1,15 @@
-import { SignerWithAddress } from '@enzymefinance/hardhat';
+import type { SignerWithAddress } from '@enzymefinance/hardhat';
+import type { AaveAdapter, ComptrollerLib, IntegrationManager, StandardToken } from '@enzymefinance/protocol';
 import {
-  AaveAdapter,
   aaveLendArgs,
   aaveRedeemArgs,
   callOnIntegrationArgs,
-  ComptrollerLib,
-  IntegrationManager,
   IntegrationManagerActionId,
   lendSelector,
   redeemSelector,
-  StandardToken,
 } from '@enzymefinance/protocol';
-import { BigNumberish, utils } from 'ethers';
+import type { BigNumberish } from 'ethers';
+import { utils } from 'ethers';
 
 export async function aaveLend({
   comptrollerProxy,
@@ -35,8 +33,8 @@ export async function aaveLend({
 
   const callArgs = callOnIntegrationArgs({
     adapter: aaveAdapter,
-    selector: lendSelector,
     encodedCallArgs: lendArgs,
+    selector: lendSelector,
   });
 
   const lendTx = comptrollerProxy
@@ -68,8 +66,8 @@ export async function aaveRedeem({
 
   const callArgs = callOnIntegrationArgs({
     adapter: aaveAdapter,
-    selector: redeemSelector,
     encodedCallArgs: redeemArgs,
+    selector: redeemSelector,
   });
 
   const redeemTx = comptrollerProxy