@enzymefinance/testutils 3.0.0

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

@@ -0,0 +1,97 @@
+import { AddressLike } from '@enzymefinance/ethers';
+import {
+  callOnIntegrationArgs,
+  ComptrollerLib,
+  encodeArgs,
+  IntegrationManager,
+  IntegrationManagerActionId,
+  ISynthetixAddressResolver,
+  StandardToken,
+  SynthetixAdapter,
+  synthetixAssignExchangeDelegateSelector,
+  synthetixTakeOrderArgs,
+  takeOrderSelector,
+  VaultLib,
+} from '@enzymefinance/protocol';
+import { BigNumberish, Signer, utils } from 'ethers';
+
+export async function synthetixAssignExchangeDelegate({
+  comptrollerProxy,
+  addressResolver,
+  fundOwner,
+  delegate,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  addressResolver: ISynthetixAddressResolver;
+  fundOwner: Signer;
+  delegate: AddressLike;
+}) {
+  const delegateApprovals = await synthetixResolveAddress({
+    addressResolver,
+    name: 'DelegateApprovals',
+  });
+
+  await comptrollerProxy
+    .connect(fundOwner)
+    .vaultCallOnContract(
+      delegateApprovals,
+      synthetixAssignExchangeDelegateSelector,
+      encodeArgs(['address'], [delegate]),
+    );
+}
+
+export async function synthetixResolveAddress({
+  addressResolver,
+  name,
+}: {
+  addressResolver: ISynthetixAddressResolver;
+  name: string;
+}) {
+  return addressResolver.requireAndGetAddress(utils.formatBytes32String(name), `Missing ${name}`);
+}
+
+export async function synthetixTakeOrder({
+  comptrollerProxy,
+  vaultProxy,
+  integrationManager,
+  fundOwner,
+  synthetixAdapter,
+  outgoingAsset,
+  outgoingAssetAmount = utils.parseEther('1'),
+  incomingAsset,
+  minIncomingAssetAmount = utils.parseEther('1'),
+  seedFund = false,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  vaultProxy: VaultLib;
+  integrationManager: IntegrationManager;
+  fundOwner: Signer;
+  synthetixAdapter: SynthetixAdapter;
+  outgoingAsset: StandardToken;
+  outgoingAssetAmount?: BigNumberish;
+  incomingAsset: StandardToken;
+  minIncomingAssetAmount?: BigNumberish;
+  seedFund?: boolean;
+}) {
+  if (seedFund) {
+    // Seed the VaultProxy with enough outgoingAsset for the tx
+    await outgoingAsset.transfer(vaultProxy, outgoingAssetAmount);
+  }
+
+  const takeOrderArgs = synthetixTakeOrderArgs({
+    incomingAsset: incomingAsset,
+    minIncomingAssetAmount: minIncomingAssetAmount,
+    outgoingAsset: outgoingAsset,
+    outgoingAssetAmount: outgoingAssetAmount,
+  });
+
+  const callArgs = await callOnIntegrationArgs({
+    adapter: synthetixAdapter,
+    selector: takeOrderSelector,
+    encodedCallArgs: takeOrderArgs,
+  });
+
+  return comptrollerProxy
+    .connect(fundOwner)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+}

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

@@ -0,0 +1,66 @@
+import { AddressLike } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import {
+  addTrackedAssetsArgs,
+  addTrackedAssetsSelector,
+  callOnIntegrationArgs,
+  ComptrollerLib,
+  IntegrationManager,
+  IntegrationManagerActionId,
+  removeTrackedAssetsArgs,
+  removeTrackedAssetsSelector,
+  TrackedAssetsAdapter,
+} from '@enzymefinance/protocol';
+
+export async function addTrackedAssets({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  trackedAssetsAdapter,
+  incomingAssets,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  integrationManager: IntegrationManager;
+  fundOwner: SignerWithAddress;
+  trackedAssetsAdapter: TrackedAssetsAdapter;
+  incomingAssets: AddressLike[];
+}) {
+  const args = addTrackedAssetsArgs(incomingAssets);
+  const callArgs = callOnIntegrationArgs({
+    adapter: trackedAssetsAdapter,
+    selector: addTrackedAssetsSelector,
+    encodedCallArgs: args,
+  });
+
+  const addTrackedAssetsTx = comptrollerProxy
+    .connect(fundOwner)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+
+  await expect(addTrackedAssetsTx).resolves.toBeReceipt();
+
+  return addTrackedAssetsTx;
+}
+
+export async function removeTrackedAssets({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  trackedAssetsAdapter,
+  spendAssets,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  integrationManager: IntegrationManager;
+  fundOwner: SignerWithAddress;
+  trackedAssetsAdapter: TrackedAssetsAdapter;
+  spendAssets: AddressLike[];
+}) {
+  const callArgs = callOnIntegrationArgs({
+    adapter: trackedAssetsAdapter,
+    selector: removeTrackedAssetsSelector,
+    encodedCallArgs: removeTrackedAssetsArgs(spendAssets),
+  });
+
+  return comptrollerProxy
+    .connect(fundOwner)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+}

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

@@ -0,0 +1,171 @@
+import { AddressLike, Call, Contract, contract, Send } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import {
+  callOnIntegrationArgs,
+  ComptrollerLib,
+  IntegrationManager,
+  IntegrationManagerActionId,
+  lendSelector,
+  redeemSelector,
+  StandardToken,
+  takeOrderSelector,
+  UniswapV2Adapter,
+  uniswapV2LendArgs,
+  uniswapV2RedeemArgs,
+  uniswapV2TakeOrderArgs,
+  VaultLib,
+} from '@enzymefinance/protocol';
+import { BigNumberish } from 'ethers';
+
+export interface UniswapV2Factory extends Contract<UniswapV2Factory> {
+  createPair: Send<(_token0: AddressLike, _token1: AddressLike) => AddressLike>;
+  getPair: Call<(_token0: AddressLike, _token1: AddressLike) => AddressLike>;
+}
+
+export const UniswapV2Factory = contract<UniswapV2Factory>()`
+  function createPair(address,address) returns (address)
+  function getPair(address,address) view returns (address)
+`;
+
+export async function uniswapV2Lend({
+  comptrollerProxy,
+  vaultProxy,
+  integrationManager,
+  fundOwner,
+  uniswapV2Adapter,
+  tokenA,
+  tokenB,
+  amountADesired,
+  amountBDesired,
+  amountAMin,
+  amountBMin,
+  minPoolTokenAmount,
+  seedFund = false,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  vaultProxy: VaultLib;
+  integrationManager: IntegrationManager;
+  fundOwner: SignerWithAddress;
+  uniswapV2Adapter: UniswapV2Adapter;
+  tokenA: StandardToken;
+  tokenB: StandardToken;
+  amountADesired: BigNumberish;
+  amountBDesired: BigNumberish;
+  amountAMin: BigNumberish;
+  amountBMin: BigNumberish;
+  minPoolTokenAmount: BigNumberish;
+  seedFund?: boolean;
+}) {
+  if (seedFund) {
+    // Seed the VaultProxy with enough tokenA and tokenB for the tx
+    await tokenA.transfer(vaultProxy, amountADesired);
+    await tokenB.transfer(vaultProxy, amountBDesired);
+  }
+
+  const lendArgs = uniswapV2LendArgs({
+    tokenA,
+    tokenB,
+    amountADesired,
+    amountBDesired,
+    amountAMin,
+    amountBMin,
+    minPoolTokenAmount,
+  });
+
+  const callArgs = callOnIntegrationArgs({
+    adapter: uniswapV2Adapter,
+    selector: lendSelector,
+    encodedCallArgs: lendArgs,
+  });
+
+  const lendTx = comptrollerProxy
+    .connect(fundOwner)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+  await expect(lendTx).resolves.toBeReceipt();
+
+  return lendTx;
+}
+
+export async function uniswapV2Redeem({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  uniswapV2Adapter,
+  poolTokenAmount,
+  tokenA,
+  tokenB,
+  amountAMin,
+  amountBMin,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  integrationManager: IntegrationManager;
+  fundOwner: SignerWithAddress;
+  uniswapV2Adapter: UniswapV2Adapter;
+  poolTokenAmount: BigNumberish;
+  tokenA: AddressLike;
+  tokenB: AddressLike;
+  amountAMin: BigNumberish;
+  amountBMin: BigNumberish;
+}) {
+  const redeemArgs = uniswapV2RedeemArgs({
+    poolTokenAmount,
+    tokenA,
+    tokenB,
+    amountAMin,
+    amountBMin,
+  });
+  const callArgs = callOnIntegrationArgs({
+    adapter: uniswapV2Adapter,
+    selector: redeemSelector,
+    encodedCallArgs: redeemArgs,
+  });
+
+  const redeemTx = comptrollerProxy
+    .connect(fundOwner)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+  await expect(redeemTx).resolves.toBeReceipt();
+
+  return redeemTx;
+}
+
+export async function uniswapV2TakeOrder({
+  comptrollerProxy,
+  vaultProxy,
+  integrationManager,
+  fundOwner,
+  uniswapV2Adapter,
+  path,
+  outgoingAssetAmount,
+  minIncomingAssetAmount,
+  seedFund = false,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  vaultProxy: VaultLib;
+  integrationManager: IntegrationManager;
+  fundOwner: SignerWithAddress;
+  uniswapV2Adapter: UniswapV2Adapter;
+  path: StandardToken[];
+  outgoingAssetAmount: BigNumberish;
+  minIncomingAssetAmount: BigNumberish;
+  seedFund?: boolean;
+}) {
+  if (seedFund) {
+    // Seed the VaultProxy with enough outgoingAsset for the tx
+    await path[0].transfer(vaultProxy, outgoingAssetAmount);
+  }
+
+  const takeOrderArgs = uniswapV2TakeOrderArgs({
+    path,
+    outgoingAssetAmount,
+    minIncomingAssetAmount,
+  });
+  const callArgs = callOnIntegrationArgs({
+    adapter: uniswapV2Adapter,
+    selector: takeOrderSelector,
+    encodedCallArgs: takeOrderArgs,
+  });
+
+  return comptrollerProxy
+    .connect(fundOwner)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+}

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

@@ -0,0 +1,56 @@
+import { AddressLike } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import {
+  callOnIntegrationArgs,
+  ComptrollerLib,
+  IntegrationManager,
+  IntegrationManagerActionId,
+  StandardToken,
+  takeOrderSelector,
+  uniswapV3TakeOrderArgs,
+} from '@enzymefinance/protocol';
+import { BigNumber, BigNumberish } from 'ethers';
+
+export async function uniswapV3TakeOrder({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  uniswapV3Adapter,
+  pathAddresses,
+  pathFees,
+  outgoingAssetAmount,
+  minIncomingAssetAmount = 1,
+  seedFund = false,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  integrationManager: IntegrationManager;
+  fundOwner: SignerWithAddress;
+  uniswapV3Adapter: AddressLike;
+  pathAddresses: StandardToken[];
+  pathFees: BigNumber[];
+  outgoingAssetAmount: BigNumberish;
+  minIncomingAssetAmount?: BigNumberish;
+  seedFund?: boolean;
+}) {
+  if (seedFund) {
+    // Seed the VaultProxy with enough outgoingAsset for the tx
+    await pathAddresses[0].transfer(await comptrollerProxy.getVaultProxy(), outgoingAssetAmount);
+  }
+
+  const takeOrderArgs = uniswapV3TakeOrderArgs({
+    pathAddresses,
+    pathFees,
+    outgoingAssetAmount,
+    minIncomingAssetAmount,
+  });
+
+  const callArgs = callOnIntegrationArgs({
+    adapter: uniswapV3Adapter,
+    selector: takeOrderSelector,
+    encodedCallArgs: takeOrderArgs,
+  });
+
+  return comptrollerProxy
+    .connect(fundOwner)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+}

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

@@ -0,0 +1,81 @@
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import {
+  callOnIntegrationArgs,
+  ComptrollerLib,
+  IntegrationManager,
+  IntegrationManagerActionId,
+  lendSelector,
+  redeemSelector,
+  StandardToken,
+  YearnVaultV2Adapter,
+  yearnVaultV2LendArgs,
+  yearnVaultV2RedeemArgs,
+} from '@enzymefinance/protocol';
+import { BigNumber, BigNumberish } from 'ethers';
+
+export async function yearnVaultV2Lend({
+  signer,
+  comptrollerProxy,
+  integrationManager,
+  yearnVaultV2Adapter,
+  yVault,
+  outgoingUnderlyingAmount,
+  minIncomingYVaultSharesAmount = BigNumber.from(1),
+}: {
+  signer: SignerWithAddress;
+  comptrollerProxy: ComptrollerLib;
+  integrationManager: IntegrationManager;
+  yearnVaultV2Adapter: YearnVaultV2Adapter;
+  yVault: StandardToken;
+  outgoingUnderlyingAmount: BigNumberish;
+  minIncomingYVaultSharesAmount?: BigNumberish;
+}) {
+  const callArgs = callOnIntegrationArgs({
+    adapter: yearnVaultV2Adapter,
+    selector: lendSelector,
+    encodedCallArgs: yearnVaultV2LendArgs({
+      yVault,
+      outgoingUnderlyingAmount,
+      minIncomingYVaultSharesAmount,
+    }),
+  });
+
+  return comptrollerProxy
+    .connect(signer)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+
+export async function yearnVaultV2Redeem({
+  signer,
+  comptrollerProxy,
+  integrationManager,
+  yearnVaultV2Adapter,
+  yVault,
+  maxOutgoingYVaultSharesAmount,
+  minIncomingUnderlyingAmount = BigNumber.from(1),
+  slippageToleranceBps = 1,
+}: {
+  signer: SignerWithAddress;
+  comptrollerProxy: ComptrollerLib;
+  integrationManager: IntegrationManager;
+  yearnVaultV2Adapter: YearnVaultV2Adapter;
+  yVault: StandardToken;
+  maxOutgoingYVaultSharesAmount: BigNumberish;
+  minIncomingUnderlyingAmount?: BigNumberish;
+  slippageToleranceBps?: BigNumberish;
+}) {
+  const callArgs = callOnIntegrationArgs({
+    adapter: yearnVaultV2Adapter,
+    selector: redeemSelector,
+    encodedCallArgs: yearnVaultV2RedeemArgs({
+      yVault,
+      maxOutgoingYVaultSharesAmount,
+      minIncomingUnderlyingAmount,
+      slippageToleranceBps,
+    }),
+  });
+
+  return comptrollerProxy
+    .connect(signer)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+}