Writing tests for NovaVault interfaces

src/NovaAdapterBase.sol

@@ -25,7 +25,7 @@ abstract contract NovaAdapterBase is ERC20 {
         sDAI = _sDAI;
     }
 
-    function deposit(uint256 assets) external returns (bool , uint256) {
+    function deposit(uint256 assets) external returns (bool, uint256) {
         bool success = asset.transferFrom(msg.sender, address(this), assets);
         if(!success){
             revert TransferFailed(msg.sender, address(this), assets);

src/NovaAdapterVelo.sol

@@ -67,4 +67,8 @@ contract NovaAdapterVelo is NovaAdapterBase {
 
         return (amount0, amount1);
     }
+
+    function getAsset() external view returns (ERC20) {
+        return asset;
+    }
 }

src/NovaVault.sol

@@ -4,20 +4,21 @@ pragma solidity ^0.8.13;
 import {Errors} from "./libraries/Errors.sol";
 import {INovaVault} from "./interfaces/INovaVault.sol";
 import {INovaAdapterBase} from "./interfaces/INovaAdapterBase.sol";
+import {ERC20} from "@solmate/tokens/ERC20.sol";
 
 contract NovaVault is INovaVault {
     mapping(address => address) public _novaAdapters;
 
-    function constructor(
-        address[] calldata stables,
-        address[] calldata novaAdapters
+    constructor(
+        address[] memory stables,
+        address[] memory novaAdapters
     ) {
         _approveNovaAdapters(stables, novaAdapters);
     }
 
     function _approveNovaAdapters(
-        address[] calldata stables,
-        address[] calldata novaAdapters,
+        address[] memory stables,
+        address[] memory novaAdapters
     ) internal {
         require(
             stables.length == novaAdapters.length,
@@ -39,7 +40,8 @@ contract NovaVault is INovaVault {
             Errors.ADAPTER_ALREADY_APPROVED
         );
 
-        ERC20 underlyingAsset = INovaAdapterBase(adapter).asset();
+        ERC20 underlyingAsset = INovaAdapterBase(adapter).getAsset();
+
         require(
             address(underlyingAsset) == stable,
             Errors.INVALID_STABLE_TO_ADAPTER_MAPPING
@@ -55,10 +57,14 @@ contract NovaVault is INovaVault {
             adapter != address(0),
             Errors.NO_ADAPTER_APPROVED
         );
-        (bool success, bytes memory data) = adapter.delegatecall(
+
+        ERC20(stable).transferFrom(msg.sender, address(this), assets);
+        ERC20(stable).approve(adapter, assets);
+
+        (bool success, bytes memory data) = adapter.call(
             abi.encodeWithSignature("deposit(uint256)", assets)
         );
-        return (success, data)
+        return (success, data);
     }
 
     function withdraw(address stable, uint256 shares) external returns (bool , bytes memory) {
@@ -67,9 +73,9 @@ contract NovaVault is INovaVault {
             adapter != address(0),
             Errors.NO_ADAPTER_APPROVED
         );
-        (bool success, bytes memory data) = adapter.delegatecall(
+        (bool success, bytes memory data) = adapter.call(
             abi.encodeWithSignature("withdraw(uint256)", shares)
         );
-        return (success, data)
+        return (success, data);
     }
 }

src/interfaces/INovaAdapterBase.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.8.13;
 import {ERC20} from "@solmate/tokens/ERC20.sol";
 
 interface INovaAdapterBase {
-    function asset() external view returns (ERC20);
+    function getAsset() external view returns (ERC20);
     function deposit(uint256 assets) external returns (bool , uint256);
     function withdraw(uint256 shares) external returns (bool, uint256);
 }

test/NovaAdapterVelo.t.sol

@@ -9,7 +9,7 @@ import {IVelodromePool} from "../src/interfaces/IVelodromePool.sol";
 contract NovaAdapterVeloTest is Test {
     address public POOL = 0x94c0A04C0d74571aa9EE25Dd6c29E2A36f5699aE;
     address public sDAI = 0x2218a117083f5B482B0bB821d27056Ba9c04b1D3;
-    NovaAdapterVelo public vault;
+    NovaAdapterVelo public adapter;
     IVelodromePool veloPool;
     address underlyingAddress;
     ERC20 underlying;
@@ -32,7 +32,7 @@ contract NovaAdapterVeloTest is Test {
 
         underlying = ERC20(underlyingAddress);
 
-        vault = new NovaAdapterVelo(
+        adapter = new NovaAdapterVelo(
             underlying,
             sDAI,
             POOL,
@@ -50,16 +50,16 @@ contract NovaAdapterVeloTest is Test {
         underlying.transfer(alice, aliceUnderlyingAmount);
 
         vm.prank(alice);
-        underlying.approve(address(vault), aliceUnderlyingAmount);
-        assertEq(underlying.allowance(alice, address(vault)), aliceUnderlyingAmount);
+        underlying.approve(address(adapter), aliceUnderlyingAmount);
+        assertEq(underlying.allowance(alice, address(adapter)), aliceUnderlyingAmount);
 
         vm.prank(alice);
-        (bool success, uint256 sDaiMinted) = vault.deposit(aliceUnderlyingAmount);
+        (bool success, uint256 sDaiMinted) = adapter.deposit(aliceUnderlyingAmount);
 
         assert(success);
         assertEq(underlying.balanceOf(alice), 0);
-        assertEq(vault.balanceOf(alice), sDaiMinted);
-        assertEq(ERC20(sDAI).balanceOf(address(vault)), sDaiMinted);
+        assertEq(adapter.balanceOf(alice), sDaiMinted);
+        assertEq(ERC20(sDAI).balanceOf(address(adapter)), sDaiMinted);
     }
 
     function testWithdraw() public{
@@ -70,22 +70,22 @@ contract NovaAdapterVeloTest is Test {
         underlying.transfer(alice, aliceUnderlyingAmount);
 
         vm.prank(alice);
-        underlying.approve(address(vault), aliceUnderlyingAmount);
-        assertEq(underlying.allowance(alice, address(vault)), aliceUnderlyingAmount);
+        underlying.approve(address(adapter), aliceUnderlyingAmount);
+        assertEq(underlying.allowance(alice, address(adapter)), aliceUnderlyingAmount);
 
         vm.prank(alice);
-        (bool succesDeposit, uint256 sDaiMinted) = vault.deposit(aliceUnderlyingAmount);
+        (bool succesDeposit, uint256 sDaiMinted) = adapter.deposit(aliceUnderlyingAmount);
         assert(succesDeposit);
         assertEq(underlying.balanceOf(alice), 0);
-        assertEq(vault.balanceOf(alice), sDaiMinted);
-        assertEq(ERC20(sDAI).balanceOf(address(vault)), sDaiMinted);
+        assertEq(adapter.balanceOf(alice), sDaiMinted);
+        assertEq(ERC20(sDAI).balanceOf(address(adapter)), sDaiMinted);
 
         vm.prank(alice);
-        (bool successWithdraw, uint256 underlyingWithdrawn) = vault.withdraw(sDaiMinted);
+        (bool successWithdraw, uint256 underlyingWithdrawn) = adapter.withdraw(sDaiMinted);
         assert(successWithdraw);
         assertEq(underlying.balanceOf(alice), underlyingWithdrawn);
-        assertEq(vault.balanceOf(alice), 0);
-        assertEq(ERC20(sDAI).balanceOf(address(vault)), 0);
-        assertEq(underlying.balanceOf(address(vault)), 0);
+        assertEq(adapter.balanceOf(alice), 0);
+        assertEq(ERC20(sDAI).balanceOf(address(adapter)), 0);
+        assertEq(underlying.balanceOf(address(adapter)), 0);
     }
 }

test/NovaVault.t.sol

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import {ERC20} from "@solmate/tokens/ERC20.sol";
+import {Test, console} from "forge-std/Test.sol";
+import {NovaVault} from "../src/NovaVault.sol";
+import {NovaAdapterVelo} from "../src/NovaAdapterVelo.sol";
+import {IVelodromePool} from "../src/interfaces/IVelodromePool.sol";
+
+contract NovaVaultTest is Test {
+    address public POOL = 0x94c0A04C0d74571aa9EE25Dd6c29E2A36f5699aE;
+    address public sDAI = 0x2218a117083f5B482B0bB821d27056Ba9c04b1D3;
+    NovaAdapterVelo public adapter;
+    NovaVault public vault;
+    IVelodromePool veloPool;
+    address underlyingAddress;
+    ERC20 underlying;
+    address private veloToken0;
+    address private veloToken1;
+    address[] stables;
+    address[] novaAdapters;
+
+    address public underlyingWhale = 0xacD03D601e5bB1B275Bb94076fF46ED9D753435A;
+
+    function setUp() public {
+        veloPool = IVelodromePool(POOL);
+        veloToken0 = veloPool.token0();
+        veloToken1 = veloPool.token1();
+        if (veloToken0 == sDAI) {
+            underlyingAddress = veloToken1;
+        } else if (veloToken1 == sDAI) {
+            underlyingAddress = veloToken0;
+        } else {
+            revert("Velodrome pool should be made of `asset` and `sDAI`!");
+        }
+
+        underlying = ERC20(underlyingAddress);
+
+        adapter = new NovaAdapterVelo(
+            underlying,
+            sDAI,
+            POOL,
+            "NovaAdapterVelo",
+            "NV",
+            18
+        );
+
+        stables.push(underlyingAddress);
+        novaAdapters.push(address(adapter));
+
+        vault = new NovaVault(stables, novaAdapters);
+    }
+
+    function testNovaVaultDepositAndWithdraw() public {
+        uint256 aliceUnderlyingAmount = 100 * 1e6;
+        address alice = address(0xABCD);
+
+        vm.prank(underlyingWhale);
+        underlying.transfer(alice, aliceUnderlyingAmount);
+
+        vm.prank(alice);
+        underlying.approve(address(vault), aliceUnderlyingAmount);
+        assertEq(underlying.allowance(alice, address(vault)), aliceUnderlyingAmount);
+
+
+        vm.prank(alice);
+        (bool success, bytes memory data) = vault.deposit(address(underlyingAddress), aliceUnderlyingAmount);
+        assert(success);
+
+        vm.prank(alice);
+        (success, data) = vault.withdraw(underlyingAddress, aliceUnderlyingAmount);
+        assert(success);
+    }
+
+}