Connectors v1

.gitmodules

@@ -7,4 +7,4 @@
 [submodule "lib/memview-sol"]
 	path = lib/memview-sol
 	url = https://github.com/summa-tx/memview-sol
-	branch = v2.1.1
+	branch = main

src/Connector.sol

@@ -5,12 +5,13 @@ pragma abicoder v2;
 import { RestrictedTokenFactoryLike, MemberlistFactoryLike } from "./token/factory.sol";
 import { RestrictedTokenLike } from "./token/restricted.sol";
 import { MemberlistLike } from "./token/memberlist.sol";
-import "forge-std/Test.sol";
+import { ConnectorMessages } from "src/Messages.sol";
 
 interface RouterLike {
+    function sendMessage(uint64 poolId, bytes16 trancheId, uint256 amount, address user) external;
 }
 
-contract CentrifugeConnector is Test {
+contract CentrifugeConnector {
 
     RouterLike public router;
     RestrictedTokenFactoryLike public immutable tokenFactory;
@@ -24,7 +25,7 @@ contract CentrifugeConnector is Test {
 
     struct Tranche {
         address token;
-        uint256 latestPrice; // [ray]
+        uint128 latestPrice; // [ray]
         uint256 lastPriceUpdate;
         // TODO: the token name & symbol need to be stored because of the separation between adding and deploying tranches.
         // This leads to duplicate storage (also in the ERC20 contract), ideally we should refactor this somehow
@@ -86,15 +87,16 @@ contract CentrifugeConnector is Test {
         emit PoolAdded(poolId);
     }
 
-    function addTranche(uint64 poolId, bytes16 trancheId, string memory tokenName, string memory tokenSymbol)
+    function addTranche(uint64 poolId, bytes16 trancheId, string memory tokenName, string memory tokenSymbol, uint128 price)
         public
         onlyRouter
     {
         Pool storage pool = pools[poolId];
         require(pool.createdAt > 0, "CentrifugeConnector/invalid-pool");
 
         Tranche storage tranche = tranches[poolId][trancheId];
-        tranche.latestPrice = 1*10**27;
+        tranche.latestPrice = price;
+        tranche.lastPriceUpdate = block.timestamp;
         tranche.tokenName = tokenName;
         tranche.tokenSymbol = tokenSymbol;
 
@@ -111,17 +113,17 @@ 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 TrancheDeployed(poolId, trancheId, token);
     }
 
     function updateTokenPrice(
         uint64 poolId,
         bytes16 trancheId,
-        uint256 price
+        uint128 price
     ) public onlyRouter {
         Tranche storage tranche = tranches[poolId][trancheId];
-        require(tranche.latestPrice > 0, "CentrifugeConnector/invalid-pool-or-tranche");
+        require(tranche.lastPriceUpdate > 0, "CentrifugeConnector/invalid-pool-or-tranche");
         tranche.latestPrice = price;
         tranche.lastPriceUpdate = block.timestamp;
     }
@@ -130,24 +132,40 @@ contract CentrifugeConnector is Test {
         uint64 poolId,
         bytes16 trancheId,
         address user,
-        uint256 validUntil
+        uint64 validUntil
     ) public onlyRouter {
         Tranche storage tranche = tranches[poolId][trancheId];
-        require(tranche.latestPrice > 0, "CentrifugeConnector/invalid-pool-or-tranche");
+        require(tranche.lastPriceUpdate > 0, "CentrifugeConnector/invalid-pool-or-tranche");
         RestrictedTokenLike token = RestrictedTokenLike(tranche.token);
         MemberlistLike memberlist = MemberlistLike(token.memberlist());
         memberlist.updateMember(user, validUntil);
     }
 
-    function transferTo(
+    function handleTransfer(
         uint64 poolId,
         bytes16 trancheId,
         address user,
         uint256 amount
     ) public onlyRouter {
         RestrictedTokenLike token = RestrictedTokenLike(tranches[poolId][trancheId].token);
         require(token.hasMember(user), "CentrifugeConnector/not-a-member");
+
         token.mint(user, amount);
     }
-
+
+    function transfer(
+        uint64 poolId,
+        bytes16 trancheId,
+        address user,
+        uint256 amount,
+        ConnectorMessages.Domain domain
+    ) public {
+        require(domain == ConnectorMessages.Domain.Centrifuge, "CentrifugeConnector/invalid-domain");
+        RestrictedTokenLike token = RestrictedTokenLike(tranches[poolId][trancheId].token);
+        require(address(token) != address(0), "CentrifugeConnector/unknown-token");
+        require(token.balanceOf(user) >= amount, "CentrifugeConnector/insufficient-balance");
+        require(token.transferFrom(user, address(this), amount), "CentrifugeConnector/token-transfer-failed");
+        token.burn(address(this), amount);
+        router.sendMessage(poolId, trancheId, amount, user);
+    }
 }

src/Messages.sol

@@ -13,9 +13,11 @@ library ConnectorMessages {
         AddTranche,
         UpdateTokenPrice,
         UpdateMember,
-        TransferTo
+        Transfer
     }
 
+    enum Domain { Centrifuge, EVM }
+
     function messageType(bytes29 _msg) internal pure returns (Call _call) {
         _call = Call(uint8(_msg.indexUint(0, 1)));
     }
@@ -43,26 +45,35 @@ library ConnectorMessages {
      * 
      * 0: call type (uint8 = 1 byte)
      * 1-8: poolId (uint64 = 8 bytes)
-     * 9-25: trancheId (16 bytes)
-     * 26-154: tokenName (string = 128 bytes)
+     * 9-24: trancheId (16 bytes)
+     * 25-154: tokenName (string = 128 bytes)
      * 155-187: tokenSymbol (string = 32 bytes)
+     * 185-200: price (uint128 = 16 bytes)
      */
-    function formatAddTranche(uint64 poolId, bytes16 trancheId, string memory tokenName, string memory tokenSymbol) internal pure returns (bytes memory) {
+    function formatAddTranche(uint64 poolId, bytes16 trancheId, string memory tokenName, string memory tokenSymbol, uint128 price) internal pure returns (bytes memory) {
         // TODO(nuno): Now, we encode `tokenName` as a 128-bytearray by first encoding `tokenName`
         // to bytes32 and then we encode three empty bytes32's, which sum up to a total of 128 bytes.
-        // Add support to actually encode `tokennName` fully as a 128 bytes string.
-        return abi.encodePacked(uint8(Call.AddTranche), poolId, trancheId, stringToBytes32(tokenName), bytes32(""), bytes32(""), bytes32(""), stringToBytes32(tokenSymbol));
+        // Add support to actually encode `tokenName` fully as a 128 bytes string.
+        return abi.encodePacked(
+            uint8(Call.AddTranche),
+            poolId,
+            trancheId,
+            stringToBytes32(tokenName), bytes32(""), bytes32(""), bytes32(""),
+            stringToBytes32(tokenSymbol),
+            price
+        );
     }
 
     function isAddTranche(bytes29 _msg) internal pure returns (bool) {
         return messageType(_msg) == Call.AddTranche;
     }
 
-    function parseAddTranche(bytes29 _msg) internal pure returns (uint64 poolId, bytes16 trancheId, string memory tokenName, string memory tokenSymbol) {
+    function parseAddTranche(bytes29 _msg) internal pure returns (uint64 poolId, bytes16 trancheId, string memory tokenName, string memory tokenSymbol, uint128 price) {
         poolId = uint64(_msg.indexUint(1, 8));
         trancheId = bytes16(_msg.index(9, 16));
         tokenName = bytes32ToString(bytes32(_msg.index(25, 32)));
         tokenSymbol = bytes32ToString(bytes32(_msg.index(153, 32)));
+        price = uint128(_msg.indexUint(185, 16));
     }
 
     // TODO: should be moved to a util contract
@@ -95,48 +106,82 @@ library ConnectorMessages {
      * 
      * 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: validUntil (uint256 = 32 bytes)
+     * 9-24: trancheId (16 bytes)
+     * 25-45: user (Ethereum address, 20 bytes - Skip 12 bytes from 32-byte addresses)
+     * 57-65: validUntil (uint64 = 8 bytes)
      * 
      * TODO: use bytes32 for user (for non-EVM compatibility)
      */
-    function formatUpdateMember(uint64 poolId, bytes16 trancheId, address user, uint256 validUntil) internal pure returns (bytes memory) {
-        return abi.encodePacked(uint8(Call.UpdateMember), poolId, trancheId, user, validUntil);
+    function formatUpdateMember(uint64 poolId, bytes16 trancheId, address user, uint64 validUntil) internal pure returns (bytes memory) {
+        // NOTE: Since parseUpdateMember parses the first 20 bytes of `user` and skips the following 12
+        // here we need to append 12 zeros to make it right. Drop once we support 32-byte addresses.
+        return abi.encodePacked(uint8(Call.UpdateMember), poolId, trancheId, user, bytes(hex"000000000000000000000000"), validUntil);
     }
 
     function isUpdateMember(bytes29 _msg) internal pure returns (bool) {
         return messageType(_msg) == Call.UpdateMember;
     }
 
-    function parseUpdateMember(bytes29 _msg) internal pure returns (uint64 poolId, bytes16 trancheId, address user, uint256 validUntil) {
+    function parseUpdateMember(bytes29 _msg) internal pure returns (uint64 poolId, bytes16 trancheId, address user, uint64 validUntil) {
         poolId = uint64(_msg.indexUint(1, 8));
         trancheId = bytes16(_msg.index(9, 16));
         user = address(bytes20(_msg.index(25, 20)));
-        // TODO: skip 12 padded zeroes from address
-        validUntil = uint256(_msg.index(45, 32));
+        validUntil = uint64(_msg.indexUint(57, 8));
     }
 
     /**
      * Update token price
      * 
      * 0: call type (uint8 = 1 byte)
      * 1-8: poolId (uint64 = 8 bytes)
-     * 9-25: trancheId (16 bytes)
-     * 26-58: price (uint256 = 32 bytes)
+     * 9-24: trancheId (16 bytes)
+     * 25-41: price (uint128 = 16 bytes)
      */
-    function formatUpdateTokenPrice(uint64 poolId, bytes16 trancheId, uint256 price) internal pure returns (bytes memory) {
+    function formatUpdateTokenPrice(uint64 poolId, bytes16 trancheId, uint128 price) internal pure returns (bytes memory) {
         return abi.encodePacked(uint8(Call.UpdateTokenPrice), poolId, trancheId, price);
     }
 
     function isUpdateTokenPrice(bytes29 _msg) internal pure returns (bool) {
         return messageType(_msg) == Call.UpdateTokenPrice;
     }
 
-    function parseUpdateTokenPrice(bytes29 _msg) internal pure returns (uint64 poolId, bytes16 trancheId, uint256 price) {
+    function parseUpdateTokenPrice(bytes29 _msg) internal pure returns (uint64 poolId, bytes16 trancheId, uint128 price) {
         poolId = uint64(_msg.indexUint(1, 8));
         trancheId = bytes16(_msg.index(9, 16));
-        price = uint256(_msg.index(25, 32));
+        price = uint128(_msg.indexUint(25, 16));
+    }
+
+     /**
+     * Transfer
+     * 
+     * 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 formatTransfer(uint64 poolId, bytes16 trancheId, address user, uint256 amount, bytes9 destinationDomain) internal pure returns (bytes memory) {
+        return abi.encodePacked(uint8(Call.Transfer), poolId, trancheId, user, amount, destinationDomain);
+    }
+
+    function isTransfer(bytes29 _msg) internal pure returns (bool) {
+        return messageType(_msg) == Call.Transfer;
+    }
+
+    function parseTransfer(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));
+    }
+
+    function formatDomain(Domain domain) public pure returns (bytes9) {
+        return bytes9(byte(uint8(domain)));
+    }
+
+    function formatDomain(Domain domain, uint64 domainId) public pure returns (bytes9) {
+        return bytes9(abi.encodePacked(uint8(domain), domainId).ref(0).index(0, 9));
     }
 
 }

src/routers/xcm/Router.sol

@@ -7,9 +7,10 @@ import {ConnectorMessages} from "../../Messages.sol";
 
 interface ConnectorLike {
   function addPool(uint64 poolId) external;
-  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 addTranche(uint64 poolId, bytes16 trancheId, string memory tokenName, string memory tokenSymbol, uint128 price) external;
+  function updateMember(uint64 poolId, bytes16 trancheId, address user, uint64 validUntil) external;
+  function updateTokenPrice(uint64 poolId, bytes16 trancheId, uint128 price) external;
+  function handleTransfer(uint64 poolId, bytes16 trancheId, address user, uint256 amount) external;
 }
 
 contract ConnectorXCMRouter {
@@ -26,30 +27,57 @@ contract ConnectorXCMRouter {
         connector = ConnectorLike(connector_);
         centrifugeChainOrigin = centrifugeChainOrigin_;
     }
-
+
+
     modifier onlyCentrifugeChainOrigin() {
         require(msg.sender == address(centrifugeChainOrigin), "ConnectorXCMRouter/invalid-origin");
         _;
     }
 
+    modifier onlyConnector() {
+        require(msg.sender == address(connector), "ConnectorXCMRouter/only-connector-allowed-to-call");
+        _;
+    }
+
     function handle(
         bytes memory _message
     ) external onlyCentrifugeChainOrigin {
         bytes29 _msg = _message.ref(0);
-        if (ConnectorMessages.isAddPool(_msg) == true) {
+        if (ConnectorMessages.isAddPool(_msg)) {
             uint64 poolId = ConnectorMessages.parseAddPool(_msg);
             connector.addPool(poolId);
-        } else if (ConnectorMessages.isAddTranche(_msg) == true) {
-            (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);
-        } else if (ConnectorMessages.isUpdateTokenPrice(_msg) == true) {
-            (uint64 poolId, bytes16 trancheId, uint256 price) = ConnectorMessages.parseUpdateTokenPrice(_msg);
+        } else if (ConnectorMessages.isAddTranche(_msg)) {
+            (uint64 poolId, bytes16 trancheId, string memory tokenName, string memory tokenSymbol, uint128 price) = ConnectorMessages.parseAddTranche(_msg);
+            connector.addTranche(poolId, trancheId, tokenName, tokenSymbol, price);
+        } else if (ConnectorMessages.isUpdateMember(_msg)) {
+            (uint64 poolId, bytes16 trancheId, address user, uint64 validUntil) = ConnectorMessages.parseUpdateMember(_msg);
+            connector.updateMember(poolId, trancheId, user, validUntil);
+        } else if (ConnectorMessages.isUpdateTokenPrice(_msg)) {
+            (uint64 poolId, bytes16 trancheId, uint128 price) = ConnectorMessages.parseUpdateTokenPrice(_msg);
             connector.updateTokenPrice(poolId, trancheId, price);
+        } else if (ConnectorMessages.isTransfer(_msg)) {
+            (uint64 poolId, bytes16 trancheId, address user, uint256 amount) = ConnectorMessages.parseTransfer(_msg);
+            connector.handleTransfer(poolId, trancheId, user, amount);
         } else {
             require(false, "invalid-message");
         }
     }
+
+    function sendMessage(uint64 poolId, bytes16 trancheId, uint256 amount, address user) external onlyConnector {
+        // TODO: implement
+    }
+
+    function bytes32ToString(bytes32 _bytes32) internal pure returns (string memory) {
+        uint8 i = 0;
+        while (i < 32 && _bytes32[i] != 0) {
+            i++;
+        }
+
+        bytes memory bytesArray = new bytes(i);
+        for (i = 0; i < 32 && _bytes32[i] != 0; i++) {
+            bytesArray[i] = _bytes32[i];
+        }
+        return string(bytesArray);
+    }
+
 }

src/token/restricted.sol

@@ -12,6 +12,11 @@ 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);
+    function totalSupply() external returns (uint);
+    function approve(address _spender, uint256 _value) external returns (bool);
 }
 
 interface RestrictedTokenLike is ERC20Like {