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

Add methods to decode information from output scripts

Browse source
This commit is contained in:
Thomas Kerin 2016-11-01 16:06:01 +01:00 • committed by Daniel Cousens
parent 53f08a7569
commit 27b48e8aa2
5 changed files with 252 additions and 82 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

240
src/script.js
View file

@ -12,6 +12,16 @@ var REVERSE_OPS = (function () {
return result
})()
var LIST_DECODE_NAMES = [
decodePubKeyOutput,
decodePubKeyHashOutput,
decodeMultisigOutput,
decodeNullDataOutput,
decodeScriptHashOutput,
decodeWitnessPubKeyHashOutput,
decodeWitnessScriptHashOutput
]
var OP_INT_BASE = OPS.OP_RESERVED // OP_1 - 1
function compile (chunks) {
@ -167,15 +177,34 @@ function isPubKeyHashInput (script) {
isCanonicalPubKey(chunks[1])
}
function isPubKeyHashOutput (script) {
var buffer = compile(script)
function decodePubKeyHashOutput (buffer, chunks) {
if (buffer.length !== 25) {
throw new Error('pub-key-hash output script is 25 bytes')
}
if (buffer[0] !== OPS.OP_DUP) {
throw new Error('PubKeyHash script missing OP_DUP')
}
if (buffer[1] !== OPS.OP_HASH160) {
throw new Error('PubKeyHash script missing OP_HASH160')
}
if (buffer[2] !== 0x14) {
throw new Error('Incorrect opcode for pubkeyhash')
}
if (buffer[23] !== OPS.OP_EQUALVERIFY) {
throw new Error('PubKeyHash script missing OP_EQUALVERIFY')
}
if (buffer[24] !== OPS.OP_CHECKSIG) {
throw new Error('PubKeyHash script missing OP_CHECKSIG')
}
return buffer.length === 25 &&
buffer[0] === OPS.OP_DUP &&
buffer[1] === OPS.OP_HASH160 &&
buffer[2] === 0x14 &&
buffer[23] === OPS.OP_EQUALVERIFY &&
buffer[24] === OPS.OP_CHECKSIG
return {
type: 'pubkeyhash',
pubKeyHash: chunks[2]
}
}
function isPubKeyHashOutput (script) {
return determinesTypeOrNonstandard([decodePubKeyHashOutput], script) === 'pubkeyhash'
}
function isPubKeyInput (script) {
@ -185,12 +214,27 @@ function isPubKeyInput (script) {
isCanonicalSignature(chunks[0])
}
function isPubKeyOutput (script) {
var chunks = decompile(script)
function decodePubKeyOutput (script, chunks) {
if (script[0] !== 0x21 && script[0] !== 0x41) {
throw new Error('Bad (or non-minimal) public key length for pub')
}
if (!isCanonicalPubKey(chunks[0])) {
throw new Error('pub-key output does not have a canonical public key')
}
if (chunks[1] !== OPS.OP_CHECKSIG) {
throw new Error('pub-key output missing OP_CHECKSIG operator')
}
if (chunks.length !== 2) {
throw new Error('pub-key output has two elements')
}
return {
type: 'pubkey',
publicKey: chunks[0]
}
}
return chunks.length === 2 &&
isCanonicalPubKey(chunks[0]) &&
chunks[1] === OPS.OP_CHECKSIG
function isPubKeyOutput (script) {
return determinesTypeOrNonstandard([decodePubKeyOutput], script) === 'pubkey'
}
function isScriptHashInput (script, allowIncomplete) {
@ -206,32 +250,69 @@ function isScriptHashInput (script, allowIncomplete) {
// is redeemScript a valid script?
if (redeemScriptChunks.length === 0) return false
return classifyInput(scriptSigChunks, allowIncomplete) === classifyOutput(redeemScriptChunks)
return classifyInput(scriptSigChunks, allowIncomplete) === classifyOutput(lastChunk)
}
function decodeScriptHashOutput (chunks) {
if (chunks[0] !== OPS.OP_HASH160) {
throw new Error()
}
if (chunks[1] !== 0x14) {
throw new Error()
}
if (chunks[22] !== OPS.OP_EQUAL) {
throw new Error()
}
return {
type: 'scripthash',
scriptHash: chunks[1]
}
}
function isScriptHashOutput (script) {
var buffer = compile(script)
return determinesTypeOrNonstandard([decodeScriptHashOutput], script) === 'scripthash'
}
return buffer.length === 23 &&
buffer[0] === OPS.OP_HASH160 &&
buffer[1] === 0x14 &&
buffer[22] === OPS.OP_EQUAL
function decodeWitnessPubKeyHashOutput (script, chunks) {
if (script.length !== 22) {
throw new Error('P2WPKH script should be 22 bytes')
}
if (script[0] !== OPS.OP_0) {
throw new Error('Missing v0 prefix for witness keyhash')
}
if (script[1] !== 0x14) {
throw new Error('Witness keyhash length marker is wrong')
}
return {
type: 'witnesspubkeyhash',
witnessKeyHash: chunks[2]
}
}
function isWitnessPubKeyHashOutput (script) {
var buffer = compile(script)
return determinesTypeOrNonstandard([decodeWitnessPubKeyHashOutput], script) === 'witnesspubkeyhash'
}
return buffer.length === 22 &&
buffer[0] === OPS.OP_0 &&
buffer[1] === 0x14
function decodeWitnessScriptHashOutput (script, chunks) {
if (script.length !== 34) {
throw new Error('P2WSH script should be 34 bytes')
}
if (script[0] !== OPS.OP_0) {
throw new Error('Missing v0 prefix for witness script hash')
}
if (script[1] !== 0x20) {
throw new Error('Witness program length marker is wrong')
}
return {
type: 'witnessscripthash',
witnessScriptHash: chunks[2]
}
}
function isWitnessScriptHashOutput (script) {
var buffer = compile(script)
return buffer.length === 34 &&
buffer[0] === OPS.OP_0 &&
buffer[1] === 0x20
return determinesTypeOrNonstandard([decodeWitnessScriptHashOutput], script) === 'witnessscripthash'
}
// allowIncomplete is to account for combining signatures
@ -250,8 +331,7 @@ function isMultisigInput (script, allowIncomplete) {
return chunks.slice(1).every(isCanonicalSignature)
}
function parseMultisigScript (scriptPubKey) {
var chunks = decompile(scriptPubKey)
function decodeMultisigOutput (scriptPubKey, chunks) {
if (chunks.length < 4) {
throw new Error('Multisig script should contain at least 4 elements')
}
@ -286,6 +366,7 @@ function parseMultisigScript (scriptPubKey) {
}
return {
type: 'multisig',
nRequiredSigs: m,
nPublicKeys: n,
publicKeyBuffers: keys
@ -293,39 +374,47 @@ function parseMultisigScript (scriptPubKey) {
}
function isMultisigOutput (script) {
try {
parseMultisigScript(script)
return true
} catch (e) {
return false
}
return determinesTypeOrNonstandard([decodeMultisigOutput], script) === 'multisig'
}
function isNullDataOutput (script) {
var chunks = decompile(script)
return chunks[0] === OPS.OP_RETURN
return determinesTypeOrNonstandard([decodeNullDataOutput], script) === 'nulldata'
}
function decodeNullDataOutput (script, chunks) {
if (script[0] !== OPS.OP_RETURN) {
throw new Error('Missing OP_RETURN at start of script')
}
return {
type: 'nulldata'
}
}
function determinesTypeOrNonstandard (functions, script) {
if (!types.Array(functions)) {
throw new Error('Must provide an array of functions to determinesTypeOrNonstandard')
}
if (!types.Buffer(script)) {
throw new Error('Must provide a script to determinesTypeOrNonstandard')
}
var decoded
var decompiled = decompile(script)
var type = 'nonstandard'
for (var i = 0; i < functions.length && type === 'nonstandard'; i++) {
try {
decoded = functions[i](script, decompiled)
type = decoded.type
} catch (e) {
}
}
return type
}
function classifyOutput (script) {
var chunks = decompile(script)
if (isWitnessPubKeyHashOutput(chunks)) {
return 'witnesspubkeyhash'
} else if (isWitnessScriptHashOutput(chunks)) {
return 'witnessscripthash'
} else if (isPubKeyHashOutput(chunks)) {
return 'pubkeyhash'
} else if (isScriptHashOutput(chunks)) {
return 'scripthash'
} else if (isMultisigOutput(chunks)) {
return 'multisig'
} else if (isPubKeyOutput(chunks)) {
return 'pubkey'
} else if (isNullDataOutput(chunks)) {
return 'nulldata'
}
return 'nonstandard'
return determinesTypeOrNonstandard(LIST_DECODE_NAMES, script)
}
function classifyInput (script, allowIncomplete) {
@ -426,7 +515,7 @@ function witnessScriptHashInput (scriptSig, scriptPubKey) {
// OP_0 [signatures ...]
function multisigInput (signatures, scriptPubKey) {
if (scriptPubKey) {
var scriptData = parseMultisigScript(scriptPubKey)
var scriptData = decodeMultisigOutput(scriptPubKey, decompile(scriptPubKey))
if (signatures.length < scriptData.nRequiredSigs) throw new Error('Not enough signatures provided')
if (signatures.length > scriptData.nPublicKeys) throw new Error('Too many signatures provided')
}
@ -449,32 +538,41 @@ module.exports = {
isCanonicalPubKey: isCanonicalPubKey,
isCanonicalSignature: isCanonicalSignature,
isDefinedHashType: isDefinedHashType,
isPubKeyHashInput: isPubKeyHashInput,
isPubKeyHashOutput: isPubKeyHashOutput,
isPubKeyInput: isPubKeyInput,
decodePubKeyOutput: decodePubKeyOutput,
decodePubKeyHashOutput: decodePubKeyHashOutput,
decodeMultisigOutput: decodeMultisigOutput,
decodeScriptHashOutput: decodeScriptHashOutput,
decodeNullDataOutput: decodeNullDataOutput,
decodeWitnessPubKeyHashOutput: decodeWitnessPubKeyHashOutput,
decodeWitnessScriptHashOutput: decodeWitnessScriptHashOutput,
isPubKeyOutput: isPubKeyOutput,
isScriptHashInput: isScriptHashInput,
isPubKeyHashOutput: isPubKeyHashOutput,
isMultisigOutput: isMultisigOutput,
isScriptHashOutput: isScriptHashOutput,
isNullDataOutput: isNullDataOutput,
isWitnessPubKeyHashOutput: isWitnessPubKeyHashOutput,
isWitnessScriptHashOutput: isWitnessScriptHashOutput,
isMultisigInput: isMultisigInput,
isMultisigOutput: isMultisigOutput,
isNullDataOutput: isNullDataOutput,
parseMultisigScript: parseMultisigScript,
classifyOutput: classifyOutput,
isPubKeyInput: isPubKeyInput,
isPubKeyHashInput: isPubKeyHashInput,
isMultisigInput: isMultisigInput,
isScriptHashInput: isScriptHashInput,
classifyInput: classifyInput,
pubKeyOutput: pubKeyOutput,
pubKeyHashOutput: pubKeyHashOutput,
multisigOutput: multisigOutput,
scriptHashOutput: scriptHashOutput,
nullDataOutput: nullDataOutput,
witnessPubKeyHashOutput: witnessPubKeyHashOutput,
witnessScriptHashInput: witnessScriptHashInput,
witnessScriptHashOutput: witnessScriptHashOutput,
multisigOutput: multisigOutput,
pubKeyInput: pubKeyInput,
pubKeyHashInput: pubKeyHashInput,
scriptHashInput: scriptHashInput,
multisigInput: multisigInput,
nullDataOutput: nullDataOutput
scriptHashInput: scriptHashInput,
witnessScriptHashInput: witnessScriptHashInput
}

2
src/transaction_builder.js
View file

@ -108,7 +108,7 @@ function expandOutput (script, scriptType, ourPubKey) {
var scriptChunks = bscript.decompile(script)
if (!scriptType) {
scriptType = bscript.classifyOutput(scriptChunks)
scriptType = bscript.classifyOutput(script)
}
var pubKeys = []

9
test/address.js
View file

@ -36,15 +36,6 @@ describe('address', function () {
})
})
fixtures.valid.forEach(function (f) {
it('parses (as chunks) ' + f.script.slice(0, 30) + '... (' + f.network + ')', function () {
var chunks = bscript.decompile(bscript.fromASM(f.script))
var address = baddress.fromOutputScript(chunks, networks[f.network])
assert.strictEqual(address, f.base58check)
})
})
fixtures.invalid.fromOutputScript.forEach(function (f) {
it('throws when ' + f.script.slice(0, 30) + '... ' + f.exception, function () {
var script = bscript.fromASM(f.script)

72
test/fixtures/script.json vendored
View file

@ -226,18 +226,90 @@
{
"description": "non-canonical pubkey (too long)",
"scriptPubKey": "02359c6e3f04cefbf089cf1d6670dc47c3fb4df68e2bad1fa5a369f9ce4b42bbd1ffffff OP_CHECKSIG"
},
{
"description": "last operator is wrong for pubkey-output",
"scriptPubKeyHex": "21027a71801ab59336de37785c50005b6abd8ea859eecce1edbe8e81afa74ee5c752ae"
},
{
"description": "missing OP_CHECKSIG",
"scriptPubKeyHex": "21027a71801ab59336de37785c50005b6abd8ea859eecce1edbe8e81afa74ee5c752"
},
{
"description": "non-canonical pubkey (bad prefix)",
"scriptPubKey": "427a71801ab59336de37785c50005b6abd8ea859eecce1edbe8e81afa74ee5c752 OP_CHECKSIG"
},
{
"description": "has extra opcode at the end isPubKeyOutput",
"scriptPubKey": "027a71801ab59336de37785c50005b6abd8ea859eecce1edbe8e81afa74ee5c752 OP_CHECKSIG OP_0"
}
],
"isPubKeyHashOutput": [
{
"description": "non-minimal encoded isPubKeyHashOutput (non BIP62 compliant)",
"scriptPubKeyHex": "76a94c14aa4d7985c57e011a8b3dd8e0e5a73aaef41629c588ac"
},
{
"description": "bad OP_DUP isPubKeyHashOutput",
"scriptPubKeyHex": "aca914aa4d7985c57e011a8b3dd8e0e5a73aaef41629c588ac"
},
{
"description": "bad OP_HASH160 isPubKeyHashOutput",
"scriptPubKeyHex": "76ac14aa4d7985c57e011a8b3dd8e0e5a73aaef41629c588ac"
},
{
"description": "bad OP_EQUALVERIFY isPubKeyHashOutput",
"scriptPubKeyHex": "76a914aa4d7985c57e011a8b3dd8e0e5a73aaef41629c5acac"
},
{
"description": "bad OP_CHECKSIG isPubKeyHashOutput",
"scriptPubKeyHex": "76a914aa4d7985c57e011a8b3dd8e0e5a73aaef41629c58888"
},
{
"description": "bad length isPubKeyHashOutput",
"scriptPubKeyHex": "76a920aa4d7985c57e011a8b3dd8e0e5a73aaef41629c588ac"
},
{
"description": "has something at the end isPubKeyHashOutput",
"scriptPubKeyHex": "76a920aa4d7985c57e011a8b3dd8e0e5a73aaef41629c588ac00"
}
],
"isScriptHashOutput": [
{
"description": "non-minimal encoded isScriptHashOutput (non BIP62 compliant)",
"scriptPubKeyHex": "a94c14c286a1af0947f58d1ad787385b1c2c4a976f9e7187"
},
{
"description": "wrong OP_HASH160 opcode",
"scriptPubKeyHex": "ac4c14c286a1af0947f58d1ad787385b1c2c4a976f9e7187"
},
{
"description": "wrong length marker",
"scriptPubKeyHex": "a916c286a1af0947f58d1ad787385b1c2c4a976f9e7187"
},
{
"description": "wrong OP_EQUAL opcode",
"scriptPubKeyHex": "a914c286a1af0947f58d1ad787385b1c2c4a976f9e7188"
}
],
"isWitnessPubKeyHashOutput": [
{
"description": "wrong version",
"scriptPubKeyHex": "51149090909090909090909090909090909090909090"
},
{
"description": "wrong length marker",
"scriptPubKeyHex": "00209090909090909090909090909090909090909090"
}
],
"isWitnessScriptHashOutput": [
{
"description": "wrong version",
"scriptPubKeyHex": "51209090909090909090909090909090909090909090909090909090909090909090"
},
{
"description": "wrong length marker",
"scriptPubKeyHex": "00219090909090909090909090909090909090909090909090909090909090909090"
}
],
"isMultisigOutput": [

11
test/script.js
View file

@ -10,7 +10,16 @@ var fixtures = require('./fixtures/script.json')
describe('script', function () {
// TODO
describe.skip('isCanonicalPubKey', function () {})
describe('isCanonicalPubKey', function () {
it('rejects if not provided a Buffer', function () {
assert.strictEqual(false, bscript.isCanonicalPubKey(0))
})
it('rejects smaller than 33', function () {
for (var i = 0; i < 33; i++) {
assert.strictEqual(false, bscript.isCanonicalPubKey(new Buffer('', i)))
}
})
})
describe.skip('isCanonicalSignature', function () {})
describe('fromASM/toASM', function () {