scripts: extract all scripts to encode/decode/check style

src/address.js

@@ -28,8 +28,8 @@ function toBase58Check (hash, version) {
 function fromOutputScript (scriptPubKey, network) {
   network = network || networks.bitcoin
 
-  if (bscript.isPubKeyHashOutput(scriptPubKey)) return toBase58Check(bscript.compile(scriptPubKey).slice(3, 23), network.pubKeyHash)
+  if (bscript.pubKeyHash.output.check(scriptPubKey)) return toBase58Check(bscript.compile(scriptPubKey).slice(3, 23), network.pubKeyHash)
-  if (bscript.isScriptHashOutput(scriptPubKey)) return toBase58Check(bscript.compile(scriptPubKey).slice(2, 22), network.scriptHash)
+  if (bscript.scriptHash.output.check(scriptPubKey)) return toBase58Check(bscript.compile(scriptPubKey).slice(2, 22), network.scriptHash)
 
   throw new Error(bscript.toASM(scriptPubKey) + ' has no matching Address')
 }
@@ -38,8 +38,8 @@ function toOutputScript (address, network) {
   network = network || networks.bitcoin
 
   var decode = fromBase58Check(address)
-  if (decode.version === network.pubKeyHash) return bscript.pubKeyHashOutput(decode.hash)
+  if (decode.version === network.pubKeyHash) return bscript.pubKeyHash.output.encode(decode.hash)
-  if (decode.version === network.scriptHash) return bscript.scriptHashOutput(decode.hash)
+  if (decode.version === network.scriptHash) return bscript.scriptHash.output.encode(decode.hash)
 
   throw new Error(address + ' has no matching Script')
 }

src/script.js

@@ -12,16 +12,6 @@ var REVERSE_OPS = (function () {
   return result
 })()
 
-var LIST_DECODE_NAMES = [
-  decodePubKeyOutput,
-  decodePubKeyHashOutput,
-  decodeMultisigOutput,
-  decodeNullDataOutput,
-  decodeScriptHashOutput,
-  decodeWitnessPubKeyHashOutput,
-  decodeWitnessScriptHashOutput
-]
-
 var OP_INT_BASE = OPS.OP_RESERVED // OP_1 - 1
 
 function compile (chunks) {
@@ -169,410 +159,71 @@ function isCanonicalSignature (buffer) {
   return bip66.check(buffer.slice(0, -1))
 }
 
-function isPubKeyHashInput (script) {
+module.exports = {
-  var chunks = decompile(script)
+  compile: compile,
-
+  decompile: decompile,
-  return chunks.length === 2 &&
+  fromASM: fromASM,
-    isCanonicalSignature(chunks[0]) &&
+  toASM: toASM,
-    isCanonicalPubKey(chunks[1])
+  number: require('./script_number'),
-}
-
-function decodePubKeyHashOutput (buffer, chunks) {
-  if (buffer.length !== 25) {
-    throw new Error('pub-key-hash output script is 25 bytes')
-  }
-  if (buffer[0] !== OPS.OP_DUP) {
-    throw new Error('PubKeyHash script missing OP_DUP')
-  }
-  if (buffer[1] !== OPS.OP_HASH160) {
-    throw new Error('PubKeyHash script missing OP_HASH160')
-  }
-  if (buffer[2] !== 0x14) {
-    throw new Error('Incorrect opcode for pubkeyhash')
-  }
-  if (buffer[23] !== OPS.OP_EQUALVERIFY) {
-    throw new Error('PubKeyHash script missing OP_EQUALVERIFY')
-  }
-  if (buffer[24] !== OPS.OP_CHECKSIG) {
-    throw new Error('PubKeyHash script missing OP_CHECKSIG')
-  }
-
-  return {
-    type: 'pubkeyhash',
-    pubKeyHash: chunks[2]
-  }
-}
-
-function isPubKeyHashOutput (script) {
-  return determinesTypeOrNonstandard([decodePubKeyHashOutput], script) === 'pubkeyhash'
-}
-
-function isPubKeyInput (script) {
-  var chunks = decompile(script)
-
-  return chunks.length === 1 &&
-    isCanonicalSignature(chunks[0])
-}
-
-function decodePubKeyOutput (script, chunks) {
-  if (script[0] !== 0x21 && script[0] !== 0x41) {
-    throw new Error('Bad (or non-minimal) public key length for pub')
-  }
-  if (!isCanonicalPubKey(chunks[0])) {
-    throw new Error('pub-key output does not have a canonical public key')
-  }
-  if (chunks[1] !== OPS.OP_CHECKSIG) {
-    throw new Error('pub-key output missing OP_CHECKSIG operator')
-  }
-  if (chunks.length !== 2) {
-    throw new Error('pub-key output has two elements')
-  }
-  return {
-    type: 'pubkey',
-    publicKey: chunks[0]
-  }
-}
-
-function isPubKeyOutput (script) {
-  return determinesTypeOrNonstandard([decodePubKeyOutput], script) === 'pubkey'
-}
-
-function isScriptHashInput (script, allowIncomplete) {
-  var chunks = decompile(script)
-  if (chunks.length < 2) return false
-
-  var lastChunk = chunks[chunks.length - 1]
-  if (!Buffer.isBuffer(lastChunk)) return false
-
-  var scriptSigChunks = chunks.slice(0, -1)
-  var redeemScriptChunks = decompile(lastChunk)
-
-  // is redeemScript a valid script?
-  if (redeemScriptChunks.length === 0) return false
-
-  return classifyInput(scriptSigChunks, allowIncomplete) === classifyOutput(lastChunk)
-}
-
-function decodeScriptHashOutput (chunks) {
-  if (chunks[0] !== OPS.OP_HASH160) {
-    throw new Error()
-  }
-  if (chunks[1] !== 0x14) {
-    throw new Error()
-  }
-  if (chunks[22] !== OPS.OP_EQUAL) {
-    throw new Error()
-  }
-  return {
-    type: 'scripthash',
-    scriptHash: chunks[1]
-  }
-}
-
-function isScriptHashOutput (script) {
-  return determinesTypeOrNonstandard([decodeScriptHashOutput], script) === 'scripthash'
-}
-
-function decodeWitnessPubKeyHashOutput (script, chunks) {
-  if (script.length !== 22) {
-    throw new Error('P2WPKH script should be 22 bytes')
-  }
-  if (script[0] !== OPS.OP_0) {
-    throw new Error('Missing v0 prefix for witness keyhash')
-  }
-  if (script[1] !== 0x14) {
-    throw new Error('Witness keyhash length marker is wrong')
-  }
-
-  return {
-    type: 'witnesspubkeyhash',
-    witnessKeyHash: chunks[2]
-  }
-}
 
-function isWitnessPubKeyHashOutput (script) {
+  isCanonicalPubKey: isCanonicalPubKey,
-  return determinesTypeOrNonstandard([decodeWitnessPubKeyHashOutput], script) === 'witnesspubkeyhash'
+  isCanonicalSignature: isCanonicalSignature,
+  isDefinedHashType: isDefinedHashType
 }
 
-function decodeWitnessScriptHashOutput (script, chunks) {
+//
-  if (script.length !== 34) {
-    throw new Error('P2WSH script should be 34 bytes')
-  }
-  if (script[0] !== OPS.OP_0) {
-    throw new Error('Missing v0 prefix for witness script hash')
-  }
-  if (script[1] !== 0x20) {
-    throw new Error('Witness program length marker is wrong')
-  }
 
-  return {
+var multisig = require('./templates/multisig')
-    type: 'witnessscripthash',
+var nullData = require('./templates/nulldata')
-    witnessScriptHash: chunks[2]
+var pubKey = require('./templates/pubkey')
-  }
+var pubKeyHash = require('./templates/pubkeyhash')
-}
+var scriptHash = require('./templates/scripthash')
+var witnessPubKeyHash = require('./templates/witnesspubkeyhash')
+var witnessScriptHash = require('./templates/witnessscripthash')
 
-function isWitnessScriptHashOutput (script) {
+function classifyOutput (script) {
-  return determinesTypeOrNonstandard([decodeWitnessScriptHashOutput], script) === 'witnessscripthash'
+  if (witnessPubKeyHash.output.check(script)) return 'witnesspubkeyhash'
-}
+  if (witnessScriptHash.output.check(script)) return 'witnessscripthash'
+  if (pubKeyHash.output.check(script)) return 'pubkeyhash'
+  if (scriptHash.output.check(script)) return 'scripthash'
 
-// allowIncomplete is to account for combining signatures
+  // XXX: optimization, below functions .decompile before use
-// See https://github.com/bitcoin/bitcoin/blob/f425050546644a36b0b8e0eb2f6934a3e0f6f80f/src/script/sign.cpp#L195-L197
-function isMultisigInput (script, allowIncomplete) {
   var chunks = decompile(script)
-  if (chunks.length < 2) return false
+  if (multisig.output.check(chunks)) return 'multisig'
-  if (chunks[0] !== OPS.OP_0) return false
+  if (pubKey.output.check(chunks)) return 'pubkey'
-
+  if (nullData.output.check(chunks)) return 'nulldata'
-  if (allowIncomplete) {
-    return chunks.slice(1).every(function (chunk) {
-      return chunk === OPS.OP_0 || isCanonicalSignature(chunk)
-    })
-  }
-
-  return chunks.slice(1).every(isCanonicalSignature)
-}
-
-function decodeMultisigOutput (scriptPubKey, chunks) {
-  if (chunks.length < 4) {
-    throw new Error('Multisig script should contain at least 4 elements')
-  }
-  if (chunks[chunks.length - 1] !== OPS.OP_CHECKMULTISIG) {
-    throw new Error('Final opcode should be OP_CHECKMULTISIG')
-  }
-  if (!types.Number(chunks[0])) {
-    throw new Error('First element must be a number-push opcode')
-  }
-  if (!types.Number(chunks[chunks.length - 2])) {
-    throw new Error('Second-last element must be a number-push opcode')
-  }
-  var m = chunks[0] - OP_INT_BASE
-  var n = chunks[chunks.length - 2] - OP_INT_BASE
 
-  if (m <= 0) {
+  return 'nonstandard'
-    throw new Error('Number of signatures required must be greater than zero')
-  }
-  if (n > 16) {
-    throw new Error('Number of public keys must be less than 17')
-  }
-  if (m > n) {
-    throw new Error('Number of signatures cannot exceed the number of public keys')
-  }
-  if (n !== chunks.length - 3) {
-    throw new Error('n does not match the number of public keys')
-  }
-
-  var keys = chunks.slice(1, -2)
-  if (!keys.every(isCanonicalPubKey)) {
-    throw new Error('Non-canonical pubic key found')
-  }
-
-  return {
-    type: 'multisig',
-    nRequiredSigs: m,
-    nPublicKeys: n,
-    publicKeyBuffers: keys
-  }
-}
-
-function isMultisigOutput (script) {
-  return determinesTypeOrNonstandard([decodeMultisigOutput], script) === 'multisig'
-}
-
-function isNullDataOutput (script) {
-  return determinesTypeOrNonstandard([decodeNullDataOutput], script) === 'nulldata'
-}
-
-function decodeNullDataOutput (script, chunks) {
-  if (script[0] !== OPS.OP_RETURN) {
-    throw new Error('Missing OP_RETURN at start of script')
-  }
-
-  return {
-    type: 'nulldata'
-  }
-}
-
-function determinesTypeOrNonstandard (functions, script) {
-  if (!types.Array(functions)) {
-    throw new Error('Must provide an array of functions to determinesTypeOrNonstandard')
-  }
-  if (!types.Buffer(script)) {
-    throw new Error('Must provide a script to determinesTypeOrNonstandard')
-  }
-  var decoded
-  var decompiled = decompile(script)
-  var type = 'nonstandard'
-  for (var i = 0; i < functions.length && type === 'nonstandard'; i++) {
-    try {
-      decoded = functions[i](script, decompiled)
-      type = decoded.type
-    } catch (e) {
-
-    }
-  }
-
-  return type
-}
-
-function classifyOutput (script) {
-  return determinesTypeOrNonstandard(LIST_DECODE_NAMES, script)
 }
 
 function classifyInput (script, allowIncomplete) {
+  // XXX: optimization, below functions .decompile before use
   var chunks = decompile(script)
 
-  if (isPubKeyHashInput(chunks)) {
+  if (pubKeyHash.input.check(chunks)) return 'pubkeyhash'
-    return 'pubkeyhash'
+  if (scriptHash.input.check(chunks, allowIncomplete)) return 'scripthash'
-  } else if (isMultisigInput(chunks, allowIncomplete)) {
+  if (multisig.input.check(chunks, allowIncomplete)) return 'multisig'
-    return 'multisig'
+  if (pubKey.input.check(chunks)) return 'pubkey'
-  } else if (isScriptHashInput(chunks, allowIncomplete)) {
-    return 'scripthash'
-  } else if (isPubKeyInput(chunks)) {
-    return 'pubkey'
-  }
 
   return 'nonstandard'
 }
 
-// Standard Script Templates
+function classifyWitness (script, allowIncomplete) {
-// {pubKey} OP_CHECKSIG
+  // XXX: optimization, below functions .decompile before use
-function pubKeyOutput (pubKey) {
+  var chunks = decompile(script)
-  return compile([pubKey, OPS.OP_CHECKSIG])
-}
-
-// OP_DUP OP_HASH160 {pubKeyHash} OP_EQUALVERIFY OP_CHECKSIG
-function pubKeyHashOutput (pubKeyHash) {
-  typeforce(types.Hash160bit, pubKeyHash)
-
-  return compile([OPS.OP_DUP, OPS.OP_HASH160, pubKeyHash, OPS.OP_EQUALVERIFY, OPS.OP_CHECKSIG])
-}
-
-// OP_HASH160 {scriptHash} OP_EQUAL
-function scriptHashOutput (scriptHash) {
-  typeforce(types.Hash160bit, scriptHash)
-
-  return compile([OPS.OP_HASH160, scriptHash, OPS.OP_EQUAL])
-}
-
-// m [pubKeys ...] n OP_CHECKMULTISIG
-function multisigOutput (m, pubKeys) {
-  typeforce(types.tuple(types.Number, [types.Buffer]), arguments)
-
-  var n = pubKeys.length
-  if (n < m) throw new Error('Not enough pubKeys provided')
-
-  return compile([].concat(
-    OP_INT_BASE + m,
-    pubKeys,
-    OP_INT_BASE + n,
-    OPS.OP_CHECKMULTISIG
-  ))
-}
-
-// OP_0 {pubKeyHash}
-function witnessPubKeyHashOutput (pubKeyHash) {
-  typeforce(types.Hash160bit, pubKeyHash)
-
-  return compile([OPS.OP_0, pubKeyHash])
-}
-
-// OP_0 {scriptHash}
-function witnessScriptHashOutput (scriptHash) {
-  typeforce(types.Hash256bit, scriptHash)
-
-  return compile([OPS.OP_0, scriptHash])
-}
-
-// {signature}
-function pubKeyInput (signature) {
-  typeforce(types.Buffer, signature)
-
-  return compile([signature])
-}
-
-// {signature} {pubKey}
-function pubKeyHashInput (signature, pubKey) {
-  typeforce(types.tuple(types.Buffer, types.Buffer), arguments)
-
-  return compile([signature, pubKey])
-}
-
-// <scriptSig> {serialized scriptPubKey script}
-function scriptHashInput (scriptSig, scriptPubKey) {
-  var scriptSigChunks = decompile(scriptSig)
-  var serializedScriptPubKey = compile(scriptPubKey)
-
-  return compile([].concat(
-    scriptSigChunks,
-    serializedScriptPubKey
-  ))
-}
-
-// <scriptSig> {serialized scriptPubKey script}
-function witnessScriptHashInput (scriptSig, scriptPubKey) {
-  return scriptHashInput(scriptSig, scriptPubKey)
-}
-
-// OP_0 [signatures ...]
-function multisigInput (signatures, scriptPubKey) {
-  if (scriptPubKey) {
-    var scriptData = decodeMultisigOutput(scriptPubKey, decompile(scriptPubKey))
-    if (signatures.length < scriptData.nRequiredSigs) throw new Error('Not enough signatures provided')
-    if (signatures.length > scriptData.nPublicKeys) throw new Error('Too many signatures provided')
-  }
-
-  return compile([].concat(OPS.OP_0, signatures))
-}
 
-function nullDataOutput (data) {
+  if (pubKeyHash.input.check(chunks)) return 'witnesspubkeyhash'
-  return compile([OPS.OP_RETURN, data])
+  if (scriptHash.input.check(chunks)) return 'witnessscripthash'
+  return 'nonstandard'
 }
 
-module.exports = {
+module.exports.classifyInput = classifyInput
-  compile: compile,
+module.exports.classifyOutput = classifyOutput
-  decompile: decompile,
+module.exports.classifyWitness = classifyWitness
-  fromASM: fromASM,
+module.exports.multisig = multisig
-  toASM: toASM,
+module.exports.nullData = nullData
-
+module.exports.pubKey = pubKey
-  number: require('./script_number'),
+module.exports.pubKeyHash = pubKeyHash
-
+module.exports.scriptHash = scriptHash
-  isCanonicalPubKey: isCanonicalPubKey,
+module.exports.witnessPubKeyHash = witnessPubKeyHash
-  isCanonicalSignature: isCanonicalSignature,
+module.exports.witnessScriptHash = witnessScriptHash
-  isDefinedHashType: isDefinedHashType,
-
-  decodePubKeyOutput: decodePubKeyOutput,
-  decodePubKeyHashOutput: decodePubKeyHashOutput,
-  decodeMultisigOutput: decodeMultisigOutput,
-  decodeScriptHashOutput: decodeScriptHashOutput,
-  decodeNullDataOutput: decodeNullDataOutput,
-  decodeWitnessPubKeyHashOutput: decodeWitnessPubKeyHashOutput,
-  decodeWitnessScriptHashOutput: decodeWitnessScriptHashOutput,
-
-  isPubKeyOutput: isPubKeyOutput,
-  isPubKeyHashOutput: isPubKeyHashOutput,
-  isMultisigOutput: isMultisigOutput,
-  isScriptHashOutput: isScriptHashOutput,
-  isNullDataOutput: isNullDataOutput,
-  isWitnessPubKeyHashOutput: isWitnessPubKeyHashOutput,
-  isWitnessScriptHashOutput: isWitnessScriptHashOutput,
-  classifyOutput: classifyOutput,
-
-  isPubKeyInput: isPubKeyInput,
-  isPubKeyHashInput: isPubKeyHashInput,
-  isMultisigInput: isMultisigInput,
-  isScriptHashInput: isScriptHashInput,
-  classifyInput: classifyInput,
-
-  pubKeyOutput: pubKeyOutput,
-  pubKeyHashOutput: pubKeyHashOutput,
-  multisigOutput: multisigOutput,
-  scriptHashOutput: scriptHashOutput,
-  nullDataOutput: nullDataOutput,
-  witnessPubKeyHashOutput: witnessPubKeyHashOutput,
-  witnessScriptHashOutput: witnessScriptHashOutput,
-
-  pubKeyInput: pubKeyInput,
-  pubKeyHashInput: pubKeyHashInput,
-  multisigInput: multisigInput,
-  scriptHashInput: scriptHashInput,
-  witnessScriptHashInput: witnessScriptHashInput
-}

src/templates/multisig/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+  input: require('./input'),
+  output: require('./output')
+}

src/templates/multisig/input.js

@@ -0,0 +1,54 @@
+// OP_0 [signatures ...]
+
+var bscript = require('../../script')
+var typeforce = require('typeforce')
+var OPS = require('../../opcodes.json')
+
+function partialSignature (value) {
+  return value === OPS.OP_0 || bscript.isCanonicalSignature(value)
+}
+
+function check (script, allowIncomplete) {
+  var chunks = bscript.decompile(script)
+  if (chunks.length < 2) return false
+  if (chunks[0] !== OPS.OP_0) return false
+
+  if (allowIncomplete) {
+    return chunks.slice(1).every(partialSignature)
+  }
+
+  return chunks.slice(1).every(bscript.isCanonicalSignature)
+}
+
+function encode (signatures, scriptPubKey) {
+  typeforce([partialSignature], signatures)
+
+  if (scriptPubKey) {
+    var scriptData = bscript.multisig.output.decode(scriptPubKey)
+
+    if (signatures.length < scriptData.m) {
+      throw new TypeError('Not enough signatures provided')
+    }
+
+    if (signatures.length > scriptData.pubKeys.length) {
+      throw new TypeError('Too many signatures provided')
+    }
+  }
+
+  return bscript.compile([].concat(OPS.OP_0, signatures))
+}
+
+function decode (buffer, allowIncomplete) {
+  var chunks = bscript.decompile(buffer)
+  typeforce(check, chunks, allowIncomplete)
+
+  return {
+    signatures: chunks.slice(1)
+  }
+}
+
+module.exports = {
+  check: check,
+  decode: decode,
+  encode: encode
+}

src/templates/multisig/output.js

@@ -0,0 +1,63 @@
+// m [pubKeys ...] n OP_CHECKMULTISIG
+
+var bscript = require('../../script')
+var types = require('../../types')
+var typeforce = require('typeforce')
+var OPS = require('../../opcodes.json')
+var OP_INT_BASE = OPS.OP_RESERVED // OP_1 - 1
+
+function check (script, allowIncomplete) {
+  var chunks = bscript.decompile(script)
+
+  if (chunks.length < 4) return false
+  if (chunks[chunks.length - 1] !== OPS.OP_CHECKMULTISIG) return false
+  if (!types.Number(chunks[0])) return false
+  if (!types.Number(chunks[chunks.length - 2])) return false
+  var m = chunks[0] - OP_INT_BASE
+  var n = chunks[chunks.length - 2] - OP_INT_BASE
+
+  if (m <= 0) return false
+  if (n > 16) return false
+  if (m > n) return false
+  if (n !== chunks.length - 3) return false
+  if (allowIncomplete) return true
+
+  var keys = chunks.slice(1, -2)
+  return keys.every(bscript.isCanonicalPubKey)
+}
+
+function encode (m, pubKeys) {
+  typeforce({
+    m: types.Number,
+    pubKeys: [bscript.isCanonicalPubKey]
+  }, {
+    m: m,
+    pubKeys: pubKeys
+  })
+
+  var n = pubKeys.length
+  if (n < m) throw new TypeError('Not enough pubKeys provided')
+
+  return bscript.compile([].concat(
+    OP_INT_BASE + m,
+    pubKeys,
+    OP_INT_BASE + n,
+    OPS.OP_CHECKMULTISIG
+  ))
+}
+
+function decode (buffer, allowIncomplete) {
+  var chunks = bscript.decompile(buffer)
+  typeforce(check, chunks, allowIncomplete)
+
+  return {
+    m: chunks[0] - OP_INT_BASE,
+    pubKeys: chunks.slice(1, -2)
+  }
+}
+
+module.exports = {
+  check: check,
+  decode: decode,
+  encode: encode
+}

src/templates/nulldata.js

@@ -0,0 +1,34 @@
+// OP_RETURN {data}
+
+var bscript = require('../script')
+var types = require('../types')
+var typeforce = require('typeforce')
+var OPS = require('../opcodes.json')
+
+function check (script) {
+  var buffer = bscript.compile(script)
+
+  return buffer.length > 1 &&
+    buffer[0] === OPS.OP_RETURN
+}
+
+function encode (data) {
+  typeforce(types.Buffer, data)
+
+  return bscript.compile([OPS.OP_RETURN, data])
+}
+
+function decode (buffer) {
+  typeforce(check, buffer)
+
+  return buffer.slice(1)
+}
+
+module.exports = {
+  output: {
+    check: check,
+    decode: decode,
+    encode: encode
+  }
+}
+

src/templates/pubkey/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+  input: require('./input'),
+  output: require('./output')
+}

src/templates/pubkey/input.js

@@ -0,0 +1,31 @@
+// {signature}
+
+var bscript = require('../../script')
+var types = require('../../types')
+var typeforce = require('typeforce')
+
+function check (script) {
+  var chunks = bscript.decompile(script)
+
+  return chunks.length === 1 &&
+    bscript.isCanonicalSignature(chunks[0])
+}
+
+function encode (signature) {
+  typeforce(types.Buffer, signature)
+
+  return bscript.compile([signature])
+}
+
+function decode (buffer) {
+  var chunks = bscript.decompile(buffer)
+  typeforce(check, chunks)
+
+  return chunks[0]
+}
+
+module.exports = {
+  check: check,
+  decode: decode,
+  encode: encode
+}

src/templates/pubkey/output.js

@@ -0,0 +1,32 @@
+// {pubKey} OP_CHECKSIG
+
+var bscript = require('../../script')
+var typeforce = require('typeforce')
+var OPS = require('../../opcodes.json')
+
+function check (script) {
+  var chunks = bscript.decompile(script)
+
+  return chunks.length === 2 &&
+    bscript.isCanonicalPubKey(chunks[0]) &&
+    chunks[1] === OPS.OP_CHECKSIG
+}
+
+function encode (pubKey) {
+  typeforce(bscript.isCanonicalPubKey, pubKey)
+
+  return bscript.compile([pubKey, OPS.OP_CHECKSIG])
+}
+
+function decode (buffer) {
+  var chunks = bscript.decompile(buffer)
+  typeforce(check, chunks)
+
+  return chunks[0]
+}
+
+module.exports = {
+  check: check,
+  decode: decode,
+  encode: encode
+}

src/templates/pubkeyhash/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+  input: require('./input'),
+  output: require('./output')
+}

src/templates/pubkeyhash/input.js

@@ -0,0 +1,39 @@
+// {pubKey} OP_CHECKSIG
+
+var bscript = require('../../script')
+var types = require('../../types')
+var typeforce = require('typeforce')
+
+function check (script) {
+  var chunks = bscript.decompile(script)
+
+  return chunks.length === 2 &&
+    bscript.isCanonicalSignature(chunks[0]) &&
+    bscript.isCanonicalPubKey(chunks[1])
+}
+
+function encode (signature, pubKey) {
+  typeforce({
+    signature: types.Buffer, pubKey: types.Buffer
+  }, {
+    signature: signature, pubKey: pubKey
+  })
+
+  return bscript.compile([signature, pubKey])
+}
+
+function decode (buffer) {
+  var chunks = bscript.decompile(buffer)
+  typeforce(check, chunks)
+
+  return {
+    signature: chunks[0],
+    pubKey: chunks[1]
+  }
+}
+
+module.exports = {
+  check: check,
+  decode: decode,
+  encode: encode
+}

src/templates/pubkeyhash/output.js

@@ -0,0 +1,41 @@
+// OP_DUP OP_HASH160 {pubKeyHash} OP_EQUALVERIFY OP_CHECKSIG
+
+var bscript = require('../../script')
+var types = require('../../types')
+var typeforce = require('typeforce')
+var OPS = require('../../opcodes.json')
+
+function check (script) {
+  var buffer = bscript.compile(script)
+
+  return buffer.length === 25 &&
+    buffer[0] === OPS.OP_DUP &&
+    buffer[1] === OPS.OP_HASH160 &&
+    buffer[2] === 0x14 &&
+    buffer[23] === OPS.OP_EQUALVERIFY &&
+    buffer[24] === OPS.OP_CHECKSIG
+}
+
+function encode (pubKeyHash) {
+  typeforce(types.Hash160bit, pubKeyHash)
+
+  return bscript.compile([
+    OPS.OP_DUP,
+    OPS.OP_HASH160,
+    pubKeyHash,
+    OPS.OP_EQUALVERIFY,
+    OPS.OP_CHECKSIG
+  ])
+}
+
+function decode (buffer) {
+  typeforce(check, buffer)
+
+  return buffer.slice(3, 23)
+}
+
+module.exports = {
+  check: check,
+  decode: decode,
+  encode: encode
+}

src/templates/scripthash/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+  input: require('./input'),
+  output: require('./output')
+}

src/templates/scripthash/input.js

@@ -0,0 +1,48 @@
+// <scriptSig> {serialized scriptPubKey script}
+
+var bscript = require('../../script')
+var typeforce = require('typeforce')
+
+function check (script, allowIncomplete) {
+  var chunks = bscript.decompile(script)
+  if (chunks.length < 2) return false
+
+  var lastChunk = chunks[chunks.length - 1]
+  if (!Buffer.isBuffer(lastChunk)) return false
+
+  var scriptSigChunks = chunks.slice(0, -1)
+  var redeemScriptChunks = bscript.decompile(lastChunk)
+
+  // is redeemScript a valid script?
+  if (redeemScriptChunks.length === 0) return false
+
+  var inputType = bscript.classifyInput(scriptSigChunks, allowIncomplete)
+  var outputType = bscript.classifyOutput(redeemScriptChunks)
+  return inputType === outputType
+}
+
+function encode (scriptSignature, scriptPubKey) {
+  var scriptSigChunks = bscript.decompile(scriptSignature)
+  var serializedScriptPubKey = bscript.compile(scriptPubKey)
+
+  return bscript.compile([].concat(
+    scriptSigChunks,
+    serializedScriptPubKey
+  ))
+}
+
+function decode (buffer) {
+  var chunks = bscript.decompile(buffer)
+  typeforce(check, chunks)
+
+  return {
+    scriptSignature: chunks.slice(0, -1),
+    scriptPubKey: chunks[chunks.length - 1]
+  }
+}
+
+module.exports = {
+  check: check,
+  decode: decode,
+  encode: encode
+}

src/templates/scripthash/output.js

@@ -0,0 +1,33 @@
+// OP_HASH160 {scriptHash} OP_EQUAL
+
+var bscript = require('../../script')
+var types = require('../../types')
+var typeforce = require('typeforce')
+var OPS = require('../../opcodes.json')
+
+function check (script) {
+  var buffer = bscript.compile(script)
+
+  return buffer.length === 23 &&
+    buffer[0] === OPS.OP_HASH160 &&
+    buffer[1] === 0x14 &&
+    buffer[22] === OPS.OP_EQUAL
+}
+
+function encode (scriptHash) {
+  typeforce(types.Hash160bit, scriptHash)
+
+  return bscript.compile([OPS.OP_HASH160, scriptHash, OPS.OP_EQUAL])
+}
+
+function decode (buffer) {
+  typeforce(check, buffer)
+
+  return buffer.slice(2, 22)
+}
+
+module.exports = {
+  check: check,
+  decode: decode,
+  encode: encode
+}

src/templates/witnesspubkeyhash/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+  output: require('./output')
+}

src/templates/witnesspubkeyhash/output.js

@@ -0,0 +1,32 @@
+// OP_0 {pubKeyHash}
+
+var bscript = require('../../script')
+var types = require('../../types')
+var typeforce = require('typeforce')
+var OPS = require('../../opcodes.json')
+
+function check (script) {
+  var buffer = bscript.compile(script)
+
+  return buffer.length === 22 &&
+    buffer[0] === OPS.OP_0 &&
+    buffer[1] === 0x14
+}
+
+function encode (pubKeyHash) {
+  typeforce(types.Hash160bit, pubKeyHash)
+
+  return bscript.compile([OPS.OP_0, pubKeyHash])
+}
+
+function decode (buffer) {
+  typeforce(check, buffer)
+
+  return buffer.slice(2)
+}
+
+module.exports = {
+  check: check,
+  decode: decode,
+  encode: encode
+}

src/templates/witnessscripthash/index.js

@@ -0,0 +1,3 @@
+module.exports = {
+  output: require('./output')
+}

src/templates/witnessscripthash/output.js

@@ -0,0 +1,32 @@
+// OP_0 {scriptHash}
+
+var bscript = require('../../script')
+var types = require('../../types')
+var typeforce = require('typeforce')
+var OPS = require('../../opcodes.json')
+
+function check (script) {
+  var buffer = bscript.compile(script)
+
+  return buffer.length === 34 &&
+    buffer[0] === OPS.OP_0 &&
+    buffer[1] === 0x20
+}
+
+function encode (scriptHash) {
+  typeforce(types.Hash256bit, scriptHash)
+
+  return bscript.compile([OPS.OP_0, scriptHash])
+}
+
+function decode (buffer) {
+  typeforce(check, buffer)
+
+  return buffer.slice(2)
+}
+
+module.exports = {
+  check: check,
+  decode: decode,
+  encode: encode
+}

src/transaction_builder.js

@@ -29,7 +29,7 @@ function expandInput (scriptSig, redeemScript) {
       var result = expandInput(redeemScriptSig, redeemScript)
       result.redeemScript = redeemScript
       result.redeemScriptType = result.prevOutType
-      result.prevOutScript = bscript.scriptHashOutput(bcrypto.hash160(redeemScript))
+      result.prevOutScript = bscript.scriptHash.output.encode(bcrypto.hash160(redeemScript))
       result.prevOutType = 'scripthash'
       return result
 
@@ -39,7 +39,7 @@ function expandInput (scriptSig, redeemScript) {
       signatures = scriptSigChunks.slice(0, 1)
 
       if (redeemScript) break
-      prevOutScript = bscript.pubKeyHashOutput(bcrypto.hash160(pubKeys[0]))
+      prevOutScript = bscript.pubKeyHash.output.encode(bcrypto.hash160(pubKeys[0]))
       break
 
     case 'pubkey':
@@ -161,7 +161,7 @@ function prepareInput (input, kpPubKey, redeemScript) {
     input.signatures = expanded.signatures
     input.redeemScript = redeemScript
     input.redeemScriptType = expanded.scriptType
-    input.prevOutScript = input.prevOutScript || bscript.scriptHashOutput(redeemScriptHash)
+    input.prevOutScript = input.prevOutScript || bscript.scriptHash.output.encode(redeemScriptHash)
     input.prevOutType = 'scripthash'
 
   // maybe we have some prevOut knowledge
@@ -178,7 +178,7 @@ function prepareInput (input, kpPubKey, redeemScript) {
 
   // no prior knowledge, assume pubKeyHash
   } else {
-    input.prevOutScript = bscript.pubKeyHashOutput(bcrypto.hash160(kpPubKey))
+    input.prevOutScript = bscript.pubKeyHash.output.encode(bcrypto.hash160(kpPubKey))
     input.prevOutType = 'pubkeyhash'
     input.pubKeys = [kpPubKey]
     input.signatures = [undefined]
@@ -195,9 +195,9 @@ function buildInput (input, allowIncomplete) {
     case 'pubkey':
       if (signatures.length < 1 || !signatures[0]) throw new Error('Not enough signatures provided')
       if (scriptType === 'pubkeyhash') {
-        scriptSig = bscript.pubKeyHashInput(signatures[0], input.pubKeys[0])
+        scriptSig = bscript.pubKeyHash.input.encode(signatures[0], input.pubKeys[0])
       } else {
-        scriptSig = bscript.pubKeyInput(signatures[0])
+        scriptSig = bscript.pubKey.input.encode(signatures[0])
       }
 
       break
@@ -213,7 +213,7 @@ function buildInput (input, allowIncomplete) {
         signatures = signatures.filter(function (x) { return x !== ops.OP_0 })
       }
 
-      scriptSig = bscript.multisigInput(signatures, allowIncomplete ? undefined : input.redeemScript)
+      scriptSig = bscript.multisig.input.encode(signatures, allowIncomplete ? undefined : input.redeemScript)
       break
 
     default: return
@@ -221,7 +221,7 @@ function buildInput (input, allowIncomplete) {
 
   // wrap as scriptHash if necessary
   if (input.prevOutType === 'scripthash') {
-    scriptSig = bscript.scriptHashInput(scriptSig, input.redeemScript)
+    scriptSig = bscript.scriptHash.input.encode(scriptSig, input.redeemScript)
   }
 
   return scriptSig

test/fixtures/script.json

@@ -188,23 +188,8 @@
         "hex": "4effffffff01"
       }
     ],
-    "isPubKeyHashInput": [
+    "pubKey": {
-      {
+      "inputs": [
-        "description": "pubKeyHash input : extraneous data",
-        "scriptSig": "304402207515cf147d201f411092e6be5a64a6006f9308fad7b2a8fdaab22cd86ce764c202200974b8aca7bf51dbf54150d3884e1ae04f675637b926ec33bf75939446f6ca2801 02359c6e3f04cefbf089cf1d6670dc47c3fb4df68e2bad1fa5a369f9ce4b42bbd1 ffffffff"
-      }
-    ],
-    "isScriptHashInput": [
-      {
-        "description": "redeemScript not data",
-        "scriptSig": "OP_0 304402207515cf147d201f411092e6be5a64a6006f9308fad7b2a8fdaab22cd86ce764c202200974b8aca7bf51dbf54150d3884e1ae04f675637b926ec33bf75939446f6ca2801 3045022100ef253c1faa39e65115872519e5f0a33bbecf430c0f35cf562beabbad4da24d8d02201742be8ee49812a73adea3007c9641ce6725c32cd44ddb8e3a3af460015d140501 OP_RESERVED"
-      },
-      {
-        "description": "redeemScript is a signature, therefore not a valid script",
-        "scriptSig": "OP_0 3045022100e12b17b3a4c80c401a1687487bd2bafee9e5f1f8f1ffc6180ce186672ad7b43a02205e316d1e5e71822f5ef301b694e578fa9c94af4f5f098c952c833f4691307f4e01"
-      }
-    ],
-    "isPubKeyInput": [
         {
           "description": "non-canonical signature (too short)",
           "scriptSig": "304402207515cf147d201f411092e6be5a64a6006f9308fad7b2a8fdaab22cd86ce764c202200974b8aca7bf51dbf54150d3884e1ae04f675637b926ec33bf7593"
@@ -218,7 +203,7 @@
           "scriptSig": "304402207515cf147d201f411092e6be5a64a6006f9308fad7b2a8fdaab22cd86ce764c202200974b8aca7bf51dbf54150d3884e1ae04f675637b926ec33bf75939446f6ca28ff"
         }
       ],
-    "isPubKeyOutput": [
+      "outputs": [
         {
           "description": "non-canonical pubkey (too short)",
           "scriptPubKey": "02359c6e3f04cefbf089cf1d6670dc47c3fb4df68e2bad1fa5a369f9ce OP_CHECKSIG"
@@ -243,8 +228,16 @@
           "description": "has extra opcode at the end isPubKeyOutput",
           "scriptPubKey": "027a71801ab59336de37785c50005b6abd8ea859eecce1edbe8e81afa74ee5c752 OP_CHECKSIG OP_0"
         }
+      ]
+    },
+    "pubKeyHash": {
+      "inputs": [
+        {
+          "description": "pubKeyHash input : extraneous data",
+          "scriptSig": "304402207515cf147d201f411092e6be5a64a6006f9308fad7b2a8fdaab22cd86ce764c202200974b8aca7bf51dbf54150d3884e1ae04f675637b926ec33bf75939446f6ca2801 02359c6e3f04cefbf089cf1d6670dc47c3fb4df68e2bad1fa5a369f9ce4b42bbd1 ffffffff"
+        }
       ],
-    "isPubKeyHashOutput": [
+      "outputs": [
         {
           "description": "non-minimal encoded isPubKeyHashOutput (non BIP62 compliant)",
           "scriptPubKeyHex": "76a94c14aa4d7985c57e011a8b3dd8e0e5a73aaef41629c588ac"
@@ -272,9 +265,25 @@
         {
           "description": "has something at the end isPubKeyHashOutput",
           "scriptPubKeyHex": "76a920aa4d7985c57e011a8b3dd8e0e5a73aaef41629c588ac00"
+        },
+        {
+          "exception": "Expected Buffer\\(Length: 20\\), got Buffer\\(Length: 2\\)",
+          "hash": "ffff"
+        }
+      ]
+    },
+    "scriptHash": {
+      "inputs": [
+        {
+          "description": "redeemScript not data",
+          "scriptSig": "OP_0 304402207515cf147d201f411092e6be5a64a6006f9308fad7b2a8fdaab22cd86ce764c202200974b8aca7bf51dbf54150d3884e1ae04f675637b926ec33bf75939446f6ca2801 3045022100ef253c1faa39e65115872519e5f0a33bbecf430c0f35cf562beabbad4da24d8d02201742be8ee49812a73adea3007c9641ce6725c32cd44ddb8e3a3af460015d140501 OP_RESERVED"
+        },
+        {
+          "description": "redeemScript is a signature, therefore not a valid script",
+          "scriptSig": "OP_0 3045022100e12b17b3a4c80c401a1687487bd2bafee9e5f1f8f1ffc6180ce186672ad7b43a02205e316d1e5e71822f5ef301b694e578fa9c94af4f5f098c952c833f4691307f4e01"
         }
       ],
-    "isScriptHashOutput": [
+      "outputs": [
         {
           "description": "non-minimal encoded isScriptHashOutput (non BIP62 compliant)",
           "scriptPubKeyHex": "a94c14c286a1af0947f58d1ad787385b1c2c4a976f9e7187"
@@ -290,29 +299,39 @@
         {
           "description": "wrong OP_EQUAL opcode",
           "scriptPubKeyHex": "a914c286a1af0947f58d1ad787385b1c2c4a976f9e7188"
-      }
-    ],
-    "isWitnessPubKeyHashOutput": [
-      {
-        "description": "wrong version",
-        "scriptPubKeyHex": "51149090909090909090909090909090909090909090"
         },
         {
-        "description": "wrong length marker",
+          "exception": "Expected Buffer\\(Length: 20\\), got Buffer\\(Length: 3\\)",
-        "scriptPubKeyHex": "00209090909090909090909090909090909090909090"
+          "hash": "ffffff"
         }
-    ],
+      ]
-    "isWitnessScriptHashOutput": [
+    },
+    "multisig": {
+      "inputs": [
         {
-        "description": "wrong version",
+          "description": "Not enough signatures provided",
-        "scriptPubKeyHex": "51209090909090909090909090909090909090909090909090909090909090909090"
+          "type": "multisig",
+          "scriptPubKey": "OP_2 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 02b80011a883a0fd621ad46dfc405df1e74bf075cbaf700fd4aebef6e96f848340 OP_2 OP_CHECKMULTISIG",
+          "signatures": []
         },
         {
-        "description": "wrong length marker",
+          "exception": "Not enough signatures provided",
-        "scriptPubKeyHex": "00219090909090909090909090909090909090909090909090909090909090909090"
+          "scriptPubKey": "OP_2 02359c6e3f04cefbf089cf1d6670dc47c3fb4df68e2bad1fa5a369f9ce4b42bbd1 0395a9d84d47d524548f79f435758c01faec5da2b7e551d3b8c995b7e06326ae4a OP_2 OP_CHECKMULTISIG",
+          "signatures": [
+            "304402207515cf147d201f411092e6be5a64a6006f9308fad7b2a8fdaab22cd86ce764c202200974b8aca7bf51dbf54150d3884e1ae04f675637b926ec33bf75939446f6ca2801"
+          ]
+        },
+        {
+          "exception": "Too many signatures provided",
+          "scriptPubKey": "OP_2 02359c6e3f04cefbf089cf1d6670dc47c3fb4df68e2bad1fa5a369f9ce4b42bbd1 0395a9d84d47d524548f79f435758c01faec5da2b7e551d3b8c995b7e06326ae4a OP_2 OP_CHECKMULTISIG",
+          "signatures": [
+            "304402207515cf147d201f411092e6be5a64a6006f9308fad7b2a8fdaab22cd86ce764c202200974b8aca7bf51dbf54150d3884e1ae04f675637b926ec33bf75939446f6ca2801",
+            "3045022100ef253c1faa39e65115872519e5f0a33bbecf430c0f35cf562beabbad4da24d8d02201742be8ee49812a73adea3007c9641ce6725c32cd44ddb8e3a3af460015d140501",
+            "3045022100ef253c1faa39e65115872519e5f0a33bbecf430c0f35cf562beabbad4da24d8d02201742be8ee49812a73adea3007c9641ce6725c32cd44ddb8e3a3af460015d140501"
+          ]
         }
       ],
-    "isMultisigOutput": [
+      "outputs": [
         {
           "description": "OP_CHECKMULTISIG not found",
           "scriptPubKey": "OP_0 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 02b80011a883a0fd621ad46dfc405df1e74bf075cbaf700fd4aebef6e96f848340 OP_2 OP_HASH160"
@@ -368,33 +387,7 @@
         {
           "description": "non-canonical pubKey (bad length)",
           "scriptPubKey": "OP_1 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798ffff OP_1 OP_CHECKMULTISIG"
-      }
-    ],
-    "multisigInput": [
-      {
-        "description": "Not enough signatures provided",
-        "type": "multisig",
-        "scriptPubKey": "OP_2 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 02b80011a883a0fd621ad46dfc405df1e74bf075cbaf700fd4aebef6e96f848340 OP_2 OP_CHECKMULTISIG",
-        "signatures": []
-      },
-      {
-        "exception": "Not enough signatures provided",
-        "scriptPubKey": "OP_2 02359c6e3f04cefbf089cf1d6670dc47c3fb4df68e2bad1fa5a369f9ce4b42bbd1 0395a9d84d47d524548f79f435758c01faec5da2b7e551d3b8c995b7e06326ae4a OP_2 OP_CHECKMULTISIG",
-        "signatures": [
-          "304402207515cf147d201f411092e6be5a64a6006f9308fad7b2a8fdaab22cd86ce764c202200974b8aca7bf51dbf54150d3884e1ae04f675637b926ec33bf75939446f6ca2801"
-        ]
         },
-      {
-        "exception": "Too many signatures provided",
-        "scriptPubKey": "OP_2 02359c6e3f04cefbf089cf1d6670dc47c3fb4df68e2bad1fa5a369f9ce4b42bbd1 0395a9d84d47d524548f79f435758c01faec5da2b7e551d3b8c995b7e06326ae4a OP_2 OP_CHECKMULTISIG",
-        "signatures": [
-          "304402207515cf147d201f411092e6be5a64a6006f9308fad7b2a8fdaab22cd86ce764c202200974b8aca7bf51dbf54150d3884e1ae04f675637b926ec33bf75939446f6ca2801",
-          "3045022100ef253c1faa39e65115872519e5f0a33bbecf430c0f35cf562beabbad4da24d8d02201742be8ee49812a73adea3007c9641ce6725c32cd44ddb8e3a3af460015d140501",
-          "3045022100ef253c1faa39e65115872519e5f0a33bbecf430c0f35cf562beabbad4da24d8d02201742be8ee49812a73adea3007c9641ce6725c32cd44ddb8e3a3af460015d140501"
-        ]
-      }
-    ],
-    "multisigOutput": [
         {
           "exception": "Not enough pubKeys provided",
           "m": 4,
@@ -407,26 +400,36 @@
             "304402207515cf147d201f411092e6be5a64a6006f9308fad7b2a8fdaab22cd86ce764c202200974b8aca7bf51dbf54150d3884e1ae04f675637b926ec33bf75939446f6ca2801"
           ]
         }
-    ],
+      ]
-    "pubKeyHashOutput": [
+    },
+    "witnessPubKeyHash": {
+      "inputs": [],
+      "outputs": [
         {
-        "exception": "Expected Buffer\\(Length: 20\\), got Buffer\\(Length: 2\\)",
+          "description": "wrong version",
-        "hash": "ffff"
+          "scriptPubKeyHex": "51149090909090909090909090909090909090909090"
-      }
+        },
-    ],
-    "scriptHashOutput": [
         {
-        "exception": "Expected Buffer\\(Length: 20\\), got Buffer\\(Length: 3\\)",
+          "description": "wrong length marker",
-        "hash": "ffffff"
+          "scriptPubKeyHex": "00209090909090909090909090909090909090909090"
-      }
+        },
-    ],
-    "witnessPubKeyHashOutput": [
         {
           "exception": "Expected Buffer\\(Length: 20\\), got Buffer\\(Length: 3\\)",
           "hash": "ffffff"
         }
-    ],
+      ]
-    "witnessScriptHashOutput": [
+    },
+    "witnessScriptHash": {
+      "inputs": [],
+      "outputs": [
+        {
+          "description": "wrong version",
+          "scriptPubKeyHex": "51209090909090909090909090909090909090909090909090909090909090909090"
+        },
+        {
+          "description": "wrong length marker",
+          "scriptPubKeyHex": "00219090909090909090909090909090909090909090909090909090909090909090"
+        },
         {
           "exception": "Expected Buffer\\(Length: 32\\), got Buffer\\(Length: 3\\)",
           "hash": "ffffff"
@@ -434,3 +437,4 @@
       ]
     }
   }
+}

test/script.js

@@ -146,44 +146,43 @@ describe('script', function () {
   })
 
   ;[
-    'PubKey',
+    'pubKey',
-    'PubKeyHash',
+    'pubKeyHash',
-    'ScriptHash',
+    'scriptHash',
-    'WitnessPubKeyHash',
+    'witnessPubKeyHash',
-    'WitnessScriptHash',
+    'witnessScriptHash',
-    'Multisig',
+    'multisig',
-    'NullData'
+    'nullData'
-  ].forEach(function (type) {
+  ].forEach(function (name) {
-    var inputFnName = 'is' + type + 'Input'
+    var inputType = bscript[name].input
-    var outputFnName = 'is' + type + 'Output'
+    var outputType = bscript[name].output
-
+
-    var inputFn = bscript[inputFnName]
+    describe(name + '.input.check', function () {
-    var outputFn = bscript[outputFnName]
-
-    describe('is' + type + 'Input', function () {
       fixtures.valid.forEach(function (f) {
-        var expected = type.toLowerCase() === f.type
+        var expected = name.toLowerCase() === f.type
 
-        if (inputFn && f.scriptSig) {
+        if (inputType && f.scriptSig) {
           var scriptSig = bscript.fromASM(f.scriptSig)
 
           it('returns ' + expected + ' for ' + f.scriptSig, function () {
-            assert.strictEqual(inputFn(scriptSig), expected)
+            assert.strictEqual(inputType.check(scriptSig), expected)
           })
 
           if (f.typeIncomplete) {
-            var expectedIncomplete = type.toLowerCase() === f.typeIncomplete
+            var expectedIncomplete = name.toLowerCase() === f.typeIncomplete
 
             it('returns ' + expected + ' for ' + f.scriptSig, function () {
-              assert.strictEqual(inputFn(scriptSig, true), expectedIncomplete)
+              assert.strictEqual(inputType.check(scriptSig, true), expectedIncomplete)
             })
           }
         }
       })
 
-      if (!(inputFnName in fixtures.invalid)) return
+      if (!(fixtures.invalid[name])) return
+
+      fixtures.invalid[name].inputs.forEach(function (f) {
+        if (!f.scriptSig && !f.scriptSigHex) return
 
-      fixtures.invalid[inputFnName].forEach(function (f) {
         it('returns false for ' + f.description + ' (' + (f.scriptSig || f.scriptSigHex) + ')', function () {
           var scriptSig
 
@@ -193,27 +192,29 @@ describe('script', function () {
             scriptSig = new Buffer(f.scriptSigHex, 'hex')
           }
 
-          assert.strictEqual(inputFn(scriptSig), false)
+          assert.strictEqual(inputType.check(scriptSig), false)
         })
       })
     })
 
-    describe('is' + type + 'Output', function () {
+    describe(name + '.output.check', function () {
       fixtures.valid.forEach(function (f) {
-        var expected = type.toLowerCase() === f.type
+        var expected = name.toLowerCase() === f.type
 
-        if (outputFn && f.scriptPubKey) {
+        if (outputType && f.scriptPubKey) {
           it('returns ' + expected + ' for ' + f.scriptPubKey, function () {
             var scriptPubKey = bscript.fromASM(f.scriptPubKey)
 
-            assert.strictEqual(outputFn(scriptPubKey), expected)
+            assert.strictEqual(outputType.check(scriptPubKey), expected)
           })
         }
       })
 
-      if (!(outputFnName in fixtures.invalid)) return
+      if (!(fixtures.invalid[name])) return
+
+      fixtures.invalid[name].outputs.forEach(function (f) {
+        if (!f.scriptPubKey && !f.scriptPubKeyHex) return
 
-      fixtures.invalid[outputFnName].forEach(function (f) {
         it('returns false for ' + f.description + ' (' + (f.scriptPubKey || f.scriptPubKeyHex) + ')', function () {
           var scriptPubKey
 
@@ -223,39 +224,39 @@ describe('script', function () {
             scriptPubKey = new Buffer(f.scriptPubKeyHex, 'hex')
           }
 
-          assert.strictEqual(outputFn(scriptPubKey), false)
+          assert.strictEqual(outputType.check(scriptPubKey), false)
         })
       })
     })
   })
 
-  describe('pubKeyInput', function () {
+  describe('pubKey.input.encode', function () {
     fixtures.valid.forEach(function (f) {
       if (f.type !== 'pubkey') return
 
       it('returns ' + f.scriptSig, function () {
         var signature = new Buffer(f.signature, 'hex')
 
-        var scriptSig = bscript.pubKeyInput(signature)
+        var scriptSig = bscript.pubKey.input.encode(signature)
         assert.strictEqual(bscript.toASM(scriptSig), f.scriptSig)
       })
     })
   })
 
-  describe('pubKeyOutput', function () {
+  describe('pubKey.output.encode', function () {
     fixtures.valid.forEach(function (f) {
       if (f.type !== 'pubkey') return
 
       it('returns ' + f.scriptPubKey, function () {
         var pubKey = new Buffer(f.pubKey, 'hex')
-        var scriptPubKey = bscript.pubKeyOutput(pubKey)
+        var scriptPubKey = bscript.pubKey.output.encode(pubKey)
 
         assert.strictEqual(bscript.toASM(scriptPubKey), f.scriptPubKey)
       })
     })
   })
 
-  describe('pubKeyHashInput', function () {
+  describe('pubKeyHash.input.encode', function () {
     fixtures.valid.forEach(function (f) {
       if (f.type !== 'pubkeyhash') return
 
@@ -264,13 +265,13 @@ describe('script', function () {
       it('returns ' + f.scriptSig, function () {
         var signature = new Buffer(f.signature, 'hex')
 
-        var scriptSig = bscript.pubKeyHashInput(signature, pubKey)
+        var scriptSig = bscript.pubKeyHash.input.encode(signature, pubKey)
         assert.strictEqual(bscript.toASM(scriptSig), f.scriptSig)
       })
     })
   })
 
-  describe('pubKeyHashOutput', function () {
+  describe('pubKeyHash.output.encode', function () {
     fixtures.valid.forEach(function (f) {
       if (f.type !== 'pubkeyhash') return
 
@@ -278,23 +279,24 @@ describe('script', function () {
       var pubKeyHash = bcrypto.hash160(pubKey)
 
       it('returns ' + f.scriptPubKey, function () {
-        var scriptPubKey = bscript.pubKeyHashOutput(pubKeyHash)
+        var scriptPubKey = bscript.pubKeyHash.output.encode(pubKeyHash)
         assert.strictEqual(bscript.toASM(scriptPubKey), f.scriptPubKey)
       })
     })
 
-    fixtures.invalid.pubKeyHashOutput.forEach(function (f) {
+    fixtures.invalid.pubKeyHash.outputs.forEach(function (f) {
+      if (!f.hash) return
       var hash = new Buffer(f.hash, 'hex')
 
       it('throws on ' + f.exception, function () {
         assert.throws(function () {
-          bscript.pubKeyHashOutput(hash)
+          bscript.pubKeyHash.output.encode(hash)
         }, new RegExp(f.exception))
       })
     })
   })
 
-  describe('multisigInput', function () {
+  describe('multisig.input.encode', function () {
     fixtures.valid.forEach(function (f) {
       if (f.type !== 'multisig') return
 
@@ -303,12 +305,13 @@ describe('script', function () {
           return signature ? new Buffer(signature, 'hex') : ops.OP_0
         })
 
-        var scriptSig = bscript.multisigInput(signatures)
+        var scriptSig = bscript.multisig.input.encode(signatures)
         assert.strictEqual(bscript.toASM(scriptSig), f.scriptSig)
       })
     })
 
-    fixtures.invalid.multisigInput.forEach(function (f) {
+    fixtures.invalid.multisig.inputs.forEach(function (f) {
+      if (!f.scriptPubKey) return
       var scriptPubKey = bscript.fromASM(f.scriptPubKey)
 
       it('throws on ' + f.exception, function () {
@@ -317,38 +320,39 @@ describe('script', function () {
         })
 
         assert.throws(function () {
-          bscript.multisigInput(signatures, scriptPubKey)
+          bscript.multisig.input.encode(signatures, scriptPubKey)
         }, new RegExp(f.exception))
       })
     })
   })
 
-  describe('multisigOutput', function () {
+  describe('multisig.output.encode', function () {
     fixtures.valid.forEach(function (f) {
       if (f.type !== 'multisig') return
 
       var pubKeys = f.pubKeys.map(function (p) { return new Buffer(p, 'hex') })
-      var scriptPubKey = bscript.multisigOutput(pubKeys.length, pubKeys)
+      var scriptPubKey = bscript.multisig.output.encode(pubKeys.length, pubKeys)
 
       it('returns ' + f.scriptPubKey, function () {
         assert.strictEqual(bscript.toASM(scriptPubKey), f.scriptPubKey)
       })
     })
 
-    fixtures.invalid.multisigOutput.forEach(function (f) {
+    fixtures.invalid.multisig.outputs.forEach(function (f) {
+      if (!f.pubKeys) return
       var pubKeys = f.pubKeys.map(function (p) {
         return new Buffer(p, 'hex')
       })
 
       it('throws on ' + f.exception, function () {
         assert.throws(function () {
-          bscript.multisigOutput(f.m, pubKeys)
+          bscript.multisig.output.encode(f.m, pubKeys)
         }, new RegExp(f.exception))
       })
     })
   })
 
-  describe('scriptHashInput', function () {
+  describe('scriptHash.input.encode', function () {
     fixtures.valid.forEach(function (f) {
       if (f.type !== 'scripthash') return
 
@@ -356,7 +360,7 @@ describe('script', function () {
       var redeemScriptSig = bscript.fromASM(f.redeemScriptSig)
 
       it('returns ' + f.scriptSig, function () {
-        var scriptSig = bscript.scriptHashInput(redeemScriptSig, redeemScript)
+        var scriptSig = bscript.scriptHash.input.encode(redeemScriptSig, redeemScript)
 
         if (f.scriptSig) {
           assert.strictEqual(bscript.toASM(scriptSig), f.scriptSig)
@@ -367,31 +371,32 @@ describe('script', function () {
     })
   })
 
-  describe('scriptHashOutput', function () {
+  describe('scriptHash.output.encode', function () {
     fixtures.valid.forEach(function (f) {
       if (f.type !== 'scripthash') return
       if (!f.scriptPubKey) return
 
       it('returns ' + f.scriptPubKey, function () {
         var redeemScript = bscript.fromASM(f.redeemScript)
-        var scriptPubKey = bscript.scriptHashOutput(bcrypto.hash160(redeemScript))
+        var scriptPubKey = bscript.scriptHash.output.encode(bcrypto.hash160(redeemScript))
 
         assert.strictEqual(bscript.toASM(scriptPubKey), f.scriptPubKey)
       })
     })
 
-    fixtures.invalid.scriptHashOutput.forEach(function (f) {
+    fixtures.invalid.scriptHash.outputs.forEach(function (f) {
+      if (!f.hash) return
       var hash = new Buffer(f.hash, 'hex')
 
       it('throws on ' + f.exception, function () {
         assert.throws(function () {
-          bscript.scriptHashOutput(hash)
+          bscript.scriptHash.output.encode(hash)
         }, new RegExp(f.exception))
       })
     })
   })
 
-  describe('witnessPubKeyHashOutput', function () {
+  describe('witnessPubKeyHash.output.encode', function () {
     fixtures.valid.forEach(function (f) {
       if (f.type !== 'witnesspubkeyhash') return
       if (!f.scriptPubKey) return
@@ -400,23 +405,24 @@ describe('script', function () {
       var pubKeyHash = bcrypto.hash160(pubKey)
 
       it('returns ' + f.scriptPubKey, function () {
-        var scriptPubKey = bscript.witnessPubKeyHashOutput(pubKeyHash)
+        var scriptPubKey = bscript.witnessPubKeyHash.output.encode(pubKeyHash)
         assert.strictEqual(bscript.toASM(scriptPubKey), f.scriptPubKey)
       })
     })
 
-    fixtures.invalid.witnessPubKeyHashOutput.forEach(function (f) {
+    fixtures.invalid.witnessPubKeyHash.outputs.forEach(function (f) {
+      if (!f.hash) return
       var hash = new Buffer(f.hash, 'hex')
 
       it('throws on ' + f.exception, function () {
         assert.throws(function () {
-          bscript.witnessPubKeyHashOutput(hash)
+          bscript.witnessPubKeyHash.output.encode(hash)
         }, new RegExp(f.exception))
       })
     })
   })
 
-  describe('witnessScriptHashInput', function () {
+  describe('witnessScriptHash.inputs.encode', function () {
     fixtures.valid.forEach(function (f) {
       if (f.type !== 'witnessscripthash') return
 
@@ -424,43 +430,44 @@ describe('script', function () {
       var witnessScriptSig = bscript.fromASM(f.witnessScriptSig)
 
       it('returns ' + f.witness, function () {
-        var witness = bscript.witnessScriptHashInput(witnessScriptSig, witnessScript)
+        var witness = bscript.witnessScriptHash.input.encode(witnessScriptSig, witnessScript)
 
         assert.strictEqual(bscript.toASM(witness), f.witness)
       })
     })
   })
 
-  describe('witnessScriptHashOutput', function () {
+  describe('witnessScriptHash.outputs.encode', function () {
     fixtures.valid.forEach(function (f) {
       if (f.type !== 'witnessscripthash') return
       if (!f.scriptPubKey) return
 
       it('returns ' + f.scriptPubKey, function () {
         var witnessScriptPubKey = bscript.fromASM(f.witnessScriptPubKey)
-        var scriptPubKey = bscript.witnessScriptHashOutput(bcrypto.hash256(witnessScriptPubKey))
+        var scriptPubKey = bscript.witnessScriptHash.output.encode(bcrypto.hash256(witnessScriptPubKey))
 
         assert.strictEqual(bscript.toASM(scriptPubKey), f.scriptPubKey)
       })
     })
 
-    fixtures.invalid.witnessScriptHashOutput.forEach(function (f) {
+    fixtures.invalid.witnessScriptHash.outputs.forEach(function (f) {
+      if (!f.hash) return
       var hash = new Buffer(f.hash, 'hex')
 
       it('throws on ' + f.exception, function () {
         assert.throws(function () {
-          bscript.witnessScriptHashOutput(hash)
+          bscript.witnessScriptHash.output.encode(hash)
         }, new RegExp(f.exception))
       })
     })
   })
 
-  describe('nullDataOutput', function () {
+  describe('nullData.output.encode', function () {
     fixtures.valid.forEach(function (f) {
       if (f.type !== 'nulldata') return
 
       var data = new Buffer(f.data, 'hex')
-      var scriptPubKey = bscript.nullDataOutput(data)
+      var scriptPubKey = bscript.nullData.output.encode(data)
 
       it('returns ' + f.scriptPubKey, function () {
         assert.strictEqual(bscript.toASM(scriptPubKey), f.scriptPubKey)

test/transaction_builder.js

@@ -357,7 +357,7 @@ describe('TransactionBuilder', function () {
                 var signatures = bscript.decompile(scriptSig).slice(1, -1).filter(function (x) { return x !== ops.OP_0 })
 
                 // rebuild/replace the scriptSig without them
-                var replacement = bscript.scriptHashInput(bscript.multisigInput(signatures), redeemScript)
+                var replacement = bscript.scriptHash.input.encode(bscript.multisig.input.encode(signatures), redeemScript)
                 assert.strictEqual(bscript.toASM(replacement), sign.scriptSigFiltered)
 
                 tx.ins[i].script = replacement