GNS: cleanup and v1 (#199)

* GNS: cleanup and v1

Author: abarmat

contracts/GNS.sol

@@ -4,162 +4,105 @@ pragma experimental ABIEncoderV2;
 import "./Governed.sol";
 
 
+/**
+ * @title GNS
+ * @dev The Graph Name System contract provides a decentralized namings system for subgraphs
+ * used in the scope of the Graph Network. It translate subgraph names into subgraphID regarded as
+ * versions.
+ */
 contract GNS is Governed {
-    /* Events */
-    event DomainAdded(bytes32 indexed topLevelDomainHash, address indexed owner, string domainName);
-    event DomainTransferred(bytes32 indexed domainHash, address indexed newOwner);
-    event SubgraphCreated(
-        bytes32 indexed topLevelDomainHash,
-        bytes32 indexed registeredHash,
-        string subdomainName,
-        address indexed owner
-    );
-    event SubgraphIDUpdated(bytes32 indexed domainHash, bytes32 indexed subgraphID);
-    event DomainDeleted(bytes32 indexed domainHash);
-    event AccountMetadataChanged(address indexed account, bytes32 indexed ipfsHash);
-    event SubgraphMetadataChanged(bytes32 indexed domainHash, bytes32 indexed ipfsHash);
-
-    /* TYPES */
-    struct Domain {
+    // -- Types --
+
+    enum RecordType { GNS }
+
+    struct Record {
         address owner;
         bytes32 subgraphID;
+        RecordType nameSystem;
     }
 
-    /* STATE VARIABLES */
-    // Storage of a hashed top level domain to owners.
-    mapping(bytes32 => Domain) public domains;
+    // -- State --
 
-    /* Contract Constructor */
-    /* @param _governor <address> - Address of the multisig contract as Governor */
-    constructor(address _governor) public Governed(_governor) {}
+    mapping(bytes32 => Record) public records;
 
-    /* Graph Protocol Functions */
+    // -- Events --
 
-    modifier onlyDomainOwner(bytes32 _domainHash) {
-        require(msg.sender == domains[_domainHash].owner, "Only domain owner can call.");
-        _;
-    }
+    /**
+     * @dev Emitted when `owner` publish a `subgraphID` version under subgraph `name`.
+     * The event also attach `metadataHash` with extra information.
+     */
+    event SubgraphPublished(string name, address owner, bytes32 subgraphID, bytes32 metadataHash);
 
-    /*
-     * @notice Register a domain to an owner.
-     * @param _domainName <string> - Domain name, which is treated as a username.
+    /**
+     * @dev Emitted when subgraph `nameHash` is unpublished by its owner.
      */
-    function registerDomain(string calldata _domainName) external {
-        bytes32 hashedName = keccak256(abi.encodePacked(_domainName));
-        // Require that this domain is not yet owned by anyone.
-        require(domains[hashedName].owner == address(0), "Domain is already owned.");
-        domains[hashedName].owner = msg.sender;
-        emit DomainAdded(hashedName, msg.sender, _domainName);
-    }
+    event SubgraphUnpublished(bytes32 nameHash);
 
-    /*
-     * @notice Create a subgraph by registering a subdomain, or registering the top level
-     * domain as a subgraph.
-     * @notice To register to the top level domain, pass _subdomainName as a blank string.
-     * @dev Only the domain owner may do this.
-     *
-     * @param _topLevelDomainHash <bytes32> - Hash of the top level domain name.
-     * @param _subdomainName <string> - Name of the Subdomain. If you were
-     * registering 'david.thegraph', _subdomainName would be just 'david'.
-     * @param _ipfsHash <bytes32> - Hash of the subgraph metadata, such as description.
+    /**
+     * @dev Emitted when subgraph `nameHash` is transferred to new owner.
      */
-    function createSubgraph(
-        bytes32 _topLevelDomainHash,
-        string calldata _subdomainName,
-        bytes32 _ipfsHash
-    ) external onlyDomainOwner(_topLevelDomainHash) {
-        bytes32 domainHash;
-        bytes32 subdomainHash = keccak256(abi.encodePacked(_subdomainName));
-
-        // Subdomain is blank, therefore we are setting the subgraphID of the top level domain
-        if (subdomainHash == keccak256("")) {
-            // The domain hash ends up being the top level domain hash.
-            domainHash = _topLevelDomainHash;
-        } else {
-            // The domain hash becomes the subdomain concatenated with the top level domain hash.
-            domainHash = keccak256(abi.encodePacked(subdomainHash, _topLevelDomainHash));
-            require(
-                domains[domainHash].owner == address(0),
-                "Someone already owns this subdomain."
-            );
-            domains[domainHash].owner = msg.sender;
-        }
-
-        // Note - subdomain name and IPFS hash are only emitted through the events.
-        // Note - if the subdomain is blank, the domain hash ends up being the top level
-        // domain hash, not the hash of a blank string.
-        emit SubgraphCreated(_topLevelDomainHash, domainHash, _subdomainName, msg.sender);
-        emit SubgraphMetadataChanged(domainHash, _ipfsHash);
+    event SubgraphTransferred(bytes32 nameHash, address from, address to);
+
+    modifier onlyRecordOwner(bytes32 _nameHash) {
+        require(msg.sender == records[_nameHash].owner, "GNS: Only record owner can call");
+        _;
     }
 
-    /*
-     * @notice Update an existing subdomain with a subgraph ID.
-     * @dev Only the domain owner may do this.
-     *
-     * @param _domainHash <bytes32> - Hash of the domain name.
-     * @param _subgraphID <bytes32> - IPLD subgraph ID of the domain.
+    /**
+     * @dev Contract Constructor
+     * @param _governor Owner address of this contract
      */
-    function updateDomainSubgraphID(bytes32 _domainHash, bytes32 _subgraphID)
-        external
-        onlyDomainOwner(_domainHash)
-    {
+    constructor(address _governor) public Governed(_governor) {}
+
+    /**
+     * @dev Publish a version using `subgraphID` under a subgraph name.
+     * @param _name Name of the subgraph
+     * @param _subgraphID Subgraph ID to link to the subgraph name
+     * @param _metadataHash IPFS hash linked to the metadata
+     */
+    function publish(
+        string calldata _name,
+        bytes32 _subgraphID,
+        bytes32 _metadataHash
+    ) external {
+        address owner = msg.sender;
+        bytes32 nameHash = keccak256(bytes(_name));
         require(
-            _subgraphID != bytes32(0),
-            "If you want to reset the subgraphID, call deleteSubdomain."
+            !isReserved(nameHash) || records[nameHash].owner == owner,
+            "GNS: Record reserved, only record owner can publish"
         );
-        domains[_domainHash].subgraphID = _subgraphID;
-        emit SubgraphIDUpdated(_domainHash, _subgraphID);
-    }
 
-    /*
-     * @notice Remove an existing domain owner and subgraphID
-     * @dev Only the domain owner may do this.
-     *
-     * @param _domainHash <bytes32> - Hash of the domain name.
-     */
-    function deleteSubdomain(bytes32 _domainHash) external onlyDomainOwner(_domainHash) {
-        delete domains[_domainHash];
-        emit DomainDeleted(_domainHash);
+        records[nameHash] = Record(owner, _subgraphID, RecordType.GNS);
+        emit SubgraphPublished(_name, owner, _subgraphID, _metadataHash);
     }
 
-    /*
-     * @notice Transfer ownership of domain by existing domain owner.
-     * @dev Only the domain owner may do this.
-     *
-     * @param _domainHash <bytes32> - Hash of the domain name.
-     * @param _newOwner <address> - New owner of the domain.
+    /**
+     * @dev Unpublish a subgraph name. Can only be done by the owner.
+     * @param _nameHash Keccak256 hash of the subgraph name
      */
-    function transferDomainOwnership(bytes32 _domainHash, address _newOwner)
-        external
-        onlyDomainOwner(_domainHash)
-    {
-        require(_newOwner != address(0), "If you want to reset the owner, call deleteSubdomain.");
-        domains[_domainHash].owner = _newOwner;
-        emit DomainTransferred(_domainHash, _newOwner);
+    function unpublish(bytes32 _nameHash) external onlyRecordOwner(_nameHash) {
+        delete records[_nameHash];
+        emit SubgraphUnpublished(_nameHash);
     }
 
-    /*
-     * @notice Change or initalize the Account Metadata, which is stored in a schema on IPFS.
-     * @dev Only the msg.sender can do this.
-     *
-     * @param _ipfsHash <bytes32> - Hash of the IPFS file that stores the account metadata.
-     * @param _account <address> - msg.sender.
+    /**
+     * @dev Tranfer the subgraph name to a new owner.
+     * @param _nameHash Keccak256 hash of the subgraph name
+     * @param _to Address of the new owner
      */
-    function changeAccountMetadata(bytes32 _ipfsHash) external {
-        emit AccountMetadataChanged(msg.sender, _ipfsHash);
+    function transfer(bytes32 _nameHash, address _to) external onlyRecordOwner(_nameHash) {
+        require(_to != address(0), "GNS: Cannot transfer to empty address");
+        require(records[_nameHash].owner != _to, "GNS: Cannot transfer to itself");
+        records[_nameHash].owner = _to;
+        emit SubgraphTransferred(_nameHash, msg.sender, _to);
     }
 
-    /*
-     * @notice Change or initalize the Account Metadata, which is stored in a schema on IPFS.
-     * @dev Only the msg.sender can do this.
-     *
-     * @param _ipfsHash <bytes32> - Hash of the IPFS file that stores the subgraph metadata.
-     * @param _domainHash <bytes32> - Hash of the domain name.
+    /**
+     * @dev Return whether a subgraph name is registed or not.
+     * @param _nameHash Keccak256 hash of the subgraph name
+     * @return Return true if subgraph name exists
      */
-    function changeSubgraphMetadata(bytes32 _domainHash, bytes32 _ipfsHash)
-        public
-        onlyDomainOwner(_domainHash)
-    {
-        emit SubgraphMetadataChanged(_domainHash, _ipfsHash);
+    function isReserved(bytes32 _nameHash) public view returns (bool) {
+        return records[_nameHash].owner != address(0);
     }
 }

test/curation.test.js

@@ -39,7 +39,7 @@ contract('Curation', ([me, other, governor, curator, staking]) => {
     await this.grt.approve(this.curation.address, this.curatorTokens, { from: staking })
 
     // Randomize a subgraphId
-    this.subgraphId = helpers.randomSubgraphIdHex0x()
+    this.subgraphId = helpers.randomSubgraphId()
   })
 
   describe('configuration', function() {
@@ -146,7 +146,7 @@ contract('Curation', ([me, other, governor, curator, staking]) => {
 
   context('> bonding curve', function() {
     beforeEach(function() {
-      this.subgraphId = helpers.randomSubgraphIdHex0x()
+      this.subgraphId = helpers.randomSubgraphId()
     })
 
     it('convert shares to tokens', async function() {

test/disputes.test.js

@@ -205,7 +205,7 @@ contract('Disputes', ([me, other, governor, arbitrator, indexer, fisherman, othe
       const receipt = {
         requestCID: web3.utils.randomHex(32),
         responseCID: web3.utils.randomHex(32),
-        subgraphID: helpers.randomSubgraphIdHex0x(),
+        subgraphID: helpers.randomSubgraphId(),
       }
       this.dispute = await attestation.createDispute(
         receipt,