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 Script object

hk-custom-address
Daniel Cousens 10 years ago
parent
e743c58ed6
commit
e05f8a542d
11 changed files with 222 additions and 304 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. 6
      src/address.js
  2. 134
      src/script.js
  3. 221
      src/scripts.js
  4. 4
      src/transaction.js
  5. 16
      src/transaction_builder.js
  6. 6
      test/address.js
  7. 5
      test/bitcoin.core.js
  8. 62
      test/script.js
  9. 48
      test/scripts.js
  10. 6
      test/transaction.js
  11. 18
      test/transaction_builder.js

6
src/address.js
View File

@ -20,10 +20,10 @@ function fromBase58Check (address) {
function fromOutputScript (script, network) {
network = network || networks.bitcoin
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)
if (scripts.isPubKeyHashOutput(script)) return toBase58Check(script[2], network.pubKeyHash)
if (scripts.isScriptHashOutput(script)) return toBase58Check(script[1], network.scriptHash)
throw new Error(Script.fromBuffer(script).toASM() + ' has no matching Address')
throw new Error(Script.toASM(script) + ' has no matching Address')
}
function toBase58Check (hash, version) {

134
src/script.js
View File

@ -1,17 +1,30 @@
var bufferutils = require('./bufferutils')
var crypto = require('./crypto')
var opcodes = require('./opcodes')
var typeforce = require('typeforce')
var types = require('./types')
var opcodes = require('./opcodes')
function Script (buffer, chunks) {
typeforce(types.tuple(types.Buffer, types.Array), arguments)
function coerceChunks (chunks) {
return types.Array(chunks) ? chunks : decompile(chunks)
}
function toASM (chunks) {
chunks = coerceChunks(chunks)
return chunks.map(function (chunk) {
// data chunk
if (Buffer.isBuffer(chunk)) {
return chunk.toString('hex')
this.buffer = buffer
this.chunks = chunks
// opcode
} else {
return reverseOps[chunk]
}
}).join(' ')
}
Script.fromASM = function (asm) {
function fromASM (asm) {
typeforce(types.String, asm)
var strChunks = asm.split(' ')
var chunks = strChunks.map(function (strChunk) {
// opcode
@ -24,44 +37,10 @@ Script.fromASM = function (asm) {
}
})
return Script.fromChunks(chunks)
}
Script.fromBuffer = function (buffer) {
var chunks = []
var i = 0
while (i < buffer.length) {
var opcode = buffer.readUInt8(i)
// data chunk
if ((opcode > opcodes.OP_0) && (opcode <= opcodes.OP_PUSHDATA4)) {
var d = bufferutils.readPushDataInt(buffer, i)
// did reading a pushDataInt fail? return non-chunked script
if (d === null) return new Script(buffer, [])
i += d.size
// attempt to read too much data?
if (i + d.number > buffer.length) return new Script(buffer, [])
var data = buffer.slice(i, i + d.number)
i += d.number
chunks.push(data)
// opcode
} else {
chunks.push(opcode)
i += 1
}
}
return new Script(buffer, chunks)
return chunks
}
Script.fromChunks = function (chunks) {
function compile (chunks) {
typeforce(types.Array, chunks)
var bufferSize = chunks.reduce(function (accum, chunk) {
@ -93,55 +72,54 @@ Script.fromChunks = function (chunks) {
})
if (offset !== buffer.length) throw new Error('Could not decode chunks')
return new Script(buffer, chunks)
return buffer
}
Script.fromHex = function (hex) {
return Script.fromBuffer(new Buffer(hex, 'hex'))
}
function decompile (buffer) {
typeforce(types.Buffer, buffer)
Script.EMPTY = Script.fromChunks([])
var chunks = []
var i = 0
Script.prototype.equals = function (script) {
return bufferutils.equal(this.buffer, script.buffer)
}
while (i < buffer.length) {
var opcode = buffer.readUInt8(i)
Script.prototype.getHash = function () {
return crypto.hash160(this.buffer)
}
// data chunk
if ((opcode > opcodes.OP_0) && (opcode <= opcodes.OP_PUSHDATA4)) {
var d = bufferutils.readPushDataInt(buffer, i)
// FIXME: doesn't work for data chunks, maybe time to use buffertools.compare...
Script.prototype.without = function (needle) {
return Script.fromChunks(this.chunks.filter(function (op) {
return op !== needle
}))
}
// did reading a pushDataInt fail? empty script
if (d === null) return []
i += d.size
var reverseOps = []
for (var op in opcodes) {
var code = opcodes[op]
reverseOps[code] = op
}
// attempt to read too much data? empty script
if (i + d.number > buffer.length) return []
Script.prototype.toASM = function () {
return this.chunks.map(function (chunk) {
// data chunk
if (Buffer.isBuffer(chunk)) {
return chunk.toString('hex')
var data = buffer.slice(i, i + d.number)
i += d.number
chunks.push(data)
// opcode
} else {
return reverseOps[chunk]
chunks.push(opcode)
i += 1
}
}).join(' ')
}
}
Script.prototype.toBuffer = function () {
return this.buffer
return chunks
}
Script.prototype.toHex = function () {
return this.toBuffer().toString('hex')
var reverseOps = []
for (var op in opcodes) {
var code = opcodes[op]
reverseOps[code] = op
}
module.exports = Script
module.exports = {
compile: compile,
decompile: decompile,
toASM: toASM,
fromASM: fromASM
}

221
src/scripts.js
View File

@ -40,105 +40,102 @@ function isCanonicalSignature (buffer) {
return true
}
function isPubKeyHashInput (script) {
typeforce(types.Buffer, script)
script = Script.fromBuffer(script)
function coerceBuffer (buffer) {
return types.Buffer(buffer) ? buffer : Script.compile(buffer)
}
return script.chunks.length === 2 &&
isCanonicalSignature(script.chunks[0]) &&
isCanonicalPubKey(script.chunks[1])
function coerceChunks (chunks) {
return types.Array(chunks) ? chunks : Script.decompile(chunks)
}
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 &&
Buffer.isBuffer(script.chunks[2]) &&
script.chunks[2].length === 20 &&
script.chunks[3] === ops.OP_EQUALVERIFY &&
script.chunks[4] === ops.OP_CHECKSIG
function isPubKeyHashInput (chunks) {
chunks = coerceChunks(chunks)
return chunks.length === 2 &&
isCanonicalSignature(chunks[0]) &&
isCanonicalPubKey(chunks[1])
}
function isPubKeyInput (script) {
typeforce(types.Buffer, script)
script = Script.fromBuffer(script)
function isPubKeyHashOutput (chunks) {
chunks = coerceChunks(chunks)
return script.chunks.length === 1 &&
isCanonicalSignature(script.chunks[0])
return chunks.length === 5 &&
chunks[0] === ops.OP_DUP &&
chunks[1] === ops.OP_HASH160 &&
Buffer.isBuffer(chunks[2]) &&
chunks[2].length === 20 &&
chunks[3] === ops.OP_EQUALVERIFY &&
chunks[4] === ops.OP_CHECKSIG
}
function isPubKeyOutput (script) {
typeforce(types.Buffer, script)
script = Script.fromBuffer(script)
function isPubKeyInput (chunks) {
chunks = coerceChunks(chunks)
return script.chunks.length === 2 &&
isCanonicalPubKey(script.chunks[0]) &&
script.chunks[1] === ops.OP_CHECKSIG
return chunks.length === 1 &&
isCanonicalSignature(chunks[0])
}
function isScriptHashInput (script, allowIncomplete) {
typeforce(types.Buffer, script)
script = Script.fromBuffer(script)
function isPubKeyOutput (chunks) {
chunks = coerceChunks(chunks)
return chunks.length === 2 &&
isCanonicalPubKey(chunks[0]) &&
chunks[1] === ops.OP_CHECKSIG
}
if (script.chunks.length < 2) return false
function isScriptHashInput (chunks, allowIncomplete) {
chunks = coerceChunks(chunks)
if (chunks.length < 2) return false
var lastChunk = script.chunks[script.chunks.length - 1]
var lastChunk = chunks[chunks.length - 1]
if (!Buffer.isBuffer(lastChunk)) return false
var scriptSig = Script.fromChunks(script.chunks.slice(0, -1)).buffer
var redeemScript = lastChunk
var scriptSigChunks = chunks.slice(0, -1)
var redeemScriptChunks = Script.decompile(lastChunk)
// is redeemScript a valid script?
if (Script.fromBuffer(redeemScript).chunks.length === 0) return false
if (redeemScriptChunks.length === 0) return false
return classifyInput(scriptSig, allowIncomplete) === classifyOutput(redeemScript)
return classifyInput(scriptSigChunks, allowIncomplete) === classifyOutput(redeemScriptChunks)
}
function isScriptHashOutput (script) {
typeforce(types.Buffer, script)
script = Script.fromBuffer(script)
function isScriptHashOutput (chunks) {
chunks = coerceChunks(chunks)
return script.chunks.length === 3 &&
script.chunks[0] === ops.OP_HASH160 &&
Buffer.isBuffer(script.chunks[1]) &&
script.chunks[1].length === 20 &&
script.chunks[2] === ops.OP_EQUAL
return chunks.length === 3 &&
chunks[0] === ops.OP_HASH160 &&
Buffer.isBuffer(chunks[1]) &&
chunks[1].length === 20 &&
chunks[2] === ops.OP_EQUAL
}
// 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
function isMultisigInput (chunks, allowIncomplete) {
chunks = coerceChunks(chunks)
if (chunks.length < 2) return false
if (chunks[0] !== ops.OP_0) return false
if (allowIncomplete) {
return script.chunks.slice(1).every(function (chunk) {
return chunks.slice(1).every(function (chunk) {
return chunk === ops.OP_0 || isCanonicalSignature(chunk)
})
}
return script.chunks.slice(1).every(isCanonicalSignature)
return chunks.slice(1).every(isCanonicalSignature)
}
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
function isMultisigOutput (chunks) {
chunks = coerceChunks(chunks)
if (chunks.length < 4) return false
if (chunks[chunks.length - 1] !== ops.OP_CHECKMULTISIG) return false
var mOp = script.chunks[0]
var mOp = chunks[0]
if (mOp === ops.OP_0) return false
if (mOp < ops.OP_1) return false
if (mOp > ops.OP_16) return false
var nOp = script.chunks[script.chunks.length - 2]
var nOp = chunks[chunks.length - 2]
if (nOp === ops.OP_0) return false
if (nOp < ops.OP_1) return false
if (nOp > ops.OP_16) return false
@ -147,47 +144,43 @@ function isMultisigOutput (script) {
var n = nOp - (ops.OP_1 - 1)
if (n < m) return false
var pubKeys = script.chunks.slice(1, -2)
var pubKeys = chunks.slice(1, -2)
if (n < pubKeys.length) return false
return pubKeys.every(isCanonicalPubKey)
}
function isNullDataOutput (script) {
typeforce(types.Buffer, script)
script = Script.fromBuffer(script)
return script.chunks[0] === ops.OP_RETURN
function isNullDataOutput (chunks) {
chunks = coerceChunks(chunks)
return chunks[0] === ops.OP_RETURN
}
function classifyOutput (script) {
typeforce(types.Buffer, script)
if (isPubKeyHashOutput(script)) {
function classifyOutput (chunks) {
chunks = coerceChunks(chunks)
if (isPubKeyHashOutput(chunks)) {
return 'pubkeyhash'
} else if (isScriptHashOutput(script)) {
} else if (isScriptHashOutput(chunks)) {
return 'scripthash'
} else if (isMultisigOutput(script)) {
} else if (isMultisigOutput(chunks)) {
return 'multisig'
} else if (isPubKeyOutput(script)) {
} else if (isPubKeyOutput(chunks)) {
return 'pubkey'
} else if (isNullDataOutput(script)) {
} else if (isNullDataOutput(chunks)) {
return 'nulldata'
}
return 'nonstandard'
}
function classifyInput (script, allowIncomplete) {
typeforce(types.Buffer, script)
if (isPubKeyHashInput(script)) {
function classifyInput (chunks, allowIncomplete) {
chunks = coerceChunks(chunks)
if (isPubKeyHashInput(chunks)) {
return 'pubkeyhash'
} else if (isMultisigInput(script, allowIncomplete)) {
} else if (isMultisigInput(chunks, allowIncomplete)) {
return 'multisig'
} else if (isScriptHashInput(script, allowIncomplete)) {
} else if (isScriptHashInput(chunks, allowIncomplete)) {
return 'scripthash'
} else if (isPubKeyInput(script)) {
} else if (isPubKeyInput(chunks)) {
return 'pubkey'
}
@ -197,34 +190,21 @@ function classifyInput (script, allowIncomplete) {
// Standard Script Templates
// {pubKey} OP_CHECKSIG
function pubKeyOutput (pubKey) {
return Script.fromChunks([
pubKey,
ops.OP_CHECKSIG
]).buffer
return Script.compile([pubKey, ops.OP_CHECKSIG])
}
// OP_DUP OP_HASH160 {pubKeyHash} OP_EQUALVERIFY OP_CHECKSIG
function pubKeyHashOutput (hash) {
typeforce(types.Hash160bit, hash)
return Script.fromChunks([
ops.OP_DUP,
ops.OP_HASH160,
hash,
ops.OP_EQUALVERIFY,
ops.OP_CHECKSIG
]).buffer
function pubKeyHashOutput (pubKeyHash) {
typeforce(typeforce.Buffer, pubKeyHash)
return Script.compile([ops.OP_DUP, ops.OP_HASH160, pubKeyHash, ops.OP_EQUALVERIFY, ops.OP_CHECKSIG])
}
// OP_HASH160 {scriptHash} OP_EQUAL
function scriptHashOutput (hash) {
typeforce(types.Hash160bit, hash)
return Script.fromChunks([
ops.OP_HASH160,
hash,
ops.OP_EQUAL
]).buffer
function scriptHashOutput (scriptHash) {
typeforce(typeforce.Buffer, scriptHash)
return Script.compile([ops.OP_HASH160, scriptHash, ops.OP_EQUAL])
}
// m [pubKeys ...] n OP_CHECKMULTISIG
@ -234,46 +214,47 @@ function multisigOutput (m, pubKeys) {
var n = pubKeys.length
if (n < m) throw new Error('Not enough pubKeys provided')
return Script.fromChunks([].concat(
return Script.compile([].concat(
(ops.OP_1 - 1) + m,
pubKeys,
(ops.OP_1 - 1) + n,
ops.OP_CHECKMULTISIG
)).buffer
))
}
// {signature}
function pubKeyInput (signature) {
typeforce(types.Buffer, signature)
return Script.fromChunks([signature]).buffer
return Script.compile([signature])
}
// {signature} {pubKey}
function pubKeyHashInput (signature, pubKey) {
typeforce(types.tuple(types.Buffer, types.Buffer), arguments)
return Script.fromChunks([signature, pubKey]).buffer
return Script.compile([signature, pubKey])
}
// <scriptSig> {serialized scriptPubKey script}
function scriptHashInput (scriptSig, scriptPubKey) {
var scriptSigChunks = Script.fromBuffer(scriptSig).chunks
return Script.fromChunks([].concat(
scriptSigChunks,
scriptPubKey
)).buffer
function scriptHashInput (scriptSig, scriptPubKeyBuffer) {
scriptSig = coerceChunks(scriptSig)
scriptPubKeyBuffer = coerceBuffer(scriptPubKeyBuffer)
return Script.compile([].concat(
scriptSig,
scriptPubKeyBuffer
))
}
// OP_0 [signatures ...]
function multisigInput (signatures, scriptPubKey) {
if (scriptPubKey) {
if (!isMultisigOutput(scriptPubKey)) throw new Error('Expected multisig scriptPubKey')
scriptPubKey = Script.fromBuffer(scriptPubKey)
scriptPubKey = coerceChunks(scriptPubKey)
var mOp = scriptPubKey.chunks[0]
var nOp = scriptPubKey.chunks[scriptPubKey.chunks.length - 2]
var mOp = scriptPubKey[0]
var nOp = scriptPubKey[scriptPubKey.length - 2]
var m = mOp - (ops.OP_1 - 1)
var n = nOp - (ops.OP_1 - 1)
@ -281,11 +262,11 @@ function multisigInput (signatures, scriptPubKey) {
if (signatures.length > n) throw new Error('Too many signatures provided')
}
return Script.fromChunks([].concat(ops.OP_0, signatures)).buffer
return Script.compile([].concat(ops.OP_0, signatures))
}
function nullDataOutput (data) {
return Script.fromChunks([ops.OP_RETURN, data]).buffer
return Script.compile([ops.OP_RETURN, data])
}
module.exports = {

4
src/transaction.js
View File

@ -193,7 +193,9 @@ 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 = Script.fromBuffer(prevOutScript).without(opcodes.OP_CODESEPARATOR).buffer
var hashScript = Script.compile(Script.decompile(prevOutScript).filter(function (x) {
return x !== opcodes.OP_CODESEPARATOR
}))
var i
// blank out other inputs' signatures

16
src/transaction_builder.js
View File

@ -13,7 +13,7 @@ var Transaction = require('./transaction')
function extractInput (txIn) {
var redeemScript
var scriptSig = txIn.script
var scriptSigChunks = Script.fromBuffer(scriptSig).chunks
var scriptSigChunks = Script.decompile(scriptSig)
var prevOutScript
var prevOutType = scripts.classifyInput(scriptSig, true)
@ -24,7 +24,7 @@ function extractInput (txIn) {
redeemScript = scriptSigChunks.slice(-1)[0]
prevOutScript = scripts.scriptHashOutput(bcrypto.hash160(redeemScript))
scriptSig = Script.fromChunks(scriptSigChunks.slice(0, -1)).buffer
scriptSig = Script.compile(scriptSigChunks.slice(0, -1))
scriptSigChunks = scriptSigChunks.slice(0, -1)
scriptType = scripts.classifyInput(scriptSig, true)
@ -51,7 +51,7 @@ function extractInput (txIn) {
signatures = [parsed.signature]
if (redeemScript) {
pubKeys = Script.fromBuffer(redeemScript).chunks.slice(0, 1)
pubKeys = Script.decompile(redeemScript).slice(0, 1)
}
break
@ -67,7 +67,7 @@ function extractInput (txIn) {
})
if (redeemScript) {
pubKeys = Script.fromBuffer(redeemScript).chunks.slice(1, -2)
pubKeys = Script.decompile(redeemScript).slice(1, -2)
}
break
@ -142,8 +142,8 @@ TransactionBuilder.prototype.addInput = function (txHash, vout, sequence, prevOu
var input = {}
if (prevOutScript) {
var prevOutType = scripts.classifyOutput(prevOutScript)
var prevOutScriptChunks = Script.fromBuffer(prevOutScript).chunks
var prevOutScriptChunks = Script.decompile(prevOutScript)
var prevOutType = scripts.classifyOutput(prevOutScriptChunks)
// if we can, extract pubKey information
switch (prevOutType) {
@ -313,14 +313,14 @@ TransactionBuilder.prototype.sign = function (index, keyPair, redeemScript, hash
if (input.prevOutScript) {
if (input.prevOutType !== 'scripthash') throw new Error('PrevOutScript must be P2SH')
var scriptHash = Script.fromBuffer(input.prevOutScript).chunks[1]
var scriptHash = Script.decompile(input.prevOutScript)[1]
if (!bufferutils.equal(scriptHash, bcrypto.hash160(redeemScript))) throw new Error('RedeemScript does not match ' + scriptHash.toString('hex'))
}
var scriptType = scripts.classifyOutput(redeemScript)
if (!canSignTypes[scriptType]) throw new Error('RedeemScript not supported (' + scriptType + ')')
var redeemScriptChunks = Script.fromBuffer(redeemScript).chunks
var redeemScriptChunks = Script.decompile(redeemScript)
var pubKeys = []
switch (scriptType) {
case 'multisig':

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).buffer
var script = Script.fromASM(f.script)
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).buffer
var script = Script.fromASM(f.script)
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.fromBuffer(script).toASM(), f.script)
assert.strictEqual(Script.toASM(script), f.script)
})
})

5
test/bitcoin.core.js
View File

@ -227,8 +227,9 @@ describe('Bitcoin-core', function () {
var transaction = Transaction.fromHex(txHex)
assert.strictEqual(transaction.toHex(), txHex)
var script = Script.fromHex(scriptHex).buffer
assert.strictEqual(Script.fromBuffer(script).toHex(), scriptHex)
var script = new Buffer(scriptHex, 'hex')
var scriptChunks = Script.decompile(script)
assert.strictEqual(Script.compile(scriptChunks).toString('hex'), scriptHex)
var hash = transaction.hashForSignature(inIndex, script, hashType)
assert.deepEqual(hash, expectedHash)

62
test/script.js
View File

@ -2,30 +2,12 @@
/* eslint-disable no-new */
var assert = require('assert')
var opcodes = require('../src/opcodes')
var Script = require('../src/script')
var OPS = require('../src/opcodes')
var fixtures = require('./fixtures/script.json')
describe('Script', function () {
describe('constructor', function () {
it('accepts valid parameters', function () {
var buffer = new Buffer([1])
var chunks = [1]
var script = new Script(buffer, chunks)
assert.strictEqual(script.buffer, buffer)
assert.strictEqual(script.chunks, chunks)
})
it('throws an error when input is not an array', function () {
assert.throws(function () {
new Script({})
}, /Expected Buffer, got/)
})
})
describe('fromASM/toASM', function () {
fixtures.valid.forEach(function (f) {
if (!f.asm) return
@ -33,53 +15,23 @@ describe('Script', function () {
it('decodes/encodes ' + f.description, function () {
var script = Script.fromASM(f.asm)
assert.strictEqual(script.toASM(), f.asm)
assert.strictEqual(script.buffer.toString('hex'), f.hex)
})
})
})
describe('fromHex/toHex', function () {
fixtures.valid.forEach(function (f) {
it('decodes/encodes ' + f.description, function () {
var script = Script.fromHex(f.hex)
assert.strictEqual(script.toASM(), f.asm)
assert.strictEqual(script.buffer.toString('hex'), f.hex)
assert.strictEqual(Script.toASM(script), f.asm)
})
})
})
describe('fromChunks', function () {
describe('compile', function () {
it('should match expected behaviour', function () {
var hash = new Buffer(32)
hash.fill(0)
var script = Script.fromChunks([
opcodes.OP_HASH160,
var script = Script.compile([
OPS.OP_HASH160,
hash,
opcodes.OP_EQUAL
OPS.OP_EQUAL
])
assert.strictEqual(script.buffer.toString('hex'), 'a920000000000000000000000000000000000000000000000000000000000000000087')
})
})
describe('without', function () {
var hex = 'a914e8c300c87986efa94c37c0519929019ef86eb5b487'
var script = Script.fromHex(hex)
it('should return a script without the given value', function () {
var subScript = script.without(opcodes.OP_HASH160)
assert.strictEqual(subScript.buffer.toString('hex'), '14e8c300c87986efa94c37c0519929019ef86eb5b487')
})
it('shouldnt mutate the original script', function () {
var subScript = script.without(opcodes.OP_EQUAL)
assert.notEqual(subScript.buffer.toString('hex'), hex)
assert.strictEqual(script.buffer.toString('hex'), hex)
assert.strictEqual(script.toString('hex'), 'a920000000000000000000000000000000000000000000000000000000000000000087')
})
})
})

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).buffer
var script = Script.fromASM(f.scriptSig)
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).buffer
var script = Script.fromASM(f.scriptSig)
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).buffer
var script = Script.fromASM(f.scriptPubKey)
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).buffer
script = Script.fromASM(f.scriptSig)
} else {
script = Script.fromHex(f.scriptSigHex).buffer
script = Script.fromHex(f.scriptSigHex)
}
it('returns ' + expected + ' for ' + f.scriptSig, function () {
@ -94,9 +94,9 @@ describe('Scripts', function () {
var script
if (f.scriptSig) {
script = Script.fromASM(f.scriptSig).buffer
script = Script.fromASM(f.scriptSig)
} else {
script = Script.fromHex(f.scriptSigHex).buffer
script = Script.fromHex(f.scriptSigHex)
}
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).buffer
var script = Script.fromASM(f.scriptPubKey)
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).buffer
var script = Script.fromASM(f.scriptPubKey)
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(Script.fromBuffer(scriptSig).toASM(), f.scriptSig)
assert.strictEqual(Script.toASM(scriptSig), f.scriptSig)
})
})
})
@ -152,7 +152,8 @@ describe('Scripts', function () {
it('returns ' + f.scriptPubKey, function () {
var pubKey = new Buffer(f.pubKey, 'hex')
var scriptPubKey = scripts.pubKeyOutput(pubKey)
assert.strictEqual(Script.fromBuffer(scriptPubKey).toASM(), f.scriptPubKey)
assert.strictEqual(Script.toASM(scriptPubKey), f.scriptPubKey)
})
})
})
@ -167,7 +168,7 @@ describe('Scripts', function () {
var signature = new Buffer(f.signature, 'hex')
var scriptSig = scripts.pubKeyHashInput(signature, pubKey)
assert.strictEqual(Script.fromBuffer(scriptSig).toASM(), f.scriptSig)
assert.strictEqual(Script.toASM(scriptSig), f.scriptSig)
})
})
})
@ -181,7 +182,7 @@ describe('Scripts', function () {
it('returns ' + f.scriptPubKey, function () {
var scriptPubKey = scripts.pubKeyHashOutput(pubKeyHash)
assert.strictEqual(Script.fromBuffer(scriptPubKey).toASM(), f.scriptPubKey)
assert.strictEqual(Script.toASM(scriptPubKey), f.scriptPubKey)
})
})
})
@ -196,12 +197,12 @@ describe('Scripts', function () {
})
var scriptSig = scripts.multisigInput(signatures)
assert.strictEqual(Script.fromBuffer(scriptSig).toASM(), f.scriptSig)
assert.strictEqual(Script.toASM(scriptSig), f.scriptSig)
})
})
fixtures.invalid.multisigInput.forEach(function (f) {
var scriptPubKey = Script.fromASM(f.scriptPubKey).buffer
var scriptPubKey = Script.fromASM(f.scriptPubKey)
it('throws on ' + f.exception, function () {
var signatures = f.signatures.map(function (signature) {
@ -223,7 +224,7 @@ describe('Scripts', function () {
var scriptPubKey = scripts.multisigOutput(pubKeys.length, pubKeys)
it('returns ' + f.scriptPubKey, function () {
assert.strictEqual(Script.fromBuffer(scriptPubKey).toASM(), f.scriptPubKey)
assert.strictEqual(Script.toASM(scriptPubKey), f.scriptPubKey)
})
})
@ -244,16 +245,17 @@ describe('Scripts', function () {
fixtures.valid.forEach(function (f) {
if (f.type !== 'scripthash') return
var redeemScript = Script.fromASM(f.redeemScript).buffer
var redeemScriptSig = Script.fromASM(f.redeemScriptSig).buffer
var redeemScript = Script.fromASM(f.redeemScript)
var redeemScriptSig = Script.fromASM(f.redeemScriptSig)
it('returns ' + f.scriptSig, function () {
var scriptSig = scripts.scriptHashInput(redeemScriptSig, redeemScript)
if (f.scriptSig) {
assert.strictEqual(Script.fromBuffer(scriptSig).toASM(), f.scriptSig)
assert.strictEqual(Script.toASM(scriptSig), f.scriptSig)
} else {
assert.strictEqual(Script.fromBuffer(scriptSig).toHex(), f.scriptSigHex)
assert.strictEqual(scriptSig.toString('hex'), f.scriptSigHex)
}
})
})
@ -265,10 +267,10 @@ describe('Scripts', function () {
if (!f.scriptPubKey) return
it('returns ' + f.scriptPubKey, function () {
var redeemScript = Script.fromASM(f.redeemScript).buffer
var redeemScript = Script.compile(Script.fromASM(f.redeemScript))
var scriptPubKey = scripts.scriptHashOutput(bcrypto.hash160(redeemScript))
assert.strictEqual(Script.fromBuffer(scriptPubKey).toASM(), f.scriptPubKey)
assert.strictEqual(Script.toASM(scriptPubKey), f.scriptPubKey)
})
})
})
@ -281,7 +283,7 @@ describe('Scripts', function () {
var scriptPubKey = scripts.nullDataOutput(data)
it('returns ' + f.scriptPubKey, function () {
assert.strictEqual(Script.fromBuffer(scriptPubKey).toASM(), f.scriptPubKey)
assert.strictEqual(Script.toASM(scriptPubKey), f.scriptPubKey)
})
})
})

6
test/transaction.js
View File

@ -20,8 +20,9 @@ describe('Transaction', function () {
if (txIn.data) {
var data = new Buffer(txIn.data, 'hex')
script = data
} else if (txIn.script) {
script = Script.fromASM(txIn.script).buffer
script = Script.compile(Script.fromASM(txIn.script))
}
tx.addInput(txHash, txIn.index, txIn.sequence, script)
@ -33,8 +34,9 @@ describe('Transaction', function () {
if (txOut.data) {
var data = new Buffer(txOut.data, 'hex')
script = data
} else if (txOut.script) {
script = Script.fromASM(txOut.script).buffer
script = Script.compile(Script.fromASM(txOut.script))
}
tx.addOutput(script, txOut.value)

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).buffer
prevTxScript = Script.compile(Script.fromASM(input.prevTxScript))
}
txb.addInput(input.txId, input.vout, input.sequence, prevTxScript)
})
f.outputs.forEach(function (output) {
var script = Script.fromASM(output.script).buffer
var script = Script.compile(Script.fromASM(output.script))
txb.addOutput(script, output.value)
})
@ -41,7 +41,7 @@ function construct (f, sign) {
var redeemScript
if (sign.redeemScript) {
redeemScript = Script.fromASM(sign.redeemScript).buffer
redeemScript = Script.compile(Script.fromASM(sign.redeemScript))
}
txb.sign(index, keyPair, redeemScript, sign.hashType)
@ -200,7 +200,7 @@ describe('TransactionBuilder', function () {
var redeemScript
if (sign.redeemScript) {
redeemScript = Script.fromASM(sign.redeemScript).buffer
redeemScript = Script.compile(Script.fromASM(sign.redeemScript))
}
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).buffer
var redeemScript = Script.compile(Script.fromASM(input.redeemScript))
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 = Script.fromBuffer(scriptSig).chunks.slice(1, -1).filter(function (x) { return x !== ops.OP_0 })
var signatures = Script.decompile(scriptSig).slice(1, -1).filter(function (x) { return x !== ops.OP_0 })
// rebuild/replace the scriptSig without them
var replacement = scripts.scriptHashInput(scripts.multisigInput(signatures), redeemScript)
assert.strictEqual(Script.fromBuffer(replacement).toASM(), sign.scriptSigFiltered)
assert.strictEqual(Script.toASM(replacement), 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(Script.fromBuffer(tx.ins[i].script).toASM(), sign.scriptSig)
assert.strictEqual(Script.toASM(tx.ins[i].script), 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').buffer
var redeemScript = Script.compile(Script.fromASM('OP_2 0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 04c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee51ae168fea63dc339a3c58419466ceaeef7f632653266d0e1236431a950cfe52a 04f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672 OP_3 OP_CHECKMULTISIG'))
var keyPair = ECPair.fromWIF('91avARGdfge8E4tZfYLoxeJ5sGBdNJQH4kvjJoQFacbgx3cTMqe', network)
txb.sign(0, keyPair, redeemScript)

Write Preview
Loading…
Cancel
Save