wallet: check account ownership of name before making transfer TX

also: make finalize

Author: pinheadmz

lib/wallet/wallet.js

@@ -2626,16 +2626,22 @@ class Wallet extends EventEmitter {
    * Make a transfer MTX.
    * @param {String} name
    * @param {Address} address
+   * @param {String|Number} acct
    * @returns {MTX}
    */
 
-  async makeTransfer(name, address) {
+  async makeTransfer(name, address, acct) {
     assert(typeof name === 'string');
     assert(address instanceof Address);
 
     if (!rules.verifyName(name))
       throw new Error('Invalid name.');
 
+    if (acct != null) {
+      assert((acct >>> 0) === acct || typeof acct === 'string');
+      acct = await this.getAccountIndex(acct);
+    }
+
     const rawName = Buffer.from(name, 'ascii');
     const nameHash = rules.hashName(rawName);
     const ns = await this.getNameState(nameHash);
@@ -2658,6 +2664,9 @@ class Wallet extends EventEmitter {
     if (coin.height < ns.height)
       throw new Error(`Wallet does not own: "${name}".`);
 
+    if (acct != null && !await this.txdb.hasCoinByAccount(acct, hash, index))
+      throw new Error(`Account does not own: "${name}".`);
+
     const state = ns.state(height, network);
 
     if (state !== states.CLOSED)
@@ -2696,7 +2705,8 @@ class Wallet extends EventEmitter {
    */
 
   async _createTransfer(name, address, options) {
-    const mtx = await this.makeTransfer(name, address);
+    const acct = options ? options.account : null;
+    const mtx = await this.makeTransfer(name, address, acct);
     await this.fill(mtx, options);
     return this.finalize(mtx, options);
   }
@@ -2876,15 +2886,21 @@ class Wallet extends EventEmitter {
    * Make a transfer-finalizing MTX.
    * @private
    * @param {String} name
+   * @param {String|Number} acct
    * @returns {MTX}
    */
 
-  async makeFinalize(name) {
+  async makeFinalize(name, acct) {
     assert(typeof name === 'string');
 
     if (!rules.verifyName(name))
       throw new Error('Invalid name.');
 
+    if (acct != null) {
+      assert((acct >>> 0) === acct || typeof acct === 'string');
+      acct = await this.getAccountIndex(acct);
+    }
+
     const rawName = Buffer.from(name, 'ascii');
     const nameHash = rules.hashName(rawName);
     const ns = await this.getNameState(nameHash);
@@ -2907,6 +2923,9 @@ class Wallet extends EventEmitter {
     if (coin.height < ns.height)
       throw new Error(`Wallet does not own: "${name}".`);
 
+    if (acct != null && !await this.txdb.hasCoinByAccount(acct, hash, index))
+      throw new Error(`Account does not own: "${name}".`);
+
     const state = ns.state(height, network);
 
     if (state !== states.CLOSED)
@@ -2955,7 +2974,8 @@ class Wallet extends EventEmitter {
    */
 
   async _createFinalize(name, options) {
-    const mtx = await this.makeFinalize(name);
+    const acct = options ? options.account : null;
+    const mtx = await this.makeFinalize(name, acct);
     await this.fill(mtx, options);
     return this.finalize(mtx, options);
   }

test/wallet-accounts-auction-test.js

@@ -256,4 +256,81 @@ describe('Multiple accounts participating in same auction', function() {
       assert.strictEqual(node.mempool.map.size, 0);
     });
   });
+
+  describe('TRANSFER', function() {
+    // Alice will transfer to Bob
+    let toAddr;
+
+    before(async () => {
+      toAddr = await bob.receiveAddress();
+    });
+
+    it('should reject TRANSFER from wrong account', async () => {
+      await assert.rejects(async () => {
+        await wallet.sendTransfer(name, toAddr, {account: 'bob'});
+      }, {
+        name: 'Error',
+        message: `Account does not own: "${name}".`
+      });
+    });
+
+    it('should send TRANSFER from correct account', async () => {
+      const tx = await wallet.sendTransfer(name, toAddr, {account: 0});
+      assert(tx);
+
+      await wallet.abandon(tx.hash());
+
+      assert.strictEqual(node.mempool.map.size, 1);
+      await node.mempool.reset();
+      assert.strictEqual(node.mempool.map.size, 0);
+    });
+
+    it('should send TRANSFER from correct account automatically', async () => {
+      const tx = await wallet.sendTransfer(name, toAddr);
+      assert(tx);
+
+      await mineBlocks(1);
+    });
+  });
+
+  describe('FINALIZE', function() {
+    it('should advance chain until FINALIZE is allowed', async () => {
+      await mineBlocks(network.names.transferLockup);
+      const ns = await node.chain.db.getNameStateByName(name);
+      assert(ns.isClosed(node.chain.height, network));
+
+      await wdb.rescan(0);
+    });
+
+    it('should reject FINALIZE from wrong account', async () => {
+      await assert.rejects(async () => {
+        await wallet.sendFinalize(name, {account: 'bob'});
+      }, {
+        name: 'Error',
+        message: `Account does not own: "${name}".`
+      });
+    });
+
+    it('should send FINALIZE from correct account', async () => {
+      const tx = await wallet.sendFinalize(name, {account: 0});
+      assert(tx);
+
+      await wallet.abandon(tx.hash());
+
+      assert.strictEqual(node.mempool.map.size, 1);
+      await node.mempool.reset();
+      assert.strictEqual(node.mempool.map.size, 0);
+    });
+
+    it('should send FINALIZE from correct account automatically', async () => {
+      const tx = await wallet.sendFinalize(name);
+      assert(tx);
+
+      await wallet.abandon(tx.hash());
+
+      assert.strictEqual(node.mempool.map.size, 1);
+      await node.mempool.reset();
+      assert.strictEqual(node.mempool.map.size, 0);
+    });
+  });
 });