feat: converting the ERC20 and ERC4626 into OApps (#1568)

Signed-off-by: shankar <shankar@layerzerolabs.org>

Author: shankars99

packages/ovault-composer/contracts/ERC20MintBurn.sol

@@ -10,6 +10,8 @@ contract ERC20MintBurn is IERC20MintBurnExtension, ERC20, Ownable {
     mapping(address => uint256) public approvedBurners;
     address public approvedSpender;
 
+    bool public constant ERC4626AdapterCompliant = true;
+
     constructor(string memory _name, string memory _symbol) ERC20(_name, _symbol) Ownable(msg.sender) {}
 
     function setMinter(address _minter, uint256 _amount) external onlyOwner {

packages/ovault-composer/contracts/OFTMintBurn.sol

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity >=0.8.0;
+
+import { OFT } from "@layerzerolabs/oft-evm/contracts/OFT.sol";
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+import { IERC20MintBurnExtension } from "./interfaces/IERC20MintBurnExtension.sol";
+
+contract OFTMintBurn is OFT, IERC20MintBurnExtension {
+    mapping(address => uint256) public approvedMinters;
+    mapping(address => uint256) public approvedBurners;
+    address public approvedSpender;
+
+    bool public constant ERC4626AdapterCompliant = true;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _lzEndpoint,
+        address _delegate
+    ) OFT(_name, _symbol, _lzEndpoint, _delegate) Ownable(_delegate) {}
+
+    function setMinter(address _minter, uint256 _amount) external onlyOwner {
+        approvedMinters[_minter] = _amount;
+        emit MinterSet(_minter, _amount);
+    }
+
+    function setBurner(address _burner, uint256 _amount) external onlyOwner {
+        approvedBurners[_burner] = _amount;
+        emit BurnerSet(_burner, _amount);
+    }
+
+    function setSpender(address _spender) external onlyOwner {
+        approvedSpender = _spender;
+        emit SpenderSet(_spender);
+    }
+
+    function mint(address _to, uint256 _amount) external {
+        require(approvedMinters[msg.sender] >= _amount, "ERC20MintBurn: minter not approved");
+        _mint(_to, _amount);
+    }
+
+    function burn(address _from, uint256 _amount) external {
+        require(approvedBurners[msg.sender] >= _amount, "ERC20MintBurn: burner not approved");
+        _burn(_from, _amount);
+    }
+
+    function spendAllowance(address _owner, address _spender, uint256 _amount) external {
+        require(msg.sender == approvedSpender, "ERC20MintBurn: spender not approved");
+        _spendAllowance(_owner, _spender, _amount);
+    }
+}

packages/ovault-composer/contracts/OVault.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import { IOFT } from "@layerzerolabs/oft-evm/contracts/interfaces/IOFT.sol";
+import { IERC20MintBurnExtension } from "./interfaces/IERC20MintBurnExtension.sol";
+import { ERC4626Adapter } from "./ERC4626Adapter.sol";
+import { IOVault } from "./interfaces/IOVault.sol";
+
+contract OVault is ERC4626Adapter, IOVault {
+    constructor(IOFT _asset, IOFT _share) ERC4626Adapter(_asset.token(), _share.token()) {
+        if (!IERC20MintBurnExtension(_share.token()).ERC4626AdapterCompliant()) {
+            revert ShareNotERC4626AdapterCompliant();
+        }
+    }
+}

packages/ovault-composer/contracts/interfaces/IERC20MintBurnExtension.sol

@@ -6,6 +6,10 @@ interface IERC20MintBurnExtension {
     event BurnerSet(address burner, uint256 amount);
     event SpenderSet(address spender);
 
+    error CanNotMintAmount(address minter, uint256 amount);
+    error CanNotBurnAmount(address burner, uint256 amount);
+    error CanNotSpend(address spender);
+
     function approvedMinters(address minter) external view returns (uint256);
     function approvedBurners(address burner) external view returns (uint256);
     function approvedSpender() external view returns (address);
@@ -17,4 +21,6 @@ interface IERC20MintBurnExtension {
     function mint(address to, uint256 amount) external;
     function burn(address from, uint256 amount) external;
     function spendAllowance(address owner, address spender, uint256 amount) external;
+
+    function ERC4626AdapterCompliant() external view returns (bool);
 }

packages/ovault-composer/contracts/interfaces/IOVault.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+interface IOVault {
+    error ShareNotERC4626AdapterCompliant();
+}

packages/ovault-composer/test/ERC44626.t.sol

@@ -34,13 +34,13 @@ contract ERC4626AdapterTest is Test {
         share.setSpender(address(vault));
     }
 
-    function test_invariantMetadata() public view {
+    function test_erc4626_invariantMetadata() public view {
         assertEq(vault.name(), SHARE_NAME);
         assertEq(vault.symbol(), SHARE_SYMBOL);
         assertEq(vault.decimals(), 18);
     }
 
-    function test_Metadata(string calldata name, string calldata symbol) public {
+    function test_erc4626_Metadata(string calldata name, string calldata symbol) public {
         address shareAddress = address(new MockERC20MintBurn(name, symbol));
         MockERC4626Adapter vlt = new MockERC4626Adapter(address(asset), shareAddress);
         assertEq(vlt.name(), name);
@@ -49,7 +49,7 @@ contract ERC4626AdapterTest is Test {
         assertEq(address(vlt.share()), shareAddress);
     }
 
-    function testFuzz_SingleDepositWithdraw(uint128 amount) public {
+    function testFuzz_erc4626_SingleDepositWithdraw(uint128 amount) public {
         if (amount == 0) amount = 1;
 
         uint256 aliceassetAmount = amount;
@@ -93,7 +93,7 @@ contract ERC4626AdapterTest is Test {
         assertEq(asset.balanceOf(alice), alicePreDepositBal);
     }
 
-    function testFuzz_SingleMintRedeem(uint128 amount) public {
+    function testFuzz_erc4626_SingleMintRedeem(uint128 amount) public {
         if (amount == 0) amount = 1;
 
         uint256 aliceShareAmount = amount;
@@ -130,7 +130,7 @@ contract ERC4626AdapterTest is Test {
         assertEq(asset.balanceOf(alice), alicePreDepositBal);
     }
 
-    function testMultipleMintDepositRedeemWithdraw() public {
+    function test_erc4626_MultipleMintDepositRedeemWithdraw() public {
         // Scenario:
         // A = Alice, B = Bob
         //  ________________________________________________________
@@ -346,7 +346,7 @@ contract ERC4626AdapterTest is Test {
         assertEq(asset.balanceOf(address(vault)), 0);
     }
 
-    function test_FailDepositWithNotEnoughApproval() public {
+    function test_erc4626_FailDepositWithNotEnoughApproval() public {
         asset.mint(address(this), 0.5e18);
         asset.approve(address(vault), 0.5e18);
         assertEq(asset.allowance(address(this), address(vault)), 0.5e18);
@@ -357,7 +357,7 @@ contract ERC4626AdapterTest is Test {
         vault.deposit(1e18, address(this));
     }
 
-    function test_FailWithdrawExceedsMaxWithdraw() public {
+    function test_erc4626_FailWithdrawExceedsMaxWithdraw() public {
         asset.mint(address(this), 0.5e18);
         asset.approve(address(vault), 0.5e18);
 
@@ -369,7 +369,7 @@ contract ERC4626AdapterTest is Test {
         vault.withdraw(1e18, address(this), address(this));
     }
 
-    function test_FailRedeemWithNotEnoughShareAmount() public {
+    function test_erc4626_FailRedeemWithNotEnoughShareAmount() public {
         asset.mint(address(this), 0.5e18);
         asset.approve(address(vault), 0.5e18);
 
@@ -381,35 +381,35 @@ contract ERC4626AdapterTest is Test {
         vault.redeem(1e18, address(this), address(this));
     }
 
-    function test_FailWithdrawWithNoassetAmount() public {
+    function test_erc4626_FailWithdrawWithNoassetAmount() public {
         vm.expectRevert(
             abi.encodeWithSelector(IERC4626Adapter.ERC4626ExceededMaxWithdraw.selector, address(this), 1e18, 0)
         );
         vault.withdraw(1e18, address(this), address(this));
     }
 
-    function test_FailRedeemWithNoShareAmount() public {
+    function test_erc4626_FailRedeemWithNoShareAmount() public {
         vm.expectRevert(
             abi.encodeWithSelector(IERC4626Adapter.ERC4626ExceededMaxRedeem.selector, address(this), 1e18, 0)
         );
         vault.redeem(1e18, address(this), address(this));
     }
 
-    function test_FailDepositWithNoApproval() public {
+    function test_erc4626_FailDepositWithNoApproval() public {
         vm.expectRevert(
             abi.encodeWithSelector(IERC20Errors.ERC20InsufficientAllowance.selector, address(vault), 0, 1e18)
         );
         vault.deposit(1e18, address(this));
     }
 
-    function test_FailMintWithNoApproval() public {
+    function test_erc4626_FailMintWithNoApproval() public {
         vm.expectRevert(
             abi.encodeWithSelector(IERC20Errors.ERC20InsufficientAllowance.selector, address(vault), 0, 1e18)
         );
         vault.mint(1e18, address(this));
     }
 
-    function test_MintZero() public {
+    function test_erc4626_MintZero() public {
         vault.mint(0, address(this));
 
         assertEq(vault.balanceOf(address(this)), 0);
@@ -418,7 +418,7 @@ contract ERC4626AdapterTest is Test {
         assertEq(vault.totalAssets(), 0);
     }
 
-    function test_WithdrawZero() public {
+    function test_erc4626_WithdrawZero() public {
         vault.withdraw(0, address(this), address(this));
 
         assertEq(vault.balanceOf(address(this)), 0);