add encoding decoding tests

.gitmodules

@@ -3,6 +3,7 @@
 	url = https://github.com/foundry-rs/forge-std
 [submodule "lib/monorepo"]
 	path = lib/monorepo
+	branch = main
 	url = https://github.com/nomad-xyz/monorepo
 [submodule "lib/openzeppelin-contracts-upgradeable"]
 	path = lib/openzeppelin-contracts-upgradeable

foundry.toml

@@ -3,4 +3,5 @@ src = 'src'
 out = 'out'
 libs = ['lib']
 
+fuzz-runs = 1000
 solc_version = "0.7.6"

src/Messages.sol

@@ -58,8 +58,8 @@ library ConnectorMessages {
     function parseAddTranche(bytes29 _msg) internal pure returns (uint64 poolId, bytes16 trancheId, string memory tokenName, string memory tokenSymbol) {
         poolId = uint64(_msg.indexUint(1, 8));
         trancheId = bytes16(_msg.index(9, 16));
-        tokenName = bytes32ToString(bytes32(_msg.index(26, 32)));
-        tokenSymbol = bytes32ToString(bytes32(_msg.index(59, 32)));
+        tokenName = bytes32ToString(bytes32(_msg.index(25, 32)));
+        tokenSymbol = bytes32ToString(bytes32(_msg.index(57, 32)));
     }
 
     // TODO: should be moved to a util contract

src/routers/xcm/Router.sol

@@ -16,6 +16,7 @@ interface ConnectorLike {
 
 contract ConnectorXCMRouter is Router, Test {
     using TypedMemView for bytes;
+    // why bytes29? - https://github.com/summa-tx/memview-sol#why-bytes29
     using TypedMemView for bytes29;
     using ConnectorMessages for bytes29;
 

test/Messages.t.sol

@@ -4,6 +4,8 @@ pragma abicoder v2;
 
 import {TypedMemView} from "@summa-tx/memview-sol/contracts/TypedMemView.sol";
 import {ConnectorMessages} from "src/Messages.sol";
+import "forge-std/console.sol";
+import "forge-std/console2.sol";
 import "forge-std/Test.sol";
 
 contract MessagesTest is Test {
@@ -17,7 +19,7 @@ contract MessagesTest is Test {
         assertEq(
             ConnectorMessages.formatAddPool(0),
             fromHex("010000000000000000")
-        );
+        );       
         assertEq(
             ConnectorMessages.formatAddPool(1),
             fromHex("010000000000000001")
@@ -34,16 +36,16 @@ contract MessagesTest is Test {
             uint256(actualPoolId1),
             0
         );
-
+     
         uint64 actualPoolId2 = ConnectorMessages.parseAddPool(fromHex("010000000000000001").ref(0));
         assertEq(
-            uint256(actualPoolId1),
+            uint256(actualPoolId2),
             1
         );
 
         uint64 actualPoolId3 = ConnectorMessages.parseAddPool(fromHex("010000000000bce1a4").ref(0));
         assertEq(
-            uint256(actualPoolId1),
+            uint256(actualPoolId3),
             12378532
         );
     }
@@ -56,14 +58,23 @@ contract MessagesTest is Test {
 
     function testAddTrancheEncoding() public {
         assertEq(
-            ConnectorMessages.formatAddTranche(0, toBytes16(fromHex("100")), "Some Name", "SYMBOL"),
-            fromHex("010000000000000000")
+            ConnectorMessages.formatAddTranche(0, toBytes16(fromHex("010000000000000064")), "Some Name", "SYMBOL"),
+            fromHex("02000000000000000000000000000000000000000000000009536f6d65204e616d65000000000000000000000000000000000000000000000053594d424f4c0000000000000000000000000000000000000000000000000000")
         );
     }
 
+    function testAddTrancheDecoding() public returns (bytes memory) {
+        (uint64 decodedPoolId, bytes16 decodedTrancheId, string memory decodedTokenName, string memory decodedTokenSymbol) = ConnectorMessages.parseAddTranche(fromHex("02000000000000000000000000000000000000000000000009536f6d65204e616d65000000000000000000000000000000000000000000000053594d424f4c0000000000000000000000000000000000000000000000000000").ref(0));
+        assertEq(uint(decodedPoolId), uint(0));
+        assertEq(decodedTrancheId, toBytes16(fromHex("010000000000000064")));
+        assertEq(decodedTokenName, "Some Name"); 
+        assertEq(decodedTokenSymbol, "SYMBOL");
+    }
+
     function testAddTrancheEquivalence(uint64 poolId, bytes16 trancheId, string memory tokenName, string memory tokenSymbol)
         public
     {
+        // edge case token Symbol - not passing "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
         bytes memory _message = ConnectorMessages.formatAddTranche(
             poolId,
             trancheId,
@@ -78,6 +89,21 @@ contract MessagesTest is Test {
         assertEq(decodedTokenSymbol, tokenSymbol);
     }
 
+    function testUpdateMemberEncoding() public returns (bytes memory) {
+        assertEq(
+            ConnectorMessages.formatUpdateMember(5, toBytes16(fromHex("010000000000000003")), 0x225ef95fa90f4F7938A5b34234d14768cB4263dd, 1657870537), 
+            fromHex("04000000000000000500000000000000000000000000000009225ef95fa90f4f7938a5b34234d14768cb4263dd0000000000000000000000000000000000000000000000000000000062d118c9")
+            );
+    }
+
+    function testUpdateMemberDecoding() public returns (bytes memory) {
+        (uint64 decodedPoolId, bytes16 decodedTrancheId, address decodedUser, uint256 decodedValidUntil) = ConnectorMessages.parseUpdateMember(fromHex("04000000000000000500000000000000000000000000000009225ef95fa90f4f7938a5b34234d14768cb4263dd0000000000000000000000000000000000000000000000000000000062d118c9").ref(0));
+        assertEq(uint(decodedPoolId), uint(5));
+        assertEq(decodedTrancheId, toBytes16(fromHex("010000000000000003")));
+        assertEq(decodedUser, 0x225ef95fa90f4F7938A5b34234d14768cB4263dd);
+        assertEq(decodedValidUntil, uint(1657870537));
+    }
+
     function testUpdateMemberEquivalence(
         uint64 poolId,
         bytes16 trancheId,
@@ -102,6 +128,20 @@ contract MessagesTest is Test {
         assertEq(decodedAmount, amount);
     }
 
+    function testUpdateTokenPriceEncoding() public returns (bytes memory) {
+        assertEq(
+            ConnectorMessages.formatUpdateTokenPrice(3, toBytes16(fromHex("010000000000000005")), 100), 
+            fromHex("030000000000000003000000000000000000000000000000090000000000000000000000000000000000000000000000000000000000000064")
+            );
+    }
+
+      function testUpdateTokenPriceDecoding() public returns (bytes memory) {
+        (uint64 decodedPoolId, bytes16 decodedTrancheId, uint256 decodedPrice) = ConnectorMessages.parseUpdateTokenPrice(fromHex("030000000000000003000000000000000000000000000000090000000000000000000000000000000000000000000000000000000000000064").ref(0));
+        assertEq(uint(decodedPoolId), uint(3));
+        assertEq(decodedTrancheId, toBytes16(fromHex("010000000000000005")));
+        assertEq(decodedPrice, uint(100));
+    }
+
     function testUpdateTokenPriceEquivalence(
         uint64 poolId,
         bytes16 trancheId,
@@ -154,9 +194,8 @@ contract MessagesTest is Test {
 
     function toBytes16(bytes memory f) internal pure returns (bytes16 fc) {
         assembly {
-          fc := mload(add(f, 32))
+          fc := mload(add(f, 16))
         }
         return fc;
     }
-
 }