ens-usernames/contracts/registry/ENSSubdomainRegistry.sol

405 lines
14 KiB
Solidity
Raw Normal View History

pragma solidity ^0.4.23;
2018-01-09 17:07:58 +00:00
2018-08-24 07:56:00 +00:00
import "../common/MerkleProof.sol";
2018-03-24 03:40:03 +00:00
import "../common/Controlled.sol";
import "../token/ERC20Token.sol";
import "../ens/ENS.sol";
import "../ens/PublicResolver.sol";
/**
* @author Ricardo Guilherme Schmidt (Status Research & Development GmbH)
* @notice Sell ENS subdomains of owned domains.
*/
contract ENSSubdomainRegistry is Controlled {
ERC20Token public token;
ENS public ens;
PublicResolver public resolver;
address public parentRegistry;
uint256 public releaseDelay = 365 days;
mapping (bytes32 => Domain) public domains;
mapping (bytes32 => Account) public accounts;
2018-08-24 07:56:00 +00:00
bytes32 public unallowedCharactersMerkleRoot;
event FundsOwner(bytes32 indexed subdomainhash, address fundsOwner);
event DomainPrice(bytes32 indexed namehash, uint256 price);
event DomainMoved(bytes32 indexed namehash, address newRegistry);
2018-05-07 03:37:56 +00:00
enum NodeState { Free, Owned, Moved }
2018-03-24 03:40:03 +00:00
struct Domain {
2018-05-07 03:37:56 +00:00
NodeState state;
2018-03-24 03:40:03 +00:00
uint256 price;
}
struct Account {
uint256 tokenBalance;
uint256 creationTime;
address fundsOwner;
}
2018-03-24 03:40:03 +00:00
2018-05-16 22:22:54 +00:00
modifier onlyParentRegistry {
2018-08-24 07:39:32 +00:00
require(msg.sender == parentRegistry, "Migration only.");
2018-05-16 22:22:54 +00:00
_;
}
/**
* @notice Initializes a UserRegistry contract
* @param _token fee token base
* @param _ens Ethereum Name Service root address
* @param _resolver Default resolver to use in initial settings
* @param _parentRegistry Address of old registry (if any) for account migration.
*/
constructor(
ERC20Token _token,
ENS _ens,
PublicResolver _resolver,
2018-08-24 07:56:00 +00:00
bytes32 _unallowedCharactersMerkleRoot,
address _parentRegistry
2018-03-24 03:40:03 +00:00
)
public
{
token = _token;
ens = _ens;
resolver = _resolver;
2018-08-24 07:56:00 +00:00
unallowedCharactersMerkleRoot = _unallowedCharactersMerkleRoot;
parentRegistry = _parentRegistry;
}
/**
* @notice Registers `_userHash` subdomain to `_domainHash` setting msg.sender as owner.
* @param _userHash choosen unowned subdomain hash
2018-05-08 02:41:21 +00:00
* @param _domainHash choosen contract owned domain hash
* @param _account optional address to set at public resolver
* @param _pubkeyA optional pubkey part A to set at public resolver
* @param _pubkeyB optional pubkey part B to set at public resolver
*/
2018-03-24 03:40:03 +00:00
function register(
bytes32 _userHash,
bytes32 _domainHash,
address _account,
bytes32 _pubkeyA,
bytes32 _pubkeyB
2018-03-24 03:40:03 +00:00
)
external
returns(bytes32 subdomainHash)
{
2018-03-24 03:40:03 +00:00
Domain memory domain = domains[_domainHash];
2018-08-24 07:39:32 +00:00
require(domain.state == NodeState.Owned, "Domain unavailable.");
subdomainHash = keccak256(abi.encodePacked(_domainHash, _userHash));
require(ens.owner(subdomainHash) == address(0), "ENS node already owned.");
require(accounts[subdomainHash].creationTime == 0, "Username already registered.");
2018-05-06 23:42:06 +00:00
accounts[subdomainHash] = Account(domain.price, block.timestamp, msg.sender);
2018-08-24 07:39:32 +00:00
if(domain.price > 0) {
require(token.allowance(msg.sender, address(this)) >= domain.price, "Unallowed to spend.");
require(
token.transferFrom(
address(msg.sender),
address(this),
domain.price
),
"Transfer failed"
);
}
bool resolvePubkey = _pubkeyA != 0 || _pubkeyB != 0;
bool resolveAccount = _account != address(0);
if (resolvePubkey || resolveAccount) {
//set to self the ownship to setup initial resolver
ens.setSubnodeOwner(_domainHash, _userHash, address(this));
ens.setResolver(subdomainHash, resolver); //default resolver
if (resolveAccount) {
resolver.setAddr(subdomainHash, _account);
}
if (resolvePubkey) {
resolver.setPubkey(subdomainHash, _pubkeyA, _pubkeyB);
}
ens.setOwner(subdomainHash, msg.sender);
}else {
//transfer ownship of subdone to registrant
ens.setSubnodeOwner(_domainHash, _userHash, msg.sender);
}
}
/**
* @notice release subdomain and retrieve locked fee, needs to be called after `releasePeriod` from creation time.
* @param _userHash `msg.sender` owned subdomain hash
2018-05-08 02:41:21 +00:00
* @param _domainHash choosen contract owned domain hash
*/
function release(
bytes32 _userHash,
bytes32 _domainHash
)
external
{
2018-05-06 23:42:06 +00:00
bool isDomainController = ens.owner(_domainHash) == address(this);
2018-08-24 07:39:32 +00:00
bytes32 subdomainHash = keccak256(abi.encodePacked(_domainHash, _userHash));
Account memory account = accounts[subdomainHash];
2018-08-24 07:39:32 +00:00
require(account.creationTime > 0, "Username not registered.");
2018-05-06 23:42:06 +00:00
if (isDomainController) {
2018-08-24 07:39:32 +00:00
require(msg.sender == ens.owner(subdomainHash), "Not owner of ENS node.");
require(block.timestamp > account.creationTime + releaseDelay, "Release period not reached.");
ens.setSubnodeOwner(_domainHash, _userHash, address(this));
ens.setResolver(subdomainHash, address(0));
ens.setOwner(subdomainHash, address(0));
2018-05-06 23:42:06 +00:00
} else {
2018-08-24 07:39:32 +00:00
require(msg.sender == account.fundsOwner, "Not the former account owner.");
}
2018-05-06 23:42:06 +00:00
delete accounts[subdomainHash];
if (account.tokenBalance > 0) {
2018-08-24 07:39:32 +00:00
require(token.transfer(msg.sender, account.tokenBalance), "Transfer failed");
}
2018-01-09 17:07:58 +00:00
}
2018-05-06 23:42:06 +00:00
/**
2018-08-24 07:39:32 +00:00
* @notice updates funds owner, useful to move subdomain account to new registry.
2018-05-15 22:37:45 +00:00
* @param _userHash `msg.sender` owned subdomain hash
* @param _domainHash choosen contract owned domain hash
2018-05-06 23:42:06 +00:00
**/
function updateFundsOwner(
bytes32 _userHash,
bytes32 _domainHash
)
2018-05-15 22:37:45 +00:00
external
{
2018-08-24 07:39:32 +00:00
bytes32 subdomainHash = keccak256(abi.encodePacked(_domainHash, _userHash));
require(accounts[subdomainHash].creationTime > 0, "Username not registered.");
require(msg.sender == ens.owner(subdomainHash), "Caller not owner of ENS node.");
require(ens.owner(_domainHash) == address(this), "Registry not owner of domain.");
accounts[subdomainHash].fundsOwner = msg.sender;
emit FundsOwner(subdomainHash, msg.sender);
2018-03-24 03:40:03 +00:00
}
2018-08-24 07:56:00 +00:00
/**
* @notice removes account of invalid subdomain, and send funds to reporter
* @param _subdomain raw value of offending subdomain
* @param _offendingPos position of invalid character
* @param _rangeStart start of invalid character range
* @param _rangeEnd end of invalid character range
* @param _proof merkle proof that range is defined in merkle root
*/
function slashSubdomain(
bytes _subdomain,
bytes32 _domainHash,
uint256 _offendingPos,
uint256 _rangeStart,
uint256 _rangeEnd,
bytes32[] _proof
)
external
{
require(_subdomain.length > _offendingPos, "Invalid position.");
bytes32 userHash = keccak256(_subdomain);
bytes32 subdomainHash = keccak256(abi.encodePacked(_domainHash, userHash));
require(accounts[subdomainHash].creationTime == 0, "Username not registered.");
uint256 offendingChar = uint256(_subdomain[_offendingPos]);
require(offendingChar >= _rangeStart && offendingChar <= _rangeEnd, "Invalid range.");
require(
MerkleProof.verifyProof(
_proof,
unallowedCharactersMerkleRoot,
keccak256(abi.encodePacked(rangeStart, rangeEnd))
),
"Invalid Proof."
);
ens.setSubnodeOwner(_domainHash, userHash, address(this));
ens.setResolver(subdomainHash, address(0));
ens.setOwner(subdomainHash, address(0));
uint256 amountToTransfer = accounts[subdomainHash].tokenBalance;
delete accounts[subdomainHash];
require(token.transfer(msg.sender, amountToTransfer), "Error in transfer.");
}
/**
* @notice Migrate account to new registry
* @param _userHash `msg.sender` owned subdomain hash
2018-05-08 02:41:21 +00:00
* @param _domainHash choosen contract owned domain hash
**/
2018-05-06 22:16:50 +00:00
function moveAccount(
bytes32 _userHash,
bytes32 _domainHash
)
external
{
2018-08-24 07:39:32 +00:00
bytes32 subdomainHash = keccak256(abi.encodePacked(_domainHash, _userHash));
require(msg.sender == accounts[subdomainHash].fundsOwner, "Callable only by account owner.");
ENSSubdomainRegistry _newRegistry = ENSSubdomainRegistry(ens.owner(_domainHash));
Account memory account = accounts[subdomainHash];
delete accounts[subdomainHash];
//require(address(this) == _newRegistry.parentRegistry(), "Wrong update.");
token.approve(_newRegistry, account.tokenBalance);
2018-08-24 07:39:32 +00:00
_newRegistry.migrateAccount(
_userHash,
_domainHash,
account.tokenBalance,
account.creationTime,
account.fundsOwner
);
}
2018-05-06 22:16:50 +00:00
/**
2018-08-24 07:39:32 +00:00
* @dev callabe only by parent registry to continue migration of domain
**/
2018-05-06 22:16:50 +00:00
function migrateDomain(
bytes32 _domain,
uint256 _price
)
external
2018-05-16 22:22:54 +00:00
onlyParentRegistry
2018-05-06 22:16:50 +00:00
{
2018-08-24 07:39:32 +00:00
require(ens.owner(_domain) == address(this), "ENS domain owner not transfered.");
assert(domains[_domain].state == NodeState.Free);
2018-05-07 03:37:56 +00:00
domains[_domain] = Domain(NodeState.Owned, _price);
2018-05-06 22:16:50 +00:00
}
2018-08-24 07:39:32 +00:00
/**
* @dev callable only by parent registry for continue user opt-in migration
* @param _userHash any subdomain hash coming from parent
2018-05-08 02:41:21 +00:00
* @param _domainHash choosen contract owned domain hash
* @param _tokenBalance amount being transferred
* @param _creationTime any value coming from parent
* @param _fundsOwner fundsOwner for opt-out/release at domain move
**/
2018-05-06 22:16:50 +00:00
function migrateAccount(
bytes32 _userHash,
bytes32 _domainHash,
uint256 _tokenBalance,
2018-05-06 23:42:06 +00:00
uint256 _creationTime,
address _fundsOwner
)
external
2018-05-16 22:22:54 +00:00
onlyParentRegistry
{
2018-08-24 07:39:32 +00:00
bytes32 subdomainHash = keccak256(abi.encodePacked(_domainHash, _userHash));
accounts[subdomainHash] = Account(_tokenBalance, _creationTime, _fundsOwner);
if (_tokenBalance > 0) {
2018-08-24 07:39:32 +00:00
require(
token.transferFrom(
parentRegistry,
address(this),
_tokenBalance
),
"Error moving funds from old registar."
);
}
}
2018-05-16 22:22:54 +00:00
2018-08-24 07:39:32 +00:00
/**
2018-05-16 22:22:54 +00:00
* @notice moves a domain to other Registry (will not move subdomains accounts)
* @param _newRegistry new registry hodling this domain
* @param _domain domain being moved
*/
function moveDomain(
ENSSubdomainRegistry _newRegistry,
bytes32 _domain
)
external
onlyController
{
2018-08-24 07:39:32 +00:00
require(domains[_domain].state == NodeState.Owned, "Wrong domain");
require(ens.owner(_domain) == address(this), "Domain not owned anymore.");
2018-05-16 22:22:54 +00:00
uint256 price = domains[_domain].price;
domains[_domain].state = NodeState.Moved;
ens.setOwner(_domain, _newRegistry);
_newRegistry.migrateDomain(_domain, price);
emit DomainMoved(_domain, _newRegistry);
}
/**
* @notice Controller include new domain available to register
* @param _domain domain owned by user registry being activated
* @param _price cost to register subnode from this node
*/
function setDomainPrice(
2018-05-16 22:22:54 +00:00
bytes32 _domain,
uint256 _price
)
external
onlyController
{
require(domains[_domain].state == NodeState.Free, "Domain state is not free");
require(ens.owner(_domain) == address(this), "Registry does not own domain");
2018-05-16 22:22:54 +00:00
domains[_domain] = Domain(NodeState.Owned, _price);
emit DomainPrice(_domain, _price);
}
/**
* @notice updates domain price
* @param _domain active domain being defined price
* @param _price new price
*/
function updateDomainPrice(
2018-05-16 22:22:54 +00:00
bytes32 _domain,
uint256 _price
)
external
onlyController
{
Domain storage domain = domains[_domain];
2018-08-24 07:39:32 +00:00
require(domain.state == NodeState.Owned, "Domain not owned");
2018-05-16 22:22:54 +00:00
domain.price = _price;
emit DomainPrice(_domain, _price);
}
/**
* @notice updates default public resolver for newly registred subdomains
* @param _resolver new default resolver
*/
function setResolver(
address _resolver
)
external
onlyController
{
resolver = PublicResolver(_resolver);
}
function getPrice(bytes32 _domainHash)
external
view
returns(uint256 subdomainPrice)
{
subdomainPrice = domains[_domainHash].price;
}
function getAccountBalance(bytes32 _subdomainHash)
external
view
returns(uint256 accountBalance)
{
accountBalance = accounts[_subdomainHash].tokenBalance;
}
function getFundsOwner(bytes32 _subdomainHash)
external
view
returns(address fundsOwner)
{
fundsOwner = accounts[_subdomainHash].fundsOwner;
}
function getCreationTime(bytes32 _subdomainHash)
external
view
returns(uint256 creationTime)
{
creationTime = accounts[_subdomainHash].creationTime;
}
2018-06-19 14:12:49 +00:00
function getExpirationTime(bytes32 _subdomainHash)
2018-08-24 07:39:32 +00:00
external
view
returns(uint256 expirationTime)
2018-06-19 14:12:49 +00:00
{
2018-08-24 07:39:32 +00:00
expirationTime = accounts[_subdomainHash].creationTime + releaseDelay;
2018-06-19 14:12:49 +00:00
}
}