diff --git a/src/address.js b/src/address.js index 879b089..98eb888 100644 --- a/src/address.js +++ b/src/address.js @@ -1,6 +1,8 @@ var base58check = require('bs58check') var typeforce = require('typeforce') var networks = require('./networks') + +var Script = require('./script') var scripts = require('./scripts') var types = require('./types') @@ -18,10 +20,10 @@ function fromBase58Check (address) { function fromOutputScript (script, network) { network = network || networks.bitcoin - if (scripts.isPubKeyHashOutput(script)) return toBase58Check(script.chunks[2], network.pubKeyHash) - if (scripts.isScriptHashOutput(script)) return toBase58Check(script.chunks[1], network.scriptHash) + if (scripts.isPubKeyHashOutput(script)) return toBase58Check(Script.fromBuffer(script).chunks[2], network.pubKeyHash) + if (scripts.isScriptHashOutput(script)) return toBase58Check(Script.fromBuffer(script).chunks[1], network.scriptHash) - throw new Error(script.toASM() + ' has no matching Address') + throw new Error(Script.fromBuffer(script).toASM() + ' has no matching Address') } function toBase58Check (hash, version) { diff --git a/src/scripts.js b/src/scripts.js index d6add2f..5437cdb 100644 --- a/src/scripts.js +++ b/src/scripts.js @@ -41,12 +41,18 @@ function isCanonicalSignature (buffer) { } function isPubKeyHashInput (script) { + typeforce(types.Buffer, script) + script = Script.fromBuffer(script) + return script.chunks.length === 2 && isCanonicalSignature(script.chunks[0]) && isCanonicalPubKey(script.chunks[1]) } function isPubKeyHashOutput (script) { + typeforce(types.Buffer, script) + script = Script.fromBuffer(script) + return script.chunks.length === 5 && script.chunks[0] === ops.OP_DUP && script.chunks[1] === ops.OP_HASH160 && @@ -57,32 +63,44 @@ function isPubKeyHashOutput (script) { } function isPubKeyInput (script) { + typeforce(types.Buffer, script) + script = Script.fromBuffer(script) + return script.chunks.length === 1 && isCanonicalSignature(script.chunks[0]) } function isPubKeyOutput (script) { + typeforce(types.Buffer, script) + script = Script.fromBuffer(script) + return script.chunks.length === 2 && isCanonicalPubKey(script.chunks[0]) && script.chunks[1] === ops.OP_CHECKSIG } function isScriptHashInput (script, allowIncomplete) { + typeforce(types.Buffer, script) + script = Script.fromBuffer(script) + if (script.chunks.length < 2) return false var lastChunk = script.chunks[script.chunks.length - 1] if (!Buffer.isBuffer(lastChunk)) return false - var scriptSig = Script.fromChunks(script.chunks.slice(0, -1)) - var redeemScript = Script.fromBuffer(lastChunk) + var scriptSig = Script.fromChunks(script.chunks.slice(0, -1)).buffer + var redeemScript = lastChunk // is redeemScript a valid script? - if (redeemScript.chunks.length === 0) return false + if (Script.fromBuffer(redeemScript).chunks.length === 0) return false return classifyInput(scriptSig, allowIncomplete) === classifyOutput(redeemScript) } function isScriptHashOutput (script) { + typeforce(types.Buffer, script) + script = Script.fromBuffer(script) + return script.chunks.length === 3 && script.chunks[0] === ops.OP_HASH160 && Buffer.isBuffer(script.chunks[1]) && @@ -93,6 +111,9 @@ 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) { + typeforce(types.Buffer, script) + script = Script.fromBuffer(script) + if (script.chunks.length < 2) return false if (script.chunks[0] !== ops.OP_0) return false @@ -106,6 +127,9 @@ function isMultisigInput (script, allowIncomplete) { } function isMultisigOutput (script) { + typeforce(types.Buffer, script) + script = Script.fromBuffer(script) + if (script.chunks.length < 4) return false if (script.chunks[script.chunks.length - 1] !== ops.OP_CHECKMULTISIG) return false @@ -130,11 +154,14 @@ function isMultisigOutput (script) { } function isNullDataOutput (script) { + typeforce(types.Buffer, script) + script = Script.fromBuffer(script) + return script.chunks[0] === ops.OP_RETURN } function classifyOutput (script) { - typeforce(types.Script, script) + typeforce(types.Buffer, script) if (isPubKeyHashOutput(script)) { return 'pubkeyhash' @@ -152,7 +179,7 @@ function classifyOutput (script) { } function classifyInput (script, allowIncomplete) { - typeforce(types.Script, script) + typeforce(types.Buffer, script) if (isPubKeyHashInput(script)) { return 'pubkeyhash' @@ -173,7 +200,7 @@ function pubKeyOutput (pubKey) { return Script.fromChunks([ pubKey, ops.OP_CHECKSIG - ]) + ]).buffer } // OP_DUP OP_HASH160 {pubKeyHash} OP_EQUALVERIFY OP_CHECKSIG @@ -186,7 +213,7 @@ function pubKeyHashOutput (hash) { hash, ops.OP_EQUALVERIFY, ops.OP_CHECKSIG - ]) + ]).buffer } // OP_HASH160 {scriptHash} OP_EQUAL @@ -197,7 +224,7 @@ function scriptHashOutput (hash) { ops.OP_HASH160, hash, ops.OP_EQUAL - ]) + ]).buffer } // m [pubKeys ...] n OP_CHECKMULTISIG @@ -212,35 +239,38 @@ function multisigOutput (m, pubKeys) { pubKeys, (ops.OP_1 - 1) + n, ops.OP_CHECKMULTISIG - )) + )).buffer } // {signature} function pubKeyInput (signature) { typeforce(types.Buffer, signature) - return Script.fromChunks([signature]) + return Script.fromChunks([signature]).buffer } // {signature} {pubKey} function pubKeyHashInput (signature, pubKey) { typeforce(types.tuple(types.Buffer, types.Buffer), arguments) - return Script.fromChunks([signature, pubKey]) + return Script.fromChunks([signature, pubKey]).buffer } // {serialized scriptPubKey script} function scriptHashInput (scriptSig, scriptPubKey) { + var scriptSigChunks = Script.fromBuffer(scriptSig).chunks + return Script.fromChunks([].concat( - scriptSig.chunks, - scriptPubKey.toBuffer() - )) + scriptSigChunks, + scriptPubKey + )).buffer } // OP_0 [signatures ...] function multisigInput (signatures, scriptPubKey) { if (scriptPubKey) { if (!isMultisigOutput(scriptPubKey)) throw new Error('Expected multisig scriptPubKey') + scriptPubKey = Script.fromBuffer(scriptPubKey) var mOp = scriptPubKey.chunks[0] var nOp = scriptPubKey.chunks[scriptPubKey.chunks.length - 2] @@ -251,11 +281,11 @@ function multisigInput (signatures, scriptPubKey) { if (signatures.length > n) throw new Error('Too many signatures provided') } - return Script.fromChunks([].concat(ops.OP_0, signatures)) + return Script.fromChunks([].concat(ops.OP_0, signatures)).buffer } function nullDataOutput (data) { - return Script.fromChunks([ops.OP_RETURN, data]) + return Script.fromChunks([ops.OP_RETURN, data]).buffer } module.exports = { diff --git a/src/transaction.js b/src/transaction.js index 1267b5e..0933589 100644 --- a/src/transaction.js +++ b/src/transaction.js @@ -45,11 +45,7 @@ Transaction.fromBuffer = function (buffer, __noStrict) { } function readScript () { - return Script.fromBuffer(readSlice(readVarInt())) - } - - function readGenerationScript () { - return new Script(readSlice(readVarInt()), []) + return readSlice(readVarInt()) } var tx = new Transaction() @@ -63,7 +59,7 @@ Transaction.fromBuffer = function (buffer, __noStrict) { tx.ins.push({ hash: hash, index: readUInt32(), - script: readGenerationScript(), + script: readScript(), sequence: readUInt32() }) } else { @@ -102,19 +98,21 @@ Transaction.isCoinbaseHash = function (buffer) { }) } +var EMPTY = new Buffer(0) + Transaction.prototype.addInput = function (hash, index, sequence, script) { typeforce(types.tuple( types.Hash256bit, types.UInt32, types.maybe(types.UInt32), - types.maybe(types.Script) + types.maybe(types.Buffer) ), arguments) if (types.Null(sequence)) { sequence = Transaction.DEFAULT_SEQUENCE } - script = script || Script.EMPTY + script = script || EMPTY // Add the input and return the input's index return (this.ins.push({ @@ -126,7 +124,7 @@ Transaction.prototype.addInput = function (hash, index, sequence, script) { } Transaction.prototype.addOutput = function (scriptPubKey, value) { - typeforce(types.tuple(types.Script, types.UInt53), arguments) + typeforce(types.tuple(types.Buffer, types.UInt53), arguments) // Add the output and return the output's index return (this.outs.push({ @@ -137,7 +135,7 @@ Transaction.prototype.addOutput = function (scriptPubKey, value) { Transaction.prototype.byteLength = function () { function scriptSize (script) { - var length = script.buffer.length + var length = script.length return bufferutils.varIntSize(length) + length } @@ -186,7 +184,7 @@ var ONE = new Buffer('0000000000000000000000000000000000000000000000000000000000 * This hash can then be used to sign the provided transaction input. */ Transaction.prototype.hashForSignature = function (inIndex, prevOutScript, hashType) { - typeforce(types.tuple(types.UInt32, types.Script, /* types.UInt8 */ types.Number), arguments) + typeforce(types.tuple(types.UInt32, types.Buffer, /* types.UInt8 */ types.Number), arguments) // https://github.com/bitcoin/bitcoin/blob/master/src/test/sighash_tests.cpp#L29 if (inIndex >= this.ins.length) return ONE @@ -195,11 +193,11 @@ 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 = prevOutScript.without(opcodes.OP_CODESEPARATOR) + var hashScript = Script.fromBuffer(prevOutScript).without(opcodes.OP_CODESEPARATOR).buffer var i // blank out other inputs' signatures - txTmp.ins.forEach(function (input) { input.script = Script.EMPTY }) + txTmp.ins.forEach(function (input) { input.script = EMPTY }) txTmp.ins[inIndex].script = hashScript // blank out some of the inputs @@ -225,7 +223,7 @@ Transaction.prototype.hashForSignature = function (inIndex, prevOutScript, hashT // blank all other outputs (clear scriptPubKey, value === -1) var stubOut = { - script: Script.EMPTY, + script: EMPTY, valueBuffer: new Buffer('ffffffffffffffff', 'hex') } @@ -294,8 +292,8 @@ Transaction.prototype.toBuffer = function () { this.ins.forEach(function (txIn) { writeSlice(txIn.hash) writeUInt32(txIn.index) - writeVarInt(txIn.script.buffer.length) - writeSlice(txIn.script.buffer) + writeVarInt(txIn.script.length) + writeSlice(txIn.script) writeUInt32(txIn.sequence) }) @@ -307,8 +305,8 @@ Transaction.prototype.toBuffer = function () { writeSlice(txOut.valueBuffer) } - writeVarInt(txOut.script.buffer.length) - writeSlice(txOut.script.buffer) + writeVarInt(txOut.script.length) + writeSlice(txOut.script) }) writeUInt32(this.locktime) @@ -321,7 +319,7 @@ Transaction.prototype.toHex = function () { } Transaction.prototype.setInputScript = function (index, script) { - typeforce(types.tuple(types.Number, types.Script), arguments) + typeforce(types.tuple(types.Number, types.Buffer), arguments) this.ins[index].script = script } diff --git a/src/transaction_builder.js b/src/transaction_builder.js index 421bb9b..fd6ab38 100644 --- a/src/transaction_builder.js +++ b/src/transaction_builder.js @@ -13,16 +13,20 @@ var Transaction = require('./transaction') function extractInput (txIn) { var redeemScript var scriptSig = txIn.script + var scriptSigChunks = Script.fromBuffer(scriptSig).chunks + var prevOutScript var prevOutType = scripts.classifyInput(scriptSig, true) var scriptType // Re-classify if scriptHash if (prevOutType === 'scripthash') { - redeemScript = Script.fromBuffer(scriptSig.chunks.slice(-1)[0]) - prevOutScript = scripts.scriptHashOutput(redeemScript.getHash()) + redeemScript = scriptSigChunks.slice(-1)[0] + prevOutScript = scripts.scriptHashOutput(bcrypto.hash160(redeemScript)) + + scriptSig = Script.fromChunks(scriptSigChunks.slice(0, -1)).buffer + scriptSigChunks = scriptSigChunks.slice(0, -1) - scriptSig = Script.fromChunks(scriptSig.chunks.slice(0, -1)) scriptType = scripts.classifyInput(scriptSig, true) } else { scriptType = prevOutType @@ -33,27 +37,27 @@ function extractInput (txIn) { switch (scriptType) { case 'pubkeyhash': - parsed = ECSignature.parseScriptSignature(scriptSig.chunks[0]) + parsed = ECSignature.parseScriptSignature(scriptSigChunks[0]) hashType = parsed.hashType - pubKeys = scriptSig.chunks.slice(1) + pubKeys = scriptSigChunks.slice(1) signatures = [parsed.signature] prevOutScript = scripts.pubKeyHashOutput(bcrypto.hash160(pubKeys[0])) break case 'pubkey': - parsed = ECSignature.parseScriptSignature(scriptSig.chunks[0]) + parsed = ECSignature.parseScriptSignature(scriptSigChunks[0]) hashType = parsed.hashType signatures = [parsed.signature] if (redeemScript) { - pubKeys = redeemScript.chunks.slice(0, 1) + pubKeys = Script.fromBuffer(redeemScript).chunks.slice(0, 1) } break case 'multisig': - signatures = scriptSig.chunks.slice(1).map(function (chunk) { + signatures = scriptSigChunks.slice(1).map(function (chunk) { if (chunk === ops.OP_0) return chunk var parsed = ECSignature.parseScriptSignature(chunk) @@ -63,7 +67,7 @@ function extractInput (txIn) { }) if (redeemScript) { - pubKeys = redeemScript.chunks.slice(1, -2) + pubKeys = Script.fromBuffer(redeemScript).chunks.slice(1, -2) } break @@ -115,7 +119,7 @@ TransactionBuilder.fromTransaction = function (transaction, network) { } // Ignore empty scripts - if (txIn.script.buffer.length === 0) return {} + if (txIn.script.length === 0) return {} return extractInput(txIn) }) @@ -139,15 +143,16 @@ TransactionBuilder.prototype.addInput = function (txHash, vout, sequence, prevOu var input = {} if (prevOutScript) { var prevOutType = scripts.classifyOutput(prevOutScript) + var prevOutScriptChunks = Script.fromBuffer(prevOutScript).chunks // if we can, extract pubKey information switch (prevOutType) { case 'multisig': - input.pubKeys = prevOutScript.chunks.slice(1, -2) + input.pubKeys = prevOutScriptChunks.slice(1, -2) break case 'pubkey': - input.pubKeys = prevOutScript.chunks.slice(0, 1) + input.pubKeys = prevOutScriptChunks.slice(0, 1) break } @@ -308,21 +313,22 @@ TransactionBuilder.prototype.sign = function (index, keyPair, redeemScript, hash if (input.prevOutScript) { if (input.prevOutType !== 'scripthash') throw new Error('PrevOutScript must be P2SH') - var scriptHash = input.prevOutScript.chunks[1] - if (!bufferutils.equal(scriptHash, redeemScript.getHash())) throw new Error('RedeemScript does not match ' + scriptHash.toString('hex')) + var scriptHash = Script.fromBuffer(input.prevOutScript).chunks[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 = Script.fromBuffer(redeemScript).chunks var pubKeys = [] switch (scriptType) { case 'multisig': - pubKeys = redeemScript.chunks.slice(1, -2) + pubKeys = redeemScriptChunks.slice(1, -2) break case 'pubkeyhash': - var pkh1 = redeemScript.chunks[2] + var pkh1 = redeemScriptChunks[2] var pkh2 = bcrypto.hash160(keyPair.getPublicKeyBuffer()) if (!bufferutils.equal(pkh1, pkh2)) throw new Error('privateKey cannot sign for this input') @@ -330,12 +336,13 @@ TransactionBuilder.prototype.sign = function (index, keyPair, redeemScript, hash break case 'pubkey': - pubKeys = redeemScript.chunks.slice(0, 1) + pubKeys = redeemScriptChunks.slice(0, 1) break } + // if we don't have a prevOutScript, generate a P2SH script if (!input.prevOutScript) { - input.prevOutScript = scripts.scriptHashOutput(redeemScript.getHash()) + input.prevOutScript = scripts.scriptHashOutput(bcrypto.hash160(redeemScript)) input.prevOutType = 'scripthash' } diff --git a/test/address.js b/test/address.js index 541fb88..ab37ed8 100644 --- a/test/address.js +++ b/test/address.js @@ -31,7 +31,7 @@ describe('Address', function () { describe('fromOutputScript', function () { fixtures.valid.forEach(function (f) { it('parses ' + f.script.slice(0, 30) + '... (' + f.network + ')', function () { - var script = Script.fromASM(f.script) + var script = Script.fromASM(f.script).buffer var address = Address.fromOutputScript(script, networks[f.network]) assert.strictEqual(address, f.base58check) @@ -40,7 +40,7 @@ describe('Address', function () { fixtures.invalid.fromOutputScript.forEach(function (f) { it('throws when ' + f.script.slice(0, 30) + '... ' + f.exception, function () { - var script = Script.fromASM(f.script) + var script = Script.fromASM(f.script).buffer assert.throws(function () { Address.fromOutputScript(script) @@ -66,7 +66,7 @@ describe('Address', function () { it('exports ' + f.script.slice(0, 30) + '... (' + f.network + ')', function () { var script = Address.toOutputScript(f.base58check, network) - assert.strictEqual(script.toASM(), f.script) + assert.strictEqual(Script.fromBuffer(script).toASM(), f.script) }) }) diff --git a/test/bitcoin.core.js b/test/bitcoin.core.js index ff6cbff..769a612 100644 --- a/test/bitcoin.core.js +++ b/test/bitcoin.core.js @@ -227,8 +227,8 @@ describe('Bitcoin-core', function () { var transaction = Transaction.fromHex(txHex) assert.strictEqual(transaction.toHex(), txHex) - var script = Script.fromHex(scriptHex) - assert.strictEqual(script.toHex(), scriptHex) + var script = Script.fromHex(scriptHex).buffer + assert.strictEqual(Script.fromBuffer(script).toHex(), scriptHex) var hash = transaction.hashForSignature(inIndex, script, hashType) assert.deepEqual(hash, expectedHash) diff --git a/test/integration/multisig.js b/test/integration/multisig.js index 28a2d93..cae7a47 100644 --- a/test/integration/multisig.js +++ b/test/integration/multisig.js @@ -15,7 +15,7 @@ describe('bitcoinjs-lib (multisig)', function () { }) var redeemScript = bitcoin.scripts.multisigOutput(2, pubKeys) // 2 of 3 - var scriptPubKey = bitcoin.scripts.scriptHashOutput(redeemScript.getHash()) + var scriptPubKey = bitcoin.scripts.scriptHashOutput(bitcoin.crypto.hash160(redeemScript)) var address = bitcoin.Address.fromOutputScript(scriptPubKey) assert.strictEqual(address, '36NUkt6FWUi3LAWBqWRdDmdTWbt91Yvfu7') @@ -33,7 +33,7 @@ describe('bitcoinjs-lib (multisig)', function () { var pubKeys = keyPairs.map(function (x) { return x.getPublicKeyBuffer() }) var redeemScript = bitcoin.scripts.multisigOutput(2, pubKeys) // 2 of 4 - var scriptPubKey = bitcoin.scripts.scriptHashOutput(redeemScript.getHash()) + var scriptPubKey = bitcoin.scripts.scriptHashOutput(bitcoin.crypto.hash160(redeemScript)) var address = bitcoin.Address.fromOutputScript(scriptPubKey, bitcoin.networks.testnet) // attempt to send funds to the source address diff --git a/test/script.js b/test/script.js index 4ce400e..8c20403 100644 --- a/test/script.js +++ b/test/script.js @@ -34,7 +34,7 @@ describe('Script', function () { var script = Script.fromASM(f.asm) assert.strictEqual(script.toASM(), f.asm) - assert.strictEqual(script.toHex(), f.hex) + assert.strictEqual(script.buffer.toString('hex'), f.hex) }) }) }) @@ -45,17 +45,7 @@ describe('Script', function () { var script = Script.fromHex(f.hex) assert.strictEqual(script.toASM(), f.asm) - assert.strictEqual(script.toHex(), f.hex) - }) - }) - }) - - describe('getHash', function () { - fixtures.valid.forEach(function (f) { - it('produces a HASH160 of ' + f.description, function () { - var script = Script.fromHex(f.hex) - - assert.strictEqual(script.getHash().toString('hex'), f.hash) + assert.strictEqual(script.buffer.toString('hex'), f.hex) }) }) }) @@ -71,7 +61,7 @@ describe('Script', function () { opcodes.OP_EQUAL ]) - assert.strictEqual(script.toHex(), 'a920000000000000000000000000000000000000000000000000000000000000000087') + assert.strictEqual(script.buffer.toString('hex'), 'a920000000000000000000000000000000000000000000000000000000000000000087') }) }) @@ -82,14 +72,14 @@ describe('Script', function () { it('should return a script without the given value', function () { var subScript = script.without(opcodes.OP_HASH160) - assert.strictEqual(subScript.toHex(), '14e8c300c87986efa94c37c0519929019ef86eb5b487') + assert.strictEqual(subScript.buffer.toString('hex'), '14e8c300c87986efa94c37c0519929019ef86eb5b487') }) it('shouldnt mutate the original script', function () { var subScript = script.without(opcodes.OP_EQUAL) - assert.notEqual(subScript.toHex(), hex) - assert.strictEqual(script.toHex(), hex) + assert.notEqual(subScript.buffer.toString('hex'), hex) + assert.strictEqual(script.buffer.toString('hex'), hex) }) }) }) diff --git a/test/scripts.js b/test/scripts.js index f89c44a..64635ce 100644 --- a/test/scripts.js +++ b/test/scripts.js @@ -19,7 +19,7 @@ describe('Scripts', function () { if (!f.scriptSig) return it('classifies ' + f.scriptSig + ' as ' + f.type, function () { - var script = Script.fromASM(f.scriptSig) + var script = Script.fromASM(f.scriptSig).buffer var type = scripts.classifyInput(script) assert.strictEqual(type, f.type) @@ -31,7 +31,7 @@ describe('Scripts', function () { if (!f.typeIncomplete) return it('classifies incomplete ' + f.scriptSig + ' as ' + f.typeIncomplete, function () { - var script = Script.fromASM(f.scriptSig) + var script = Script.fromASM(f.scriptSig).buffer var type = scripts.classifyInput(script, true) assert.strictEqual(type, f.typeIncomplete) @@ -44,7 +44,7 @@ describe('Scripts', function () { if (!f.scriptPubKey) return it('classifies ' + f.scriptPubKey + ' as ' + f.type, function () { - var script = Script.fromASM(f.scriptPubKey) + var script = Script.fromASM(f.scriptPubKey).buffer var type = scripts.classifyOutput(script) assert.strictEqual(type, f.type) @@ -67,9 +67,9 @@ describe('Scripts', function () { var script if (f.scriptSig) { - script = Script.fromASM(f.scriptSig) + script = Script.fromASM(f.scriptSig).buffer } else { - script = Script.fromHex(f.scriptSigHex) + script = Script.fromHex(f.scriptSigHex).buffer } it('returns ' + expected + ' for ' + f.scriptSig, function () { @@ -94,9 +94,9 @@ describe('Scripts', function () { var script if (f.scriptSig) { - script = Script.fromASM(f.scriptSig) + script = Script.fromASM(f.scriptSig).buffer } else { - script = Script.fromHex(f.scriptSigHex) + script = Script.fromHex(f.scriptSigHex).buffer } assert.strictEqual(inputFn(script), false) @@ -111,7 +111,7 @@ describe('Scripts', function () { if (outputFn && f.scriptPubKey) { it('returns ' + expected + ' for ' + f.scriptPubKey, function () { - var script = Script.fromASM(f.scriptPubKey) + var script = Script.fromASM(f.scriptPubKey).buffer assert.strictEqual(outputFn(script), expected) }) @@ -123,7 +123,7 @@ describe('Scripts', function () { fixtures.invalid[outputFnName].forEach(function (f) { if (outputFn && f.scriptPubKey) { it('returns false for ' + f.description + ' (' + f.scriptPubKey + ')', function () { - var script = Script.fromASM(f.scriptPubKey) + var script = Script.fromASM(f.scriptPubKey).buffer assert.strictEqual(outputFn(script), false) }) @@ -140,7 +140,7 @@ describe('Scripts', function () { var signature = new Buffer(f.signature, 'hex') var scriptSig = scripts.pubKeyInput(signature) - assert.strictEqual(scriptSig.toASM(), f.scriptSig) + assert.strictEqual(Script.fromBuffer(scriptSig).toASM(), f.scriptSig) }) }) }) @@ -152,7 +152,7 @@ describe('Scripts', function () { it('returns ' + f.scriptPubKey, function () { var pubKey = new Buffer(f.pubKey, 'hex') var scriptPubKey = scripts.pubKeyOutput(pubKey) - assert.strictEqual(scriptPubKey.toASM(), f.scriptPubKey) + assert.strictEqual(Script.fromBuffer(scriptPubKey).toASM(), f.scriptPubKey) }) }) }) @@ -167,7 +167,7 @@ describe('Scripts', function () { var signature = new Buffer(f.signature, 'hex') var scriptSig = scripts.pubKeyHashInput(signature, pubKey) - assert.strictEqual(scriptSig.toASM(), f.scriptSig) + assert.strictEqual(Script.fromBuffer(scriptSig).toASM(), f.scriptSig) }) }) }) @@ -181,7 +181,7 @@ describe('Scripts', function () { it('returns ' + f.scriptPubKey, function () { var scriptPubKey = scripts.pubKeyHashOutput(pubKeyHash) - assert.strictEqual(scriptPubKey.toASM(), f.scriptPubKey) + assert.strictEqual(Script.fromBuffer(scriptPubKey).toASM(), f.scriptPubKey) }) }) }) @@ -196,12 +196,12 @@ describe('Scripts', function () { }) var scriptSig = scripts.multisigInput(signatures) - assert.strictEqual(scriptSig.toASM(), f.scriptSig) + assert.strictEqual(Script.fromBuffer(scriptSig).toASM(), f.scriptSig) }) }) fixtures.invalid.multisigInput.forEach(function (f) { - var scriptPubKey = Script.fromASM(f.scriptPubKey) + var scriptPubKey = Script.fromASM(f.scriptPubKey).buffer it('throws on ' + f.exception, function () { var signatures = f.signatures.map(function (signature) { @@ -223,7 +223,7 @@ describe('Scripts', function () { var scriptPubKey = scripts.multisigOutput(pubKeys.length, pubKeys) it('returns ' + f.scriptPubKey, function () { - assert.strictEqual(scriptPubKey.toASM(), f.scriptPubKey) + assert.strictEqual(Script.fromBuffer(scriptPubKey).toASM(), f.scriptPubKey) }) }) @@ -244,16 +244,16 @@ describe('Scripts', function () { fixtures.valid.forEach(function (f) { if (f.type !== 'scripthash') return - var redeemScript = Script.fromASM(f.redeemScript) - var redeemScriptSig = Script.fromASM(f.redeemScriptSig) + var redeemScript = Script.fromASM(f.redeemScript).buffer + var redeemScriptSig = Script.fromASM(f.redeemScriptSig).buffer it('returns ' + f.scriptSig, function () { var scriptSig = scripts.scriptHashInput(redeemScriptSig, redeemScript) if (f.scriptSig) { - assert.strictEqual(scriptSig.toASM(), f.scriptSig) + assert.strictEqual(Script.fromBuffer(scriptSig).toASM(), f.scriptSig) } else { - assert.strictEqual(scriptSig.toHex(), f.scriptSigHex) + assert.strictEqual(Script.fromBuffer(scriptSig).toHex(), f.scriptSigHex) } }) }) @@ -265,10 +265,10 @@ describe('Scripts', function () { if (!f.scriptPubKey) return it('returns ' + f.scriptPubKey, function () { - var redeemScript = Script.fromASM(f.redeemScript) - var scriptPubKey = scripts.scriptHashOutput(redeemScript.getHash()) + var redeemScript = Script.fromASM(f.redeemScript).buffer + var scriptPubKey = scripts.scriptHashOutput(bcrypto.hash160(redeemScript)) - assert.strictEqual(scriptPubKey.toASM(), f.scriptPubKey) + assert.strictEqual(Script.fromBuffer(scriptPubKey).toASM(), f.scriptPubKey) }) }) }) @@ -281,7 +281,7 @@ describe('Scripts', function () { var scriptPubKey = scripts.nullDataOutput(data) it('returns ' + f.scriptPubKey, function () { - assert.strictEqual(scriptPubKey.toASM(), f.scriptPubKey) + assert.strictEqual(Script.fromBuffer(scriptPubKey).toASM(), f.scriptPubKey) }) }) }) diff --git a/test/transaction.js b/test/transaction.js index 0cd376b..6ac9bb8 100644 --- a/test/transaction.js +++ b/test/transaction.js @@ -19,9 +19,9 @@ describe('Transaction', function () { if (txIn.data) { var data = new Buffer(txIn.data, 'hex') - script = new Script(data, []) + script = data } else if (txIn.script) { - script = Script.fromASM(txIn.script) + script = Script.fromASM(txIn.script).buffer } tx.addInput(txHash, txIn.index, txIn.sequence, script) @@ -32,9 +32,9 @@ describe('Transaction', function () { if (txOut.data) { var data = new Buffer(txOut.data, 'hex') - script = new Script(data, []) + script = data } else if (txOut.script) { - script = Script.fromASM(txOut.script) + script = Script.fromASM(txOut.script).buffer } tx.addOutput(script, txOut.value) @@ -102,7 +102,7 @@ describe('Transaction', function () { var tx = new Transaction() tx.addInput(prevTxHash, 0) - assert.strictEqual(tx.ins[0].script, Script.EMPTY) + assert.strictEqual(tx.ins[0].script.length, 0) }) fixtures.invalid.addInput.forEach(function (f) { @@ -120,8 +120,8 @@ describe('Transaction', function () { describe('addOutput', function () { it('returns an index', function () { var tx = new Transaction() - assert.strictEqual(tx.addOutput(Script.EMPTY, 0), 0) - assert.strictEqual(tx.addOutput(Script.EMPTY, 0), 1) + assert.strictEqual(tx.addOutput(new Buffer(0), 0), 0) + assert.strictEqual(tx.addOutput(new Buffer(0), 0), 1) }) }) diff --git a/test/transaction_builder.js b/test/transaction_builder.js index 3bfacd5..0367aac 100644 --- a/test/transaction_builder.js +++ b/test/transaction_builder.js @@ -22,14 +22,14 @@ function construct (f, sign) { var prevTxScript if (input.prevTxScript) { - prevTxScript = Script.fromASM(input.prevTxScript) + prevTxScript = Script.fromASM(input.prevTxScript).buffer } txb.addInput(input.txId, input.vout, input.sequence, prevTxScript) }) f.outputs.forEach(function (output) { - var script = Script.fromASM(output.script) + var script = Script.fromASM(output.script).buffer txb.addOutput(script, output.value) }) @@ -41,7 +41,7 @@ function construct (f, sign) { var redeemScript if (sign.redeemScript) { - redeemScript = Script.fromASM(sign.redeemScript) + redeemScript = Script.fromASM(sign.redeemScript).buffer } txb.sign(index, keyPair, redeemScript, sign.hashType) @@ -200,7 +200,7 @@ describe('TransactionBuilder', function () { var redeemScript if (sign.redeemScript) { - redeemScript = Script.fromASM(sign.redeemScript) + redeemScript = Script.fromASM(sign.redeemScript).buffer } if (!sign.throws) { @@ -262,7 +262,7 @@ describe('TransactionBuilder', function () { var network = NETWORKS[f.network] f.inputs.forEach(function (input, i) { - var redeemScript = Script.fromASM(input.redeemScript) + var redeemScript = Script.fromASM(input.redeemScript).buffer input.signs.forEach(function (sign) { // rebuild the transaction each-time after the first @@ -272,11 +272,11 @@ describe('TransactionBuilder', function () { var scriptSig = tx.ins[i].script // ignore OP_0 on the front, ignore redeemScript - var signatures = scriptSig.chunks.slice(1, -1).filter(function (x) { return x !== ops.OP_0 }) + var signatures = Script.fromBuffer(scriptSig).chunks.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) - assert.strictEqual(replacement.toASM(), sign.scriptSigFiltered) + assert.strictEqual(Script.fromBuffer(replacement).toASM(), sign.scriptSigFiltered) tx.ins[i].script = replacement } @@ -292,7 +292,7 @@ describe('TransactionBuilder', function () { tx = txb.buildIncomplete() // now verify the serialized scriptSig is as expected - assert.strictEqual(tx.ins[i].script.toASM(), sign.scriptSig) + assert.strictEqual(Script.fromBuffer(tx.ins[i].script).toASM(), sign.scriptSig) }) }) @@ -309,7 +309,7 @@ describe('TransactionBuilder', function () { txb = TransactionBuilder.fromTransaction(lameTx, network) - var redeemScript = Script.fromASM('OP_2 0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 04c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee51ae168fea63dc339a3c58419466ceaeef7f632653266d0e1236431a950cfe52a 04f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672 OP_3 OP_CHECKMULTISIG') + var redeemScript = Script.fromASM('OP_2 0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 04c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee51ae168fea63dc339a3c58419466ceaeef7f632653266d0e1236431a950cfe52a 04f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672 OP_3 OP_CHECKMULTISIG').buffer var keyPair = ECPair.fromWIF('91avARGdfge8E4tZfYLoxeJ5sGBdNJQH4kvjJoQFacbgx3cTMqe', network) txb.sign(0, keyPair, redeemScript)