> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mellow.finance/llms.txt
> Use this file to discover all available pages before exploring further.

# Vault

## Overview

The `Vault` contract is the central entry point in the Flexible Vault system. It composes three foundational modules:

* `ACLModule`: Role-based access control.
* `ShareModule`: Management of user-facing shares, including deposit and redemption processes.
* `VaultModule`: Subvault management.

This contract allows secure, extensible, and upgradeable vault implementations by coordinating all external and internal interactions within the system. It is typically instantiated through `Factory` or `VaultConfigurator` and initialized with all the required components and role assignments in a single atomic transaction.

## Inheritance Structure

```solidity theme={null}
contract Vault is IFactoryEntity, VaultModule, ShareModule, ACLModule
```

The contract inherits three modules:

* `ACLModule`: Admin and permission management
* `ShareModule`: Deposits, redemptions, share management
* `VaultModule`: Subvault delegation control

It also implements the `IFactoryEntity` interface for standard factory-based deployment patterns.

## Constructor

```solidity theme={null}
constructor(
    string memory name_,
    uint256 version_,
    address depositQueueFactory_,
    address redeemQueueFactory_,
    address subvaultFactory_,
    address verifierFactory_
)
```

### Parameters:

* `name_`: Unique name identifier for the vault instance
* `version_`: Configuration version of the vault
* `depositQueueFactory_`: Address of the factory used to deploy deposit queues
* `redeemQueueFactory_`: Address of the factory used to deploy redemption queues
* `subvaultFactory_`: Address of the factory used to deploy subvaults
* `verifierFactory_`: Address of the factory for deploying verifier contracts

### Behavior:

Passes these arguments to the parent module constructors:

* `ACLModule(name_, version_)`
* `ShareModule(name_, version_, depositQueueFactory_, redeemQueueFactory_)`
* `VaultModule(name_, version_, subvaultFactory_, verifierFactory_)`

## Structs

### `RoleHolder`

```solidity theme={null}
struct RoleHolder {
    bytes32 role;
    address holder;
}
```

Used to batch-assign multiple roles during initialization. Each entry maps a role identifier to a designated address.

## External Functions

### `initialize`

```solidity theme={null}
function initialize(bytes calldata initParams) external initializer
```

Initializes the vault instance. Can only be called once due to the `initializer` modifier.

### `initParams` structure (ABI-encoded):

```solidity theme={null}
(
    address admin_,
    address shareManager_,
    address feeManager_,
    address riskManager_,
    address oracle_,
    address defaultDepositHook_,
    address defaultRedeemHook_,
    uint256 queueLimit_,
    RoleHolder[] roleHolders
)
```

### Initialization Logic:

* Calls `__ACLModule_init(admin_)` to configure the default admin.
* Calls `__ShareModule_init(...)` to link share management and hook modules.
* Calls `__VaultModule_init(riskManager_)` to initialize risk management.
* Iterates over `roleHolders` and grants each role using `_grantRole(...)`.
* Emits `Initialized(initParams)`.

## Design Notes

* **Modular Composition**: The vault is composed by inheriting three upgradeable modules, enabling reuse and flexible configuration.
* **Factory-Compatible**: The contract is factory-deployable and supports atomic configuration during creation.
* **Centralized Control Layer**: Acts as a trusted coordinator for hooks, queues, shares, and strategy logic.
* **Role Assignment**: Enables full delegation of operational control via batched `RoleHolder` entries.
* **Upgradeable and Isolated**: Each module manages its own storage via deterministic slots (`SlotLibrary`) to support safe upgrades.

## Events

### `Initialized(bytes data)`

Emitted after successful initialization. Includes all parameters passed for transparency.