Add tests

Author: lastperson

contracts/LiquidityHub.sol

@@ -8,13 +8,15 @@ import {
     ERC4626Upgradeable,
     Math
 } from "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC4626Upgradeable.sol";
+import {AccessControlUpgradeable} from '@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol';
 import {ERC7201Helper} from './utils/ERC7201Helper.sol';
 import {IManagedToken} from './interfaces/IManagedToken.sol';
 
-contract LiquidityHub is ERC4626Upgradeable {
+contract LiquidityHub is ERC4626Upgradeable, AccessControlUpgradeable {
     using Math for uint256;
 
     IManagedToken immutable public SHARES;
+    bytes32 public constant ASSETS_UPDATE_ROLE = "ASSETS_UPDATE_ROLE";
 
     error ZeroAddress();
     error NotImplemented();
@@ -37,14 +39,15 @@ contract LiquidityHub is ERC4626Upgradeable {
         _disableInitializers();
     }
 
-    function initialize(IERC20 asset_) external initializer() {
+    function initialize(IERC20 asset_, address admin) external initializer() {
         ERC4626Upgradeable.__ERC4626_init(asset_);
         require(
             IERC20Metadata(address(asset_)).decimals() <= IERC20Metadata(address(SHARES)).decimals(),
             IncompatibleAssetsAndShares()
         );
         // Deliberately not initializing ERC20Upgradable because its
         // functionality is delegated to SHARES.
+        _grantRole(DEFAULT_ADMIN_ROLE, admin);
     }
 
     function name() public pure override(IERC20Metadata, ERC20Upgradeable) returns (string memory) {
@@ -88,6 +91,28 @@ contract LiquidityHub is ERC4626Upgradeable {
         return _getStorage().totalAssets;
     }
 
+    function _convertToShares(uint256 assets, Math.Rounding rounding) internal view virtual override returns (uint256) {
+        (uint256 supplyShares, uint256 supplyAssets) = _getTotals();
+        return assets.mulDiv(supplyShares, supplyAssets, rounding);
+    }
+
+    function _convertToAssets(uint256 shares, Math.Rounding rounding) internal view virtual override returns (uint256) {
+        (uint256 supplyShares, uint256 supplyAssets) = _getTotals();
+        return shares.mulDiv(supplyAssets, supplyShares, rounding);
+    }
+
+    function _getTotals() internal view returns (uint256 supply, uint256 assets) {
+        supply = totalSupply();
+        if (supply == 0) {
+            supply = 10 ** _decimalsOffset();
+        }
+        assets = totalAssets();
+        if (assets == 0) {
+            assets = 1;
+        }
+        return (supply, assets);
+    }
+
     function _update(address from, address to, uint256 value) internal virtual override {
         if (from == address(0)) {
             SHARES.mint(to, value);

test/LiquidityHub.ts

@@ -24,7 +24,7 @@ describe("LiquidityHub", function () {
     const LP = 10n ** (await lpToken.decimals());
 
     const liquidityHubImpl = await deploy("LiquidityHub", deployer, {nonce: startingNonce + 1}, lpToken.target);
-    const liquidityHubInit = (await liquidityHubImpl.initialize.populateTransaction(usdc.target)).data;
+    const liquidityHubInit = (await liquidityHubImpl.initialize.populateTransaction(usdc.target, admin.address)).data;
     const liquidityHubProxy = await deploy(
       "TransparentUpgradeableProxy", deployer, {nonce: startingNonce + 2},
       liquidityHubImpl.target, admin, liquidityHubInit
@@ -83,6 +83,34 @@ describe("LiquidityHub", function () {
     expect(await usdc.balanceOf(liquidityHub.target)).to.equal(10n * USDC);
   });
 
+  it("Should allow to deposit twice", async function () {
+    const {lpToken, liquidityHub, usdc, deployer, user, USDC, LP} = await loadFixture(deployAll);
+
+    await usdc.connect(deployer).transfer(user.address, 10n * USDC);
+    await usdc.connect(user).approve(liquidityHub.target, 10n * USDC);
+    const tx = liquidityHub.connect(user).deposit(3n * USDC, user.address);
+    await expect(tx)
+      .to.emit(lpToken, "Transfer")
+      .withArgs(ZERO_ADDRESS, user.address, 3n * LP);
+    await expect(tx)
+      .to.emit(usdc, "Transfer")
+      .withArgs(user.address, liquidityHub.target, 3n * USDC);
+    const tx2 = liquidityHub.connect(user).deposit(7n * USDC, user.address);
+    await expect(tx2)
+      .to.emit(lpToken, "Transfer")
+      .withArgs(ZERO_ADDRESS, user.address, 7n * LP);
+    await expect(tx2)
+      .to.emit(usdc, "Transfer")
+      .withArgs(user.address, liquidityHub.target, 7n * USDC);
+    expect(await lpToken.balanceOf(user.address)).to.equal(10n * LP);
+    expect(await lpToken.totalSupply()).to.equal(10n * LP);
+    expect(await liquidityHub.totalSupply()).to.equal(10n * LP);
+    expect(await liquidityHub.totalAssets()).to.equal(10n * USDC);
+    expect(await liquidityHub.balanceOf(user.address)).to.equal(10n * LP);
+    expect(await usdc.balanceOf(user.address)).to.equal(0n);
+    expect(await usdc.balanceOf(liquidityHub.target)).to.equal(10n * USDC);
+  });
+
   it("Should allow to mint", async function () {
     const {lpToken, liquidityHub, usdc, deployer, user, USDC, LP} = await loadFixture(deployAll);
 
@@ -195,4 +223,34 @@ describe("LiquidityHub", function () {
     expect(await usdc.balanceOf(user2.address)).to.equal(10n * USDC);
     expect(await usdc.balanceOf(liquidityHub.target)).to.equal(0n);
   });
+
+  it("Should allow to deposit and withdraw multiple times", async function () {
+    const {lpToken, liquidityHub, usdc, deployer, user, USDC, LP} = await loadFixture(deployAll);
+
+    await usdc.connect(deployer).transfer(user.address, 10n * USDC);
+    await usdc.connect(user).approve(liquidityHub.target, 10n * USDC);
+    const tx = liquidityHub.connect(user).deposit(3n * USDC, user.address);
+    await expect(tx)
+      .to.emit(lpToken, "Transfer")
+      .withArgs(ZERO_ADDRESS, user.address, 3n * LP);
+    await expect(tx)
+      .to.emit(usdc, "Transfer")
+      .withArgs(user.address, liquidityHub.target, 3n * USDC);
+    await liquidityHub.connect(user).withdraw(1n * USDC, user.address, user.address);
+    const tx2 = liquidityHub.connect(user).deposit(7n * USDC, user.address);
+    await expect(tx2)
+      .to.emit(lpToken, "Transfer")
+      .withArgs(ZERO_ADDRESS, user.address, 7n * LP);
+    await expect(tx2)
+      .to.emit(usdc, "Transfer")
+      .withArgs(user.address, liquidityHub.target, 7n * USDC);
+    await liquidityHub.connect(user).withdraw(4n * USDC, user.address, user.address);
+    expect(await lpToken.balanceOf(user.address)).to.equal(5n * LP);
+    expect(await lpToken.totalSupply()).to.equal(5n * LP);
+    expect(await liquidityHub.totalSupply()).to.equal(5n * LP);
+    expect(await liquidityHub.totalAssets()).to.equal(5n * USDC);
+    expect(await liquidityHub.balanceOf(user.address)).to.equal(5n * LP);
+    expect(await usdc.balanceOf(user.address)).to.equal(5n * USDC);
+    expect(await usdc.balanceOf(liquidityHub.target)).to.equal(5n * USDC);
+  });
 });