smom-dbis-138/test/emoney/unit/BridgeVault138Test.t.sol

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

import {Test} from "forge-std/Test.sol";
import {BridgeVault138} from "@emoney/BridgeVault138.sol";
import {PolicyManager} from "@emoney/PolicyManager.sol";
import {ComplianceRegistry} from "@emoney/ComplianceRegistry.sol";
import {DebtRegistry} from "@emoney/DebtRegistry.sol";
import {eMoneyToken} from "@emoney/eMoneyToken.sol";
import {MockLightClient} from "../mocks/MockLightClient.sol";
import "@emoney/errors/BridgeErrors.sol";
import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract BridgeVault138Test is Test {
    BridgeVault138 public bridgeVault;
    PolicyManager public policyManager;
    ComplianceRegistry public complianceRegistry;
    DebtRegistry public debtRegistry;
    eMoneyToken public token;
    MockLightClient public mockLightClient;

    address public admin;
    address public bridgeOperator;
    address public user1;
    address public user2;

    function setUp() public {
        admin = address(0x1);
        bridgeOperator = address(0x2);
        user1 = address(0x10);
        user2 = address(0x20);

        complianceRegistry = new ComplianceRegistry(admin);
        debtRegistry = new DebtRegistry(admin);
        policyManager = new PolicyManager(admin, address(complianceRegistry), address(debtRegistry));

        // Deploy token implementation
        eMoneyToken implementation = new eMoneyToken();
        bytes memory initData = abi.encodeWithSelector(
            eMoneyToken.initialize.selector,
            "Test Token",
            "TEST",
            18,
            admin,
            address(policyManager),
            address(debtRegistry),
            address(complianceRegistry)
        );
        ERC1967Proxy proxy = new ERC1967Proxy(address(implementation), initData);
        token = eMoneyToken(address(proxy));

        bridgeVault = new BridgeVault138(admin, address(policyManager), address(complianceRegistry));
        mockLightClient = new MockLightClient();

        // Set up roles
        vm.startPrank(admin);
        bridgeVault.grantRole(bridgeVault.BRIDGE_OPERATOR_ROLE(), bridgeOperator);
        bridgeVault.setLightClient(address(mockLightClient));
        complianceRegistry.grantRole(complianceRegistry.COMPLIANCE_ROLE(), admin);
        complianceRegistry.setCompliance(user1, true, 1, bytes32(0));
        complianceRegistry.setCompliance(user2, true, 1, bytes32(0));
        complianceRegistry.setCompliance(address(bridgeVault), true, 1, bytes32(0));
        policyManager.grantRole(policyManager.POLICY_OPERATOR_ROLE(), admin);
        policyManager.setLienMode(address(token), 2);
        vm.stopPrank();

        // Grant issuer role (admin has DEFAULT_ADMIN_ROLE from token initialization)
        vm.startPrank(admin);
        token.grantRole(token.ISSUER_ROLE(), admin);
        vm.stopPrank();
    }

    function test_lock_success() public {
        vm.prank(admin);
        token.mint(user1, 1000, bytes32(0));

        vm.prank(user1);
        token.approve(address(bridgeVault), 500);

        vm.prank(user1);
        // forge-lint: disable-next-line(unsafe-typecast)
        // casting to 'bytes32' is safe for test data
        bridgeVault.lock(address(token), 500, bytes32("ethereum"), user2);

        assertEq(token.balanceOf(address(bridgeVault)), 500);
        assertEq(token.balanceOf(user1), 500);
    }

    function test_lock_transferBlocked() public {
        vm.prank(admin);
        token.mint(user1, 1000, bytes32(0));

        // Freeze user1 to block transfer
        vm.prank(admin);
        complianceRegistry.setFrozen(user1, true);

        vm.prank(user1);
        token.approve(address(bridgeVault), 500);

        vm.prank(user1);
        vm.expectRevert(abi.encodeWithSelector(BridgeTransferBlocked.selector, address(token), user1, address(bridgeVault), 500));
        bridgeVault.lock(address(token), 500, bytes32("ethereum"), user2);

        // Verify tokens were NOT transferred (logic order fix)
        assertEq(token.balanceOf(address(bridgeVault)), 0);
        assertEq(token.balanceOf(user1), 1000);
    }

    function test_unlock_success() public {
        vm.prank(admin);
        token.mint(user1, 1000, bytes32(0));

        vm.prank(user1);
        token.approve(address(bridgeVault), 500);

        vm.prank(user1);
        // forge-lint: disable-next-line(unsafe-typecast)
        // casting to 'bytes32' is safe for test data
        bridgeVault.lock(address(token), 500, bytes32("ethereum"), user2);

        // forge-lint: disable-next-line(unsafe-typecast)
        // casting to 'bytes32' is safe for test data
        bytes32 sourceChain = bytes32("ethereum");
        // forge-lint: disable-next-line(unsafe-typecast)
        // casting to 'bytes32' is safe for test data
        bytes32 sourceTx = bytes32("txhash");
        mockLightClient.registerProof(sourceChain, sourceTx);

        vm.prank(bridgeOperator);
        bridgeVault.unlock(address(token), user2, 500, sourceChain, sourceTx, "");

        assertEq(token.balanceOf(address(bridgeVault)), 0);
        assertEq(token.balanceOf(user2), 500);
    }

    function test_unlock_proofVerificationFails() public {
        vm.prank(admin);
        token.mint(user1, 1000, bytes32(0));

        vm.prank(user1);
        token.approve(address(bridgeVault), 500);

        vm.prank(user1);
        // forge-lint: disable-next-line(unsafe-typecast)
        // casting to 'bytes32' is safe for test data
        bridgeVault.lock(address(token), 500, bytes32("ethereum"), user2);

        mockLightClient.setAlwaysVerify(false);

        vm.prank(bridgeOperator);
        // forge-lint: disable-next-line(unsafe-typecast)
        // casting to 'bytes32' is safe for test data
        vm.expectRevert(abi.encodeWithSelector(BridgeProofVerificationFailed.selector, bytes32("ethereum"), bytes32("txhash")));
        bridgeVault.unlock(address(token), user2, 500, bytes32("ethereum"), bytes32("txhash"), "");
    }

    function test_unlock_lightClientNotSet() public {
        BridgeVault138 newVault = new BridgeVault138(admin, address(policyManager), address(complianceRegistry));
        vm.startPrank(admin);
        newVault.grantRole(newVault.BRIDGE_OPERATOR_ROLE(), bridgeOperator);
        complianceRegistry.setCompliance(address(newVault), true, 1, bytes32(0));
        vm.stopPrank();

        vm.prank(admin);
        token.mint(user1, 1000, bytes32(0));

        vm.prank(user1);
        token.approve(address(newVault), 500);

        vm.prank(user1);
        newVault.lock(address(token), 500, bytes32("ethereum"), user2);

        vm.prank(bridgeOperator);
        vm.expectRevert(BridgeLightClientNotSet.selector);
        newVault.unlock(address(token), user2, 500, bytes32("ethereum"), bytes32("txhash"), "");
    }

    function test_lock_zeroToken() public {
        vm.prank(user1);
        vm.expectRevert(BridgeZeroToken.selector);
        bridgeVault.lock(address(0), 500, bytes32("ethereum"), user2);
    }

    function test_lock_zeroAmount() public {
        vm.prank(admin);
        token.mint(user1, 1000, bytes32(0));

        vm.prank(user1);
        token.approve(address(bridgeVault), 500);

        vm.prank(user1);
        vm.expectRevert(BridgeZeroAmount.selector);
        bridgeVault.lock(address(token), 0, bytes32("ethereum"), user2);
    }

    function test_lock_zeroRecipient() public {
        vm.prank(admin);
        token.mint(user1, 1000, bytes32(0));

        vm.prank(user1);
        token.approve(address(bridgeVault), 500);

        vm.prank(user1);
        vm.expectRevert(BridgeZeroRecipient.selector);
        bridgeVault.lock(address(token), 500, bytes32("ethereum"), address(0));
    }

    function test_unlock_nonCompliantRecipient() public {
        address nonCompliant = address(0x99);

        vm.prank(admin);
        token.mint(user1, 1000, bytes32(0));

        vm.prank(user1);
        token.approve(address(bridgeVault), 500);

        vm.prank(user1);
        bridgeVault.lock(address(token), 500, bytes32("ethereum"), nonCompliant);

        // forge-lint: disable-next-line(unsafe-typecast)
        // casting to 'bytes32' is safe for test data
        bytes32 sourceChain = bytes32("ethereum");
        // forge-lint: disable-next-line(unsafe-typecast)
        // casting to 'bytes32' is safe for test data
        bytes32 sourceTx = bytes32("txhash");
        mockLightClient.registerProof(sourceChain, sourceTx);

        vm.prank(bridgeOperator);
        vm.expectRevert(abi.encodeWithSelector(BridgeRecipientNotCompliant.selector, nonCompliant));
        bridgeVault.unlock(address(token), nonCompliant, 500, sourceChain, sourceTx, "");
    }

    function test_unlock_frozenRecipient() public {
        vm.prank(admin);
        token.mint(user1, 1000, bytes32(0));

        vm.prank(user1);
        token.approve(address(bridgeVault), 500);

        vm.prank(user1);
        // forge-lint: disable-next-line(unsafe-typecast)
        // casting to 'bytes32' is safe for test data
        bridgeVault.lock(address(token), 500, bytes32("ethereum"), user2);

        vm.prank(admin);
        complianceRegistry.setFrozen(user2, true);

        // forge-lint: disable-next-line(unsafe-typecast)
        // casting to 'bytes32' is safe for test data
        bytes32 sourceChain = bytes32("ethereum");
        // forge-lint: disable-next-line(unsafe-typecast)
        // casting to 'bytes32' is safe for test data
        bytes32 sourceTx = bytes32("txhash");
        mockLightClient.registerProof(sourceChain, sourceTx);

        vm.prank(bridgeOperator);
        vm.expectRevert(abi.encodeWithSelector(BridgeRecipientFrozen.selector, user2));
        bridgeVault.unlock(address(token), user2, 500, sourceChain, sourceTx, "");
    }

    function test_lock_reentrancy() public {
        vm.prank(admin);
        token.mint(user1, 1000, bytes32(0));

        vm.prank(user1);
        token.approve(address(bridgeVault), 1000);

        // This test verifies that nonReentrant modifier prevents reentrancy
        // In a real attack, a malicious contract would try to reenter during the transfer
        vm.prank(user1);
        // forge-lint: disable-next-line(unsafe-typecast)
        // casting to 'bytes32' is safe for test data
        bridgeVault.lock(address(token), 500, bytes32("ethereum"), user2);

        // If reentrancy was possible, balance would be wrong
        assertEq(token.balanceOf(address(bridgeVault)), 500);
        assertEq(token.balanceOf(user1), 500);
    }
}