Initial commit

test/integration/AmortizationInvariant.t.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import "forge-std/Test.sol";
+import "../../contracts/core/RecursiveLeverageKernel.sol";
+import "../../contracts/core/DBISInstitutionalVault.sol";
+import "../../contracts/core/FlashLoanRouter.sol";
+import "../../contracts/interfaces/IVault.sol";
+import "../../contracts/interfaces/IKernel.sol";
+
+/**
+ * @title AmortizationInvariantTest
+ * @notice Invariant tests ensuring position never worsens
+ */
+contract AmortizationInvariantTest is Test {
+    // Contracts would be initialized in setUp()
+    // This is a template for invariant testing
+
+    function test_AmortizationMustImprovePosition() public {
+        // 1. Take initial snapshot
+        // 2. Execute amortization cycle
+        // 3. Verify:
+        //    - Debt decreased OR
+        //    - Collateral increased OR
+        //    - Health factor improved
+        // 4. Assert all three improved
+    }
+
+    function test_AmortizationRevertsIfHFWorsens() public {
+        // Test that if HF would worsen, transaction reverts
+    }
+
+    function test_AmortizationRevertsIfDebtIncreases() public {
+        // Test that if debt increases, transaction reverts
+    }
+
+    function test_AmortizationRevertsIfCollateralDecreases() public {
+        // Test that if collateral decreases, transaction reverts
+    }
+
+    function invariant_HealthFactorNeverDecreases() public {
+        // Foundry invariant test
+        // Ensures HF never decreases after any operation
+    }
+
+    function invariant_DebtNeverIncreases() public {
+        // Foundry invariant test
+        // Ensures debt never increases after amortization
+    }
+
+    function invariant_CollateralNeverDecreases() public {
+        // Foundry invariant test
+        // Ensures collateral never decreases after amortization
+    }
+}
+

test/kernel/RecursiveLeverageKernel.t.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import "forge-std/Test.sol";
+import "../../contracts/core/RecursiveLeverageKernel.sol";
+import "../../contracts/interfaces/IKernel.sol";
+
+/**
+ * @title RecursiveLeverageKernelTest
+ * @notice Unit tests for Recursive Leverage Kernel
+ */
+contract RecursiveLeverageKernelTest is Test {
+    RecursiveLeverageKernel public kernel;
+    
+    function setUp() public {
+        // Initialize kernel with mocks
+        // This is a template - would need full setup with all dependencies
+    }
+
+    function test_ExecuteAmortizingCycle() public {
+        // Test successful amortization cycle
+    }
+
+    function test_ExecuteAmortizingCycleRevertsIfInvariantFails() public {
+        // Test that cycle reverts if invariants fail
+    }
+
+    function test_ExecuteSingleStep() public {
+        // Test single step execution
+    }
+
+    function test_VerifyInvariants() public {
+        // Test invariant verification
+    }
+
+    function test_OnlyOperatorCanExecuteCycle() public {
+        // Test access control
+    }
+}
+

test/vault/DBISInstitutionalVault.t.sol

@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import "forge-std/Test.sol";
+import "../../contracts/core/DBISInstitutionalVault.sol";
+import "../../contracts/interfaces/IVault.sol";
+import "../../contracts/interfaces/IOracleAdapter.sol";
+
+/**
+ * @title DBISInstitutionalVaultTest
+ * @notice Unit tests for DBIS Institutional Vault
+ */
+contract DBISInstitutionalVaultTest is Test {
+    DBISInstitutionalVault public vault;
+    address public oracleAdapter;
+    address public aavePool;
+    address public aaveUserAccount;
+    address public owner;
+    address public kernel;
+    address public operator;
+
+    event CollateralAdded(address indexed asset, uint256 amount);
+    event DebtRepaid(address indexed asset, uint256 amount);
+    event PositionSnapshot(
+        uint256 collateralBefore,
+        uint256 debtBefore,
+        uint256 collateralAfter,
+        uint256 debtAfter,
+        uint256 healthFactorBefore,
+        uint256 healthFactorAfter
+    );
+
+    function setUp() public {
+        owner = address(this);
+        kernel = address(0x1);
+        operator = address(0x2);
+        oracleAdapter = address(0x3);
+        aavePool = address(0x4);
+        aaveUserAccount = address(0x5);
+
+        vault = new DBISInstitutionalVault(
+            oracleAdapter,
+            aavePool,
+            aaveUserAccount,
+            owner
+        );
+
+        vault.grantKernel(kernel);
+        vault.grantOperator(operator);
+    }
+
+    function test_InitialState() public view {
+        assertEq(address(vault.oracleAdapter()), oracleAdapter);
+        assertEq(address(vault.aavePool()), aavePool);
+        assertEq(vault.aaveUserAccount(), aaveUserAccount);
+        assertTrue(vault.hasRole(vault.DEFAULT_ADMIN_ROLE(), owner));
+    }
+
+    function test_RecordCollateralAdded() public {
+        address asset = address(0x100);
+        uint256 amount = 1000e18;
+
+        vm.prank(kernel);
+        vm.expectEmit(true, false, false, true);
+        emit CollateralAdded(asset, amount);
+        vault.recordCollateralAdded(asset, amount);
+
+        (uint256 collateral, uint256 debt) = vault.getAssetPosition(asset);
+        assertEq(collateral, amount);
+        assertEq(debt, 0);
+    }
+
+    function test_RecordDebtRepaid() public {
+        address asset = address(0x100);
+        uint256 debtAmount = 500e18;
+        uint256 repayAmount = 300e18;
+
+        // First add some debt (simulated)
+        vm.startPrank(kernel);
+        vault.recordCollateralAdded(asset, 1000e18);
+        // Manually set debt (would need internal access or mock)
+        vm.stopPrank();
+
+        vm.prank(kernel);
+        vm.expectEmit(true, false, false, true);
+        emit DebtRepaid(asset, repayAmount);
+        vault.recordDebtRepaid(asset, repayAmount);
+    }
+
+    function test_SnapshotPosition() public {
+        vm.prank(kernel);
+        (uint256 collateral, uint256 debt, uint256 hf) = vault.snapshotPosition();
+
+        // Values would depend on Aave pool mock
+        assertTrue(collateral >= 0);
+        assertTrue(debt >= 0);
+        assertTrue(hf >= 0);
+    }
+
+    function test_OnlyKernelCanRecord() public {
+        address asset = address(0x100);
+        uint256 amount = 1000e18;
+
+        vm.prank(operator);
+        vm.expectRevert();
+        vault.recordCollateralAdded(asset, amount);
+    }
+
+    function test_UpdateOracleAdapter() public {
+        address newOracle = address(0x200);
+        
+        vault.setOracleAdapter(newOracle);
+        assertEq(address(vault.oracleAdapter()), newOracle);
+    }
+
+    function test_OnlyOwnerCanUpdateOracle() public {
+        address newOracle = address(0x200);
+        
+        vm.prank(operator);
+        vm.expectRevert();
+        vault.setOracleAdapter(newOracle);
+    }
+}
+