Merge PR #819 from 'nodech/icann-lockup'

lib/blockchain/chain.js

@@ -30,6 +30,11 @@ const {CriticalError} = require('../errors');
 const thresholdStates = common.thresholdStates;
 const {states} = NameState;
 
+const {
+  VERIFY_COVENANTS_HARDENED,
+  VERIFY_COVENANTS_LOCKUP
+} = rules.nameFlags;
+
 /**
  * Blockchain
  * @alias module:blockchain.Chain
@@ -201,10 +206,9 @@ class Chain extends AsyncEmitter {
       assert(state);
 
       const view = new CoinView();
-      const hardened = state.hasHardening();
 
       for (const tx of block.txs)
-        await this.verifyCovenants(tx, view, height, hardened);
+        await this.verifyCovenants(tx, view, height, state.nameFlags);
 
       // If the chain replay crosses a tree interval, it will commit
       // and write to disk in saveNames(), resetting the `txn` like usual.
@@ -699,7 +703,11 @@ class Chain extends AsyncEmitter {
 
     // Disable RSA-1024.
     if (await this.isActive(prev, deployments.hardening))
-      state.hardening = true;
+      state.nameFlags |= rules.nameFlags.VERIFY_COVENANTS_HARDENED;
+
+    // Disable ICANN, TOP100 and CUSTOM TLDs from getting auctioned.
+    if (await this.isActive(prev, deployments.icannlockup))
+      state.nameFlags |= rules.nameFlags.VERIFY_COVENANTS_LOCKUP;
 
     return state;
   }
@@ -721,6 +729,9 @@ class Chain extends AsyncEmitter {
     if (this.height === this.network.deflationHeight)
       this.logger.warning('Name claim deflation has been activated.');
 
+    if (!this.state.hasICANNLockup() && state.hasICANNLockup())
+      this.logger.warning('ICANN lockup has been activated.');
+
     this.state = state;
   }
 
@@ -733,7 +744,6 @@ class Chain extends AsyncEmitter {
    */
 
   async updateInputs(block, prev, state) {
-    const hardened = state.hasHardening();
     const view = new CoinView();
     const height = prev.height + 1;
 
@@ -749,7 +759,7 @@ class Chain extends AsyncEmitter {
           'BUG: Spent inputs in historical data!');
       }
 
-      await this.verifyCovenants(tx, view, height, hardened);
+      await this.verifyCovenants(tx, view, height, state.nameFlags);
 
       view.addTX(tx, height);
     }
@@ -777,7 +787,6 @@ class Chain extends AsyncEmitter {
 
   async verifyInputs(block, prev, state) {
     const network = this.network;
-    const hardened = state.hasHardening();
     const view = new CoinView();
     const height = prev.height + 1;
     const interval = network.halvingInterval;
@@ -854,7 +863,7 @@ class Chain extends AsyncEmitter {
       }
 
       // Verify covenants.
-      await this.verifyCovenants(tx, view, height, hardened);
+      await this.verifyCovenants(tx, view, height, state.nameFlags);
 
       // Add new coins.
       view.addTX(tx, height);
@@ -961,14 +970,14 @@ class Chain extends AsyncEmitter {
    * @param {TX} tx
    * @param {CoinView} view
    * @param {Number} height
-   * @param {Boolean} hardened
+   * @param {NameFlags} nameFlags
    */
 
-  async verifyCovenants(tx, view, height, hardened) {
+  async verifyCovenants(tx, view, height, nameFlags) {
     assert(tx);
     assert(view instanceof CoinView);
     assert((height >>> 0) === height);
-    assert(typeof hardened === 'boolean');
+    assert(typeof nameFlags === 'number');
 
     const {types} = rules;
     const network = this.network;
@@ -1055,7 +1064,7 @@ class Chain extends AsyncEmitter {
         // any weak algorithms (i.e. RSA-1024).
         // Any future emergency soft-forks should
         // also be included below this check.
-        if (hardened && weak) {
+        if ((nameFlags & VERIFY_COVENANTS_HARDENED) && weak) {
           throw new VerifyError(tx,
             'invalid',
             'bad-claim-algorithm',
@@ -1160,6 +1169,16 @@ class Chain extends AsyncEmitter {
             100);
         }
 
+        // Make sure locked up names are not opened if ICANN LOCKUP has
+        // activated.
+        const isLockUpActive = nameFlags & VERIFY_COVENANTS_LOCKUP;
+        if (isLockUpActive && rules.isLockedUp(nameHash, height, network)) {
+          throw new VerifyError(tx,
+            'invalid',
+            'bad-open-lockedup',
+            100);
+        }
+
         // On mainnet, names are released on a
         // weekly basis for the first year.
         if (!rules.hasRollout(nameHash, height, network)) {
@@ -1307,7 +1326,7 @@ class Chain extends AsyncEmitter {
           // registrar's keys are compromised.
           if (ns.isClaimable(height, network)) {
             // Soft-fork #1 (RSA hardening).
-            if (hardened && ns.weak) {
+            if ((nameFlags & VERIFY_COVENANTS_HARDENED) && ns.weak) {
               throw new VerifyError(tx,
                 'invalid',
                 'bad-register-state',
@@ -3942,11 +3961,15 @@ class DeploymentState {
     this.tip = tip;
     this.flags = Script.flags.MANDATORY_VERIFY_FLAGS;
     this.lockFlags = common.lockFlags.MANDATORY_LOCKTIME_FLAGS;
-    this.hardening = false;
+    this.nameFlags = rules.nameFlags.MANDATORY_VERIFY_COVENANT_FLAGS;
   }
 
   hasHardening() {
-    return this.hardening;
+    return (this.nameFlags & VERIFY_COVENANTS_HARDENED) !== 0;
+  }
+
+  hasICANNLockup() {
+    return (this.nameFlags & VERIFY_COVENANTS_LOCKUP) !== 0;
   }
 }
 

lib/blockchain/common.js

@@ -23,7 +23,7 @@ exports.lockFlags = {};
  * @default
  */
 
-exports.lockFlags.MANDATORY_LOCKTIME_FLAGS = 0;;
+exports.lockFlags.MANDATORY_LOCKTIME_FLAGS = 0;
 
 /**
  * Standard locktime flags (used for mempool validation).

lib/covenants/ownership.js

@@ -258,9 +258,6 @@ class Ownership extends BNSOwnership {
   }
 }
 
-Ownership.Proof = Proof;
-Ownership.OwnershipProof = Proof;
-
 /**
  * ProofData
  */
@@ -291,4 +288,9 @@ ownership = new Ownership();
  * Expose
  */
 
-module.exports = ownership;
+module.exports = Ownership;
+
+Ownership.Proof = Proof;
+Ownership.OwnershipProof = Proof;
+Ownership.ProofData = ProofData;
+Ownership.ownership = ownership;

lib/covenants/reserved-browser.js

@@ -77,7 +77,10 @@ class Reserved {
       hash,
       target,
       value,
-      root
+      root,
+      top100,
+      custom,
+      zero
     };
   }
 

lib/covenants/reserved.js

@@ -113,7 +113,10 @@ class Reserved {
       hash,
       target,
       value,
-      root
+      root,
+      top100,
+      custom,
+      zero
     };
   }
 

lib/covenants/rules.js

@@ -106,6 +106,28 @@ rules.MAX_NAME_SIZE = 63;
 
 rules.MAX_RESOURCE_SIZE = 512;
 
+/**
+ * Consensus name verification flags (used for block validation).
+ * @enum {Number}
+ * @default
+ */
+
+rules.nameFlags = {
+  VERIFY_COVENANTS_NONE: 0,
+  // Activated when hardening soft fork activates.
+  VERIFY_COVENANTS_HARDENED: 1 << 0,
+  // Activated when ICANN lockup soft fork activates.
+  VERIFY_COVENANTS_LOCKUP: 1 << 1
+};
+
+/**
+ * Standard verify flags for covenants.
+ * @const {NameFlags}
+ * @default
+ */
+
+rules.nameFlags.MANDATORY_VERIFY_COVENANT_FLAGS = 0;
+
 /**
  * Maximum covenant size.
  * @const {Number}
@@ -374,6 +396,37 @@ rules.isReserved = function isReserved(nameHash, height, network) {
   return reserved.has(nameHash);
 };
 
+/**
+ * Test whether a name is locked up.
+ * ICANNLOCKUP soft fork.
+ * @param {Buffer} nameHash
+ * @param {Number} height
+ * @param {Network} network
+ * @returns {Boolean}
+ */
+
+rules.isLockedUp = function isLockedUp(nameHash, height, network) {
+  assert(Buffer.isBuffer(nameHash));
+  assert((height >>> 0) === height);
+  assert(network && network.names);
+
+  if (network.names.noReserved)
+    return false;
+
+  if (height < network.names.claimPeriod)
+    return false;
+
+  const item = reserved.get(nameHash);
+
+  if (!item)
+    return false;
+
+  if (item.root || item.top100 || item.custom)
+    return true;
+
+  return false;
+};
+
 /**
  * Create a blind bid hash from a value and nonce.
  * @param {Amount} value

lib/mempool/contractstate.js

@@ -316,6 +316,13 @@ class ContractState {
     return this.toSet(this.reveals, nameHash, items);
   }
 
+  /**
+   * Invalidate transactions in the mempool.
+   * @param {Number} height
+   * @param {Boolean} hardened
+   * @returns {BufferSet<Hash>} - list of invalidated tx hashes.
+   */
+
   invalidate(height, hardened) {
     const nextHeight = height + 1;
     const network = this.network;