lukechilds
/
bitcoinjs-lib
mirror of https://github.com/lukechilds/bitcoinjs-lib.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

remove usage of instanced Scripts

hk-custom-address
Daniel Cousens 10 years ago
parent
5d2abb523e
commit
e743c58ed6
11 changed files with 146 additions and 119 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 8
      src/address.js
  2. 62
      src/scripts.js
  3. 36
      src/transaction.js
  4. 43
      src/transaction_builder.js
  5. 6
      test/address.js
  6. 4
      test/bitcoin.core.js
  7. 4
      test/integration/multisig.js
  8. 22
      test/script.js
  9. 48
      test/scripts.js
  10. 14
      test/transaction.js
  11. 18
      test/transaction_builder.js

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)

Write Preview
Loading…
Cancel
Save