feat: added unit test and updated readme

dannweeeee · dannweeeee · commit e4f6c6ff3cdd · 2024-11-16T15:07:30.000+08:00
diff --git a/README.md b/README.md
@@ -28,3 +28,9 @@ forge script script/deploy/Exchange.s.sol:DeployExchange --rpc-url <PRC_URL> --b
 ```
 forge script script/deploy/Vault.s.sol:DeployVault --rpc-url <PRC_URL> --broadcast --private-key <PRIVATE_KEY>
 ```
+
+## Tests
+
+```
+forge test -vv
+```
diff --git a/test/Exchange.t.sol b/test/Exchange.t.sol
@@ -0,0 +1,216 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {Test, console2} from "forge-std/Test.sol";
+import {Exchange} from "../src/Exchange.sol";
+import {Registry} from "../src/Registry.sol";
+import {MockERC20} from "./mocks/MockERC20.sol";
+import {MockERC4626} from "./mocks/MockERC4626.sol";
+
+contract ExchangeTest is Test {
+    Exchange public exchange;
+    Registry public registry;
+    MockERC20 public usdc;
+    MockERC4626 public vault;
+
+    address public owner;
+    address public user;
+    address public merchant;
+    string constant UEN = "123456789A";
+    uint256 constant INITIAL_BALANCE = 1000000 * 10 ** 6; // 1M USDC
+    uint256 constant DEFAULT_AMOUNT = 1000 * 10 ** 6; // 1000 USDC
+
+    event Transfer(address indexed from, address indexed to, uint256 amount, string uen);
+    event FeeUpdated(uint256 newFee);
+    event FeeCollectorUpdated(address newFeeCollector);
+    event FeesWithdrawn(address indexed to, uint256 amount);
+    event VaultDeposit(address indexed merchant, uint256 assets, uint256 shares);
+    event VaultWithdraw(address indexed merchant, uint256 assets, uint256 shares);
+
+    function setUp() public {
+        owner = makeAddr("owner");
+        user = makeAddr("user");
+        merchant = makeAddr("merchant");
+
+        vm.startPrank(owner);
+
+        // Deploy mock contracts
+        usdc = new MockERC20("USDC", "USDC", 6);
+        vault = new MockERC4626(address(usdc), "Vault USDC", "vUSDC");
+
+        // Deploy registry and add merchant
+        registry = new Registry();
+        registry.addMerchant(
+            UEN, // _uen
+            "Test Merchant", // _entity_name
+            "Test Owner", // _owner_name
+            merchant // _wallet_address
+        );
+
+        // Deploy exchange
+        exchange = new Exchange(address(registry), address(usdc), address(vault));
+
+        vm.stopPrank();
+
+        // Setup initial balances
+        deal(address(usdc), user, INITIAL_BALANCE);
+    }
+
+    function test_TransferToMerchant() public {
+        vm.startPrank(user);
+        usdc.approve(address(exchange), DEFAULT_AMOUNT);
+
+        uint256 feeAmount = (DEFAULT_AMOUNT * exchange.fee()) / 10000;
+        uint256 merchantAmount = DEFAULT_AMOUNT - feeAmount;
+
+        vm.expectEmit(true, true, false, true);
+        emit Transfer(user, merchant, merchantAmount, UEN);
+
+        exchange.transferToMerchant(UEN, DEFAULT_AMOUNT);
+
+        assertEq(usdc.balanceOf(merchant), merchantAmount);
+        assertEq(usdc.balanceOf(address(exchange)), feeAmount);
+        vm.stopPrank();
+    }
+
+    function test_TransferToVault() public {
+        vm.startPrank(user);
+        usdc.approve(address(exchange), DEFAULT_AMOUNT);
+
+        uint256 feeAmount = (DEFAULT_AMOUNT * exchange.fee()) / 10000;
+        uint256 vaultAmount = DEFAULT_AMOUNT - feeAmount;
+
+        vm.expectEmit(true, true, false, true);
+        emit Transfer(user, merchant, vaultAmount, UEN);
+        vm.expectEmit(true, false, false, true);
+        emit VaultDeposit(merchant, vaultAmount, vaultAmount); // Mock vault returns 1:1 shares
+
+        exchange.transferToVault(UEN, DEFAULT_AMOUNT);
+
+        assertEq(vault.balanceOf(merchant), vaultAmount);
+        assertEq(usdc.balanceOf(address(exchange)), feeAmount);
+        vm.stopPrank();
+    }
+
+    function test_WithdrawToWallet() public {
+        // First deposit to vault
+        vm.startPrank(user);
+        usdc.approve(address(exchange), DEFAULT_AMOUNT);
+        exchange.transferToVault(UEN, DEFAULT_AMOUNT);
+        vm.stopPrank();
+
+        uint256 feeAmount = (DEFAULT_AMOUNT * exchange.fee()) / 10000;
+        uint256 vaultAmount = DEFAULT_AMOUNT - feeAmount;
+
+        // Then withdraw
+        vm.startPrank(merchant);
+        vm.expectEmit(true, false, false, true);
+        emit VaultWithdraw(merchant, vaultAmount, vaultAmount);
+
+        exchange.withdrawToWallet(vaultAmount);
+
+        assertEq(usdc.balanceOf(merchant), vaultAmount);
+        assertEq(vault.balanceOf(merchant), 0);
+        vm.stopPrank();
+    }
+
+    function test_SetFee() public {
+        uint256 newFee = 200; // 2%
+
+        vm.prank(owner);
+        vm.expectEmit(false, false, false, true);
+        emit FeeUpdated(newFee);
+
+        exchange.setFee(newFee);
+        assertEq(exchange.fee(), newFee);
+    }
+
+    function test_SetFeeCollector() public {
+        address newFeeCollector = makeAddr("newFeeCollector");
+
+        vm.prank(owner);
+        vm.expectEmit(false, false, false, true);
+        emit FeeCollectorUpdated(newFeeCollector);
+
+        exchange.setFeeCollector(newFeeCollector);
+        assertEq(exchange.feeCollector(), newFeeCollector);
+    }
+
+    function test_WithdrawFees() public {
+        // First make a transfer to generate fees
+        vm.startPrank(user);
+        usdc.approve(address(exchange), DEFAULT_AMOUNT);
+        exchange.transferToMerchant(UEN, DEFAULT_AMOUNT);
+        vm.stopPrank();
+
+        uint256 feeAmount = (DEFAULT_AMOUNT * exchange.fee()) / 10000;
+        address feeReceiver = makeAddr("feeReceiver");
+
+        vm.prank(owner);
+        vm.expectEmit(true, false, false, true);
+        emit FeesWithdrawn(feeReceiver, feeAmount);
+
+        exchange.withdrawFees(feeReceiver, feeAmount);
+        assertEq(usdc.balanceOf(feeReceiver), feeAmount);
+    }
+
+    function testFail_TransferToMerchant_InvalidUEN() public {
+        vm.prank(user);
+        exchange.transferToMerchant("INVALID_UEN", DEFAULT_AMOUNT);
+    }
+
+    function testFail_TransferToMerchant_ZeroAmount() public {
+        vm.prank(user);
+        exchange.transferToMerchant(UEN, 0);
+    }
+
+    function testFail_TransferToVault_InvalidUEN() public {
+        vm.prank(user);
+        exchange.transferToVault("INVALID_UEN", DEFAULT_AMOUNT);
+    }
+
+    function testFail_TransferToVault_ZeroAmount() public {
+        vm.prank(user);
+        exchange.transferToVault(UEN, 0);
+    }
+
+    function testFail_WithdrawToWallet_InsufficientShares() public {
+        vm.prank(merchant);
+        exchange.withdrawToWallet(1000); // No shares deposited
+    }
+
+    function testFail_SetFee_NotOwner() public {
+        vm.prank(user);
+        exchange.setFee(200);
+    }
+
+    function testFail_SetFee_TooHigh() public {
+        vm.prank(owner);
+        exchange.setFee(1001); // > 10%
+    }
+
+    function testFail_SetFeeCollector_NotOwner() public {
+        vm.prank(user);
+        exchange.setFeeCollector(address(1));
+    }
+
+    function testFail_SetFeeCollector_ZeroAddress() public {
+        vm.prank(owner);
+        exchange.setFeeCollector(address(0));
+    }
+
+    function testFail_WithdrawFees_NotOwner() public {
+        vm.prank(user);
+        exchange.withdrawFees(address(1), 100);
+    }
+
+    function testFail_WithdrawFees_ZeroAmount() public {
+        vm.prank(owner);
+        exchange.withdrawFees(address(1), 0);
+    }
+
+    function testFail_WithdrawFees_InsufficientBalance() public {
+        vm.prank(owner);
+        exchange.withdrawFees(address(1), INITIAL_BALANCE);
+    }
+}
diff --git a/test/mocks/MockERC20.sol b/test/mocks/MockERC20.sol
@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract MockERC20 is ERC20 {
+    uint8 private _decimals;
+
+    constructor(string memory name, string memory symbol, uint8 decimals_) ERC20(name, symbol) {
+        _decimals = decimals_;
+    }
+
+    function decimals() public view virtual override returns (uint8) {
+        return _decimals;
+    }
+
+    function mint(address account, uint256 amount) public {
+        _mint(account, amount);
+    }
+}
diff --git a/test/mocks/MockERC4626.sol b/test/mocks/MockERC4626.sol
@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {IERC4626} from "@openzeppelin/contracts/interfaces/IERC4626.sol";
+
+contract MockERC4626 is ERC20, IERC4626 {
+    IERC20 private _asset;
+
+    constructor(address asset, string memory name, string memory symbol) ERC20(name, symbol) {
+        _asset = IERC20(asset);
+    }
+
+    function asset() external view returns (address) {
+        return address(_asset);
+    }
+
+    function totalAssets() external view returns (uint256) {
+        return _asset.balanceOf(address(this));
+    }
+
+    function convertToShares(uint256 assets) external pure returns (uint256) {
+        return assets; // 1:1 conversion for simplicity
+    }
+
+    function convertToAssets(uint256 shares) external pure returns (uint256) {
+        return shares; // 1:1 conversion for simplicity
+    }
+
+    function maxDeposit(address) external pure returns (uint256) {
+        return type(uint256).max;
+    }
+
+    function previewDeposit(uint256 assets) external pure returns (uint256) {
+        return assets;
+    }
+
+    function deposit(uint256 assets, address receiver) external returns (uint256) {
+        _asset.transferFrom(msg.sender, address(this), assets);
+        _mint(receiver, assets);
+        return assets;
+    }
+
+    function maxMint(address) external pure returns (uint256) {
+        return type(uint256).max;
+    }
+
+    function previewMint(uint256 shares) external pure returns (uint256) {
+        return shares;
+    }
+
+    function mint(uint256 shares, address receiver) external returns (uint256) {
+        _asset.transferFrom(msg.sender, address(this), shares);
+        _mint(receiver, shares);
+        return shares;
+    }
+
+    function maxWithdraw(address owner) external view returns (uint256) {
+        return balanceOf(owner);
+    }
+
+    function previewWithdraw(uint256 assets) external pure returns (uint256) {
+        return assets;
+    }
+
+    function withdraw(uint256 assets, address receiver, address owner) external returns (uint256) {
+        require(balanceOf(owner) >= assets, "Insufficient balance");
+        _burn(owner, assets);
+        _asset.transfer(receiver, assets);
+        return assets;
+    }
+
+    function maxRedeem(address owner) external view returns (uint256) {
+        return balanceOf(owner);
+    }
+
+    function previewRedeem(uint256 shares) external pure returns (uint256) {
+        return shares;
+    }
+
+    function redeem(uint256 shares, address receiver, address owner) external returns (uint256) {
+        require(balanceOf(owner) >= shares, "Insufficient balance");
+        _burn(owner, shares);
+        _asset.transfer(receiver, shares);
+        return shares;
+    }
+}
