feat<descriptor>: added scripts and addresses generation functions

lib/descriptor/abstractdescriptor.js

@@ -10,6 +10,7 @@ const assert = require('bsert');
 const common = require('./common');
 const Network = require('../protocol/network');
 const KeyProvider = require('./keyprovider');
+const Address = require('../primitives/address');
 
 /**
  * Constants
@@ -212,6 +213,55 @@ class AbstractDescriptor {
   isSingleType() {
     return true;
   }
+
+  /**
+   * Get scripts for the descriptor at a specified position.
+   * @param {Number} pos
+   * @returns {Scripts[]}
+   */
+
+  generateScripts(pos) {
+    const pubkeys = [];
+    let subscript = null;
+
+    for (const subdesc of this.subdescriptors) {
+      subscript = subdesc.generateScripts(pos)[0];
+    }
+
+    for (const provider of this.keyProviders) {
+      const pubkey = provider.getDerivedPublicKey(pos);
+      assert(pubkey, 'Cannot derive script without private keys');
+      pubkeys.push(pubkey);
+    }
+
+    return this.getScripts(pubkeys, subscript);
+  }
+
+  /**
+   * Get the scriptsig(s).
+   * @returns {Scripts[]}
+   */
+
+  getScripts() {
+    return [];
+  }
+
+  /**
+   * Derive addresses from scripts.
+   * @param {Scripts[]} scripts
+   * @returns {Address[]}
+   */
+
+  getAddresses(scripts) {
+    const addresses = [];
+    for (const script of scripts) {
+      const address = Address.fromScript(script, this.network);
+      assert(address, 'Descriptor does not have a corresponding address');
+      addresses.push(address.toString(this.network));
+    }
+
+    return addresses;
+  }
 }
 
 /*

lib/descriptor/keyprovider.js

@@ -11,6 +11,7 @@ const HD = require('../hd/hd');
 const KeyRing = require('../primitives/keyring');
 const {scriptContext, isHex} = require('./common');
 const Network = require('../protocol/network');
+// const hash160 = require('bcrypto/lib/hash160');
 
 /**
  * Constants
@@ -272,6 +273,14 @@ class KeyProvider {
   hasPrivateKey() {
     return this.ring.privateKey !== null;
   }
+
+  /**
+   * Derive the public key
+   */
+
+  getPublicKey() {
+    return null;
+  }
 }
 
 /**
@@ -326,6 +335,15 @@ class ConstKeyProvider extends KeyProvider {
     }
     return null;
   }
+
+  /**
+   * Derive the public key.
+   * @param {KeyOriginInfo} info
+   */
+
+  getDerivedPublicKey(pos) {
+    return this.ring.publicKey;
+  }
 }
 
 /**
@@ -423,6 +441,67 @@ class HDKeyProvider extends KeyProvider {
     }
     return null;
   }
+
+  /**
+   * Derive tha last xpriv key.
+   * @returns {HDPrivateKey}
+   */
+
+  getDerivedPrivateKey(pos) {
+    if (!this.hdkey.privateKey) {
+      return null;
+    }
+
+    let childkey = this.hdkey;
+
+    if (this.path.length > 0) {
+      const path = 'm' + HD.common.format(this.path, this.hardenedMarker);
+      childkey = childkey.derivePath(path);
+    }
+
+    if (this.type === deriveType.UNHARDENED) {
+      childkey = childkey.derive(pos, false);
+    } else if (this.type === deriveType.HARDENED) {
+      childkey = childkey.derive(pos, true);
+    }
+
+    return childkey;
+  }
+
+  /**
+   * Derive public key at a given position
+   * @param {Number} pos
+   * @returns {Buffer}
+   */
+
+  getDerivedPublicKey(pos) {
+    if (this.isHardened()) {
+      const childprivkey = this.getDerivedPrivateKey(pos);
+      if (childprivkey) {
+        return childprivkey.publicKey;
+      }
+      return null;
+    }
+
+    let childkey = this.hdkey;
+
+    if (this.hdkey instanceof HD.PrivateKey) {
+      childkey = this.hdkey.toPublic();
+    }
+
+    if (this.path.length > 0) {
+      const path = 'm' + HD.common.format(this.path, this.hardenedMarker);
+      childkey = childkey.derivePath(path);
+    }
+
+    if (this.type === deriveType.UNHARDENED) {
+      childkey = childkey.derive(pos);
+    }
+
+    assert(this.type !== deriveType.HARDENED);
+
+    return childkey.publicKey;
+  }
 }
 
 /**
@@ -440,7 +519,7 @@ function getHardenedMarker(path) {
 
   let hardenedMarker = null;
   for (const p of path) {
-   const last = p[p.length - 1];
+    const last = p[p.length - 1];
     if (last === '\'' || last === 'h') {
       hardenedMarker = last;
     }

lib/descriptor/type/addr.js

@@ -12,6 +12,7 @@ const common = require('../common');
 const {isType, strip, checkChecksum, scriptContext, types} = common;
 const Address = require('../../primitives/address');
 const Network = require('../../protocol/network');
+const Script = require('../../script/script');
 
 /**
  * AddressDescriptor
@@ -118,6 +119,18 @@ class AddressDescriptor extends AbstractDescriptor {
   isSolvable() {
     return false;
   }
+
+  /**
+   * Get scriptPubkey(s) for the descriptor.
+   * @returns {Script[]}
+   */
+
+  getScripts() {
+    const scripts = [];
+    const script = Script.fromAddress(this.address);
+    scripts.push(script);
+    return scripts;
+  }
 }
 
 /*

lib/descriptor/type/combo.js

@@ -12,6 +12,8 @@ const common = require('../common');
 const {isType, strip, checkChecksum, scriptContext, types} = common;
 const KeyProvider = require('../keyprovider');
 const Network = require('../../protocol/network');
+const hash160 = require('bcrypto/lib/hash160');
+const Script = require('../../script/script');
 
 /**
  * ComboDescriptor
@@ -112,6 +114,30 @@ class ComboDescriptor extends AbstractDescriptor {
   isSolvable() {
     return true;
   }
+
+  /**
+   * Get scriptPubkey(s) for the descriptor.
+   * @param {Buffer[]} pubkeys
+   * @returns {Script[]}
+   */
+
+  getScripts(pubkeys) {
+    const scripts = [];
+
+    scripts.push(Script.fromPubkey(pubkeys[0])); // P2PK
+
+    const pubkeyhash = hash160.digest(pubkeys[0]);
+    scripts.push(Script.fromPubkeyhash(pubkeyhash)); // P2PKH
+
+    if (pubkeys[0].length === 33) {
+      const p2wpkh = Script.fromProgram(0, pubkeyhash);
+      scripts.push(p2wpkh); // P2WPKH
+      const p2sh = Script.fromScripthash(p2wpkh.hash160()); // P2SH-P2WPKH
+      scripts.push(p2sh);
+    }
+
+    return scripts;
+  }
 }
 
 /*

lib/descriptor/type/multisig.js

@@ -14,6 +14,7 @@ const {MAX_SCRIPT_PUSH, MAX_MULTISIG_PUBKEYS} = consensus;
 const KeyProvider = require('../keyprovider');
 const Network = require('../../protocol/network');
 const assert = require('bsert');
+const Script = require('../../script/script');
 
 /**
  * MultisigDescriptor
@@ -38,6 +39,7 @@ class MultisigDescriptor extends AbstractDescriptor {
     this.type = types.MULTI;
     this.isSorted = false;
     this.threshold = 0;
+    this.scriptContext = scriptContext.TOP;
 
     if (options) {
       this.fromOptions(options);
@@ -168,6 +170,30 @@ class MultisigDescriptor extends AbstractDescriptor {
   toStringExtra() {
     return this.threshold.toString();
   }
+
+  /**
+   * Get scriptPubkey(s) for the descriptor.
+   * @param {Buffer[]} pubkeys
+   * @returns {Script[]}
+   */
+
+  getScripts(pubkeys) {
+    const scripts = [];
+    const m = this.threshold;
+    const n = pubkeys.length;
+    scripts.push(Script.fromMultisig(m, n, pubkeys, this.isSorted));
+    return scripts;
+  }
+
+  /**
+   * Derive addresses from scripts.
+   * @param {Scripts[]} scripts
+   * @returns {Address[]}
+   */
+
+  getAddresses(scripts) {
+    throw new Error('Descriptor does not have a corresponding address');
+  }
 }
 
 /**

lib/descriptor/type/pk.js

@@ -12,6 +12,7 @@ const {isType, strip, checkChecksum, scriptContext, types} = common;
 const assert = require('bsert');
 const KeyProvider = require('../keyprovider');
 const Network = require('../../protocol/network');
+const Script = require('../../script/script');
 
 /**
  * PKDescriptor
@@ -103,6 +104,19 @@ class PKDescriptor extends AbstractDescriptor {
   static fromString(str, network, context = scriptContext.TOP) {
     return new this().fromString(str, network, context);
   }
+
+  /**
+   * Get scriptPubkey(s) for the descriptor.
+   * @param {Buffer[]} pubkeys
+   * @returns {Script[]}
+   */
+
+  getScripts(pubkeys) {
+    const scripts = [];
+    const script = Script.fromPubkey(pubkeys[0]);
+    scripts.push(script);
+    return scripts;
+  }
 }
 
 /*

lib/descriptor/type/pkh.js

@@ -12,6 +12,8 @@ const {isType, strip, checkChecksum, scriptContext, types} = common;
 const assert = require('bsert');
 const KeyProvider = require('../keyprovider');
 const Network = require('../../protocol/network');
+const hash160 = require('bcrypto/lib/hash160');
+const Script = require('../../script/script');
 
 /**
  * PKHDescriptor
@@ -109,6 +111,20 @@ class PKHDescriptor extends AbstractDescriptor {
   static fromString(str, network, context = scriptContext.TOP) {
     return new this().fromString(str, network, context);
   }
+
+  /**
+   * Get scriptPubkey(s) for the descriptor.
+   * @param {Buffer[]} pubkeys
+   * @returns {Script[]}
+   */
+
+  getScripts(pubkeys) {
+    const scripts = [];
+    const pubkeyhash = hash160.digest(pubkeys[0]);
+    const script = Script.fromPubkeyhash(pubkeyhash);
+    scripts.push(script);
+    return scripts;
+  }
 }
 
 /*

lib/descriptor/type/raw.js

@@ -115,6 +115,15 @@ class RawDescriptor extends AbstractDescriptor {
   toStringExtra() {
     return this.script.toJSON();
   }
+
+  /**
+   * Get scriptPubkey(s) for the descriptor.
+   * @returns {Script[]}
+   */
+
+  getScripts() {
+    return [this.script];
+  }
 }
 
 /*

lib/descriptor/type/sh.js

@@ -15,8 +15,8 @@ const WSHDescriptor = require('./wsh');
 const assert = require('bsert');
 const common = require('../common');
 const {isType, strip, getType, scriptContext, checkChecksum, types} = common;
-
 const Network = require('../../protocol/network');
+const Script = require('../../script/script');
 
 /**
  * SHDescriptor
@@ -155,6 +155,19 @@ class SHDescriptor extends AbstractDescriptor {
 
     return validSubTypes.includes(type);
   }
+
+  /**
+   * Get scriptPubkey(s) for the descriptor.
+   * @param {Buffer[]} pubkeys
+   * @param {Script} script
+   * @returns {Script[]}
+   */
+
+  getScripts(pubkeys, script) {
+    const scripts = [];
+    scripts.push(Script.fromScripthash(script.hash160()));
+    return scripts;
+  }
 }
 
 /*