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

remove Script object

Browse source
This commit is contained in:
Daniel Cousens 2015-08-18 10:17:04 +10:00
parent e743c58ed6
commit e05f8a542d
11 changed files with 223 additions and 305 deletions

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

140
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)
this.buffer = buffer
this.chunks = chunks
function coerceChunks (chunks) {
return types.Array(chunks) ? chunks : decompile(chunks)
}
Script.fromASM = function (asm) {
function toASM (chunks) {
chunks = coerceChunks(chunks)
return chunks.map(function (chunk) {
// data chunk
if (Buffer.isBuffer(chunk)) {
return chunk.toString('hex')
// opcode
} else {
return reverseOps[chunk]
}
}).join(' ')
}
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)
return 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)
}
Script.fromChunks = function (chunks) {
function compile (chunks) {
typeforce(types.Array, chunks)
var bufferSize = chunks.reduce(function (accum, chunk) {
@ -93,28 +72,43 @@ 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
// attempt to read too much data? empty script
if (i + d.number > buffer.length) return []
var data = buffer.slice(i, i + d.number)
i += d.number
chunks.push(data)
// opcode
} else {
chunks.push(opcode)
i += 1
}
}
return chunks
}
var reverseOps = []
@ -123,25 +117,9 @@ for (var op in opcodes) {
reverseOps[code] = op
}
Script.prototype.toASM = function () {
return this.chunks.map(function (chunk) {
// data chunk
if (Buffer.isBuffer(chunk)) {
return chunk.toString('hex')
// opcode
} else {
return reverseOps[chunk]
}
}).join(' ')
module.exports = {
compile: compile,
decompile: decompile,
toASM: toASM,
fromASM: fromASM
}
Script.prototype.toBuffer = function () {
return this.buffer
}
Script.prototype.toHex = function () {
return this.toBuffer().toString('hex')
}
module.exports = Script

217
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)
return script.chunks.length === 2 &&
isCanonicalSignature(script.chunks[0]) &&
isCanonicalPubKey(script.chunks[1])
function coerceBuffer (buffer) {
return types.Buffer(buffer) ? buffer : Script.compile(buffer)
}
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 coerceChunks (chunks) {
return types.Array(chunks) ? chunks : Script.decompile(chunks)
}
function isPubKeyInput (script) {
typeforce(types.Buffer, script)
script = Script.fromBuffer(script)
function isPubKeyHashInput (chunks) {
chunks = coerceChunks(chunks)
return script.chunks.length === 1 &&
isCanonicalSignature(script.chunks[0])
return chunks.length === 2 &&
isCanonicalSignature(chunks[0]) &&
isCanonicalPubKey(chunks[1])
}
function isPubKeyOutput (script) {
typeforce(types.Buffer, script)
script = Script.fromBuffer(script)
function isPubKeyHashOutput (chunks) {
chunks = coerceChunks(chunks)
return script.chunks.length === 2 &&
isCanonicalPubKey(script.chunks[0]) &&
script.chunks[1] === ops.OP_CHECKSIG
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 isScriptHashInput (script, allowIncomplete) {
typeforce(types.Buffer, script)
script = Script.fromBuffer(script)
function isPubKeyInput (chunks) {
chunks = coerceChunks(chunks)
if (script.chunks.length < 2) return false
return chunks.length === 1 &&
isCanonicalSignature(chunks[0])
}
var lastChunk = script.chunks[script.chunks.length - 1]
function isPubKeyOutput (chunks) {
chunks = coerceChunks(chunks)
return chunks.length === 2 &&
isCanonicalPubKey(chunks[0]) &&
chunks[1] === ops.OP_CHECKSIG
}
function isScriptHashInput (chunks, allowIncomplete) {
chunks = coerceChunks(chunks)
if (chunks.length < 2) return false
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)
function isMultisigOutput (chunks) {
chunks = coerceChunks(chunks)
if (chunks.length < 4) return false
if (chunks[chunks.length - 1] !== ops.OP_CHECKMULTISIG) return false
if (script.chunks.length < 4) return false
if (script.chunks[script.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)
function pubKeyHashOutput (pubKeyHash) {
typeforce(typeforce.Buffer, pubKeyHash)
return Script.fromChunks([
ops.OP_DUP,
ops.OP_HASH160,
hash,
ops.OP_EQUALVERIFY,
ops.OP_CHECKSIG
]).buffer
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)
function scriptHashOutput (scriptHash) {
typeforce(typeforce.Buffer, scriptHash)
return Script.fromChunks([
ops.OP_HASH160,
hash,
ops.OP_EQUAL
]).buffer
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
function scriptHashInput (scriptSig, scriptPubKeyBuffer) {
scriptSig = coerceChunks(scriptSig)
scriptPubKeyBuffer = coerceBuffer(scriptPubKeyBuffer)
return Script.fromChunks([].concat(
scriptSigChunks,
scriptPubKey
)).buffer
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':