LBRYCommunity/bitcoinjs-lib
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

remove usage of instanced Scripts

Browse source
This commit is contained in:
Daniel Cousens 2015-08-07 16:30:24 +10:00
parent 5d2abb523e
commit e743c58ed6
11 changed files with 146 additions and 119 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
src/address.js
View file

@ -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) {

62
src/scripts.js
View file

@ -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
}
// <scriptSig> {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 = {

36
src/transaction.js
View file

@ -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
}

43
src/transaction_builder.js
View file

@ -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'
}

6
test/address.js
View file

@ -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)
})
})

4
test/bitcoin.core.js
View file

@ -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)

4
test/integration/multisig.js
View file

@ -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

22
test/script.js
View file

@ -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)
})
})
})

48
test/scripts.js
View file

@ -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)
})
})
})

14
test/transaction.js
View file

@ -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)
})
})

18
test/transaction_builder.js
View file

@ -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)