batch open transaction support on full node

lib/dns/resource.js

@@ -880,7 +880,7 @@ function typeToClass(type) {
 function stringToClass(type) {
   assert(typeof type === 'string');
 
-  if (!hsTypes.hasOwnProperty(type))
+  if (!Object.prototype.hasOwnProperty.call(hsTypes, type))
     return null;
 
   return typeToClass(hsTypes[type]);

lib/primitives/airdropkey.js

@@ -363,7 +363,7 @@ class AirdropKey extends bio.Struct {
   fromJSON(json) {
     assert(json && typeof json === 'object');
     assert(typeof json.type === 'string');
-    assert(keyTypes.hasOwnProperty(json.type));
+    assert(Object.prototype.hasOwnProperty.call(keyTypes, json.type));
 
     this.type = keyTypes[json.type];
 

lib/wallet/http.js

@@ -1035,6 +1035,41 @@ class HTTP extends Server {
       return res.json(200, mtx.getJSON(this.network));
     });
 
+    // Create Batch Open
+    this.post('/wallet/:id/batch/open', async (req, res) => {
+      const valid = Validator.fromRequest(req);
+      const names = valid.array('names');
+      const force = valid.bool('force', false);
+      const passphrase = valid.str('passphrase');
+      const broadcast = valid.bool('broadcast', true);
+      const sign = valid.bool('sign', true);
+      const MAX_NAME_ARRAY_LENGTH = 200;
+
+      assert(names && names.length > 0, 'Names are required.');
+      assert(names.length <= MAX_NAME_ARRAY_LENGTH,
+        `Names array shoud not exceed ${MAX_NAME_ARRAY_LENGTH}`);
+      assert(broadcast ? sign : true, 'Must sign when broadcasting.');
+
+      const options = TransactionOptions.fromValidator(valid);
+      const {mtx, errors, isAllError} = await req.wallet
+      .createBatchOpen(names, force, options);
+
+      if (isAllError) { // no valid output in mtx
+        return res.json(500, {errors: errors});
+      }
+
+      if (broadcast) {
+        const tx = await req.wallet.sendMTX(mtx, passphrase);
+        return res.json(200, {tx: tx.getJSON(this.network), errors: errors});
+      }
+
+      if (sign) {
+        await req.wallet.sign(mtx, passphrase);
+      }
+
+      return res.json(200, {tx: mtx.getJSON(this.network), errors: errors});
+    });
+
     // Create Bid
     this.post('/wallet/:id/bid', async (req, res) => {
       const valid = Validator.fromRequest(req);

lib/wallet/txdb.js

@@ -845,6 +845,36 @@ class TXDB {
     return false;
   }
 
+  /**
+   * Test whether the covenant
+   * has a duplicate open.
+   * @param {Covenant}
+   * @returns {Boolean}
+   */
+
+  async isCovenantDoubleOpen(covenant) {
+    if (!covenant.isOpen()) {
+      return false;
+    } else {
+      const nameHash = covenant.getHash(0);
+      const key = layout.o.encode(nameHash);
+      const hash = await this.bucket.get(key);
+
+      // Allow a double open if previous auction period has expired
+      // this is not a complete check for name availability or status!
+      if (hash) {
+        const names = this.wdb.network.names;
+        const period = names.biddingPeriod + names.revealPeriod;
+        const oldTX = await this.getTX(hash);
+        if ( oldTX.height !== -1 && oldTX.height + period < this.wdb.height) {
+          return false;
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+
   /**
    * Remove duplicate opens.
    * @private

lib/wallet/wallet.js

@@ -1559,6 +1559,87 @@ class Wallet extends EventEmitter {
     }
   }
 
+  /**
+   * Make a batch open MTX.
+   * @param {Array} names
+   * @param {Number|String} acct
+   * @param {Boolean} force
+   * @returns {MTX}
+   */
+
+  async makeBatchOpen(names, force, acct) {
+    // TODO roza - verify this method is supported
+    assert(Array.isArray(names));
+    assert(typeof force === 'boolean');
+    assert(acct >>> 0 === acct || typeof acct === 'string');
+
+    const errors = [];
+    const mtx = new MTX();
+
+    for (const name of names) {
+      if (!rules.verifyName(name)) {
+        errors.push({name: name, error: 'Invalid name.'});
+        continue;
+      }
+
+      const rawName = Buffer.from(name, 'ascii');
+      const nameHash = rules.hashName(rawName);
+      const height = this.wdb.height + 1;
+      const network = this.network;
+
+      // TODO: Handle expired behavior.
+      if (rules.isReserved(nameHash, height, network)) {
+        errors.push({name: name, error: 'Name is reserved.'});
+        continue;
+      }
+
+      if (!rules.hasRollout(nameHash, height, network)) {
+        errors.push({name: name, error: 'Name not yet available.'});
+        continue;
+      }
+
+      let ns = await this.getNameState(nameHash);
+      if (!ns) {
+        ns = await this.wdb.getNameStatus(nameHash);
+      }
+
+      ns.maybeExpire(height, network);
+
+      const state = ns.state(height, network);
+      const start = ns.height;
+
+      if (state !== states.OPENING) {
+        errors.push({name: name, error: 'Name is not available.'});
+        continue;
+      }
+
+      if (start !== 0 && start !== height) {
+        errors.push({name: name, error: 'Name is already opening.'});
+        continue;
+      }
+
+      const addr = await this.receiveAddress(acct);
+
+      const output = new Output();
+      output.address = addr;
+      output.value = 0;
+      output.covenant.type = types.OPEN;
+      output.covenant.pushHash(nameHash);
+      output.covenant.pushU32(0);
+      output.covenant.push(rawName);
+
+      if (await this.txdb.isCovenantDoubleOpen(output.covenant)) {
+        errors.push({name: name, error: `Already sent an open for: ${name}.`});
+        continue;
+      }
+
+      mtx.outputs.push(output);
+    }
+
+    const isAllError = (names.length === errors.length);
+    return { mtx: mtx, errors: errors, isAllError: isAllError};
+  }
+
   /**
    * Make a open MTX.
    * @param {String} name
@@ -1656,6 +1737,45 @@ class Wallet extends EventEmitter {
     }
   }
 
+  /**
+   * Create and finalize a batch open
+   * MTX without a lock.
+   * @param {Array} names
+   * @param {Boolean} force
+   * @param {Object} options
+   * @returns {MTX}
+   */
+
+  async _createBatchOpen(names, force, options) {
+    const acct = options ? options.account || 0 : 0;
+    const {mtx, errors, isAllError} = await this
+    .makeBatchOpen(names, force, acct);
+    if (!isAllError) {
+        await this.fill(mtx, options);
+        return {mtx: await this.finalize(mtx, options), errors: errors};
+    } else {
+      return {mtx: null, errors: errors, isAllError: true};
+    }
+  }
+
+  /**
+   * Create and finalize a batch open
+   * MTX with a lock.
+   * @param {Array} names
+   * @param {Boolean} force
+   * @param {Object} options
+   * @returns {MTX}
+   */
+
+  async createBatchOpen(names, force, options) {
+    const unlock = await this.fundLock.lock();
+    try {
+      return await this._createBatchOpen(names, force, options);
+    } finally {
+      unlock();
+    }
+  }
+
   /**
    * Create and send an open
    * MTX without a lock.