idea 27

contracts/ens/AbstractENS.sol

@@ -0,0 +1,23 @@
+pragma solidity ^0.4.17;
+
+contract AbstractENS {
+    function owner(bytes32 node) public constant returns (address);
+    function resolver(bytes32 node) public constant returns (Resolver);
+    function ttl(bytes32 node) public constant returns (uint64);
+    function setOwner(bytes32 node, address owner) public;
+    function setSubnodeOwner(bytes32 node, bytes32 label, address owner) public;
+    function setResolver(bytes32 node, address resolver) public;
+    function setTTL(bytes32 node, uint64 ttl) public;
+
+    // Logged when the owner of a node assigns a new owner to a subnode.
+    event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);
+
+    // Logged when the owner of a node transfers ownership to a new account.
+    event Transfer(bytes32 indexed node, address owner);
+
+    // Logged when the resolver for a node changes.
+    event NewResolver(bytes32 indexed node, address resolver);
+
+    // Logged when the TTL of a node changes
+    event NewTTL(bytes32 indexed node, uint64 ttl);
+}

contracts/ens/PublicResolverInterface.sol

@@ -0,0 +1,9 @@
+pragma solidity ^0.4.17;
+
+contract PublicResolverInterface {
+    function supportsInterface(bytes4 interfaceID) public constant returns (bool);
+    function addr(bytes32 node) public constant returns (address ret);
+    function setAddr(bytes32 node, address addr) public;
+    function hash(bytes32 node) public constant returns (bytes32 ret);
+    function setHash(bytes32 node, bytes32 hash) public;
+}

contracts/ens/UsingENS.sol

@@ -0,0 +1,20 @@
+pragma solidity ^0.4.17;
+
+contract UsingENS {
+
+    function ensAddress() internal constant returns (address ensAddress) {
+        ensAddress = 0x314159265dD8dbb310642f98f50C066173C1259b; //mainnet
+        if (codeSize(ensAddress) == 0) {
+           ensAddress = 0x112234455C3a32FD11230C42E7Bccd4A84e02010; //ropsten    
+        }
+    }
+
+    function codeSize(address _addr) internal constant returns(uint size) {
+        if (_addr == 0) { 
+            return 0; 
+        }
+        assembly {
+            size := extcodesize(_addr)
+        }
+    }
+}

contracts/registry/UserRegistry.sol

@@ -0,0 +1,71 @@
+pragma solidity ^0.4.17;
+
+import "../ens/UsingENS.sol";
+import "../ens/AbstractENS.sol";
+import "../ens/PublicResolverInterface.sol";
+import "../status/UsingSNT.sol";
+import "../identity/Identity.sol";
+
+contract UserRegistry is UsingENS, UsingSNT {
+    address public owner = 0x0;
+    address public ENSroot = 0x0;
+    address public SNT = 0x0;
+    address public resolver = 0x0;
+    mapping (bytes32 => bool) public domains;
+    mapping (bytes32 => address) public registry;
+    mapping (bytes32 => bool) public taken;
+    uint public price = 1000 * 10**18;
+
+    modifier onlyOwner {
+        require(msg.sender == owner);
+    }
+
+    function UserRegistry(address _resolver) public {
+        initialize(_resolver);
+    }
+
+    function initialize(address _resolver) public {
+        require(owner == 0x0);
+        require(ENSroot == 0x0);
+        require(SNT == 0x0);
+        require(resolver == 0x0);
+        ENSroot = ensAddress();
+        SNT = sntAddress();
+        resolver = _resolver;
+        owner = msg.sender;
+    }
+
+    function registerUser(string _user, bytes32 _domain) public {
+        require(domains[_domain]);
+        SNT snt = SNT(SNT);
+        require(snt.transferFrom(msg.sender, address(this), price));
+        ENS ens = ENS(ENSroot);
+        bytes32 user = keccak256(_user);
+        ens.setSubnodeOwner(_domain, user, address(this));
+        bytes32 subdomain = keccak256(_user, _domain);
+        ens.setResolver(subdomain, resolver);
+        Identity newIdentity = new Identity(msg.sender);
+        PublicResolverInterface(resolver).setAddr(address(newIdentity));
+        taken[user] = true;
+    }
+
+    function listDomain(bytes32 _domain) public onlyOwner {
+        require(ENS(ENSroot).owner(_domain) == address(this));
+        domains[_domain] = true;
+    }
+
+    function recoverDomain(bytes32 _domain, address _dest) public onlyOwner {
+        require(domains[_domain]);
+        ENS(ENSroot).setOwner(_domain, _dest);
+        delete domains[_domain];
+    }
+
+    function setPrice(uint256 _price) public onlyOwner {
+        price = _price;
+    }
+    
+    function setOwner(address _newOwner) public onlyOwner {
+        require(_newOwner != 0x0);
+        owner = _newOwner;
+    }
+}