@enzymefinance/testutils 4.0.0-next.6 → 4.0.1

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

@@ -1,104 +0,0 @@
-import type { SignerWithAddress } from '@enzymefinance/hardhat';
-import type { ComptrollerLib, IdleAdapter, IntegrationManager, StandardToken } from '@enzymefinance/protocol';
-import {
-  callOnIntegrationArgs,
-  claimRewardsSelector,
-  idleClaimRewardsArgs,
-  idleLendArgs,
-  idleRedeemArgs,
-  IntegrationManagerActionId,
-  lendSelector,
-  redeemSelector,
-} from '@enzymefinance/protocol';
-import type { BigNumberish } from 'ethers';
-import { BigNumber } from 'ethers';
-
-export async function idleClaimRewards({
-  comptrollerProxy,
-  integrationManager,
-  fundOwner,
-  idleAdapter,
-  idleToken,
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  fundOwner: SignerWithAddress;
-  idleAdapter: IdleAdapter;
-  idleToken: StandardToken;
-}) {
-  const callArgs = callOnIntegrationArgs({
-    adapter: idleAdapter,
-    encodedCallArgs: idleClaimRewardsArgs({
-      idleToken,
-    }),
-    selector: claimRewardsSelector,
-  });
-
-  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,
-    encodedCallArgs: idleLendArgs({
-      idleToken,
-      minIncomingIdleTokenAmount,
-      outgoingUnderlyingAmount,
-    }),
-    selector: lendSelector,
-  });
-
-  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,
-    encodedCallArgs: idleRedeemArgs({
-      idleToken,
-      minIncomingUnderlyingAmount,
-      outgoingIdleTokenAmount,
-    }),
-    selector: redeemSelector,
-  });
-
-  return comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}

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

@@ -1,15 +0,0 @@
-export * from './aave';
-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';
-export * from './uniswapV3';
-export * from './yearn';
-export * from './zeroExV2';

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

@@ -1,116 +0,0 @@
-import type { AddressLike } from '@enzymefinance/ethers';
-import type { SignerWithAddress } from '@enzymefinance/hardhat';
-import type {
-  ComptrollerLib,
-  IntegrationManager,
-  MockGenericAdapter,
-  StandardToken,
-  VaultLib,
-} from '@enzymefinance/protocol';
-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)'),
-);
-
-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({
-    actualIncomingAssetAmounts,
-    actualSpendAssetAmounts,
-    incomingAssets,
-    maxSpendAssetAmounts,
-    minIncomingAssetAmounts,
-    spendAssets,
-  });
-
-  const callArgs = callOnIntegrationArgs({
-    adapter: mockGenericAdapter,
-    encodedCallArgs: swapArgs,
-    selector,
-  });
-
-  const swapTx = comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-
-  await expect(swapTx).resolves.toBeReceipt();
-
-  return swapTx;
-}

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

@@ -1,71 +0,0 @@
-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,70 +0,0 @@
-import type { AddressLike } from '@enzymefinance/ethers';
-import type { SignerWithAddress } from '@enzymefinance/hardhat';
-import type {
-  ComptrollerLib,
-  IntegrationManager,
-  ParaSwapV4Adapter,
-  ParaSwapV4Path,
-  StandardToken,
-} from '@enzymefinance/protocol';
-import {
-  callOnIntegrationArgs,
-  IntegrationManagerActionId,
-  paraSwapV4TakeOrderArgs,
-  takeOrderSelector,
-} from '@enzymefinance/protocol';
-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, // 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({
-    expectedIncomingAssetAmount,
-    minIncomingAssetAmount,
-    outgoingAsset,
-    outgoingAssetAmount,
-    paths,
-  });
-
-  const callArgs = callOnIntegrationArgs({
-    adapter: paraSwapV4Adapter,
-    encodedCallArgs: takeOrderArgs,
-    selector: takeOrderSelector,
-  });
-
-  return comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}

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

@@ -1,73 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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,130 +0,0 @@
-import type { AddressLike } from '@enzymefinance/ethers';
-import type {
-  ComptrollerLib,
-  IntegrationManager,
-  ISynthetixAddressResolver,
-  StandardToken,
-  SynthetixAdapter,
-  VaultLib,
-} from '@enzymefinance/protocol';
-import {
-  callOnIntegrationArgs,
-  encodeArgs,
-  IntegrationManagerActionId,
-  redeemSelector,
-  synthetixAssignExchangeDelegateSelector,
-  synthetixRedeemArgs,
-  synthetixTakeOrderArgs,
-  takeOrderSelector,
-} from '@enzymefinance/protocol';
-import type { BigNumberish, Signer } from 'ethers';
-import { 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 synthetixRedeem({
-  comptrollerProxy,
-  integrationManager,
-  signer,
-  synthetixAdapter,
-  synths,
-}: {
-  comptrollerProxy: ComptrollerLib;
-  integrationManager: IntegrationManager;
-  signer: Signer;
-  synthetixAdapter: SynthetixAdapter;
-  synths: AddressLike[];
-}) {
-  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({
-  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,
-    minIncomingAssetAmount,
-    outgoingAsset,
-    outgoingAssetAmount,
-  });
-
-  const callArgs = await callOnIntegrationArgs({
-    adapter: synthetixAdapter,
-    encodedCallArgs: takeOrderArgs,
-    selector: takeOrderSelector,
-  });
-
-  return comptrollerProxy
-    .connect(fundOwner)
-    .callOnExtension(integrationManager, IntegrationManagerActionId.CallOnIntegration, callArgs);
-}