Merge pull request #39 from synapsecns/feat/message-change

Add Latency to Message Body

packages/contracts/contracts/Home.sol

@@ -65,7 +65,6 @@ contract Home is Version0, QueueManager, MerkleTreeManager, SynapseBase {
         uint256 indexed leafIndex,
         uint64 indexed destinationAndNonce,
         bytes32 committedRoot,
-        uint32 optimisticSeconds,
         bytes message
     );
 
@@ -185,10 +184,11 @@ contract Home is Version0, QueueManager, MerkleTreeManager, SynapseBase {
             _nonce,
             _destinationDomain,
             _recipientAddress,
+            _optimisticSeconds,
             _messageBody
         );
         // insert the hashed message into the Merkle tree
-        bytes32 _messageHash = keccak256(abi.encodePacked(_message, _optimisticSeconds));
+        bytes32 _messageHash = keccak256(_message);
         tree.insert(_messageHash);
         // enqueue the new Merkle root after inserting the message
         queue.enqueue(root());
@@ -199,7 +199,6 @@ contract Home is Version0, QueueManager, MerkleTreeManager, SynapseBase {
             count() - 1,
             _destinationAndNonce(_destinationDomain, _nonce),
             committedRoot,
-            _optimisticSeconds,
             _message
         );
     }

packages/contracts/contracts/ReplicaManager.sol

@@ -247,11 +247,10 @@ contract ReplicaManager is Version0, Initializable, OwnableUpgradeable {
     function proveAndProcess(
         uint32 _remoteDomain,
         bytes memory _message,
-        uint32 _optimisticSeconds,
         bytes32[32] calldata _proof,
         uint256 _index
     ) external {
-        require(prove(_remoteDomain, _message, _optimisticSeconds, _proof, _index), "!prove");
+        require(prove(_remoteDomain, _message, _proof, _index), "!prove");
         process(_message);
     }
 
@@ -404,26 +403,25 @@ contract ReplicaManager is Version0, Initializable, OwnableUpgradeable {
      * @dev For convenience, we allow proving against any previous root.
      * This means that witnesses never need to be updated for the new root
      * @param _message Formatted message
-     * @param _optimisticSeconds Latency period requested by app on Home, included in part of Merkle proof
      * @param _proof Merkle proof of inclusion for leaf
      * @param _index Index of leaf in home's merkle tree
      * @return Returns true if proof was valid and `prove` call succeeded
      **/
     function prove(
         uint32 _remoteDomain,
         bytes memory _message,
-        uint32 _optimisticSeconds,
         bytes32[32] calldata _proof,
         uint256 _index
     ) public returns (bool) {
-        bytes32 _leaf = keccak256(abi.encodePacked(_message, _optimisticSeconds));
+        uint32 optimisticSeconds = _message.ref(0).optimisticSeconds();
+        bytes32 _leaf = keccak256(_message);
         ReplicaLib.Replica storage replica = allReplicas[activeReplicas[_remoteDomain]];
         // ensure that message has not been proven or processed
         require(replica.messages[_leaf] == ReplicaLib.MessageStatus.None, "!MessageStatus.None");
         // calculate the expected root based on the proof
         bytes32 _calculatedRoot = MerkleLib.branchRoot(_leaf, _proof, _index);
         // if the root is valid, change status to Proven
-        if (acceptableRoot(_remoteDomain, _optimisticSeconds, _calculatedRoot)) {
+        if (acceptableRoot(_remoteDomain, optimisticSeconds, _calculatedRoot)) {
             replica.setMessageStatus(_leaf, ReplicaLib.MessageStatus.Processed);
             return true;
         }

packages/contracts/contracts/libs/Message.sol

@@ -15,7 +15,7 @@ library Message {
     using TypedMemView for bytes29;
 
     // Number of bytes in formatted message before `body` field
-    uint256 internal constant PREFIX_LENGTH = 76;
+    uint256 internal constant PREFIX_LENGTH = 80;
 
     /**
      * @notice Returns formatted (packed) message with provided fields
@@ -33,6 +33,7 @@ library Message {
         uint32 _nonce,
         uint32 _destinationDomain,
         bytes32 _recipient,
+        uint32 _optimisticSeconds,
         bytes memory _messageBody
     ) internal pure returns (bytes memory) {
         return
@@ -42,6 +43,7 @@ library Message {
                 _nonce,
                 _destinationDomain,
                 _recipient,
+                _optimisticSeconds,
                 _messageBody
             );
     }
@@ -62,9 +64,10 @@ library Message {
         uint32 _nonce,
         uint32 _destination,
         bytes32 _recipient,
+        uint32 _optimisticSeconds,
         bytes memory _body
     ) internal pure returns (bytes32) {
-        return keccak256(formatMessage(_origin, _sender, _nonce, _destination, _recipient, _body));
+        return keccak256(formatMessage(_origin, _sender, _nonce, _destination, _recipient, _optimisticSeconds, _body));
     }
 
     /// @notice Returns message's origin field
@@ -92,6 +95,11 @@ library Message {
         return _message.index(44, 32);
     }
 
+    /// @notice Returns the optimistic seconds from the message
+    function optimisticSeconds(bytes29 _message) internal pure returns (uint32){
+        return uint32(_message.indexUint(76, 4));
+    }
+
     /// @notice Returns message's recipient field as an address
     function recipientAddress(bytes29 _message) internal pure returns (address) {
         return TypeCasts.bytes32ToAddress(recipient(_message));
@@ -110,6 +118,7 @@ library Message {
                 nonce(_message),
                 destination(_message),
                 recipient(_message),
+                optimisticSeconds(_message),
                 TypedMemView.clone(body(_message))
             );
     }

packages/contracts/test/Home.t.sol

@@ -85,7 +85,6 @@ contract HomeTest is SynapseTestWithUpdaterManager {
         uint256 indexed leafIndex,
         uint64 indexed destinationAndNonce,
         bytes32 committedRoot,
-        uint32 optimisticSeconds,
         bytes message
     );
 
@@ -101,16 +100,16 @@ contract HomeTest is SynapseTestWithUpdaterManager {
             nonce,
             remoteDomain,
             recipient,
+            optimisticSeconds,
             messageBody
         );
-        bytes32 messageHash = keccak256(abi.encodePacked(message, optimisticSeconds));
+        bytes32 messageHash = keccak256(message);
         vm.expectEmit(true, true, true, true);
         emit Dispatch(
             messageHash,
             home.count(),
             (uint64(remoteDomain) << 32) | nonce,
             home.committedRoot(),
-            optimisticSeconds,
             message
         );
         vm.prank(sender);
@@ -130,6 +129,7 @@ contract HomeTest is SynapseTestWithUpdaterManager {
             nonce,
             remoteDomain,
             recipient,
+            optimisticSeconds,
             messageBody
         );
         vm.prank(sender);

packages/contracts/test/Message.t.sol

@@ -17,6 +17,7 @@ contract MessageTest is Test {
     bytes32 sender;
     uint32 nonce;
     uint32 destinationDomain;
+    uint32 optimisticSeconds;
     bytes32 recipient;
     bytes messageBody;
 
@@ -26,6 +27,7 @@ contract MessageTest is Test {
         sender = bytes32("AAAA THE SENDOOOOOR");
         nonce = 0;
         destinationDomain = 2000;
+        optimisticSeconds = 4;
         recipient = bytes32("AAAA THE RECEIVOOOR");
         messageBody = bytes("Messagoooor");
     }
@@ -37,6 +39,7 @@ contract MessageTest is Test {
             nonce,
             destinationDomain,
             recipient,
+            optimisticSeconds,
             messageBody
         );
 
@@ -46,6 +49,7 @@ contract MessageTest is Test {
         assertEq(messageHarness.nonce(message), nonce);
         assertEq(messageHarness.destination(message), destinationDomain);
         assertEq(messageHarness.recipient(message), recipient);
+        assertEq(messageHarness.optimisticSeconds(message), optimisticSeconds);
         assertEq(messageHarness.body(message), (messageBody));
         assertEq(messageHarness.leaf(message), keccak256(message));
     }
@@ -57,6 +61,7 @@ contract MessageTest is Test {
             nonce,
             destinationDomain,
             recipient,
+            optimisticSeconds,
             messageBody
         );
 
@@ -66,6 +71,7 @@ contract MessageTest is Test {
             nonce,
             destinationDomain,
             recipient,
+            optimisticSeconds,
             messageBody
         );
 

packages/contracts/test/ReplicaManager.t.sol

@@ -121,7 +121,7 @@ contract ReplicaManagerTest is SynapseTest {
     // Relayer relays a new root signed by updater on Home chain
     function test_successfulUpdate() public {
         bytes memory newMessage = "new root";
-        bytes32 newRoot = keccak256(abi.encodePacked(newMessage, optimisticSeconds));
+        bytes32 newRoot = keccak256(newMessage);
         assertEq(replicaManager.updater(), vm.addr(updaterPK));
         bytes memory sig = signRemoteUpdate(updaterPK, committedRoot, newRoot);
         // Root doesn't exist yet
@@ -144,15 +144,15 @@ contract ReplicaManagerTest is SynapseTest {
 
     function test_updateWithIncorrectSig() public {
         bytes memory newMessage = "new root";
-        bytes32 newRoot = keccak256(abi.encodePacked(newMessage, optimisticSeconds));
+        bytes32 newRoot = keccak256(newMessage);
         bytes memory sig = signRemoteUpdate(fakeUpdaterPK, committedRoot, newRoot);
         vm.expectRevert("!updater sig");
         replicaManager.update(remoteDomain, committedRoot, newRoot, sig);
     }
 
     function test_acceptableRoot() public {
         bytes memory newMessage = "new root";
-        bytes32 newRoot = keccak256(abi.encodePacked(newMessage, optimisticSeconds));
+        bytes32 newRoot = keccak256(newMessage);
         test_successfulUpdate();
         vm.warp(block.timestamp + optimisticSeconds + 1);
         assertTrue(replicaManager.acceptableRoot(remoteDomain, optimisticSeconds, newRoot));

packages/contracts/test/harnesses/MessageHarness.sol

@@ -16,6 +16,7 @@ contract MessageHarness {
         uint32 _nonce,
         uint32 _destinationDomain,
         bytes32 _recipient,
+        uint32 _optimisticSeconds,
         bytes memory _messageBody
     ) public pure returns (bytes memory) {
         return
@@ -25,6 +26,7 @@ contract MessageHarness {
                 _nonce,
                 _destinationDomain,
                 _recipient,
+                _optimisticSeconds,
                 _messageBody
             );
     }
@@ -45,9 +47,10 @@ contract MessageHarness {
         uint32 _nonce,
         uint32 _destination,
         bytes32 _recipient,
+        uint32 _optimisticSeconds,
         bytes memory _body
     ) public pure returns (bytes32) {
-        return Message.messageHash(_origin, _sender, _nonce, _destination, _recipient, _body);
+        return Message.messageHash(_origin, _sender, _nonce, _destination, _recipient, _optimisticSeconds, _body);
     }
 
     function body(bytes memory _message) external view returns (bytes memory) {
@@ -78,6 +81,10 @@ contract MessageHarness {
         return _message.ref(0).recipientAddress();
     }
 
+    function optimisticSeconds(bytes memory _message) external pure returns (uint32) {
+        return _message.ref(0).optimisticSeconds();
+    }
+
     function leaf(bytes memory _message) external view returns (bytes32) {
         return _message.ref(0).leaf();
     }