Connectors v1

script/Connector-XCM.s.sol

@@ -18,7 +18,7 @@ contract ConnectorXCMScript is Script {
         CentrifugeConnector connector = new CentrifugeConnector(tokenFactory_, memberlistFactory_);
 
         // TODO: add centrifugeChainOrigin_ arg
-        ConnectorXCMRouter router = new ConnectorXCMRouter(address(connector), address(0));
+        ConnectorXCMRouter router = new ConnectorXCMRouter(address(connector), address(0), address(0));
         connector.file("router", address(router));
     }
 }

src/Connector.sol

@@ -5,12 +5,12 @@ 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";
 
 interface RouterLike {
+    function sendMessage(uint32 destinationDomain, uint64 poolId, bytes16 trancheId, uint256 amount, address user) external;
 }
 
-contract CentrifugeConnector is Test {
+contract CentrifugeConnector {
 
     RouterLike public router;
     RestrictedTokenFactoryLike public immutable tokenFactory;
@@ -31,11 +31,14 @@ contract CentrifugeConnector is Test {
     mapping(uint64 => Pool) public pools;
     mapping(uint64 => mapping(bytes16 => Tranche)) public tranches;
     mapping(address => uint256) public wards;
+    mapping(bytes32 => uint32) public domainLookup;
+
 
     // --- Events ---
     event Rely(address indexed user);
     event Deny(address indexed user);
     event File(bytes32 indexed what, address data);
+    event File(bytes32 indexed what, string data);
     event PoolAdded(uint256 indexed poolId);
     event TrancheAdded(uint256 indexed poolId, bytes16 indexed trancheId, address indexed token);
 
@@ -73,6 +76,14 @@ contract CentrifugeConnector is Test {
         emit File(what, data);
     }
 
+    function file(bytes32 name, string memory domainName, uint32 domainId) public auth  {
+        if(name == "domain") {
+           domainLookup[keccak256(bytes(domainName))] = domainId;
+           emit File(name, domainName);
+        } else { revert ("unknown name");}
+
+    }
+
     // --- Internal ---
     function addPool(uint64 poolId) public onlyRouter {
         Pool storage pool = pools[poolId];
@@ -96,7 +107,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);
     }
 
@@ -124,15 +135,33 @@ contract CentrifugeConnector is Test {
         memberlist.updateMember(user, validUntil);
     }
 
-    function transferTo(
+    function transfer(
         uint64 poolId,
         bytes16 trancheId,
         address user,
         uint256 amount
     ) public onlyRouter {
         RestrictedTokenLike token = RestrictedTokenLike(tranches[poolId][trancheId].token);
+        require(address(token) != address(0), "CentrifugeConnector/unknown-token");
         require(token.hasMember(user), "CentrifugeConnector/not-a-member");
         token.mint(user, amount);
     }
-
+
+    function transferTo(
+        uint64 poolId,
+        bytes16 trancheId,
+        address user,
+        uint256 amount,
+        string memory domainName
+    ) public {
+        uint32 domainId = domainLookup[keccak256(bytes(domainName))];
+        require(domainId > 0, "CentrifugeConnector/domain-does-not-exist");
+
+        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(domainId, poolId, trancheId, amount, user);
+    }
 }

src/Messages.sol

@@ -13,7 +13,7 @@ library ConnectorMessages {
         AddTranche,
         UpdateTokenPrice,
         UpdateMember,
-        TransferTo
+        Transfer
     }
 
     function messageType(bytes29 _msg) internal pure returns (Call _call) {
@@ -135,4 +135,29 @@ library ConnectorMessages {
         price = uint256(_msg.index(25, 32));
     }
 
+     /**
+     * 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) internal pure returns (bytes memory) {
+        return abi.encodePacked(uint8(Call.Transfer), poolId, trancheId, user, amount);
+    }
+
+    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));
+    }
+
 }

src/routers/xcm/Router.sol

@@ -4,6 +4,7 @@ pragma abicoder v2;
 
 import {TypedMemView} from "@summa-tx/memview-sol/contracts/TypedMemView.sol";
 import {Router} from "@nomad-xyz/contracts-router/contracts/Router.sol";
+import {Home} from "@nomad-xyz/contracts-core/contracts/Home.sol";
 import {ConnectorMessages} from "../..//Messages.sol";
 import "forge-std/Test.sol";
 
@@ -12,6 +13,7 @@ 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 transfer(uint64 poolId, bytes16 trancheId, address user, uint256 amount) external;
 }
 
 contract ConnectorXCMRouter is Router, Test {
@@ -24,16 +26,25 @@ contract ConnectorXCMRouter is Router, Test {
 
     address immutable centrifugeChainOrigin;
 
-    constructor(address connector_, address centrifugeChainOrigin_) {
+    constructor(address connector_, address centrifugeChainOrigin_, address xAppConnectionManager) {
         connector = ConnectorLike(connector_);
         centrifugeChainOrigin = centrifugeChainOrigin_;
-    }
 
+        __Ownable_init();
+        __XAppConnectionClient_initialize(xAppConnectionManager);
+    }
+
+
     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(
         uint32 _origin,
         uint32 _nonce,
@@ -48,13 +59,38 @@ 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 if (ConnectorMessages.isTransfer(_msg) == true) {
+            (uint64 poolId, bytes16 trancheId, address user, uint256 amount) = ConnectorMessages.parseTransfer(_msg);
+            connector.transfer(poolId, trancheId, user, amount);
         } else {
             require(false, "invalid-message");
         }
     }
+
+    function sendMessage(uint32 destinationDomain, uint64 poolId, bytes16 trancheId, uint256 amount, address user) external onlyConnector {
+        bytes32 remoteAddress = _mustHaveRemote(destinationDomain);
+        Home(xAppConnectionManager.home()).dispatch(
+            destinationDomain,
+            remoteAddress,
+            ConnectorMessages.formatTransfer(poolId, trancheId, user, amount));
+    }
+
+       function bytes32ToString(bytes32 _bytes32) internal 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 {