@enzymefinance/testutils 3.0.0

package/dist/declarations/src/scaffolding/extensions/integrations/idle.d.ts

@@ -0,0 +1,57 @@
+import { AddressLike } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import { ComptrollerLib, IdleAdapter, IntegrationManager, StandardToken } from '@enzymefinance/protocol';
+import { BigNumberish } from 'ethers';
+export declare function idleApproveAssets({ comptrollerProxy, integrationManager, fundOwner, idleAdapter, idleToken, assets, amounts, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    idleAdapter: IdleAdapter;
+    idleToken: StandardToken;
+    assets: AddressLike[];
+    amounts: BigNumberish[];
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: import("ethers").BytesLike], void, ComptrollerLib>>>;
+export declare function idleClaimRewards({ comptrollerProxy, integrationManager, fundOwner, idleAdapter, idleToken, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    idleAdapter: IdleAdapter;
+    idleToken: StandardToken;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: import("ethers").BytesLike], void, ComptrollerLib>>>;
+export declare function idleClaimRewardsAndReinvest({ comptrollerProxy, integrationManager, fundOwner, idleAdapter, idleToken, minIncomingIdleTokenAmount, useFullBalances, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    idleAdapter: IdleAdapter;
+    idleToken: StandardToken;
+    minIncomingIdleTokenAmount?: BigNumberish;
+    useFullBalances: boolean;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: import("ethers").BytesLike], void, ComptrollerLib>>>;
+export declare function idleClaimRewardsAndSwap({ comptrollerProxy, integrationManager, fundOwner, idleAdapter, idleToken, incomingAsset, minIncomingAssetAmount, useFullBalances, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    idleAdapter: IdleAdapter;
+    idleToken: StandardToken;
+    incomingAsset: AddressLike;
+    minIncomingAssetAmount?: BigNumberish;
+    useFullBalances: boolean;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: import("ethers").BytesLike], void, ComptrollerLib>>>;
+export declare function idleLend({ comptrollerProxy, integrationManager, fundOwner, idleAdapter, idleToken, outgoingUnderlyingAmount, minIncomingIdleTokenAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    idleAdapter: IdleAdapter;
+    idleToken: StandardToken;
+    outgoingUnderlyingAmount: BigNumberish;
+    minIncomingIdleTokenAmount?: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: import("ethers").BytesLike], void, ComptrollerLib>>>;
+export declare function idleRedeem({ comptrollerProxy, integrationManager, fundOwner, idleAdapter, idleToken, outgoingIdleTokenAmount, minIncomingUnderlyingAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    idleAdapter: IdleAdapter;
+    idleToken: StandardToken;
+    outgoingIdleTokenAmount: BigNumberish;
+    minIncomingUnderlyingAmount?: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: import("ethers").BytesLike], void, ComptrollerLib>>>;

package/dist/declarations/src/scaffolding/extensions/integrations/index.d.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/dist/declarations/src/scaffolding/extensions/integrations/kyber.d.ts

@@ -0,0 +1,23 @@
+import { AddressLike, Call, Contract } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import { StandardToken, ComptrollerLib, IntegrationManager, KyberAdapter, VaultLib } from '@enzymefinance/protocol';
+import { BigNumber, BigNumberish, utils } from 'ethers';
+export interface KyberNetworkProxy extends Contract<KyberNetworkProxy> {
+    getExpectedRate: Call<(src: AddressLike, dest: AddressLike, srcQty: BigNumberish) => {
+        expectedRate: BigNumber;
+        worstRate: BigNumber;
+    }, KyberNetworkProxy>;
+}
+export declare const KyberNetworkProxy: import("@enzymefinance/ethers").ContractFactory<KyberNetworkProxy, never>;
+export declare function kyberTakeOrder({ comptrollerProxy, vaultProxy, integrationManager, fundOwner, kyberAdapter, outgoingAsset, outgoingAssetAmount, incomingAsset, minIncomingAssetAmount, seedFund, }: {
+    comptrollerProxy: ComptrollerLib;
+    vaultProxy: VaultLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    kyberAdapter: KyberAdapter;
+    outgoingAsset: StandardToken;
+    outgoingAssetAmount?: BigNumberish;
+    incomingAsset: StandardToken;
+    minIncomingAssetAmount?: BigNumberish;
+    seedFund?: boolean;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;

package/dist/declarations/src/scaffolding/extensions/integrations/mock.d.ts

@@ -0,0 +1,32 @@
+import { AddressLike } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import { ComptrollerLib, IntegrationManager, VaultLib, MockGenericAdapter, StandardToken } from '@enzymefinance/protocol';
+import { BigNumberish, BytesLike } from 'ethers';
+export declare const mockGenericRemoveOnlySelector: string;
+export declare const mockGenericSwapASelector: string;
+export declare const mockGenericSwapBSelector: string;
+export declare const mockGenericSwapDirectFromVaultSelector: string;
+export declare const mockGenericSwapViaApprovalSelector: string;
+export declare function mockGenericSwapArgs({ spendAssets, actualSpendAssetAmounts, maxSpendAssetAmounts, incomingAssets, actualIncomingAssetAmounts, minIncomingAssetAmounts, }: {
+    spendAssets?: AddressLike[];
+    maxSpendAssetAmounts?: BigNumberish[];
+    actualSpendAssetAmounts?: BigNumberish[];
+    incomingAssets?: AddressLike[];
+    minIncomingAssetAmounts?: BigNumberish[];
+    actualIncomingAssetAmounts?: BigNumberish[];
+}): string;
+export declare function mockGenericSwap({ comptrollerProxy, vaultProxy, integrationManager, fundOwner, mockGenericAdapter, selector, spendAssets, actualSpendAssetAmounts, maxSpendAssetAmounts, incomingAssets, actualIncomingAssetAmounts, minIncomingAssetAmounts, seedFund, }: {
+    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;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: BytesLike], void, ComptrollerLib>>>;

package/dist/declarations/src/scaffolding/extensions/integrations/paraSwapV4.d.ts

@@ -0,0 +1,22 @@
+import { AddressLike } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import { ComptrollerLib, IntegrationManager, ParaSwapV4Adapter, ParaSwapV4Path, StandardToken } from '@enzymefinance/protocol';
+import { BigNumberish, utils } from 'ethers';
+export declare function paraSwapV4GenerateDummyPaths({ toTokens }: {
+    toTokens: AddressLike[];
+}): {
+    to: AddressLike;
+    totalNetworkFee: number;
+    routes: never[];
+}[];
+export declare function paraSwapV4TakeOrder({ comptrollerProxy, integrationManager, fundOwner, paraSwapV4Adapter, outgoingAsset, outgoingAssetAmount, minIncomingAssetAmount, expectedIncomingAssetAmount, paths, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    paraSwapV4Adapter: ParaSwapV4Adapter;
+    outgoingAsset: StandardToken;
+    outgoingAssetAmount?: BigNumberish;
+    minIncomingAssetAmount?: BigNumberish;
+    expectedIncomingAssetAmount?: BigNumberish;
+    paths: ParaSwapV4Path[];
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;

package/dist/declarations/src/scaffolding/extensions/integrations/synthetix.d.ts

@@ -0,0 +1,25 @@
+import { AddressLike } from '@enzymefinance/ethers';
+import { ComptrollerLib, IntegrationManager, ISynthetixAddressResolver, StandardToken, SynthetixAdapter, VaultLib } from '@enzymefinance/protocol';
+import { BigNumberish, Signer, utils } from 'ethers';
+export declare function synthetixAssignExchangeDelegate({ comptrollerProxy, addressResolver, fundOwner, delegate, }: {
+    comptrollerProxy: ComptrollerLib;
+    addressResolver: ISynthetixAddressResolver;
+    fundOwner: Signer;
+    delegate: AddressLike;
+}): Promise<void>;
+export declare function synthetixResolveAddress({ addressResolver, name, }: {
+    addressResolver: ISynthetixAddressResolver;
+    name: string;
+}): Promise<string>;
+export declare function synthetixTakeOrder({ comptrollerProxy, vaultProxy, integrationManager, fundOwner, synthetixAdapter, outgoingAsset, outgoingAssetAmount, incomingAsset, minIncomingAssetAmount, seedFund, }: {
+    comptrollerProxy: ComptrollerLib;
+    vaultProxy: VaultLib;
+    integrationManager: IntegrationManager;
+    fundOwner: Signer;
+    synthetixAdapter: SynthetixAdapter;
+    outgoingAsset: StandardToken;
+    outgoingAssetAmount?: BigNumberish;
+    incomingAsset: StandardToken;
+    minIncomingAssetAmount?: BigNumberish;
+    seedFund?: boolean;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: utils.BytesLike], void, ComptrollerLib>>>;

package/dist/declarations/src/scaffolding/extensions/integrations/trackedAssets.d.ts

@@ -0,0 +1,17 @@
+import { AddressLike } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import { ComptrollerLib, IntegrationManager, TrackedAssetsAdapter } from '@enzymefinance/protocol';
+export declare function addTrackedAssets({ comptrollerProxy, integrationManager, fundOwner, trackedAssetsAdapter, incomingAssets, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    trackedAssetsAdapter: TrackedAssetsAdapter;
+    incomingAssets: AddressLike[];
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: import("ethers").BigNumberish, _callArgs: import("ethers").BytesLike], void, ComptrollerLib>>>;
+export declare function removeTrackedAssets({ comptrollerProxy, integrationManager, fundOwner, trackedAssetsAdapter, spendAssets, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    trackedAssetsAdapter: TrackedAssetsAdapter;
+    spendAssets: AddressLike[];
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: import("ethers").BigNumberish, _callArgs: import("ethers").BytesLike], void, ComptrollerLib>>>;

package/dist/declarations/src/scaffolding/extensions/integrations/uniswapV2.d.ts

@@ -0,0 +1,46 @@
+import { AddressLike, Call, Contract, Send } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import { ComptrollerLib, IntegrationManager, StandardToken, UniswapV2Adapter, 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 declare const UniswapV2Factory: import("@enzymefinance/ethers").ContractFactory<UniswapV2Factory, never>;
+export declare function uniswapV2Lend({ comptrollerProxy, vaultProxy, integrationManager, fundOwner, uniswapV2Adapter, tokenA, tokenB, amountADesired, amountBDesired, amountAMin, amountBMin, minPoolTokenAmount, seedFund, }: {
+    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;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: import("ethers").BytesLike], void, ComptrollerLib>>>;
+export declare 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;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: import("ethers").BytesLike], void, ComptrollerLib>>>;
+export declare function uniswapV2TakeOrder({ comptrollerProxy, vaultProxy, integrationManager, fundOwner, uniswapV2Adapter, path, outgoingAssetAmount, minIncomingAssetAmount, seedFund, }: {
+    comptrollerProxy: ComptrollerLib;
+    vaultProxy: VaultLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    uniswapV2Adapter: UniswapV2Adapter;
+    path: StandardToken[];
+    outgoingAssetAmount: BigNumberish;
+    minIncomingAssetAmount: BigNumberish;
+    seedFund?: boolean;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: import("ethers").BytesLike], void, ComptrollerLib>>>;

package/dist/declarations/src/scaffolding/extensions/integrations/uniswapV3.d.ts

@@ -0,0 +1,15 @@
+import { AddressLike } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import { ComptrollerLib, IntegrationManager, StandardToken } from '@enzymefinance/protocol';
+import { BigNumber, BigNumberish } from 'ethers';
+export declare function uniswapV3TakeOrder({ comptrollerProxy, integrationManager, fundOwner, uniswapV3Adapter, pathAddresses, pathFees, outgoingAssetAmount, minIncomingAssetAmount, seedFund, }: {
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    uniswapV3Adapter: AddressLike;
+    pathAddresses: StandardToken[];
+    pathFees: BigNumber[];
+    outgoingAssetAmount: BigNumberish;
+    minIncomingAssetAmount?: BigNumberish;
+    seedFund?: boolean;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: AddressLike, _actionId: BigNumberish, _callArgs: import("ethers").BytesLike], void, ComptrollerLib>>>;

package/dist/declarations/src/scaffolding/extensions/integrations/yearn.d.ts

@@ -0,0 +1,22 @@
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import { ComptrollerLib, IntegrationManager, StandardToken, YearnVaultV2Adapter } from '@enzymefinance/protocol';
+import { BigNumberish } from 'ethers';
+export declare function yearnVaultV2Lend({ signer, comptrollerProxy, integrationManager, yearnVaultV2Adapter, yVault, outgoingUnderlyingAmount, minIncomingYVaultSharesAmount, }: {
+    signer: SignerWithAddress;
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    yearnVaultV2Adapter: YearnVaultV2Adapter;
+    yVault: StandardToken;
+    outgoingUnderlyingAmount: BigNumberish;
+    minIncomingYVaultSharesAmount?: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: import("@enzymefinance/ethers").AddressLike, _actionId: BigNumberish, _callArgs: import("ethers").BytesLike], void, ComptrollerLib>>>;
+export declare function yearnVaultV2Redeem({ signer, comptrollerProxy, integrationManager, yearnVaultV2Adapter, yVault, maxOutgoingYVaultSharesAmount, minIncomingUnderlyingAmount, slippageToleranceBps, }: {
+    signer: SignerWithAddress;
+    comptrollerProxy: ComptrollerLib;
+    integrationManager: IntegrationManager;
+    yearnVaultV2Adapter: YearnVaultV2Adapter;
+    yVault: StandardToken;
+    maxOutgoingYVaultSharesAmount: BigNumberish;
+    minIncomingUnderlyingAmount?: BigNumberish;
+    slippageToleranceBps?: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: import("@enzymefinance/ethers").AddressLike, _actionId: BigNumberish, _callArgs: import("ethers").BytesLike], void, ComptrollerLib>>>;

package/dist/declarations/src/scaffolding/extensions/integrations/zeroExV2.d.ts

@@ -0,0 +1,12 @@
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import { ComptrollerLib, IntegrationManager, ZeroExV2Adapter, VaultLib, SignedZeroExV2Order } from '@enzymefinance/protocol';
+import { BigNumberish } from 'ethers';
+export declare function zeroExV2TakeOrder({ comptrollerProxy, integrationManager, fundOwner, zeroExV2Adapter, signedOrder, takerAssetFillAmount, }: {
+    comptrollerProxy: ComptrollerLib;
+    vaultProxy: VaultLib;
+    integrationManager: IntegrationManager;
+    fundOwner: SignerWithAddress;
+    zeroExV2Adapter: ZeroExV2Adapter;
+    signedOrder: SignedZeroExV2Order;
+    takerAssetFillAmount: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_extension: import("@enzymefinance/ethers").AddressLike, _actionId: BigNumberish, _callArgs: import("ethers").BytesLike], void, ComptrollerLib>>>;

package/dist/declarations/src/scaffolding/extensions/policies.d.ts

@@ -0,0 +1,15 @@
+import { IPolicy, PolicyManager } from '@enzymefinance/protocol';
+import { Signer } from 'ethers';
+export declare function generatePolicyManagerConfigWithMockPolicies({ deployer, policyManager, }: {
+    deployer: Signer;
+    policyManager: PolicyManager;
+}): Promise<string>;
+export declare function generateRegisteredMockPolicies({ deployer, policyManager, }: {
+    deployer: Signer;
+    policyManager: PolicyManager;
+}): Promise<{
+    mockPreBuySharesPolicy: import("@enzymefinance/ethers").MockContract<IPolicy>;
+    mockPostBuySharesPolicy: import("@enzymefinance/ethers").MockContract<IPolicy>;
+    mockPreCoIPolicy: import("@enzymefinance/ethers").MockContract<IPolicy>;
+    mockPostCoIPolicy: import("@enzymefinance/ethers").MockContract<IPolicy>;
+}>;

package/dist/declarations/src/scaffolding/index.d.ts

@@ -0,0 +1,9 @@
+export * from './assets';
+export * from './chainlink';
+export * from './common';
+export * from './core';
+export * from './extensions';
+export * from './peripheral';
+export * from './setup';
+export * from './shares';
+export * from './vaultCalls';

package/dist/declarations/src/scaffolding/peripheral/index.d.ts

@@ -0,0 +1 @@
+export * from './sharesRequestors';

package/dist/declarations/src/scaffolding/peripheral/sharesRequestors.d.ts

@@ -0,0 +1,19 @@
+import { AddressLike } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import { AuthUserExecutedSharesRequestorFactory, AuthUserExecutedSharesRequestorLib, StandardToken } from '@enzymefinance/protocol';
+import { BigNumberish } from 'ethers';
+export declare function createAuthUserExecutedSharesRequestorProxy({ signer, authUserExecutedSharesRequestorFactory, comptrollerProxy, }: {
+    signer: SignerWithAddress;
+    authUserExecutedSharesRequestorFactory: AuthUserExecutedSharesRequestorFactory;
+    comptrollerProxy: AddressLike;
+}): Promise<{
+    authUserExecutedSharesRequestorProxy: AuthUserExecutedSharesRequestorLib;
+    receipt: import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_comptrollerProxy: AddressLike], string, AuthUserExecutedSharesRequestorFactory>>;
+}>;
+export declare function createAuthUserExecutedSharesRequest({ buyer, authUserExecutedSharesRequestorProxy, denominationAsset, investmentAmount, minSharesQuantity, }: {
+    buyer: SignerWithAddress;
+    authUserExecutedSharesRequestorProxy: AuthUserExecutedSharesRequestorLib;
+    denominationAsset: StandardToken;
+    investmentAmount?: BigNumberish;
+    minSharesQuantity?: BigNumberish;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_investmentAmount: BigNumberish, _minSharesQuantity: BigNumberish], void, AuthUserExecutedSharesRequestorLib>>>;

package/dist/declarations/src/scaffolding/setup.d.ts

@@ -0,0 +1,46 @@
+import { AddressLike } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import { ComptrollerLib, ComptrollerProxy, FundDeployer, VaultLib } from '@enzymefinance/protocol';
+import { BigNumberish, BytesLike } from 'ethers';
+import { BuySharesParams, DenominationAssetInterface } from './shares';
+export declare type InitialInvestmentParams = Omit<BuySharesParams, 'comptrollerProxy' | 'denominationAsset'>;
+export interface CreateMigratedFundConfigParams {
+    signer: SignerWithAddress;
+    fundDeployer: FundDeployer;
+    denominationAsset: DenominationAssetInterface;
+    sharesActionTimelock?: BigNumberish;
+    feeManagerConfigData?: BytesLike;
+    policyManagerConfigData?: BytesLike;
+}
+export interface CreateNewFundParams {
+    signer: SignerWithAddress;
+    fundDeployer: FundDeployer;
+    denominationAsset: DenominationAssetInterface;
+    sharesActionTimelock?: BigNumberish;
+    fundOwner?: AddressLike;
+    fundName?: string;
+    feeManagerConfig?: BytesLike;
+    policyManagerConfig?: BytesLike;
+    investment?: InitialInvestmentParams;
+}
+export declare function createComptrollerProxy({ signer, comptrollerLib, denominationAsset, sharesActionTimelock, }: {
+    signer: SignerWithAddress;
+    comptrollerLib: ComptrollerLib;
+    denominationAsset: AddressLike;
+    sharesActionTimelock?: BigNumberish;
+}): Promise<{
+    comptrollerProxy: ComptrollerLib;
+    receipt: import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").ConstructorFunction<any, ComptrollerProxy>>;
+}>;
+export declare function createMigratedFundConfig({ signer, fundDeployer, denominationAsset, sharesActionTimelock, feeManagerConfigData, policyManagerConfigData, }: CreateMigratedFundConfigParams): Promise<{
+    receipt: import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_denominationAsset: AddressLike, _sharesActionTimelock: BigNumberish, _feeManagerConfigData: BytesLike, _policyManagerConfigData: BytesLike], string, FundDeployer>>;
+    comptrollerProxy: ComptrollerLib;
+}>;
+export declare function createNewFund({ signer, fundDeployer, denominationAsset, sharesActionTimelock, fundOwner, fundName, feeManagerConfig, policyManagerConfig, investment, }: CreateNewFundParams): Promise<{
+    comptrollerProxy: ComptrollerLib;
+    receipt: import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_fundOwner: AddressLike, _fundName: string, _denominationAsset: AddressLike, _sharesActionTimelock: BigNumberish, _feeManagerConfigData: BytesLike, _policyManagerConfigData: BytesLike], {
+        comptrollerProxy_: string;
+        vaultProxy_: string;
+    }, FundDeployer>>;
+    vaultProxy: VaultLib;
+}>;

package/dist/declarations/src/scaffolding/shares.d.ts

@@ -0,0 +1,30 @@
+import { AddressLike, Contract, Send } from '@enzymefinance/ethers';
+import { SignerWithAddress } from '@enzymefinance/hardhat';
+import { ComptrollerLib } from '@enzymefinance/protocol';
+import { BigNumber, BigNumberish } from 'ethers';
+export interface DenominationAssetInterface extends Contract<any> {
+    approve: Send<(spender: AddressLike, amount: BigNumberish) => boolean, any>;
+}
+export interface BuySharesParams {
+    comptrollerProxy: ComptrollerLib;
+    signer: SignerWithAddress;
+    buyers: AddressLike[];
+    denominationAsset: DenominationAssetInterface;
+    investmentAmounts?: BigNumberish[];
+    minSharesAmounts?: BigNumberish[];
+}
+export interface RedeemSharesParams {
+    comptrollerProxy: ComptrollerLib;
+    signer: SignerWithAddress;
+    quantity?: BigNumberish;
+    additionalAssets?: AddressLike[];
+    assetsToSkip?: AddressLike[];
+}
+export declare function buyShares({ comptrollerProxy, signer, buyers, denominationAsset, investmentAmounts, minSharesAmounts, }: BuySharesParams): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_buyers: AddressLike[], _investmentAmounts: BigNumberish[], _minSharesQuantities: BigNumberish[]], BigNumber[], ComptrollerLib>>>;
+export declare function redeemShares({ comptrollerProxy, signer, quantity, additionalAssets, assetsToSkip, }: RedeemSharesParams): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[], {
+    payoutAssets_: string[];
+    payoutAmounts_: BigNumber[];
+}, ComptrollerLib>> | import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_sharesQuantity: BigNumberish, _additionalAssets: AddressLike[], _assetsToSkip: AddressLike[]], {
+    payoutAssets_: string[];
+    payoutAmounts_: BigNumber[];
+}, ComptrollerLib>>>;

package/dist/declarations/src/scaffolding/vaultCalls.d.ts

@@ -0,0 +1,17 @@
+import { AddressLike } from '@enzymefinance/ethers';
+import { ComptrollerLib } from '@enzymefinance/protocol';
+export declare function vaultCallCurveMinterMint({ comptrollerProxy, minter, gauge, }: {
+    comptrollerProxy: ComptrollerLib;
+    minter: AddressLike;
+    gauge: AddressLike;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_contract: AddressLike, _selector: import("ethers").BytesLike, _encodedArgs: import("ethers").BytesLike], void, ComptrollerLib>>>;
+export declare function vaultCallCurveMinterMintMany({ comptrollerProxy, minter, gauges, }: {
+    comptrollerProxy: ComptrollerLib;
+    minter: AddressLike;
+    gauges: AddressLike[];
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_contract: AddressLike, _selector: import("ethers").BytesLike, _encodedArgs: import("ethers").BytesLike], void, ComptrollerLib>>>;
+export declare function vaultCallCurveMinterToggleApproveMint({ comptrollerProxy, minter, account, }: {
+    comptrollerProxy: ComptrollerLib;
+    minter: AddressLike;
+    account: AddressLike;
+}): Promise<import("@enzymefinance/ethers").ContractReceipt<import("@enzymefinance/ethers").SendFunction<[_contract: AddressLike, _selector: import("ethers").BytesLike, _encodedArgs: import("ethers").BytesLike], void, ComptrollerLib>>>;