smom-dbis-138/test/emoney/fuzz/SettlementFuzz.t.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import {Test} from "forge-std/Test.sol";
import {RailEscrowVault} from "@emoney/RailEscrowVault.sol";
import {IRailEscrowVault} from "@emoney/interfaces/IRailEscrowVault.sol";
import {RailTypes} from "@emoney/libraries/RailTypes.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MockERC20 is ERC20 {
    constructor() ERC20("Mock Token", "MOCK") {
        _mint(msg.sender, type(uint256).max / 2); // Avoid overflow
    }

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

contract SettlementFuzzTest is Test {
    RailEscrowVault public vault;
    MockERC20 public token;
    address public admin;
    address public settlementOperator;
    address public user;

    function setUp() public {
        admin = address(0x1);
        settlementOperator = address(0x2);
        user = address(0x10);

        vault = new RailEscrowVault(admin);
        token = new MockERC20();

        vm.startPrank(admin);
        vault.grantRole(vault.SETTLEMENT_OPERATOR_ROLE(), settlementOperator);
        vm.stopPrank();
    }

    function testFuzz_lockAndRelease(
        uint256 amount,
        uint256 triggerId
    ) public {
        vm.assume(amount > 0);
        vm.assume(amount < type(uint128).max);
        vm.assume(triggerId > 0);
        vm.assume(triggerId < type(uint128).max);

        // Give user tokens
        token.mint(user, amount);

        vm.startPrank(user);
        token.approve(address(vault), amount);
        vm.stopPrank();

        // Lock
        vm.prank(settlementOperator);
        vault.lock(address(token), user, amount, triggerId, RailTypes.Rail.SWIFT);

        assertEq(vault.getEscrowAmount(address(token), triggerId), amount);
        assertEq(vault.getTotalEscrow(address(token)), amount);

        // Release
        address recipient = address(0x20);
        uint256 recipientBalanceBefore = token.balanceOf(recipient);

        vm.prank(settlementOperator);
        vault.release(address(token), recipient, amount, triggerId);

        assertEq(vault.getEscrowAmount(address(token), triggerId), 0);
        assertEq(vault.getTotalEscrow(address(token)), 0);
        assertEq(token.balanceOf(recipient), recipientBalanceBefore + amount);
    }

    function testFuzz_multipleLocks(
        uint256 amount1,
        uint256 amount2,
        uint256 triggerId1,
        uint256 triggerId2
    ) public {
        vm.assume(amount1 > 0 && amount2 > 0);
        vm.assume(amount1 < type(uint128).max / 2);
        vm.assume(amount2 < type(uint128).max / 2);
        vm.assume(triggerId1 > 0 && triggerId2 > 0);
        vm.assume(triggerId1 != triggerId2);
        vm.assume(triggerId1 < type(uint128).max && triggerId2 < type(uint128).max);

        uint256 totalAmount = amount1 + amount2;
        token.mint(user, totalAmount);

        vm.startPrank(user);
        token.approve(address(vault), totalAmount);
        vm.stopPrank();

        // Lock first amount
        vm.prank(settlementOperator);
        vault.lock(address(token), user, amount1, triggerId1, RailTypes.Rail.SWIFT);

        // Lock second amount
        vm.prank(settlementOperator);
        vault.lock(address(token), user, amount2, triggerId2, RailTypes.Rail.FEDWIRE);

        assertEq(vault.getEscrowAmount(address(token), triggerId1), amount1);
        assertEq(vault.getEscrowAmount(address(token), triggerId2), amount2);
        assertEq(vault.getTotalEscrow(address(token)), totalAmount);
    }

    function testFuzz_releaseInsufficient(
        uint256 lockAmount,
        uint256 releaseAmount,
        uint256 triggerId
    ) public {
        vm.assume(lockAmount > 0);
        vm.assume(releaseAmount > lockAmount); // Try to release more than locked
        vm.assume(lockAmount < type(uint128).max);
        vm.assume(triggerId > 0);

        token.mint(user, lockAmount);

        vm.startPrank(user);
        token.approve(address(vault), lockAmount);
        vm.stopPrank();

        vm.prank(settlementOperator);
        vault.lock(address(token), user, lockAmount, triggerId, RailTypes.Rail.SWIFT);

        vm.prank(settlementOperator);
        vm.expectRevert("RailEscrowVault: insufficient escrow");
        vault.release(address(token), address(0x20), releaseAmount, triggerId);
    }
}