refactor: enhance transaction management and testing in Coordinator contract

Author: YukiTsuchida

test/Coordinator.t.sol

@@ -7,35 +7,47 @@ import "../src/core/Coordinator.sol";
 import "../src/core/TxManagerBase.sol";
 import "../src/core/TxAuthManagerBase.sol";
 import {ICrossError} from "../src/core/ICrossError.sol";
+import {ICrossEvent} from "../src/core/ICrossEvent.sol";
 import {
     QueryCoordinatorStateRequest,
     QueryCoordinatorStateResponse,
     CoordinatorState
 } from "../src/proto/cross/core/atomic/simple/AtomicSimple.sol";
-import {MsgInitiateTx} from "../src/proto/cross/core/initiator/Initiator.sol";
+import {MsgInitiateTx, ContractTransaction} from "../src/proto/cross/core/initiator/Initiator.sol";
 import {Tx} from "../src/proto/cross/core/tx/Tx.sol";
+import {Account as AuthAccount} from "../src/proto/cross/core/auth/Auth.sol";
+import {IbcCoreClientV1Height} from "../src/proto/ibc/core/client/v1/client.sol";
 
 contract MockTxManager is TxManagerBase, ICrossError {
     mapping(bytes32 => CoordinatorState.Data) internal mockStates;
-    mapping(bytes32 => bool) internal exists;
+    mapping(bytes32 => bool) internal recordedTxs;
+    mapping(bytes32 => bool) internal stateExists;
+    uint256 public runCount;
 
     function setCoordinatorState(bytes32 txID, CoordinatorState.Data memory data) public {
         mockStates[txID] = data;
-        exists[txID] = true;
+        stateExists[txID] = true;
+    }
+
+    function setTxRecorded(bytes32 txID, bool recorded) public {
+        recordedTxs[txID] = recorded;
     }
 
     function _getCoordinatorState(bytes32 txID) internal view virtual override returns (CoordinatorState.Data memory) {
-        if (!exists[txID]) {
+        if (!stateExists[txID]) {
             revert CoordinatorStateNotFound(txID);
         }
         return mockStates[txID];
     }
 
     function _createTx(bytes32, MsgInitiateTx.Data calldata) internal virtual override {}
-    function _runTxIfCompleted(MsgInitiateTx.Data calldata) internal virtual override {}
 
-    function _isTxRecorded(bytes32) internal view virtual override returns (bool) {
-        return false;
+    function _runTxIfCompleted(MsgInitiateTx.Data calldata) internal virtual override {
+        ++runCount;
+    }
+
+    function _isTxRecorded(bytes32 txID) internal view virtual override returns (bool) {
+        return recordedTxs[txID];
     }
 }
 
@@ -65,12 +77,71 @@ contract MockTxAuthManager is TxAuthManagerBase {
 
 contract CoordinatorHarness is Coordinator, MockTxManager, MockTxAuthManager {}
 
-contract CoordinatorTest is Test, ICrossError {
+contract CoordinatorTest is Test, ICrossError, ICrossEvent {
     CoordinatorHarness private harness;
-    bytes32 private txID = keccak256("test_tx_id");
+    MsgInitiateTx.Data private dummyMsg;
+    bytes32 private txID;
 
     function setUp() public {
         harness = new CoordinatorHarness();
+
+        dummyMsg = MsgInitiateTx.Data({
+            chain_id: "test-chain",
+            nonce: 1,
+            commit_protocol: Tx.CommitProtocol.COMMIT_PROTOCOL_SIMPLE,
+            timeout_height: IbcCoreClientV1Height.Data(0, 0),
+            timeout_timestamp: 0,
+            signers: new AuthAccount.Data[](0),
+            contract_transactions: new ContractTransaction.Data[](0)
+        });
+
+        txID = sha256(MsgInitiateTx.encode(dummyMsg));
+    }
+
+    function test_executeTx_Succeeds() public {
+        harness.setTxRecorded(txID, true);
+        harness.setCompletedAuth(txID, true);
+
+        vm.expectEmit(address(harness));
+        emit TxExecuted(abi.encodePacked(txID), address(this));
+
+        harness.executeTx(dummyMsg);
+
+        assertEq(harness.runCount(), 1, "runTxIfCompleted should be called");
+    }
+
+    function test_executeTx_RevertIf_TimeoutHeight() public {
+        dummyMsg.timeout_height.revision_height = uint64(block.number);
+
+        vm.expectRevert(
+            abi.encodeWithSelector(MessageTimeoutHeight.selector, block.number, dummyMsg.timeout_height.revision_height)
+        );
+        harness.executeTx(dummyMsg);
+    }
+
+    function test_executeTx_RevertIf_TimeoutTimestamp() public {
+        dummyMsg.timeout_timestamp = uint64(block.timestamp);
+
+        vm.expectRevert(
+            abi.encodeWithSelector(MessageTimeoutTimestamp.selector, block.timestamp, dummyMsg.timeout_timestamp)
+        );
+        harness.executeTx(dummyMsg);
+    }
+
+    function test_executeTx_RevertIf_TxNotRecorded() public {
+        harness.setTxRecorded(txID, false);
+        harness.setCompletedAuth(txID, true);
+
+        vm.expectRevert(abi.encodeWithSelector(TxIDNotFound.selector, txID));
+        harness.executeTx(dummyMsg);
+    }
+
+    function test_executeTx_RevertIf_AuthNotCompleted() public {
+        harness.setTxRecorded(txID, true);
+        harness.setCompletedAuth(txID, false);
+
+        vm.expectRevert(abi.encodeWithSelector(AuthNotCompleted.selector, txID));
+        harness.executeTx(dummyMsg);
     }
 
     function test_coordinatorState_ReturnsCorrectState() public {