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

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

@@ -1,19 +1,17 @@
-import { SignerWithAddress } from '@enzymefinance/hardhat';
+import type { SignerWithAddress } from '@enzymefinance/hardhat';
+import type { ComptrollerLib, IdleAdapter, IntegrationManager, StandardToken } from '@enzymefinance/protocol';
 import {
   callOnIntegrationArgs,
   claimRewardsSelector,
-  ComptrollerLib,
-  IdleAdapter,
   idleClaimRewardsArgs,
   idleLendArgs,
   idleRedeemArgs,
-  IntegrationManager,
   IntegrationManagerActionId,
   lendSelector,
   redeemSelector,
-  StandardToken,
 } from '@enzymefinance/protocol';
-import { BigNumber, BigNumberish } from 'ethers';
+import type { BigNumberish } from 'ethers';
+import { BigNumber } from 'ethers';
 
 export async function idleClaimRewards({
   comptrollerProxy,
@@ -30,10 +28,10 @@ export async function idleClaimRewards({
 }) {
   const callArgs = callOnIntegrationArgs({
     adapter: idleAdapter,
-    selector: claimRewardsSelector,
     encodedCallArgs: idleClaimRewardsArgs({
       idleToken,
     }),
+    selector: claimRewardsSelector,
   });
 
   return comptrollerProxy
@@ -60,12 +58,12 @@ export async function idleLend({
 }) {
   const callArgs = callOnIntegrationArgs({
     adapter: idleAdapter,
-    selector: lendSelector,
     encodedCallArgs: idleLendArgs({
       idleToken,
-      outgoingUnderlyingAmount,
       minIncomingIdleTokenAmount,
+      outgoingUnderlyingAmount,
     }),
+    selector: lendSelector,
   });
 
   return comptrollerProxy
@@ -92,12 +90,12 @@ export async function idleRedeem({
 }) {
   const callArgs = callOnIntegrationArgs({
     adapter: idleAdapter,
-    selector: redeemSelector,
     encodedCallArgs: idleRedeemArgs({
       idleToken,
-      outgoingIdleTokenAmount,
       minIncomingUnderlyingAmount,
+      outgoingIdleTokenAmount,
     }),
+    selector: redeemSelector,
   });
 
   return comptrollerProxy

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

@@ -3,7 +3,10 @@ export * from './compound';
 export * from './curve';
 export * from './idle';
 export * from './mock';
+export * from './olympusV2';
 export * from './paraSwapV4';
+export * from './paraSwapV5';
+export * from './poolTogetherV4';
 export * from './synthetix';
 export * from './trackedAssets';
 export * from './uniswapV2';

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

@@ -1,17 +1,15 @@
-import { AddressLike } from '@enzymefinance/ethers';
-import { SignerWithAddress } from '@enzymefinance/hardhat';
-import {
+import type { AddressLike } from '@enzymefinance/ethers';
+import type { SignerWithAddress } from '@enzymefinance/hardhat';
+import type {
   ComptrollerLib,
   IntegrationManager,
-  VaultLib,
   MockGenericAdapter,
   StandardToken,
-  sighash,
-  callOnIntegrationArgs,
-  encodeArgs,
-  IntegrationManagerActionId,
+  VaultLib,
 } from '@enzymefinance/protocol';
-import { BigNumberish, BytesLike, utils } from 'ethers';
+import { callOnIntegrationArgs, encodeArgs, IntegrationManagerActionId, sighash } from '@enzymefinance/protocol';
+import type { BigNumberish, BytesLike } from 'ethers';
+import { utils } from 'ethers';
 
 export const mockGenericRemoveOnlySelector = sighash(
   utils.FunctionFragment.fromString('removeOnly(address,bytes,bytes)'),
@@ -94,18 +92,18 @@ export async function mockGenericSwap({
   }
 
   const swapArgs = mockGenericSwapArgs({
-    spendAssets,
-    maxSpendAssetAmounts,
+    actualIncomingAssetAmounts,
     actualSpendAssetAmounts,
     incomingAssets,
+    maxSpendAssetAmounts,
     minIncomingAssetAmounts,
-    actualIncomingAssetAmounts,
+    spendAssets,
   });
 
   const callArgs = callOnIntegrationArgs({
     adapter: mockGenericAdapter,
-    selector,
     encodedCallArgs: swapArgs,
+    selector,
   });
 
   const swapTx = comptrollerProxy

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

@@ -0,0 +1,71 @@
+import type { SignerWithAddress } from '@enzymefinance/hardhat';
+import type { ComptrollerLib, IntegrationManager, OlympusV2Adapter } from '@enzymefinance/protocol';
+import {
+  callOnIntegrationArgs,
+  IntegrationManagerActionId,
+  olympusV2StakeArgs,
+  olympusV2UnstakeArgs,
+  stakeSelector,
+  unstakeSelector,
+} from '@enzymefinance/protocol';
+import type { BigNumberish } from 'ethers';
+
+export async function olympusV2Stake({
+  comptrollerProxy,
+  integrationManager,
+  signer,
+  olympusV2Adapter,
+  amount,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  integrationManager: IntegrationManager;
+  signer: SignerWithAddress;
+  olympusV2Adapter: OlympusV2Adapter;
+  amount: BigNumberish;
+}) {
+  const stakeArgs = olympusV2StakeArgs({
+    amount,
+  });
+
+  const callArgs = callOnIntegrationArgs({
+    adapter: olympusV2Adapter,
+    encodedCallArgs: stakeArgs,
+    selector: stakeSelector,
+  });
+
+  const stakeTx = comptrollerProxy
+    .connect(signer)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+
+  return stakeTx;
+}
+
+export async function olympusV2Unstake({
+  comptrollerProxy,
+  integrationManager,
+  signer,
+  olympusV2Adapter,
+  amount,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  integrationManager: IntegrationManager;
+  signer: SignerWithAddress;
+  olympusV2Adapter: OlympusV2Adapter;
+  amount: BigNumberish;
+}) {
+  const unstakeArgs = olympusV2UnstakeArgs({
+    amount,
+  });
+
+  const callArgs = callOnIntegrationArgs({
+    adapter: olympusV2Adapter,
+    encodedCallArgs: unstakeArgs,
+    selector: unstakeSelector,
+  });
+
+  const unstakeTx = comptrollerProxy
+    .connect(signer)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+
+  return unstakeTx;
+}

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

@@ -1,25 +1,30 @@
-import { AddressLike } from '@enzymefinance/ethers';
-import { SignerWithAddress } from '@enzymefinance/hardhat';
-import {
-  callOnIntegrationArgs,
+import type { AddressLike } from '@enzymefinance/ethers';
+import type { SignerWithAddress } from '@enzymefinance/hardhat';
+import type {
   ComptrollerLib,
   IntegrationManager,
-  IntegrationManagerActionId,
   ParaSwapV4Adapter,
   ParaSwapV4Path,
-  paraSwapV4TakeOrderArgs,
   StandardToken,
+} from '@enzymefinance/protocol';
+import {
+  callOnIntegrationArgs,
+  IntegrationManagerActionId,
+  paraSwapV4TakeOrderArgs,
   takeOrderSelector,
 } from '@enzymefinance/protocol';
-import { BigNumberish, utils } from 'ethers';
+import type { BigNumberish } from 'ethers';
+import { utils } from 'ethers';
 
 // ParaSwapV4Path
 export function paraSwapV4GenerateDummyPaths({ toTokens }: { toTokens: AddressLike[] }) {
   return toTokens.map((toToken) => {
     return {
+      // Not supported in our protocol
+      routes: [],
+
       to: toToken,
-      totalNetworkFee: 0, // Not supported in our protocol
-      routes: [], // Can ignore this param in the dummy
+      totalNetworkFee: 0, // Can ignore this param in the dummy
     };
   });
 }
@@ -46,8 +51,8 @@ export async function paraSwapV4TakeOrder({
   paths: ParaSwapV4Path[];
 }) {
   const takeOrderArgs = paraSwapV4TakeOrderArgs({
-    minIncomingAssetAmount,
     expectedIncomingAssetAmount,
+    minIncomingAssetAmount,
     outgoingAsset,
     outgoingAssetAmount,
     paths,
@@ -55,8 +60,8 @@ export async function paraSwapV4TakeOrder({
 
   const callArgs = callOnIntegrationArgs({
     adapter: paraSwapV4Adapter,
-    selector: takeOrderSelector,
     encodedCallArgs: takeOrderArgs,
+    selector: takeOrderSelector,
   });
 
   return comptrollerProxy

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

@@ -0,0 +1,73 @@
+import type { AddressLike } from '@enzymefinance/ethers';
+import type { SignerWithAddress } from '@enzymefinance/hardhat';
+import type {
+  ComptrollerLib,
+  IntegrationManager,
+  ParaSwapV5Adapter,
+  ParaSwapV5Path,
+  StandardToken,
+} from '@enzymefinance/protocol';
+import {
+  callOnIntegrationArgs,
+  IntegrationManagerActionId,
+  paraSwapV5TakeOrderArgs,
+  takeOrderSelector,
+} from '@enzymefinance/protocol';
+import type { BigNumberish, BytesLike } from 'ethers';
+import { utils } from 'ethers';
+
+// ParaSwapV5Path
+export function paraSwapV5GenerateDummyPaths({ toTokens }: { toTokens: AddressLike[] }) {
+  return toTokens.map((toToken) => {
+    return {
+      // Not supported in our protocol
+      adapters: [],
+
+      to: toToken,
+      totalNetworkFee: 0, // Can ignore this param in the dummy
+    };
+  });
+}
+
+export async function paraSwapV5TakeOrder({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  paraSwapV5Adapter,
+  outgoingAsset,
+  outgoingAssetAmount,
+  minIncomingAssetAmount = 1,
+  expectedIncomingAssetAmount = minIncomingAssetAmount,
+  uuid = utils.randomBytes(16),
+  paths,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  integrationManager: IntegrationManager;
+  fundOwner: SignerWithAddress;
+  paraSwapV5Adapter: ParaSwapV5Adapter;
+  outgoingAsset: StandardToken;
+  outgoingAssetAmount: BigNumberish;
+  minIncomingAssetAmount?: BigNumberish;
+  expectedIncomingAssetAmount?: BigNumberish;
+  uuid?: BytesLike;
+  paths: ParaSwapV5Path[];
+}) {
+  const takeOrderArgs = paraSwapV5TakeOrderArgs({
+    expectedIncomingAssetAmount,
+    minIncomingAssetAmount,
+    outgoingAsset,
+    outgoingAssetAmount,
+    paths,
+    uuid,
+  });
+
+  const callArgs = callOnIntegrationArgs({
+    adapter: paraSwapV5Adapter,
+    encodedCallArgs: takeOrderArgs,
+    selector: takeOrderSelector,
+  });
+
+  return comptrollerProxy
+    .connect(fundOwner)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+}

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

@@ -0,0 +1,117 @@
+import type { AddressLike } from '@enzymefinance/ethers';
+import type { SignerWithAddress } from '@enzymefinance/hardhat';
+import type { ComptrollerLib, IntegrationManager, PoolTogetherV4Adapter, StandardToken } from '@enzymefinance/protocol';
+import {
+  callOnIntegrationArgs,
+  claimRewardsSelector,
+  IntegrationManagerActionId,
+  lendSelector,
+  poolTogetherV4ClaimRewardsArgs,
+  poolTogetherV4LendArgs,
+  poolTogetherV4RedeemArgs,
+  redeemSelector,
+} from '@enzymefinance/protocol';
+import type { BigNumberish, BytesLike } from 'ethers';
+import { utils } from 'ethers';
+
+export async function poolTogetherV4Lend({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  poolTogetherV4Adapter,
+  ptToken,
+  amount = utils.parseEther('1'),
+}: {
+  comptrollerProxy: ComptrollerLib;
+  integrationManager: IntegrationManager;
+  fundOwner: SignerWithAddress;
+  poolTogetherV4Adapter: PoolTogetherV4Adapter;
+  ptToken: StandardToken;
+  amount?: BigNumberish;
+}) {
+  const lendArgs = poolTogetherV4LendArgs({
+    amount,
+    ptToken,
+  });
+
+  const callArgs = callOnIntegrationArgs({
+    adapter: poolTogetherV4Adapter,
+    encodedCallArgs: lendArgs,
+    selector: lendSelector,
+  });
+
+  const lendTx = comptrollerProxy
+    .connect(fundOwner)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+
+  return lendTx;
+}
+
+export async function poolTogetherV4Redeem({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  poolTogetherV4Adapter,
+  ptToken,
+  amount = utils.parseEther('1'),
+}: {
+  comptrollerProxy: ComptrollerLib;
+  integrationManager: IntegrationManager;
+  fundOwner: SignerWithAddress;
+  poolTogetherV4Adapter: PoolTogetherV4Adapter;
+  ptToken: StandardToken;
+  amount?: BigNumberish;
+}) {
+  const redeemArgs = poolTogetherV4RedeemArgs({
+    amount,
+    ptToken,
+  });
+
+  const callArgs = callOnIntegrationArgs({
+    adapter: poolTogetherV4Adapter,
+    encodedCallArgs: redeemArgs,
+    selector: redeemSelector,
+  });
+
+  const redeemTx = comptrollerProxy
+    .connect(fundOwner)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+
+  return redeemTx;
+}
+
+export async function poolTogetherV4ClaimRewards({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  poolTogetherV4Adapter,
+  prizeDistributor,
+  drawIds,
+  winningPicks,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  integrationManager: IntegrationManager;
+  fundOwner: SignerWithAddress;
+  poolTogetherV4Adapter: PoolTogetherV4Adapter;
+  prizeDistributor: AddressLike;
+  drawIds: BigNumberish[];
+  winningPicks: BytesLike;
+}) {
+  const claimRewardsArgs = poolTogetherV4ClaimRewardsArgs({
+    drawIds,
+    prizeDistributor,
+    winningPicks,
+  });
+
+  const callArgs = callOnIntegrationArgs({
+    adapter: poolTogetherV4Adapter,
+    encodedCallArgs: claimRewardsArgs,
+    selector: claimRewardsSelector,
+  });
+
+  const claimTx = comptrollerProxy
+    .connect(fundOwner)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+
+  return claimTx;
+}

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

@@ -1,53 +1,70 @@
-import { AddressLike } from '@enzymefinance/ethers';
-import {
-  callOnIntegrationArgs,
+import type { AddressLike } from '@enzymefinance/ethers';
+import type {
   ComptrollerLib,
-  encodeArgs,
   IntegrationManager,
-  IntegrationManagerActionId,
-  ISynthetixAddressResolver,
   StandardToken,
   SynthetixAdapter,
+  VaultLib,
+} from '@enzymefinance/protocol';
+import {
+  callOnIntegrationArgs,
+  encodeArgs,
+  IntegrationManagerActionId,
+  redeemSelector,
   synthetixAssignExchangeDelegateSelector,
+  synthetixRedeemArgs,
   synthetixTakeOrderArgs,
   takeOrderSelector,
-  VaultLib,
 } from '@enzymefinance/protocol';
-import { BigNumberish, Signer, utils } from 'ethers';
+import type { BigNumberish, Signer } from 'ethers';
+import { utils } from 'ethers';
 
 export async function synthetixAssignExchangeDelegate({
   comptrollerProxy,
-  addressResolver,
+  synthetixDelegateApprovals,
   fundOwner,
   delegate,
 }: {
   comptrollerProxy: ComptrollerLib;
-  addressResolver: ISynthetixAddressResolver;
+  synthetixDelegateApprovals: AddressLike;
   fundOwner: Signer;
   delegate: AddressLike;
 }) {
-  const delegateApprovals = await synthetixResolveAddress({
-    addressResolver,
-    name: 'DelegateApprovals',
-  });
-
   await comptrollerProxy
     .connect(fundOwner)
     .vaultCallOnContract(
-      delegateApprovals,
+      synthetixDelegateApprovals,
       synthetixAssignExchangeDelegateSelector,
       encodeArgs(['address'], [delegate]),
     );
 }
 
-export async function synthetixResolveAddress({
-  addressResolver,
-  name,
+export async function synthetixRedeem({
+  comptrollerProxy,
+  integrationManager,
+  signer,
+  synthetixAdapter,
+  synths,
 }: {
-  addressResolver: ISynthetixAddressResolver;
-  name: string;
+  comptrollerProxy: ComptrollerLib;
+  integrationManager: IntegrationManager;
+  signer: Signer;
+  synthetixAdapter: SynthetixAdapter;
+  synths: AddressLike[];
 }) {
-  return addressResolver.requireAndGetAddress(utils.formatBytes32String(name), `Missing ${name}`);
+  const redeemArgs = synthetixRedeemArgs({
+    synths,
+  });
+
+  const callArgs = callOnIntegrationArgs({
+    adapter: synthetixAdapter,
+    encodedCallArgs: redeemArgs,
+    selector: redeemSelector,
+  });
+
+  return comptrollerProxy
+    .connect(signer)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
 }
 
 export async function synthetixTakeOrder({
@@ -58,8 +75,7 @@ export async function synthetixTakeOrder({
   synthetixAdapter,
   outgoingAsset,
   outgoingAssetAmount = utils.parseEther('1'),
-  incomingAsset,
-  minIncomingAssetAmount = utils.parseEther('1'),
+  minIncomingSusdAmount = utils.parseEther('1'),
   seedFund = false,
 }: {
   comptrollerProxy: ComptrollerLib;
@@ -69,8 +85,7 @@ export async function synthetixTakeOrder({
   synthetixAdapter: SynthetixAdapter;
   outgoingAsset: StandardToken;
   outgoingAssetAmount?: BigNumberish;
-  incomingAsset: StandardToken;
-  minIncomingAssetAmount?: BigNumberish;
+  minIncomingSusdAmount?: BigNumberish;
   seedFund?: boolean;
 }) {
   if (seedFund) {
@@ -79,16 +94,15 @@ export async function synthetixTakeOrder({
   }
 
   const takeOrderArgs = synthetixTakeOrderArgs({
-    incomingAsset: incomingAsset,
-    minIncomingAssetAmount: minIncomingAssetAmount,
-    outgoingAsset: outgoingAsset,
-    outgoingAssetAmount: outgoingAssetAmount,
+    minIncomingSusdAmount,
+    outgoingAsset,
+    outgoingAssetAmount,
   });
 
   const callArgs = await callOnIntegrationArgs({
     adapter: synthetixAdapter,
-    selector: takeOrderSelector,
     encodedCallArgs: takeOrderArgs,
+    selector: takeOrderSelector,
   });
 
   return comptrollerProxy

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

@@ -1,9 +1,8 @@
-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, IntegrationManager } from '@enzymefinance/protocol';
 import {
   addTrackedAssetsToVaultArgs,
-  ComptrollerLib,
-  IntegrationManager,
   IntegrationManagerActionId,
   removeTrackedAssetsFromVaultArgs,
 } from '@enzymefinance/protocol';

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

@@ -1,22 +1,25 @@
-import { AddressLike, Call, Contract, contract, Send } from '@enzymefinance/ethers';
-import { SignerWithAddress } from '@enzymefinance/hardhat';
-import {
-  callOnIntegrationArgs,
+import type { AddressLike, Call, Contract, Send } from '@enzymefinance/ethers';
+import { contract } from '@enzymefinance/ethers';
+import type { SignerWithAddress } from '@enzymefinance/hardhat';
+import type {
   ComptrollerLib,
   IntegrationManager,
+  StandardToken,
+  UniswapV2ExchangeAdapter,
+  UniswapV2LiquidityAdapter,
+  VaultLib,
+} from '@enzymefinance/protocol';
+import {
+  callOnIntegrationArgs,
   IntegrationManagerActionId,
   lendSelector,
   redeemSelector,
-  StandardToken,
   takeOrderSelector,
-  UniswapV2ExchangeAdapter,
-  UniswapV2LiquidityAdapter,
   uniswapV2LendArgs,
   uniswapV2RedeemArgs,
   uniswapV2TakeOrderArgs,
-  VaultLib,
 } from '@enzymefinance/protocol';
-import { BigNumberish } from 'ethers';
+import type { BigNumberish } from 'ethers';
 
 export interface UniswapV2Factory extends Contract<UniswapV2Factory> {
   createPair: Send<(_token0: AddressLike, _token1: AddressLike) => AddressLike>;
@@ -64,19 +67,19 @@ export async function uniswapV2Lend({
   }
 
   const lendArgs = uniswapV2LendArgs({
-    tokenA,
-    tokenB,
     amountADesired,
-    amountBDesired,
     amountAMin,
+    amountBDesired,
     amountBMin,
     minPoolTokenAmount,
+    tokenA,
+    tokenB,
   });
 
   const callArgs = callOnIntegrationArgs({
     adapter: uniswapV2LiquidityAdapter,
-    selector: lendSelector,
     encodedCallArgs: lendArgs,
+    selector: lendSelector,
   });
 
   const lendTx = comptrollerProxy
@@ -109,16 +112,16 @@ export async function uniswapV2Redeem({
   amountBMin: BigNumberish;
 }) {
   const redeemArgs = uniswapV2RedeemArgs({
+    amountAMin,
+    amountBMin,
     poolTokenAmount,
     tokenA,
     tokenB,
-    amountAMin,
-    amountBMin,
   });
   const callArgs = callOnIntegrationArgs({
     adapter: uniswapV2LiquidityAdapter,
-    selector: redeemSelector,
     encodedCallArgs: redeemArgs,
+    selector: redeemSelector,
   });
 
   const redeemTx = comptrollerProxy
@@ -156,14 +159,14 @@ export async function uniswapV2TakeOrder({
   }
 
   const takeOrderArgs = uniswapV2TakeOrderArgs({
-    path,
-    outgoingAssetAmount,
     minIncomingAssetAmount,
+    outgoingAssetAmount,
+    path,
   });
   const callArgs = callOnIntegrationArgs({
     adapter: uniswapV2ExchangeAdapter,
-    selector: takeOrderSelector,
     encodedCallArgs: takeOrderArgs,
+    selector: takeOrderSelector,
   });
 
   return comptrollerProxy