Deposit to ERC4626 Vaults

core/contracts/Acre.sol

@@ -2,6 +2,9 @@
 pragma solidity ^0.8.21;
 
 import "@openzeppelin/contracts/token/ERC20/extensions/ERC4626.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+import "./Dispatcher.sol";
 
 /// @title Acre
 /// @notice This contract implements the ERC-4626 tokenized vault standard. By
@@ -14,12 +17,20 @@ import "@openzeppelin/contracts/token/ERC20/extensions/ERC4626.sol";
 ///      of yield-bearing vaults. This contract facilitates the minting and
 ///      burning of shares (stBTC), which are represented as standard ERC20
 ///      tokens, providing a seamless exchange with tBTC tokens.
-contract Acre is ERC4626 {
+contract Acre is ERC4626, Ownable {
+    using SafeERC20 for IERC20;
+
+    Dispatcher public dispatcher;
+
     event StakeReferral(bytes32 indexed referral, uint256 assets);
 
+    error ZeroAddress();
+    error DispatcherNotSet();
+    error ApproveFailed();
+
     constructor(
         IERC20 tbtc
-    ) ERC4626(tbtc) ERC20("Acre Staked Bitcoin", "stBTC") {}
+    ) ERC4626(tbtc) ERC20("Acre Staked Bitcoin", "stBTC") Ownable(msg.sender) {}
 
     /// @notice Stakes a given amount of tBTC token and mints shares to a
     ///         receiver.
@@ -43,4 +54,33 @@ contract Acre is ERC4626 {
 
         return shares;
     }
+
+    /// @notice Updates the dispatcher contract and gives it an unlimited
+    ///         allowance to transfer staked tBTC.
+    /// @param _dispatcher Address of the new dispatcher contract.
+    function updateDispatcher(Dispatcher _dispatcher) external onlyOwner {
+        if (address(_dispatcher) == address(0)) {
+            revert ZeroAddress();
+        }
+
+        address oldDispatcher = address(dispatcher);
+        dispatcher = _dispatcher;
+
+        if (oldDispatcher != address(0)) {
+            // Setting allowance to zero for the old dispatcher
+            bool approvedToZero = IERC20(asset()).approve(oldDispatcher, 0);
+            if (!approvedToZero) {
+                revert ApproveFailed();
+            }
+        }
+
+        // Setting allowance to max for the new dispatcher
+        bool approvedToMax = IERC20(asset()).approve(
+            address(dispatcher),
+            type(uint256).max
+        );
+        if (!approvedToMax) {
+            revert ApproveFailed();
+        }
+    }
 }

core/contracts/Dispatcher.sol

@@ -2,19 +2,27 @@
 pragma solidity ^0.8.21;
 
 import "@openzeppelin/contracts/access/Ownable.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "@openzeppelin/contracts/interfaces/IERC4626.sol";
+import "./Router.sol";
+import "./Acre.sol";
 
 /// @title Dispatcher
-/// @notice Dispatcher is a contract that routes TBTC from stBTC (Acre) to
+/// @notice Dispatcher is a contract that routes tBTC from Acre (stBTC) to
 ///         a given vault and back. Vaults supply yield strategies with TBTC that
 ///         generate yield for Bitcoin holders.
-contract Dispatcher is Ownable {
-    error VaultAlreadyAuthorized();
-    error VaultUnauthorized();
+contract Dispatcher is Router, Ownable {
+    using SafeERC20 for IERC20;
 
     struct VaultInfo {
         bool authorized;
     }
 
+    Acre public immutable acre; // Depositing tBTC into Acre returns stBTC.
+    IERC20 public immutable tBTC;
+
+    address public maintainer;
+
     /// @notice Authorized Yield Vaults that implement ERC4626 standard. These
     ///         vaults deposit assets to yield strategies, e.g. Uniswap V3
     ///         WBTC/TBTC pool. Vault can be a part of Acre ecosystem or can be
@@ -26,8 +34,29 @@ contract Dispatcher is Ownable {
 
     event VaultAuthorized(address indexed vault);
     event VaultDeauthorized(address indexed vault);
+    event DepositAllocated(
+        address indexed vault,
+        uint256 amount,
+        uint256 minSharesOut
+    );
+    event MaintainerUpdated(address indexed maintainer);
+
+    error VaultAlreadyAuthorized();
+    error VaultUnauthorized();
+    error CallerUnauthorized(string reason);
+    error ZeroAddress();
+
+    modifier onlyMaintainer() {
+        if (msg.sender != maintainer) {
+            revert CallerUnauthorized("Maintainer only");
+        }
+        _;
+    }
 
-    constructor() Ownable(msg.sender) {}
+    constructor(Acre _acre, IERC20 _tBTC) Ownable(msg.sender) {
+        acre = _acre;
+        tBTC = _tBTC;
+    }
 
     /// @notice Adds a vault to the list of authorized vaults.
     /// @param vault Address of the vault to add.
@@ -63,7 +92,46 @@ contract Dispatcher is Ownable {
         emit VaultDeauthorized(vault);
     }
 
+    /// TODO: make this function internal once the allocation distribution is
+    /// implemented
+    /// @notice Routes tBTC from Acre to a vault. Can be called by the maintainer
+    ///         only.
+    /// @param vault Address of the vault to route the assets to.
+    /// @param amount Amount of tBTC to deposit.
+    /// @param minSharesOut Minimum amount of shares to receive by Acre.
+    function depositToVault(
+        address vault,
+        uint256 amount,
+        uint256 minSharesOut
+    ) public onlyMaintainer {
+        if (!vaultsInfo[vault].authorized) {
+            revert VaultUnauthorized();
+        }
+        emit DepositAllocated(vault, amount, minSharesOut);
+
+        // slither-disable-next-line arbitrary-send-erc20
+        tBTC.safeTransferFrom(address(acre), address(this), amount);
+        tBTC.safeIncreaseAllowance(address(vault), amount);
+
+        deposit(IERC4626(vault), address(acre), amount, minSharesOut);
+    }
+
+    /// @notice Updates the maintainer address.
+    /// @param _maintainer Address of the new maintainer.
+    function updateMaintainer(address _maintainer) external onlyOwner {
+        if (_maintainer == address(0)) {
+            revert ZeroAddress();
+        }
+
+        maintainer = _maintainer;
+
+        emit MaintainerUpdated(maintainer);
+    }
+
+    /// @notice Returns the list of authorized vaults.
     function getVaults() external view returns (address[] memory) {
         return vaults;
     }
+
+    /// TODO: implement redeem() / withdraw() functions
 }

core/contracts/Router.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.21;
+
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "@openzeppelin/contracts/interfaces/IERC20.sol";
+import "@openzeppelin/contracts/interfaces/IERC4626.sol";
+
+/// @title Router
+/// @notice Router is a contract that routes tBTC from stBTC (Acre) to
+///         a given vault and back. Vaults supply yield strategies with tBTC that
+///         generate yield for Bitcoin holders.
+abstract contract Router {
+    using SafeERC20 for IERC20;
+
+    /// @notice thrown when amount of shares received is below the min set by caller
+    error MinSharesError();
+
+    /// @notice Routes funds from stBTC (Acre) to a vault. The amount of tBTC to
+    ///         Shares of deposited tBTC are minted to the stBTC contract.
+    /// @param vault Address of the vault to route the funds to.
+    /// @param receiver Address of the receiver of the shares.
+    /// @param amount Amount of tBTC to deposit.
+    /// @param minSharesOut Minimum amount of shares to receive.
+    function deposit(
+        IERC4626 vault,
+        address receiver,
+        uint256 amount,
+        uint256 minSharesOut
+    ) internal returns (uint256 sharesOut) {
+        if ((sharesOut = vault.deposit(amount, receiver)) < minSharesOut) {
+            revert MinSharesError();
+        }
+    }
+}

core/contracts/test/TestERC4626.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.21;
+
+import "@openzeppelin/contracts/token/ERC20/extensions/ERC4626.sol";
+
+contract TestERC4626 is ERC4626 {
+    constructor(
+        IERC20 asset,
+        string memory tokenName,
+        string memory tokenSymbol
+    ) ERC4626(asset) ERC20(tokenName, tokenSymbol) {}
+}

core/deploy/00_resolve_testing_erc4626.ts

@@ -0,0 +1,31 @@
+import type { HardhatRuntimeEnvironment } from "hardhat/types"
+import type { DeployFunction } from "hardhat-deploy/types"
+
+const func: DeployFunction = async (hre: HardhatRuntimeEnvironment) => {
+  const { getNamedAccounts, deployments } = hre
+  const { log } = deployments
+  const { deployer } = await getNamedAccounts()
+
+  const tBTC = await deployments.get("TBTC")
+
+  if (hre.network.tags.allowStubs) {
+    log("deploying Mock ERC4626 Vault")
+
+    await deployments.deploy("Vault", {
+      contract: "TestERC4626",
+      from: deployer,
+      args: [tBTC.address, "MockVault", "MV"],
+      log: true,
+      waitConfirmations: 1,
+    })
+  }
+}
+
+export default func
+
+func.tags = ["TestERC4626"]
+func.dependencies = ["TBTC"]
+
+if (hre.network.name === "mainnet") {
+  func.skip = async () => true
+}

core/deploy/02_deploy_acre_router.ts → core/deploy/02_deploy_dispatcher.ts

@@ -5,9 +5,12 @@ const func: DeployFunction = async (hre: HardhatRuntimeEnvironment) => {
   const { getNamedAccounts, deployments } = hre
   const { deployer } = await getNamedAccounts()
 
+  const tbtc = await deployments.get("TBTC")
+  const acre = await deployments.get("Acre")
+
   await deployments.deploy("Dispatcher", {
     from: deployer,
-    args: [],
+    args: [acre.address, tbtc.address],
     log: true,
     waitConfirmations: 1,
   })

core/deploy/11_acre_update_dispatcher.ts

@@ -0,0 +1,21 @@
+import type { HardhatRuntimeEnvironment } from "hardhat/types"
+import type { DeployFunction } from "hardhat-deploy/types"
+
+const func: DeployFunction = async (hre: HardhatRuntimeEnvironment) => {
+  const { getNamedAccounts, deployments } = hre
+  const { deployer } = await getNamedAccounts()
+
+  const dispatcher = await deployments.get("Dispatcher")
+
+  await deployments.execute(
+    "Acre",
+    { from: deployer, log: true, waitConfirmations: 1 },
+    "updateDispatcher",
+    dispatcher.address,
+  )
+}
+
+export default func
+
+func.tags = ["AcreUpdateDispatcher"]
+func.dependencies = ["Acre", "Dispatcher"]

core/deploy/12_dispatcher_update_maintainer.ts

@@ -0,0 +1,19 @@
+import type { HardhatRuntimeEnvironment } from "hardhat/types"
+import type { DeployFunction } from "hardhat-deploy/types"
+
+const func: DeployFunction = async (hre: HardhatRuntimeEnvironment) => {
+  const { getNamedAccounts, deployments } = hre
+  const { deployer, maintainer } = await getNamedAccounts()
+
+  await deployments.execute(
+    "Dispatcher",
+    { from: deployer, log: true, waitConfirmations: 1 },
+    "updateMaintainer",
+    maintainer,
+  )
+}
+
+export default func
+
+func.tags = ["DispatcherUpdateMaintainer"]
+func.dependencies = ["Dispatcher"]

core/deploy/21_transfer_ownership_acre.ts

@@ -19,5 +19,3 @@ const func: DeployFunction = async (hre: HardhatRuntimeEnvironment) => {
 export default func
 
 func.tags = ["TransferOwnershipAcre"]
-// TODO: Enable once Acre extends Ownable
-func.skip = async () => true

core/hardhat.config.ts

@@ -67,8 +67,13 @@ const config: HardhatUserConfig = {
     },
     governance: {
       default: 2,
-      sepolia: 0,
-      mainnet: "",
+      sepolia: 0, // TODO: updated to the actual address once available
+      mainnet: "", // TODO: updated to the actual address once available
+    },
+    maintainer: {
+      default: 3,
+      sepolia: 0, // TODO: updated to the actual address once available
+      mainnet: "", // TODO: updated to the actual address once available
     },
   },