Create a Morpho Vault V2

Deploying a Morpho Vault V2 is a permissionless process that anyone can initiate. This guide covers three methods for deploying your vault, ranging from the simplest user-friendly interface to more advanced technical approaches.

This guide covers three methods for deploying your vault:

1. Using the Curator App (Recommended): The easiest and most user-friendly method with a graphical interface for vault creation and configuration.
2. Using a Deployment Script: A powerful and efficient method for developers, allowing you to create, configure, and assign roles for your vault in a single, automated process.
3. Using Etherscan: A manual approach suitable for those who prefer interacting directly with contracts on a block explorer.

Method 1: Create a Vault via the Curator App

The Curator App provides the easiest and most user-friendly way to deploy a Morpho Vault V2. This web-based interface guides you through the entire vault creation process without requiring any coding or command-line experience.

Curator App: https://curator.morpho.org/vaults

Why Use the Curator App?

• No Technical Knowledge Required: User-friendly graphical interface suitable for all experience levels.
• Guided Setup: Step-by-step wizard walks you through every configuration option.
• Instant Deployment: Deploy your vault directly from your browser using your connected wallet.
• Built-in Validation: Automatic validation of parameters to prevent common configuration mistakes.
• Visual Configuration: Easily configure roles, adapters, and risk parameters through intuitive forms.

Getting Started with the Curator App

Once deployed, you can continue managing your vault through the Curator App or use the advanced methods described below for programmatic management.

Method 2: Create and Configure a Vault via Script

For developers who prefer a code-based approach, you can use the official Morpho Vaults V2 deployment repository. This method allows you to bundle multiple setup actions into a single, automated script.

Repository: https://github.com/morpho-org/vault-v2-deployment

The Power of Scripted Deployment

The key advantage of using the deployment repository is automation and efficiency. The DeployVaultV2.s.sol script performs the entire initial configuration in one go, leveraging the fact that new vaults have a zero-second timelock by default.

The deployment script performs the following actions:

1. Vault Creation: Deploys a new VaultV2 instance using the VaultV2Factory.
2. Adapter Deployment: Deploys a MorphoVaultV1Adapter for the specified Vault V1.
3. Role Assignment: Configures temporary permissions during deployment, then assigns final Owner, Curator, Allocator, and optionally Sentinel roles.
4. Core Configuration:
   • Submits and executes timelocked configuration changes.
   • Enables the adapter on the vault.
   • Sets the adapter registry.
   • Configures the adapter as the liquidityAdapter.
   • Sets initial risk caps (absolute and relative).
5. Timelock Hardening: Optionally sets timelocks on critical functions to secure the vault for production use.
6. Dead Deposit: Optionally seeds the vault with initial liquidity to prevent inflation attacks.

Prerequisites

Before deploying, ensure you have:

• Foundry installed
• Git installed
• An Ethereum wallet with sufficient funds for deployment
• RPC URL for your target network

Running the Deployment Script

git clone https://github.com/morpho-org/vault-v2-deployment
cd vault-v2-deployment
git submodule update --init --recursive

# Role addresses (replace with your actual addresses)
OWNER=0x...                    # Final owner of the vault (ideally a multisig)
CURATOR=0x...                  # Curator address (ideally a multisig)
ALLOCATOR=0x...                # Allocator address
SENTINEL=0x...                 # Sentinel address (optional)
 
# Timelock duration (in seconds) - set to 0 for immediate execution
TIMELOCK_DURATION=1814400      # 21 days (optional, leave empty for 0)
 
# Deployed contract addresses (network-specific)
# See https://docs.morpho.org/get-started/resources/addresses/ for addresses
ADAPTER_REGISTRY=0x...         # Adapter Registry address
VAULT_V2_FACTORY=0x...         # VaultV2 Factory address
MORPHO_VAULT_V1_ADAPTER_FACTORY=0x...  # MorphoVaultV1 Adapter Factory address
 
# Target Vault V1
VAULT_V1=0x...                 # The Morpho Vault V1 address to use as liquidity market
 
# RPC and deployment settings
RPC_URL=https://...            # Your RPC endpoint
PRIVATE_KEY=0x...              # Your private key (keep secure!)
 
# Optional: For contract verification
ETHERSCAN_API_KEY=...          # Your Etherscan API key
DEAD_DEPOSIT_AMOUNT=...        # Optional initial deposit to prevent inflation attacks

# Without block explorer verification
forge script script/DeployVaultV2.s.sol \
  --rpc-url $RPC_URL \
  --private-key $PRIVATE_KEY \
  --broadcast

# With verification on Etherscan
forge script script/DeployVaultV2.s.sol \
  --rpc-url $RPC_URL \
  --private-key $PRIVATE_KEY \
  --broadcast \
  --etherscan-api-key $ETHERSCAN_API_KEY \
  --verify

Testing Before Mainnet Deployment

The repository includes testing tools to help you validate your deployment:

# Run all tests
forge test
 
# Test deployment on local Anvil network
./deploy_anvil.sh

Important: Always test your deployment configuration on a testnet before deploying to mainnet.

Understanding the Deployment Steps

The DeployVaultV2.s.sol script orchestrates a comprehensive deployment process. Here's what happens internally:

Phase 1: Deploy VaultV2 Instance

// Deploy VaultV2 using the factory for deterministic addresses
bytes32 uniqueSalt = keccak256(abi.encodePacked(block.timestamp + gasleft()));
VaultV2 deployedVaultV2 = VaultV2(
    VaultV2Factory(factoryAddress).createVaultV2(
        temporaryOwner,
        underlyingAsset,
        uniqueSalt
    )
);

Phase 2: Configure Temporary Permissions

// Set broadcaster as temporary curator for configuration
vault.setCurator(temporaryCurator);

Phase 3: Deploy and Configure Morpho Adapter

// Deploy MorphoVaultV1Adapter using the adapter factory
address morphoAdapter = MorphoVaultV1AdapterFactory(factoryAddress)
    .createMorphoVaultV1Adapter(vaultV2Address, vaultV1Address);

Phase 4: Submit Timelocked Configuration Changes

// Submit all configuration changes that will be timelocked
vault.submit(abi.encodeCall(vault.setIsAllocator, (allocator, true)));
vault.submit(abi.encodeCall(vault.setAdapterRegistry, (registry)));
vault.submit(abi.encodeCall(vault.setLiquidityAdapterAndData, (adapter, bytes(""))));
 
bytes memory adapterIdData = abi.encode("this", adapter);
vault.submit(abi.encodeCall(vault.addAdapter, (adapter)));
vault.submit(abi.encodeCall(vault.increaseAbsoluteCap, (adapterIdData, type(uint128).max)));
vault.submit(abi.encodeCall(vault.increaseRelativeCap, (adapterIdData, 1e18)));

Phase 5: Execute Immediate Configuration Changes

// Since timelock is 0 initially, execute configurations immediately
vault.setAdapterRegistry(registry);
vault.setIsAllocator(allocator, true);
vault.addAdapter(adapter);
vault.setLiquidityAdapterAndData(adapter, bytes(""));
 
bytes memory adapterIdData = abi.encode("this", adapter);
vault.increaseAbsoluteCap(adapterIdData, type(uint128).max);
vault.increaseRelativeCap(adapterIdData, 1e18);
 
// Abdicate setAdapterRegistry function to prevent future changes
vault.submit(abi.encodeCall(vault.abdicate, (IVaultV2.setAdapterRegistry.selector)));
vault.abdicate(IVaultV2.setAdapterRegistry.selector);

Phase 6: Configure Timelock Settings (Optional)

// Define critical functions that should be timelocked
bytes4[] memory timelockedSelectors = new bytes4[](10);
timelockedSelectors[0] = IVaultV2.setReceiveSharesGate.selector;
timelockedSelectors[1] = IVaultV2.setSendSharesGate.selector;
timelockedSelectors[2] = IVaultV2.setReceiveAssetsGate.selector;
// ... more critical functions
 
// Submit and execute timelock increases
for (uint256 i = 0; i < timelockedSelectors.length; i++) {
    vault.submit(abi.encodeCall(vault.increaseTimelock, (timelockedSelectors[i], timelockDuration)));
    vault.increaseTimelock(timelockedSelectors[i], timelockDuration);
}

Phase 7: Set Final Role Assignments

// Assign final roles to production addresses
vault.setCurator(vaultCurator);
 
if (vaultSentinel != address(0)) {
    vault.setIsSentinel(vaultSentinel, true);
}
 
vault.setOwner(vaultOwner);

Phase 8: Execute Dead Deposit (Optional)

// Seed vault with initial liquidity to prevent inflation attacks
if (depositAmount > 0) {
    IERC20(vault.asset()).approve(address(vault), depositAmount);
    vault.deposit(depositAmount, address(0xdead)); // Burned shares
}

For a detailed explanation of how to build your own deployment script, see the repository documentation.

Method 3: Create a Vault Manually via Etherscan

If you prefer a manual approach without using the Curator App or deployment scripts, you can deploy a vault directly by interacting with the contracts on a block explorer like Etherscan.

Prerequisites

• An Ethereum wallet (e.g., MetaMask) connected to the desired network.
• The address of the ERC-20 token the vault will use as its asset.
• The address you want to designate as the initial owner.

Step-by-Step Guide

Congratulations! Your vault is now deployed. For a production-ready setup, we strongly recommend using the deployment script method as it ensures all components are properly configured.