feat: response message solidity

contracts/evm/contracts/xcall/CallService.sol

@@ -51,6 +51,8 @@
     mapping(uint256 => mapping(string => bool)) private pendingResponses;
 
     mapping(string => address) private defaultConnections;
+    bytes private callReply;
+    Types.ProxyRequest private replyState;
 
     address private owner;
     address private adminAddress;
@@ -125,8 +127,6 @@
         return _sendCallMessage(_to, _data, _rollback, src, dst);
     }
 
-
-
     function sendCall(
         string memory _to,
         bytes memory _data
@@ -157,16 +157,21 @@
         bytes memory _msg = req.encodeCSMessageRequest();
         require(_msg.length <= MAX_DATA_SIZE, "MaxDataSizeExceeded");
 
-        uint256 sendSn = result.needResponse ? sn : 0;
+        if (isReply(netTo, envelope.sources) && !result.needResponse) {
+            delete replyState;
+            callReply = _msg;
+        } else {
+            uint256 sendSn = result.needResponse ? sn : 0;
 
-        sendMessage(
-            envelope.sources,
-            netTo,
-            Types.CS_REQUEST,
-            int(sendSn),
-            _msg
-        );
-        claimProtocolFee();
+            sendMessage(
+                envelope.sources,
+                netTo,
+                Types.CS_REQUEST,
+                int(sendSn),
+                _msg
+            );
+            claimProtocolFee();
+        }
         emit CallMessageSent(caller, _to, sn);
         return sn;
     }
@@ -187,14 +192,7 @@
             for (uint i = 0; i < sources.length; i++) {
                 address conn = sources[i].parseAddress("IllegalArgument");
                 uint256 requiredFee = _getFee(conn, netTo, sn);
-                sendToConnection(
-                    conn,
-                    requiredFee,
-                    netTo,
-                    msgType,
-                    sn,
-                    data
-                );
+                sendToConnection(conn, requiredFee, netTo, msgType, sn, data);
             }
         }
     }
@@ -245,28 +243,23 @@
         Types.XCallEnvelope memory envelope;
 
         if (_rollback.length == 0) {
-
             Types.CallMessage memory _msg = Types.CallMessage(_data);
             envelope = Types.XCallEnvelope(
-           Types.CALL_MESSAGE_TYPE,
-            _msg.data,
-            sources,
-            destinations
-        );
-        } else {
-
-            Types.CallMessageWithRollback memory _msg = Types.CallMessageWithRollback(
-                _data,
-                _rollback
+                Types.CALL_MESSAGE_TYPE,
+                _msg.data,
+                sources,
+                destinations
             );
+        } else {
+            Types.CallMessageWithRollback memory _msg = Types
+                .CallMessageWithRollback(_data, _rollback);
 
             envelope = Types.XCallEnvelope(
-            Types.CALL_MESSAGE_ROLLBACK_TYPE,
-            _msg.encodeCallMessageWithRollback(),
-            sources,
-            destinations
-        );
-
+                Types.CALL_MESSAGE_ROLLBACK_TYPE,
+                _msg.encodeCallMessageWithRollback(),
+                sources,
+                destinations
+            );
         }
 
         return sendCall(_to, envelope.encodeXCallEnvelope());
@@ -283,23 +276,36 @@
 
         if (req.messageType == Types.CALL_MESSAGE_TYPE) {
             tryExecuteCall(_reqId, req.to, req.from, _data, protocols);
-        } else if (
-            req.messageType == Types.CALL_MESSAGE_ROLLBACK_TYPE
-        ) {
-            int256 code = tryExecuteCall(_reqId, req.to, req.from, _data, protocols);
+        } else if (req.messageType == Types.CALL_MESSAGE_ROLLBACK_TYPE) {
+            replyState = req;
+            int256 code = tryExecuteCall(
+                _reqId,
+                req.to,
+                req.from,
+                _data,
+                protocols
+            );
+            delete replyState;
+
+            bytes memory message;
 
+            if (callReply.length > 0 && code == Types.CS_RESP_SUCCESS) {
+                message = callReply;
+                delete callReply;
+            }
             Types.CSMessageResult memory response = Types.CSMessageResult(
                 req.sn,
-                code
+                code,
+                message
             );
 
             sendMessage(
                 protocols,
                 req.from.nid(),
                 Types.CS_RESULT,
-                int256(req.sn)*-1,
+                int256(req.sn) * -1,
                 response.encodeCSMessageResult()
-            ); 
+            );
         } else {
             revert("Message type is not yet supported");
         }
@@ -397,7 +403,7 @@
         if (csMsg.msgType == Types.CS_REQUEST) {
             handleRequest(_from, csMsg.payload);
         } else if (csMsg.msgType == Types.CS_RESULT) {
-            handlResult(csMsg.payload.decodeCSMessageResult());
+            handleResult(csMsg.payload.decodeCSMessageResult());
         } else {
             string memory errMsg = string("UnknownMsgType(")
                 .concat(uint(csMsg.msgType).toString())
@@ -407,7 +413,9 @@
     }
 
     function handleError(uint256 _sn) public override {
-        handlResult(Types.CSMessageResult(_sn, Types.CS_RESP_FAILURE));
+        handleResult(
+            Types.CSMessageResult(_sn, Types.CS_RESP_FAILURE, bytes(""))
+        );
     }
 
     function sendToConnection(
@@ -432,8 +440,8 @@
     ) internal {
         Types.CSMessageRequest memory req = msgPayload.decodeCSMessageRequest();
         string memory fromNID = req.from.nid();
-        require(netFrom.compareTo(fromNID),"Invalid NID");
-
+        require(netFrom.compareTo(fromNID), "Invalid NID");
+        
         bytes32 dataHash = keccak256(req.data);
         if (req.protocols.length > 1) {
             pendingReqs[dataHash][msg.sender.toString()] = true;
@@ -446,7 +454,10 @@
                 delete pendingReqs[dataHash][req.protocols[i]];
             }
         } else if (req.protocols.length == 1) {
-            require(msg.sender == req.protocols[0].parseAddress("IllegalArgument"), "NotAuthorized");
+            require(
+                msg.sender == req.protocols[0].parseAddress("IllegalArgument"),
+                "NotAuthorized"
+            );
         } else {
             require(msg.sender == defaultConnections[fromNID], "NotAuthorized");
         }
@@ -463,41 +474,74 @@
         emit CallMessage(req.from, req.to, req.sn, reqId, req.data);
     }
 
-    function handlResult(Types.CSMessageResult memory res) internal {
-        Types.RollbackData memory req = rollbacks[res.sn];
-        if (req.from == address(0)) {
+    function handleReply(
+        Types.RollbackData memory rollback,
+        Types.CSMessageRequest memory reply
+    ) internal {
+        require(
+            rollback.from == reply.to.parseAddress("IllegalArgument") &&
+                keccak256(bytes(rollback.to.nid())) ==
+                keccak256(bytes(reply.from.nid())),
+            "Invalid Reply"
+        );
+
+        uint256 reqId = getNextReqId();
+
+        emit CallMessage(reply.from, reply.to, reply.sn, reqId, reply.data);
+
+        proxyReqs[reqId] = Types.ProxyRequest(
+            reply.from,
+            reply.to,
+            reply.sn,
+            reply.messageType,
+            keccak256(reply.data),
+            rollback.sources
+        );
+    }
+
+    function handleResult(Types.CSMessageResult memory res) internal {
+        Types.RollbackData memory rollback = rollbacks[res.sn];
+        if (rollback.from == address(0)) {
             return;
         }
 
-        if (req.sources.length > 1) {
+        if (rollback.sources.length > 1) {
             pendingResponses[res.sn][msg.sender.toString()] = true;
-            for (uint i = 0; i < req.sources.length; i++) {
-                if (!pendingResponses[res.sn][req.sources[i]]) {
+            for (uint i = 0; i < rollback.sources.length; i++) {
+                if (!pendingResponses[res.sn][rollback.sources[i]]) {
                     return;
                 }
             }
 
-            for (uint i = 0; i < req.sources.length; i++) {
-                delete pendingResponses[res.sn][req.sources[i]];
+            for (uint i = 0; i < rollback.sources.length; i++) {
+                delete pendingResponses[res.sn][rollback.sources[i]];
             }
-        } else if (req.sources.length == 1) {
+        } else if (rollback.sources.length == 1) {
             require(
-                msg.sender == req.sources[0].parseAddress("IllegalArgument"),
+                msg.sender ==
+                    rollback.sources[0].parseAddress("IllegalArgument"),
                 "NotAuthorized"
             );
         } else {
-            require(msg.sender == defaultConnections[req.to], "NotAuthorized");
+            require(
+                msg.sender == defaultConnections[rollback.to],
+                "NotAuthorized"
+            );
         }
 
         emit ResponseMessage(res.sn, res.code);
         if (res.code == Types.CS_RESP_SUCCESS) {
             cleanupCallRequest(res.sn);
+            if (res.message.length > 0) {
+                handleReply(rollback, res.message.decodeCSMessageRequest());
+            }
             successfulResponses[res.sn] = true;
         } else {
             //emit rollback event
-            require(req.rollback.length > 0, "NoRollbackData");
-            req.enabled = true;
-            rollbacks[res.sn] = req;
+            require(rollback.rollback.length > 0, "NoRollbackData");
+            rollback.enabled = true;
+            rollbacks[res.sn] = rollback;
+
             emit RollbackMessage(res.sn);
         }
     }
@@ -588,6 +632,9 @@
         string[] memory _sources
     ) external view override returns (uint256) {
         uint256 fee = protocolFee;
+        if (isReply(_net, _sources) && !_rollback) {
+            return fee;
+        }
         for (uint i = 0; i < _sources.length; i++) {
             address conn = _sources[i].parseAddress("IllegalArgument");
             fee = fee + _getFee(conn, _net, _rollback);
@@ -596,6 +643,36 @@
         return fee;
     }
 
+    function isReply(
+        string memory _net,
+        string[] memory _sources
+    ) internal view returns (bool) {
+        if (keccak256(bytes(replyState.from)) != keccak256(bytes(""))) {
+            return
+                keccak256(bytes(replyState.from.nid())) ==
+                keccak256(bytes(_net)) &&
+                areArraysEqual(replyState.protocols, _sources);
+        }
+        return false;
+    }
+
+    function areArraysEqual(
+        string[] memory array1,
+        string[] memory array2
+    ) internal pure returns (bool) {
+        if (array1.length != array2.length) {
+            return false;
+        }
+
+        for (uint256 i = 0; i < array1.length; i++) {
+            if (keccak256(bytes(array1[i])) != keccak256(bytes(array2[i]))) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     function verifySuccess(uint256 _sn) external view returns (bool) {
         return successfulResponses[_sn];
     }

contracts/evm/library/utils/RLPDecodeStruct.sol

@@ -82,6 +82,6 @@ library RLPDecodeStruct {
         bytes memory _rlp
     ) internal pure returns (Types.CSMessageResult memory) {
         RLPDecode.RLPItem[] memory ls = _rlp.toRlpItem().toList();
-        return Types.CSMessageResult(ls[0].toUint(), int(ls[1].toInt()));
+        return Types.CSMessageResult(ls[0].toUint(), ls[1].toInt(), ls[2].toBytes());
     }
 }

contracts/evm/library/utils/RLPEncodeStruct.sol

@@ -80,7 +80,8 @@ library RLPEncodeStruct {
     ) internal pure returns (bytes memory) {
         bytes memory _rlp = abi.encodePacked(
             _bs.sn.encodeUint(),
-            _bs.code.encodeInt()
+            _bs.code.encodeInt(),
+            _bs.message.encodeBytes()
         );
         return _rlp.encodeList();
     }

contracts/evm/library/utils/Types.sol

@@ -53,6 +53,7 @@ library Types {
     struct CSMessageResult {
         uint256 sn;
         int code;
+        bytes message;
     }
 
     struct PendingResponse {