add depost & withdraw functions

.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/Connector.sol

@@ -96,6 +96,7 @@ contract CentrifugeConnector is Test {
 
         address memberlist = memberlistFactory.newMemberlist();
         RestrictedTokenLike(token).depend("memberlist", memberlist);
+        MemberlistLike(memberlist).updateMember(address(this), uint(-1)); // required to be able to receive tokens in case of withdrawals
 
         emit TrancheAdded(poolId, trancheId, token);
     }
@@ -121,7 +122,7 @@ contract CentrifugeConnector is Test {
         memberlist.updateMember(user, validUntil);
     }
 
-    function transferTo(
+    function deposit(
         uint64 poolId,
         bytes16 trancheId,
         address user,
@@ -131,5 +132,17 @@ contract CentrifugeConnector is Test {
         require(token.hasMember(user), "CentrifugeConnector/not-a-member");
         token.mint(user, amount);
     }
+
+    function withdraw(
+        uint64 poolId,
+        bytes16 trancheId,
+        address user,
+        uint256 amount
+    ) public onlyRouter {
+        RestrictedTokenLike token = RestrictedTokenLike(tranches[poolId][trancheId].token);
+        require(token.balanceOf(user) >= amount, "CentrifugeConnector/insufficient-balance"); // optional
+        require(token.transferFrom(user, address(this), amount), "CentrifugeConnector/token-transfer-failed");
+        token.burn(address(this), amount);
+    }
 
 }

src/Messages.sol

@@ -13,7 +13,10 @@ library ConnectorMessages {
         AddTranche,
         UpdateTokenPrice,
         UpdateMember,
-        TransferTo
+        TransferTo, 
+        Deposit,
+        Withdraw
+
     }
 
     function messageType(bytes29 _msg) internal pure returns (Call _call) {
@@ -58,8 +61,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
@@ -135,4 +138,54 @@ library ConnectorMessages {
         price = uint256(_msg.index(25, 32));
     }
 
+
+    /**
+     * Deposit
+     * 
+     * 0: call type (uint8 = 1 byte)
+     * 1-8: poolId (uint64 = 8 bytes)
+     * 9-25: trancheId (16 bytes)
+     * 26-46: user (Ethereum address, 20 bytes)
+     * 47-78: amount (uint256 = 32 bytes)
+     * 
+     */
+    function formatDeposit(uint64 poolId, bytes16 trancheId, address user, uint256 amount) internal pure returns (bytes memory) {
+        return abi.encodePacked(uint8(Call.Deposit), poolId, trancheId, user, amount);
+    }
+
+    function isDeposit(bytes29 _msg) internal pure returns (bool) {
+        return messageType(_msg) == Call.Deposit;
+    }
+
+    function parseDeposit(bytes29 _msg) internal pure returns (uint64 poolId, bytes16 trancheId, address user, uint256 amount) {
+        poolId = uint64(_msg.indexUint(1, 8));
+        trancheId = bytes16(_msg.index(9, 16));
+        user = address(bytes20(_msg.index(25, 20)));
+        amount = uint256(_msg.index(45, 32));
+    }
+
+     /**
+     * Withdraw
+     * 
+     * 0: call type (uint8 = 1 byte)
+     * 1-8: poolId (uint64 = 8 bytes)
+     * 9-25: trancheId (16 bytes)
+     * 26-46: user (Ethereum address, 20 bytes)
+     * 47-78: amount (uint256 = 32 bytes)
+     * 
+     */
+    function formatWithdraw(uint64 poolId, bytes16 trancheId, address user, uint256 amount) internal pure returns (bytes memory) {
+        return abi.encodePacked(uint8(Call.Withdraw), poolId, trancheId, user, amount);
+    }
+
+    function isWithdraw(bytes29 _msg) internal pure returns (bool) {
+        return messageType(_msg) == Call.Withdraw;
+    }
+
+    function parseWithdraw(bytes29 _msg) internal pure returns (uint64 poolId, bytes16 trancheId, address user, uint256 amount) {
+        poolId = uint64(_msg.indexUint(1, 8));
+        trancheId = bytes16(_msg.index(9, 16));
+        user = address(bytes20(_msg.index(25, 20)));
+        amount = uint256(_msg.index(45, 32));
+    }
 }

src/routers/xcm/Router.sol

@@ -12,10 +12,13 @@ interface ConnectorLike {
   function addTranche(uint64 poolId, bytes16 trancheId, string memory tokenName, string memory tokenSymbol) external;
   function updateMember(uint64 poolId, bytes16 trancheId, address user, uint256 validUntil) external;
   function updateTokenPrice(uint64 poolId, bytes16 trancheId, uint256 price) external;
+  function deposit(uint64 poolId, bytes16 trancheId, address user, uint256 amount) external;
+  function withdraw(uint64 poolId, bytes16 trancheId, address user, uint256 amount) external;
 }
 
 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;
 
@@ -47,12 +50,19 @@ contract ConnectorXCMRouter is Router, Test {
             (uint64 poolId, bytes16 trancheId, string memory tokenName, string memory tokenSymbol) = ConnectorMessages.parseAddTranche(_msg);
             connector.addTranche(poolId, trancheId, tokenName, tokenSymbol);
         } else if (ConnectorMessages.isUpdateMember(_msg) == true) {
-            (uint64 poolId, bytes16 trancheId, address user, uint256 amount) = ConnectorMessages.parseUpdateMember(_msg);
-            connector.updateMember(poolId, trancheId, user, amount);
+            (uint64 poolId, bytes16 trancheId, address user, uint256 validUntil) = ConnectorMessages.parseUpdateMember(_msg);
+            connector.updateMember(poolId, trancheId, user, validUntil);
         } else if (ConnectorMessages.isUpdateTokenPrice(_msg) == true) {
             (uint64 poolId, bytes16 trancheId, uint256 price) = ConnectorMessages.parseUpdateTokenPrice(_msg);
             connector.updateTokenPrice(poolId, trancheId, price);
-        } else {
+        } else if (ConnectorMessages.isDeposit(_msg) == true) {
+            (uint64 poolId, bytes16 trancheId, address user, uint256 amount) = ConnectorMessages.parseDeposit(_msg);
+            connector.deposit(poolId, trancheId, user, amount);
+        } else if (ConnectorMessages.isWithdraw(_msg) == true) {
+            (uint64 poolId, bytes16 trancheId, address user, uint256 amount) = ConnectorMessages.parseWithdraw(_msg);
+            connector.withdraw(poolId, trancheId, user, amount);
+        }
+        else {
             require(false, "invalid-message");
         }
     }

src/token/restricted.sol

@@ -12,12 +12,15 @@ interface ERC20Like {
     function mint(address usr, uint wad) external;
     function name() external view returns (string memory);
     function symbol() external view returns (string memory);
+    function balanceOf(address usr) external view returns (uint wad);
+    function burn(address usr, uint wad) external;
+    function transferFrom(address from, address to, uint amount) external returns (bool);
 }
 
 interface RestrictedTokenLike is ERC20Like {
     function memberlist() external view returns (address);
     function hasMember(address usr) external view returns (bool);
-    function depend(bytes32 contractName, address addr) external;
+    function depend(bytes32 contractName, address addr) external; 
 }
 
 // Only mebmber with a valid (not expired) membership should be allowed to receive tokens

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;
     }
-
 }