scripts: rename compile to compileToBuffer (bikeshed)

src/address.js

@@ -18,7 +18,7 @@ function fromBase58Check (address) {
 function fromOutputScript (script, network) {
   network = network || networks.bitcoin
 
-  var chunks = scripts.decompile(script)
+  var chunks = scripts.decompileToChunks(script)
   if (scripts.isPubKeyHashOutput(chunks)) return toBase58Check(chunks[2], network.pubKeyHash)
   if (scripts.isScriptHashOutput(chunks)) return toBase58Check(chunks[1], network.scriptHash)
 

src/scripts.js

@@ -15,7 +15,7 @@ for (var op in OPS) {
 
 function toASM (chunks) {
   if (types.Buffer(chunks)) {
-    chunks = decompile(chunks)
+    chunks = decompileToChunks(chunks)
   }
 
   return chunks.map(function (chunk) {
@@ -30,7 +30,7 @@ function toASM (chunks) {
 function fromASM (asm) {
   typeforce(types.String, asm)
 
-  return compile(asm.split(' ').map(function (chunkStr) {
+  return compileToBuffer(asm.split(' ').map(function (chunkStr) {
     // opcode?
     if (OPS[chunkStr] !== undefined) return OPS[chunkStr]
 
@@ -39,7 +39,7 @@ function fromASM (asm) {
   }))
 }
 
-function compile (chunks) {
+function compileToBuffer (chunks) {
   // TODO: remove me
   if (types.Buffer(chunks)) return chunks
 
@@ -77,7 +77,7 @@ function compile (chunks) {
   return buffer
 }
 
-function decompile (buffer) {
+function decompileToChunks (buffer) {
   // TODO: remove me
   if (types.Array(buffer)) return buffer
 
@@ -149,15 +149,15 @@ function isCanonicalSignature (buffer) {
 }
 
 function isPubKeyHashInput (script) {
-  var chunks = decompile(script)
+  var chunks = decompileToChunks(script)
 
   return chunks.length === 2 &&
     isCanonicalSignature(chunks[0]) &&
     isCanonicalPubKey(chunks[1])
 }
 
 function isPubKeyHashOutput (script) {
-  var chunks = decompile(script)
+  var chunks = decompileToChunks(script)
 
   return chunks.length === 5 &&
     chunks[0] === OPS.OP_DUP &&
@@ -169,29 +169,29 @@ function isPubKeyHashOutput (script) {
 }
 
 function isPubKeyInput (script) {
-  var chunks = decompile(script)
+  var chunks = decompileToChunks(script)
 
   return chunks.length === 1 &&
     isCanonicalSignature(chunks[0])
 }
 
 function isPubKeyOutput (script) {
-  var chunks = decompile(script)
+  var chunks = decompileToChunks(script)
 
   return chunks.length === 2 &&
     isCanonicalPubKey(chunks[0]) &&
     chunks[1] === OPS.OP_CHECKSIG
 }
 
 function isScriptHashInput (script, allowIncomplete) {
-  var chunks = decompile(script)
+  var chunks = decompileToChunks(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)
+  var redeemScriptChunks = decompileToChunks(lastChunk)
 
   // is redeemScript a valid script?
   if (redeemScriptChunks.length === 0) return false
@@ -200,7 +200,7 @@ function isScriptHashInput (script, allowIncomplete) {
 }
 
 function isScriptHashOutput (script) {
-  var chunks = decompile(script)
+  var chunks = decompileToChunks(script)
 
   return chunks.length === 3 &&
     chunks[0] === OPS.OP_HASH160 &&
@@ -212,7 +212,7 @@ function isScriptHashOutput (script) {
 // allowIncomplete is to account for combining signatures
 // See https://github.com/bitcoin/bitcoin/blob/f425050546644a36b0b8e0eb2f6934a3e0f6f80f/src/script/sign.cpp#L195-L197
 function isMultisigInput (script, allowIncomplete) {
-  var chunks = decompile(script)
+  var chunks = decompileToChunks(script)
   if (chunks.length < 2) return false
   if (chunks[0] !== OPS.OP_0) return false
 
@@ -226,7 +226,7 @@ function isMultisigInput (script, allowIncomplete) {
 }
 
 function isMultisigOutput (script) {
-  var chunks = decompile(script)
+  var chunks = decompileToChunks(script)
   if (chunks.length < 4) return false
   if (chunks[chunks.length - 1] !== OPS.OP_CHECKMULTISIG) return false
 
@@ -251,12 +251,12 @@ function isMultisigOutput (script) {
 }
 
 function isNullDataOutput (script) {
-  var chunks = decompile(script)
+  var chunks = decompileToChunks(script)
   return chunks[0] === OPS.OP_RETURN
 }
 
 function classifyOutput (script) {
-  var chunks = decompile(script)
+  var chunks = decompileToChunks(script)
 
   if (isPubKeyHashOutput(chunks)) {
     return 'pubkeyhash'
@@ -274,7 +274,7 @@ function classifyOutput (script) {
 }
 
 function classifyInput (script, allowIncomplete) {
-  var chunks = decompile(script)
+  var chunks = decompileToChunks(script)
 
   if (isPubKeyHashInput(chunks)) {
     return 'pubkeyhash'
@@ -292,21 +292,21 @@ function classifyInput (script, allowIncomplete) {
 // Standard Script Templates
 // {pubKey} OP_CHECKSIG
 function pubKeyOutput (pubKey) {
-  return compile([pubKey, OPS.OP_CHECKSIG])
+  return compileToBuffer([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])
+  return compileToBuffer([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])
+  return compileToBuffer([OPS.OP_HASH160, scriptHash, OPS.OP_EQUAL])
 }
 
 // m [pubKeys ...] n OP_CHECKMULTISIG
@@ -316,7 +316,7 @@ function multisigOutput (m, pubKeys) {
   var n = pubKeys.length
   if (n < m) throw new Error('Not enough pubKeys provided')
 
-  return compile([].concat(
+  return compileToBuffer([].concat(
     (OPS.OP_1 - 1) + m,
     pubKeys,
     (OPS.OP_1 - 1) + n,
@@ -328,22 +328,22 @@ function multisigOutput (m, pubKeys) {
 function pubKeyInput (signature) {
   typeforce(types.Buffer, signature)
 
-  return compile([signature])
+  return compileToBuffer([signature])
 }
 
 // {signature} {pubKey}
 function pubKeyHashInput (signature, pubKey) {
   typeforce(types.tuple(types.Buffer, types.Buffer), arguments)
 
-  return compile([signature, pubKey])
+  return compileToBuffer([signature, pubKey])
 }
 
 // <scriptSig> {serialized scriptPubKey script}
 function scriptHashInput (scriptSig, scriptPubKey) {
-  var scriptSigChunks = decompile(scriptSig)
-  var serializedScriptPubKey = compile(scriptPubKey)
+  var scriptSigChunks = decompileToChunks(scriptSig)
+  var serializedScriptPubKey = compileToBuffer(scriptPubKey)
 
-  return compile([].concat(
+  return compileToBuffer([].concat(
     scriptSigChunks,
     serializedScriptPubKey
   ))
@@ -352,7 +352,7 @@ function scriptHashInput (scriptSig, scriptPubKey) {
 // OP_0 [signatures ...]
 function multisigInput (signatures, scriptPubKey) {
   if (scriptPubKey) {
-    var chunks = decompile(scriptPubKey)
+    var chunks = decompileToChunks(scriptPubKey)
     if (!isMultisigOutput(chunks)) throw new Error('Expected multisig scriptPubKey')
 
     var mOp = chunks[0]
@@ -364,16 +364,16 @@ function multisigInput (signatures, scriptPubKey) {
     if (signatures.length > n) throw new Error('Too many signatures provided')
   }
 
-  return compile([].concat(OPS.OP_0, signatures))
+  return compileToBuffer([].concat(OPS.OP_0, signatures))
 }
 
 function nullDataOutput (data) {
-  return compile([OPS.OP_RETURN, data])
+  return compileToBuffer([OPS.OP_RETURN, data])
 }
 
 module.exports = {
-  compile: compile,
-  decompile: decompile,
+  compileToBuffer: compileToBuffer,
+  decompileToChunks: decompileToChunks,
   fromASM: fromASM,
   toASM: toASM,
 

src/transaction.js

@@ -193,7 +193,7 @@ Transaction.prototype.hashForSignature = function (inIndex, prevOutScript, hashT
 
   // in case concatenating two scripts ends up with two codeseparators,
   // or an extra one at the end, this prevents all those possible incompatibilities.
-  var hashScript = scripts.compile(scripts.decompile(prevOutScript).filter(function (x) {
+  var hashScript = scripts.compileToBuffer(scripts.decompileToChunks(prevOutScript).filter(function (x) {
     return x !== opcodes.OP_CODESEPARATOR
   }))
   var i

src/transaction_builder.js

@@ -12,7 +12,7 @@ var Transaction = require('./transaction')
 function extractInput (txIn) {
   var redeemScript
   var scriptSig = txIn.script
-  var scriptSigChunks = scripts.decompile(scriptSig)
+  var scriptSigChunks = scripts.decompileToChunks(scriptSig)
 
   var prevOutScript
   var prevOutType = scripts.classifyInput(scriptSig, true)
@@ -23,7 +23,7 @@ function extractInput (txIn) {
     redeemScript = scriptSigChunks.slice(-1)[0]
     prevOutScript = scripts.scriptHashOutput(bcrypto.hash160(redeemScript))
 
-    scriptSig = scripts.compile(scriptSigChunks.slice(0, -1))
+    scriptSig = scripts.compileToBuffer(scriptSigChunks.slice(0, -1))
     scriptSigChunks = scriptSigChunks.slice(0, -1)
 
     scriptType = scripts.classifyInput(scriptSig, true)
@@ -34,7 +34,7 @@ function extractInput (txIn) {
   // pre-empt redeemScript decompilation
   var redeemScriptChunks
   if (redeemScript) {
-    redeemScriptChunks = scripts.decompile(redeemScript)
+    redeemScriptChunks = scripts.decompileToChunks(redeemScript)
   }
 
   // Extract hashType, pubKeys and signatures
@@ -147,7 +147,7 @@ TransactionBuilder.prototype.addInput = function (txHash, vout, sequence, prevOu
 
   var input = {}
   if (prevOutScript) {
-    var prevOutScriptChunks = scripts.decompile(prevOutScript)
+    var prevOutScriptChunks = scripts.decompileToChunks(prevOutScript)
     var prevOutType = scripts.classifyOutput(prevOutScriptChunks)
 
     // if we can, extract pubKey information
@@ -318,14 +318,14 @@ TransactionBuilder.prototype.sign = function (index, keyPair, redeemScript, hash
       if (input.prevOutScript) {
         if (input.prevOutType !== 'scripthash') throw new Error('PrevOutScript must be P2SH')
 
-        var scriptHash = scripts.decompile(input.prevOutScript)[1]
+        var scriptHash = scripts.decompileToChunks(input.prevOutScript)[1]
         if (!bufferutils.equal(scriptHash, bcrypto.hash160(redeemScript))) throw new Error('RedeemScript does not match ' + scriptHash.toString('hex'))
       }
 
       var scriptType = scripts.classifyOutput(redeemScript)
       if (!canSignTypes[scriptType]) throw new Error('RedeemScript not supported (' + scriptType + ')')
 
-      var redeemScriptChunks = scripts.decompile(redeemScript)
+      var redeemScriptChunks = scripts.decompileToChunks(redeemScript)
       var pubKeys = []
       switch (scriptType) {
         case 'multisig':

test/bitcoin.core.js

@@ -228,8 +228,8 @@ describe('Bitcoin-core', function () {
         assert.strictEqual(transaction.toHex(), txHex)
 
         var script = new Buffer(scriptHex, 'hex')
-        var scriptChunks = scripts.decompile(script)
-        assert.strictEqual(scripts.compile(scriptChunks).toString('hex'), scriptHex)
+        var scriptChunks = scripts.decompileToChunks(script)
+        assert.strictEqual(scripts.compileToBuffer(scriptChunks).toString('hex'), scriptHex)
 
         var hash = transaction.hashForSignature(inIndex, script, hashType)
         assert.deepEqual(hash, expectedHash)

test/scripts.js

@@ -32,39 +32,39 @@ describe('scripts', function () {
     })
   })
 
-  describe('compile', function () {
+  describe('compileToBuffer', function () {
     fixtures.valid.forEach(function (f) {
       if (f.scriptSig) {
         it('compiles ' + f.scriptSig, function () {
           var script = scripts.fromASM(f.scriptSig)
 
-          assert.strictEqual(scripts.compile(script).toString('hex'), f.scriptSigHex)
+          assert.strictEqual(scripts.compileToBuffer(script).toString('hex'), f.scriptSigHex)
         })
       }
 
       if (f.scriptPubKey) {
         it('compiles ' + f.scriptPubKey, function () {
           var script = scripts.fromASM(f.scriptPubKey)
 
-          assert.strictEqual(scripts.compile(script).toString('hex'), f.scriptPubKeyHex)
+          assert.strictEqual(scripts.compileToBuffer(script).toString('hex'), f.scriptPubKeyHex)
         })
       }
     })
   })
 
-  describe('decompile', function () {
+  describe('decompileToChunks', function () {
     fixtures.valid.forEach(function (f) {
       if (f.scriptSigHex) {
         it('decompiles ' + f.scriptSig, function () {
-          var chunks = scripts.decompile(new Buffer(f.scriptSigHex, 'hex'))
+          var chunks = scripts.decompileToChunks(new Buffer(f.scriptSigHex, 'hex'))
 
           assert.strictEqual(scripts.toASM(chunks), f.scriptSig)
         })
       }
 
       if (f.scriptPubKeyHex) {
         it('decompiles ' + f.scriptPubKey, function () {
-          var chunks = scripts.decompile(new Buffer(f.scriptPubKeyHex, 'hex'))
+          var chunks = scripts.decompileToChunks(new Buffer(f.scriptPubKeyHex, 'hex'))
 
           assert.strictEqual(scripts.toASM(chunks), f.scriptPubKey)
         })
@@ -73,7 +73,7 @@ describe('scripts', function () {
 
     fixtures.invalid.decompile.forEach(function (f) {
       it('decompiles ' + f.hex + ' to [] because of "' + f.description + '"', function () {
-        var chunks = scripts.decompile(new Buffer(f.hex, 'hex'))
+        var chunks = scripts.decompileToChunks(new Buffer(f.hex, 'hex'))
 
         assert.strictEqual(chunks.length, 0)
       })

test/transaction_builder.js

@@ -271,7 +271,7 @@ describe('TransactionBuilder', function () {
                 var scriptSig = tx.ins[i].script
 
                 // ignore OP_0 on the front, ignore redeemScript
-                var signatures = scripts.decompile(scriptSig).slice(1, -1).filter(function (x) { return x !== ops.OP_0 })
+                var signatures = scripts.decompileToChunks(scriptSig).slice(1, -1).filter(function (x) { return x !== ops.OP_0 })
 
                 // rebuild/replace the scriptSig without them
                 var replacement = scripts.scriptHashInput(scripts.multisigInput(signatures), redeemScript)