ERC-7540: Asynchronous Tokenized Vaults

// 1. User requests a deposit
vault.requestDeposit(1000e6, controller, owner); // locks 1000 USDC

// 2. Admin fulfills (off-chain: assets deployed to yield source)
vault._fulfillDeposit(1000e6, 950e18, controller); // 950 shares at the determined rate

// 3. User claims their shares
vault.deposit(1000e6, receiver, controller); // receiver gets 950 shares

// 1. User requests a redeem
vault.requestRedeem(950e18, controller, owner); // locks 950 shares

// 2. Admin fulfills (off-chain: positions unwound, assets bridged back)
vault._fulfillRedeem(950e18, 1010e6, controller); // 1010 USDC at the determined rate

// 3. User claims their assets
vault.redeem(950e18, receiver, controller); // receiver gets 1010 USDC

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.27;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ERC7540} from "@openzeppelin/community-contracts/token/ERC20/extensions/ERC7540.sol";
import {ERC7540AdminDeposit} from "@openzeppelin/community-contracts/token/ERC20/extensions/ERC7540AdminDeposit.sol";
import {ERC7540AdminRedeem} from "@openzeppelin/community-contracts/token/ERC20/extensions/ERC7540AdminRedeem.sol";

contract RWAVault is ERC7540AdminDeposit, ERC7540AdminRedeem, Ownable {
    constructor(
        IERC20 asset_
    ) ERC7540(asset_) Ownable(msg.sender) {}

    /// @dev Admin fulfills a deposit request with the determined exchange rate.
    function fulfillDeposit(uint256 assets, uint256 shares, address controller) external onlyOwner {
        _fulfillDeposit(assets, shares, controller);
    }

    /// @dev Admin fulfills a redeem request with the determined exchange rate.
    function fulfillRedeem(uint256 shares, uint256 assets, address controller) external onlyOwner {
        _fulfillRedeem(shares, assets, controller);
    }

    // Resolve multiple inheritance for _requestDeposit and _requestRedeem
    function _requestDeposit(
        uint256 assets, address controller, address owner, uint256 requestId
    ) internal override(ERC7540, ERC7540AdminDeposit) returns (uint256) {
        return super._requestDeposit(assets, controller, owner, requestId);
    }

    function _requestRedeem(
        uint256 shares, address controller, address owner, uint256 requestId
    ) internal override(ERC7540, ERC7540AdminRedeem) returns (uint256) {
        return super._requestRedeem(shares, controller, owner, requestId);
    }
}

// 1. User requests a deposit (delay = 1 hour by default)
uint256 requestId = vault.requestDeposit(1000e6, controller, owner);
// requestId = block.timestamp + 1 hours (the maturity timestamp)

// 2. Time passes... no transaction needed

// 3. After the delay, user claims (exchange rate computed now)
vault.deposit(1000e6, receiver, controller);

flowchart LR
    T100["<b>t=100</b><br/>request 500<br/>maturity=160"] --> T120["<b>t=120</b><br/>request 300<br/>maturity=180"] --> T160["<b>t=160</b><br/>500 claimable<br/>300 still pending"] --> T180["<b>t=180</b><br/>800 claimable<br/>(all matured)"]
    CP["<b>Checkpoints (cumulative)</b><br/>key=160 → value=500<br/>key=180 → value=800"]
    T120 -.-> CP

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.27;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ERC7540} from "@openzeppelin/community-contracts/token/ERC20/extensions/ERC7540.sol";
import {ERC7540DelayDeposit} from "@openzeppelin/community-contracts/token/ERC20/extensions/ERC7540DelayDeposit.sol";
import {ERC7540DelayRedeem} from "@openzeppelin/community-contracts/token/ERC20/extensions/ERC7540DelayRedeem.sol";

contract TimeLockVault is ERC7540DelayDeposit, ERC7540DelayRedeem {
    constructor(IERC20 asset_) ERC7540(asset_) {}

    /// @dev Custom deposit delay: 1 day.
    function depositDelay(address /*controller*/) public view override returns (uint48) {
        return 1 days;
    }

    /// @dev Custom redeem delay: 7 days (e.g. unbonding period).
    function redeemDelay(address /*controller*/) public view override returns (uint48) {
        return 7 days;
    }

    // Resolve multiple inheritance
    function clock() public view override(ERC7540DelayDeposit, ERC7540DelayRedeem) returns (uint48) {
        return super.clock();
    }

    function CLOCK_MODE() public view override(ERC7540DelayDeposit, ERC7540DelayRedeem) returns (string memory) {
        return super.CLOCK_MODE();
    }

    function _requestDeposit(
        uint256 assets, address controller, address owner, uint256 requestId
    ) internal override(ERC7540, ERC7540DelayDeposit) returns (uint256) {
        return super._requestDeposit(assets, controller, owner, requestId);
    }

    function _requestRedeem(
        uint256 shares, address controller, address owner, uint256 requestId
    ) internal override(ERC7540, ERC7540DelayRedeem) returns (uint256) {
        return super._requestRedeem(shares, controller, owner, requestId);
    }
}

// 1. User requests a deposit in the current epoch
uint256 epochId = vault.requestDeposit(1000e6, controller, owner);

// 2. Time passes (next week starts, or admin bumps the counter)

// 3. Admin fulfills the entire epoch with totalShares for the epoch's totalAssets
vault.fulfillDeposit(epochId, 950e18); // 1000 USDC pending -> 950 shares allocated

// 4. User claims their pro-rata share
vault.deposit(1000e6, receiver, controller); // receiver gets 950 shares

uint256 epochId = vault.requestRedeem(950e18, controller, owner);

// next epoch
vault.fulfillRedeem(epochId, 1010e6); // 950 shares -> 1010 USDC allocated

vault.redeem(950e18, receiver, controller); // receiver gets 1010 USDC

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.27;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ERC7540} from "@openzeppelin/community-contracts/token/ERC20/extensions/ERC7540.sol";
import {ERC7540EpochDeposit} from "@openzeppelin/community-contracts/token/ERC20/extensions/ERC7540EpochDeposit.sol";
import {ERC7540EpochRedeem} from "@openzeppelin/community-contracts/token/ERC20/extensions/ERC7540EpochRedeem.sol";

contract NAVVault is ERC7540EpochDeposit, ERC7540EpochRedeem, Ownable {
    constructor(IERC20 asset_) ERC7540(asset_) Ownable(msg.sender) {}

    /// @dev Admin closes a past deposit epoch with the determined total shares.
    function fulfillDeposit(uint256 epochId, uint256 totalShares) external onlyOwner {
        _fulfillDeposit(epochId, totalShares);
    }

    /// @dev Admin closes a past redeem epoch with the determined total assets.
    function fulfillRedeem(uint256 epochId, uint256 totalAssets) external onlyOwner {
        _fulfillRedeem(epochId, totalAssets);
    }

    // Resolve multiple inheritance
    function _requestDeposit(
        uint256 assets, address controller, address owner, uint256 requestId
    ) internal override(ERC7540, ERC7540EpochDeposit) returns (uint256) {
        return super._requestDeposit(assets, controller, owner, requestId);
    }

    function _requestRedeem(
        uint256 shares, address controller, address owner, uint256 requestId
    ) internal override(ERC7540, ERC7540EpochRedeem) returns (uint256) {
        return super._requestRedeem(shares, controller, owner, requestId);
    }

}

flowchart TD
    TA["<b>totalAssets()</b> = asset.balanceOf(vault) − _totalPendingDepositAssets"]
    TA --> TA1["<b>asset.balanceOf(vault)</b><br/>All assets in the vault,<br/>including pending ones"]
    TA --> TA2["<b>_totalPendingDepositAssets</b><br/>Assets received but not yet<br/>converted to shares.<br/>Must not inflate the perceived yield."]

    TS["<b>totalSupply()</b> = ERC20.totalSupply() + _totalPendingRedeemShares"]
    TS --> TS1["<b>ERC20.totalSupply()</b><br/>The on-chain ERC-20 supply"]
    TS --> TS2["<b>_totalPendingRedeemShares</b><br/>Shares already burned/escrowed<br/>but logically still outstanding<br/>(request not yet settled)"]