Merge pull request #224 from dcousens/classify

Script classification fixes

src/opcodes.js

@@ -1,7 +1,7 @@
 module.exports = {
   // push value
-  OP_0         : 0,
   OP_FALSE     : 0,
+  OP_0         : 0,
   OP_PUSHDATA1 : 76,
   OP_PUSHDATA2 : 77,
   OP_PUSHDATA4 : 78,

src/script.js

@@ -12,6 +12,21 @@ function Script(buffer, chunks) {
 }
 
 // Import operations
+Script.fromASM = function(asm) {
+  var strChunks = asm.split(' ')
+
+  var chunks = strChunks.map(function(strChunk) {
+    if (strChunk in opcodes) {
+      return opcodes[strChunk]
+
+    } else {
+      return new Buffer(strChunk, 'hex')
+    }
+  })
+
+  return Script.fromChunks(chunks)
+}
+
 Script.fromBuffer = function(buffer) {
   var chunks = []
 
@@ -90,6 +105,23 @@ Script.prototype.without = function(needle) {
 }
 
 // Export operations
+var reverseOps = []
+for (var op in opcodes) {
+  var code = opcodes[op]
+  reverseOps[code] = op
+}
+
+Script.prototype.toASM = function() {
+  return this.chunks.map(function(chunk) {
+    if (Buffer.isBuffer(chunk)) {
+      return chunk.toString('hex')
+
+    } else {
+      return reverseOps[chunk]
+    }
+  }).join(' ')
+}
+
 Script.prototype.toBuffer = function() {
   return this.buffer
 }

src/scripts.js

@@ -1,19 +1,34 @@
 var assert = require('assert')
 var opcodes = require('./opcodes')
+
+// FIXME: use ECPubKey, currently the circular dependency breaks everything.
+//
+// Solutions:
+//  * Remove ECPubKey.getAddress
+//    - Minimal change, but likely unpopular
+//  * Move all script related functionality out of Address
+//    - Means a lot of changes to Transaction/Wallet
+//  * Ignore it (existing solution)
+//  * Some form of hackery with commonjs
+//
+var ecurve = require('ecurve')
+var curve = ecurve.getCurveByName('secp256k1')
+
+var ECSignature = require('./ecsignature')
 var Script = require('./script')
 
 function classifyOutput(script) {
   assert(script instanceof Script, 'Expected Script, got ', script)
 
-  if (isPubkeyhash.call(script)) {
+  if (isPubKeyHashOutput.call(script)) {
     return 'pubkeyhash'
-  } else if (isPubkey.call(script)) {
-    return 'pubkey'
-  } else if (isScripthash.call(script)) {
+  } else if (isScriptHashOutput.call(script)) {
     return 'scripthash'
-  } else if (isMultisig.call(script)) {
+  } else if (isMultisigOutput.call(script)) {
     return 'multisig'
-  } else if (isNulldata.call(script)) {
+  } else if (isPubKeyOutput.call(script)) {
+    return 'pubkey'
+  } else if (isNulldataOutput.call(script)) {
     return 'nulldata'
   } else {
     return 'nonstandard'
@@ -23,67 +38,128 @@ function classifyOutput(script) {
 function classifyInput(script) {
   assert(script instanceof Script, 'Expected Script, got ', script)
 
-  if (script.chunks.length == 1 && Buffer.isBuffer(script.chunks[0])) {
-    return 'pubkey'
-  } else if (script.chunks.length == 2 && Buffer.isBuffer(script.chunks[0]) && Buffer.isBuffer(script.chunks[1])) {
+  if (isPubKeyHashInput.call(script)) {
     return 'pubkeyhash'
-  } else if (script.chunks[0] == opcodes.OP_0 && script.chunks.slice(1).reduce(function(t, chunk, i) {
-      return t && Buffer.isBuffer(chunk) && (chunk[0] == 48 || i == script.chunks.length - 1)
-    }, true)) {
+  } else if (isScriptHashInput.call(script)) {
+    return 'scripthash'
+  } else if (isMultisigInput.call(script)) {
     return 'multisig'
+  } else if (isPubKeyInput.call(script)) {
+    return 'pubkey'
   } else {
     return 'nonstandard'
   }
 }
 
-function isPubkeyhash() {
-  return this.chunks.length == 5 &&
-    this.chunks[0] == opcodes.OP_DUP &&
-    this.chunks[1] == opcodes.OP_HASH160 &&
-    Buffer.isBuffer(this.chunks[2]) &&
-    this.chunks[2].length === 20 &&
-    this.chunks[3] == opcodes.OP_EQUALVERIFY &&
-    this.chunks[4] == opcodes.OP_CHECKSIG
+function isCanonicalPubKey(buffer) {
+  if (!Buffer.isBuffer(buffer)) return false
+
+  try {
+    // FIXME: boo
+    ecurve.Point.decodeFrom(curve, buffer)
+  } catch (e) {
+    if (!(e.message.match(/Invalid sequence (length|tag)/))) throw e
+
+    return false
+  }
+
+  return true
 }
 
-function isPubkey() {
+function isCanonicalSignature(buffer) {
+  if (!Buffer.isBuffer(buffer)) return false
+
+  try {
+    ECSignature.parseScriptSignature(buffer)
+  } catch(e) {
+    if (!(e.message.match(/Not a DER sequence|Invalid sequence length|Expected a DER integer|R length is zero|S length is zero|R value excessively padded|S value excessively padded|R value is negative|S value is negative|Invalid hashType/))) throw e
+
+    return false
+  }
+
+  return true
+}
+
+function isPubKeyHashInput() {
   return this.chunks.length === 2 &&
-    Buffer.isBuffer(this.chunks[0]) &&
+    isCanonicalSignature(this.chunks[0]) &&
+    isCanonicalPubKey(this.chunks[1])
+}
+
+function isPubKeyHashOutput() {
+  return this.chunks.length === 5 &&
+    this.chunks[0] === opcodes.OP_DUP &&
+    this.chunks[1] === opcodes.OP_HASH160 &&
+    Buffer.isBuffer(this.chunks[2]) &&
+    this.chunks[2].length === 20 &&
+    this.chunks[3] === opcodes.OP_EQUALVERIFY &&
+    this.chunks[4] === opcodes.OP_CHECKSIG
+}
+
+function isPubKeyInput() {
+  return this.chunks.length === 1 &&
+    isCanonicalSignature(this.chunks[0])
+}
+
+function isPubKeyOutput() {
+  return this.chunks.length === 2 &&
+    isCanonicalPubKey(this.chunks[0]) &&
     this.chunks[1] === opcodes.OP_CHECKSIG
 }
 
-function isScripthash() {
-  return this.chunks[this.chunks.length - 1] == opcodes.OP_EQUAL &&
-    this.chunks[0] == opcodes.OP_HASH160 &&
+function isScriptHashInput() {
+  if (this.chunks.length < 2) return false
+  var lastChunk = this.chunks[this.chunks.length - 1]
+
+  if (!Buffer.isBuffer(lastChunk)) return false
+
+  var scriptSig = Script.fromChunks(this.chunks.slice(0, -1))
+  var scriptPubKey = Script.fromBuffer(lastChunk)
+
+  return classifyInput(scriptSig) === classifyOutput(scriptPubKey)
+}
+
+function isScriptHashOutput() {
+  return this.chunks.length === 3 &&
+    this.chunks[0] === opcodes.OP_HASH160 &&
     Buffer.isBuffer(this.chunks[1]) &&
     this.chunks[1].length === 20 &&
-    this.chunks.length == 3
+    this.chunks[2] === opcodes.OP_EQUAL
 }
 
-function isMultisig() {
-  return this.chunks.length > 3 &&
-    // m is a smallint
-    isSmallIntOp(this.chunks[0]) &&
-    // n is a smallint
-    isSmallIntOp(this.chunks[this.chunks.length - 2]) &&
-    // n greater or equal to m
-    this.chunks[0] <= this.chunks[this.chunks.length - 2] &&
-    // n cannot be 0
-    this.chunks[this.chunks.length - 2] !== opcodes.OP_0 &&
-    // n is the size of chunk length minus 3 (m, n, OP_CHECKMULTISIG)
-    this.chunks.length - 3 === this.chunks[this.chunks.length - 2] - opcodes.OP_RESERVED &&
-    // last chunk is OP_CHECKMULTISIG
-    this.chunks[this.chunks.length - 1] == opcodes.OP_CHECKMULTISIG
+function isMultisigInput() {
+  return this.chunks[0] === opcodes.OP_0 &&
+    this.chunks.slice(1).every(isCanonicalSignature)
 }
 
-function isNulldata() {
+function isMultisigOutput() {
+  if (this.chunks < 4) return false
+  if (this.chunks[this.chunks.length - 1] !== opcodes.OP_CHECKMULTISIG) return false
+
+  var mOp = this.chunks[0]
+  if (mOp === opcodes.OP_0) return false
+  if (mOp < opcodes.OP_1) return false
+  if (mOp > opcodes.OP_16) return false
+
+  var nOp = this.chunks[this.chunks.length - 2]
+  if (nOp === opcodes.OP_0) return false
+  if (nOp < opcodes.OP_1) return false
+  if (nOp > opcodes.OP_16) return false
+
+  var m = mOp - (opcodes.OP_1 - 1)
+  var n = nOp - (opcodes.OP_1 - 1)
+  if (n < m) return false
+
+  var pubKeys = this.chunks.slice(1, -2)
+  if (n < pubKeys.length) return false
+
+  return pubKeys.every(isCanonicalPubKey)
+}
+
+function isNulldataOutput() {
   return this.chunks[0] === opcodes.OP_RETURN
 }
 
-function isSmallIntOp(opcode) {
-  return ((opcode == opcodes.OP_0) || ((opcode >= opcodes.OP_1) && (opcode <= opcodes.OP_16)))
-}
-
 // Standard Script Templates
 // {pubKey} OP_CHECKSIG
 function pubKeyOutput(pubKey) {
@@ -160,7 +236,7 @@ function scriptHashInput(scriptSig, scriptPubKey) {
 // OP_0 [signatures ...]
 function multisigInput(signatures, scriptPubKey) {
   if (scriptPubKey) {
-    assert(isMultisig.call(scriptPubKey))
+    assert(isMultisigOutput.call(scriptPubKey))
 
     var m = scriptPubKey.chunks[0]
     var k = m - (opcodes.OP_1 - 1)