@enzymefinance/testutils 3.0.0

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

@@ -0,0 +1,215 @@
+import { AddressLike } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import {
+  approveAssetsSelector,
+  callOnIntegrationArgs,
+  claimRewardsAndReinvestSelector,
+  claimRewardsAndSwapSelector,
+  claimRewardsSelector,
+  ComptrollerLib,
+  IdleAdapter,
+  idleApproveAssetsArgs,
+  idleClaimRewardsAndReinvestArgs,
+  idleClaimRewardsAndSwapArgs,
+  idleClaimRewardsArgs,
+  idleLendArgs,
+  idleRedeemArgs,
+  IntegrationManager,
+  IntegrationManagerActionId,
+  lendSelector,
+  redeemSelector,
+  StandardToken,
+} from '@enzymefinance/protocol';
+import { BigNumber, BigNumberish } from 'ethers';
+
+export async function idleApproveAssets({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  idleAdapter,
+  idleToken,
+  assets,
+  amounts,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  integrationManager: IntegrationManager;
+  fundOwner: SignerWithAddress;
+  idleAdapter: IdleAdapter;
+  idleToken: StandardToken;
+  assets: AddressLike[];
+  amounts: BigNumberish[];
+}) {
+  const callArgs = callOnIntegrationArgs({
+    adapter: idleAdapter,
+    selector: approveAssetsSelector,
+    encodedCallArgs: idleApproveAssetsArgs({
+      idleToken,
+      assets,
+      amounts,
+    }),
+  });
+
+  return comptrollerProxy
+    .connect(fundOwner)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+
+export async function idleClaimRewards({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  idleAdapter,
+  idleToken,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  integrationManager: IntegrationManager;
+  fundOwner: SignerWithAddress;
+  idleAdapter: IdleAdapter;
+  idleToken: StandardToken;
+}) {
+  const callArgs = callOnIntegrationArgs({
+    adapter: idleAdapter,
+    selector: claimRewardsSelector,
+    encodedCallArgs: idleClaimRewardsArgs({
+      vaultProxy: await comptrollerProxy.getVaultProxy(),
+      idleToken,
+    }),
+  });
+
+  return comptrollerProxy
+    .connect(fundOwner)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+
+export async function idleClaimRewardsAndReinvest({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  idleAdapter,
+  idleToken,
+  minIncomingIdleTokenAmount = BigNumber.from(1),
+  useFullBalances,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  integrationManager: IntegrationManager;
+  fundOwner: SignerWithAddress;
+  idleAdapter: IdleAdapter;
+  idleToken: StandardToken;
+  minIncomingIdleTokenAmount?: BigNumberish;
+  useFullBalances: boolean;
+}) {
+  const callArgs = callOnIntegrationArgs({
+    adapter: idleAdapter,
+    selector: claimRewardsAndReinvestSelector,
+    encodedCallArgs: idleClaimRewardsAndReinvestArgs({
+      vaultProxy: await comptrollerProxy.getVaultProxy(),
+      idleToken,
+      minIncomingIdleTokenAmount,
+      useFullBalances,
+    }),
+  });
+
+  return comptrollerProxy
+    .connect(fundOwner)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+
+export async function idleClaimRewardsAndSwap({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  idleAdapter,
+  idleToken,
+  incomingAsset,
+  minIncomingAssetAmount = BigNumber.from(1),
+  useFullBalances,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  integrationManager: IntegrationManager;
+  fundOwner: SignerWithAddress;
+  idleAdapter: IdleAdapter;
+  idleToken: StandardToken;
+  incomingAsset: AddressLike;
+  minIncomingAssetAmount?: BigNumberish;
+  useFullBalances: boolean;
+}) {
+  const callArgs = callOnIntegrationArgs({
+    adapter: idleAdapter,
+    selector: claimRewardsAndSwapSelector,
+    encodedCallArgs: idleClaimRewardsAndSwapArgs({
+      vaultProxy: await comptrollerProxy.getVaultProxy(),
+      idleToken,
+      incomingAsset,
+      minIncomingAssetAmount,
+      useFullBalances,
+    }),
+  });
+
+  return comptrollerProxy
+    .connect(fundOwner)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+
+export async function idleLend({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  idleAdapter,
+  idleToken,
+  outgoingUnderlyingAmount,
+  minIncomingIdleTokenAmount = BigNumber.from(1),
+}: {
+  comptrollerProxy: ComptrollerLib;
+  integrationManager: IntegrationManager;
+  fundOwner: SignerWithAddress;
+  idleAdapter: IdleAdapter;
+  idleToken: StandardToken;
+  outgoingUnderlyingAmount: BigNumberish;
+  minIncomingIdleTokenAmount?: BigNumberish;
+}) {
+  const callArgs = callOnIntegrationArgs({
+    adapter: idleAdapter,
+    selector: lendSelector,
+    encodedCallArgs: idleLendArgs({
+      idleToken,
+      outgoingUnderlyingAmount,
+      minIncomingIdleTokenAmount,
+    }),
+  });
+
+  return comptrollerProxy
+    .connect(fundOwner)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+}
+
+export async function idleRedeem({
+  comptrollerProxy,
+  integrationManager,
+  fundOwner,
+  idleAdapter,
+  idleToken,
+  outgoingIdleTokenAmount,
+  minIncomingUnderlyingAmount = BigNumber.from(1),
+}: {
+  comptrollerProxy: ComptrollerLib;
+  integrationManager: IntegrationManager;
+  fundOwner: SignerWithAddress;
+  idleAdapter: IdleAdapter;
+  idleToken: StandardToken;
+  outgoingIdleTokenAmount: BigNumberish;
+  minIncomingUnderlyingAmount?: BigNumberish;
+}) {
+  const callArgs = callOnIntegrationArgs({
+    adapter: idleAdapter,
+    selector: redeemSelector,
+    encodedCallArgs: idleRedeemArgs({
+      idleToken,
+      outgoingIdleTokenAmount,
+      minIncomingUnderlyingAmount,
+    }),
+  });
+
+  return comptrollerProxy
+    .connect(fundOwner)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+}

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

@@ -0,0 +1,14 @@
+export * from './aave';
+export * from './alpha';
+export * from './compound';
+export * from './curve';
+export * from './idle';
+export * from './kyber';
+export * from './mock';
+export * from './paraSwapV4';
+export * from './synthetix';
+export * from './trackedAssets';
+export * from './uniswapV2';
+export * from './uniswapV3';
+export * from './yearn';
+export * from './zeroExV2';

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

@@ -0,0 +1,69 @@
+import { AddressLike, Call, Contract, contract } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import {
+  StandardToken,
+  ComptrollerLib,
+  IntegrationManager,
+  KyberAdapter,
+  VaultLib,
+  callOnIntegrationArgs,
+  takeOrderSelector,
+  kyberTakeOrderArgs,
+  IntegrationManagerActionId,
+} from '@enzymefinance/protocol';
+import { BigNumber, BigNumberish, utils } from 'ethers';
+
+// prettier-ignore
+export interface KyberNetworkProxy extends Contract<KyberNetworkProxy> {
+  getExpectedRate: Call<(src: AddressLike, dest: AddressLike, srcQty: BigNumberish) => { expectedRate: BigNumber, worstRate: BigNumber }, KyberNetworkProxy>
+}
+
+export const KyberNetworkProxy = contract<KyberNetworkProxy>()`
+  function getExpectedRate(address src, address dest, uint256 srcQty) view returns (uint256 expectedRate, uint256 worstRate)
+`;
+
+export async function kyberTakeOrder({
+  comptrollerProxy,
+  vaultProxy,
+  integrationManager,
+  fundOwner,
+  kyberAdapter,
+  outgoingAsset,
+  outgoingAssetAmount = utils.parseEther('1'),
+  incomingAsset,
+  minIncomingAssetAmount = utils.parseEther('1'),
+  seedFund = false,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  vaultProxy: VaultLib;
+  integrationManager: IntegrationManager;
+  fundOwner: SignerWithAddress;
+  kyberAdapter: KyberAdapter;
+  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 = kyberTakeOrderArgs({
+    incomingAsset: incomingAsset,
+    minIncomingAssetAmount: minIncomingAssetAmount,
+    outgoingAsset: outgoingAsset,
+    outgoingAssetAmount: outgoingAssetAmount,
+  });
+
+  const callArgs = callOnIntegrationArgs({
+    adapter: kyberAdapter,
+    selector: takeOrderSelector,
+    encodedCallArgs: takeOrderArgs,
+  });
+
+  return comptrollerProxy
+    .connect(fundOwner)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+}

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

@@ -0,0 +1,118 @@
+import { AddressLike } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import {
+  ComptrollerLib,
+  IntegrationManager,
+  VaultLib,
+  MockGenericAdapter,
+  StandardToken,
+  sighash,
+  callOnIntegrationArgs,
+  encodeArgs,
+  IntegrationManagerActionId,
+} from '@enzymefinance/protocol';
+import { BigNumberish, BytesLike, utils } from 'ethers';
+
+export const mockGenericRemoveOnlySelector = sighash(
+  utils.FunctionFragment.fromString('removeOnly(address,bytes,bytes)'),
+);
+
+export const mockGenericSwapASelector = sighash(utils.FunctionFragment.fromString('swapA(address,bytes,bytes)'));
+
+export const mockGenericSwapBSelector = sighash(utils.FunctionFragment.fromString('swapB(address,bytes,bytes)'));
+
+export const mockGenericSwapDirectFromVaultSelector = sighash(
+  utils.FunctionFragment.fromString('swapDirectFromVault(address,bytes,bytes)'),
+);
+
+export const mockGenericSwapViaApprovalSelector = sighash(
+  utils.FunctionFragment.fromString('swapViaApproval(address,bytes,bytes)'),
+);
+
+export function mockGenericSwapArgs({
+  spendAssets = [],
+  actualSpendAssetAmounts = [],
+  maxSpendAssetAmounts = actualSpendAssetAmounts,
+  incomingAssets = [],
+  actualIncomingAssetAmounts = [],
+  minIncomingAssetAmounts = actualIncomingAssetAmounts,
+}: {
+  spendAssets?: AddressLike[];
+  maxSpendAssetAmounts?: BigNumberish[];
+  actualSpendAssetAmounts?: BigNumberish[];
+  incomingAssets?: AddressLike[];
+  minIncomingAssetAmounts?: BigNumberish[];
+  actualIncomingAssetAmounts?: BigNumberish[];
+}) {
+  return encodeArgs(
+    ['address[]', 'uint256[]', 'uint256[]', 'address[]', 'uint256[]', 'uint256[]'],
+    [
+      spendAssets,
+      maxSpendAssetAmounts,
+      actualSpendAssetAmounts,
+      incomingAssets,
+      minIncomingAssetAmounts,
+      actualIncomingAssetAmounts,
+    ],
+  );
+}
+
+export async function mockGenericSwap({
+  comptrollerProxy,
+  vaultProxy,
+  integrationManager,
+  fundOwner,
+  mockGenericAdapter,
+  selector = mockGenericSwapASelector,
+  spendAssets = [],
+  actualSpendAssetAmounts = [],
+  maxSpendAssetAmounts = actualSpendAssetAmounts,
+  incomingAssets = [],
+  actualIncomingAssetAmounts = [],
+  minIncomingAssetAmounts = actualIncomingAssetAmounts,
+  seedFund = false,
+}: {
+  comptrollerProxy: ComptrollerLib;
+  vaultProxy: VaultLib;
+  integrationManager: IntegrationManager;
+  fundOwner: SignerWithAddress;
+  mockGenericAdapter: MockGenericAdapter;
+  selector?: BytesLike;
+  spendAssets?: StandardToken[];
+  maxSpendAssetAmounts?: BigNumberish[];
+  actualSpendAssetAmounts?: BigNumberish[];
+  incomingAssets?: StandardToken[];
+  minIncomingAssetAmounts?: BigNumberish[];
+  actualIncomingAssetAmounts?: BigNumberish[];
+  seedFund?: boolean;
+}) {
+  // Seed the VaultProxy with enough spendAssets for the tx
+  if (seedFund) {
+    for (const key in spendAssets) {
+      await spendAssets[key].transfer(vaultProxy, maxSpendAssetAmounts[key]);
+    }
+  }
+
+  const swapArgs = mockGenericSwapArgs({
+    spendAssets,
+    maxSpendAssetAmounts,
+    actualSpendAssetAmounts,
+    incomingAssets,
+    minIncomingAssetAmounts,
+    actualIncomingAssetAmounts,
+  });
+
+  const callArgs = callOnIntegrationArgs({
+    adapter: mockGenericAdapter,
+    selector,
+    encodedCallArgs: swapArgs,
+  });
+
+  const swapTx = comptrollerProxy
+    .connect(fundOwner)
+    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
+
+  await expect(swapTx).resolves.toBeReceipt();
+
+  return swapTx;
+}

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

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