560 lines
10 KiB
JavaScript
560 lines
10 KiB
JavaScript
/*!
|
|
* witness.js - witness object for bcoin
|
|
* Copyright (c) 2014-2015, Fedor Indutny (MIT License)
|
|
* Copyright (c) 2014-2017, Christopher Jeffrey (MIT License).
|
|
* https://github.com/bcoin-org/bcoin
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
const assert = require('bsert');
|
|
const bio = require('bufio');
|
|
const Script = require('./script');
|
|
const common = require('./common');
|
|
const Address = require('../primitives/address');
|
|
const Stack = require('./stack');
|
|
const {encoding} = bio;
|
|
const scriptTypes = common.types;
|
|
const {inspectSymbol} = require('../utils');
|
|
|
|
/**
|
|
* Witness
|
|
* Refers to the witness vector of
|
|
* segregated witness transactions.
|
|
* @alias module:script.Witness
|
|
* @extends Stack
|
|
* @property {Buffer[]} items
|
|
* @property {Script?} redeem
|
|
* @property {Number} length
|
|
*/
|
|
|
|
class Witness extends Stack {
|
|
/**
|
|
* Create a witness.
|
|
* @alias module:script.Witness
|
|
* @constructor
|
|
* @param {Buffer[]|Object} items - Array of
|
|
* stack items.
|
|
* @property {Buffer[]} items
|
|
* @property {Script?} redeem
|
|
* @property {Number} length
|
|
*/
|
|
|
|
constructor(options) {
|
|
super();
|
|
|
|
if (options)
|
|
this.fromOptions(options);
|
|
}
|
|
|
|
/**
|
|
* Inject properties from options object.
|
|
* @private
|
|
* @param {Object} options
|
|
*/
|
|
|
|
fromOptions(options) {
|
|
assert(options, 'Witness data is required.');
|
|
|
|
if (Array.isArray(options))
|
|
return this.fromArray(options);
|
|
|
|
if (options.items)
|
|
return this.fromArray(options.items);
|
|
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Instantiate witness from options.
|
|
* @param {Object} options
|
|
* @returns {Witness}
|
|
*/
|
|
|
|
static fromOptions(options) {
|
|
return new this().fromOptions(options);
|
|
}
|
|
|
|
/**
|
|
* Convert witness to an array of buffers.
|
|
* @returns {Buffer[]}
|
|
*/
|
|
|
|
toArray() {
|
|
return this.items.slice();
|
|
}
|
|
|
|
/**
|
|
* Inject properties from an array of buffers.
|
|
* @private
|
|
* @param {Buffer[]} items
|
|
*/
|
|
|
|
fromArray(items) {
|
|
assert(Array.isArray(items));
|
|
this.items = items;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Insantiate witness from an array of buffers.
|
|
* @param {Buffer[]} items
|
|
* @returns {Witness}
|
|
*/
|
|
|
|
static fromArray(items) {
|
|
return new this().fromArray(items);
|
|
}
|
|
|
|
/**
|
|
* Convert witness to an array of buffers.
|
|
* @returns {Buffer[]}
|
|
*/
|
|
|
|
toItems() {
|
|
return this.items.slice();
|
|
}
|
|
|
|
/**
|
|
* Inject properties from an array of buffers.
|
|
* @private
|
|
* @param {Buffer[]} items
|
|
*/
|
|
|
|
fromItems(items) {
|
|
assert(Array.isArray(items));
|
|
this.items = items;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Insantiate witness from an array of buffers.
|
|
* @param {Buffer[]} items
|
|
* @returns {Witness}
|
|
*/
|
|
|
|
static fromItems(items) {
|
|
return new this().fromItems(items);
|
|
}
|
|
|
|
/**
|
|
* Convert witness to a stack.
|
|
* @returns {Stack}
|
|
*/
|
|
|
|
toStack() {
|
|
return new Stack(this.toArray());
|
|
}
|
|
|
|
/**
|
|
* Inject properties from a stack.
|
|
* @private
|
|
* @param {Stack} stack
|
|
*/
|
|
|
|
fromStack(stack) {
|
|
return this.fromArray(stack.items);
|
|
}
|
|
|
|
/**
|
|
* Insantiate witness from a stack.
|
|
* @param {Stack} stack
|
|
* @returns {Witness}
|
|
*/
|
|
|
|
static fromStack(stack) {
|
|
return new this().fromStack(stack);
|
|
}
|
|
|
|
/**
|
|
* Inspect a Witness object.
|
|
* @returns {String} Human-readable script.
|
|
*/
|
|
|
|
[inspectSymbol]() {
|
|
return `<Witness: ${this.toString()}>`;
|
|
}
|
|
|
|
/**
|
|
* Clone the witness object.
|
|
* @returns {Witness} A clone of the current witness object.
|
|
*/
|
|
|
|
clone() {
|
|
return new this.constructor().inject(this);
|
|
}
|
|
|
|
/**
|
|
* Inject properties from witness.
|
|
* Used for cloning.
|
|
* @private
|
|
* @param {Witness} witness
|
|
* @returns {Witness}
|
|
*/
|
|
|
|
inject(witness) {
|
|
this.items = witness.items.slice();
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Compile witness (NOP).
|
|
* @returns {Witness}
|
|
*/
|
|
|
|
compile() {
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* "Guess" the type of the witness.
|
|
* This method is not 100% reliable.
|
|
* @returns {ScriptType}
|
|
*/
|
|
|
|
getInputType() {
|
|
if (this.isPubkeyhashInput())
|
|
return scriptTypes.WITNESSPUBKEYHASH;
|
|
|
|
if (this.isScripthashInput())
|
|
return scriptTypes.WITNESSSCRIPTHASH;
|
|
|
|
return scriptTypes.NONSTANDARD;
|
|
}
|
|
|
|
/**
|
|
* "Guess" the address of the witness.
|
|
* This method is not 100% reliable.
|
|
* @returns {Address|null}
|
|
*/
|
|
|
|
getInputAddress() {
|
|
return Address.fromWitness(this);
|
|
}
|
|
|
|
/**
|
|
* "Test" whether the witness is a pubkey input.
|
|
* Always returns false.
|
|
* @returns {Boolean}
|
|
*/
|
|
|
|
isPubkeyInput() {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Get P2PK signature if present.
|
|
* Always returns null.
|
|
* @returns {Buffer|null}
|
|
*/
|
|
|
|
getPubkeyInput() {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* "Guess" whether the witness is a pubkeyhash input.
|
|
* This method is not 100% reliable.
|
|
* @returns {Boolean}
|
|
*/
|
|
|
|
isPubkeyhashInput() {
|
|
return this.items.length === 2
|
|
&& common.isSignatureEncoding(this.items[0])
|
|
&& common.isKeyEncoding(this.items[1]);
|
|
}
|
|
|
|
/**
|
|
* Get P2PKH signature and key if present.
|
|
* @returns {Array} [sig, key]
|
|
*/
|
|
|
|
getPubkeyhashInput() {
|
|
if (!this.isPubkeyhashInput())
|
|
return [null, null];
|
|
return [this.items[0], this.items[1]];
|
|
}
|
|
|
|
/**
|
|
* "Test" whether the witness is a multisig input.
|
|
* Always returns false.
|
|
* @returns {Boolean}
|
|
*/
|
|
|
|
isMultisigInput() {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Get multisig signatures key if present.
|
|
* Always returns null.
|
|
* @returns {Buffer[]|null}
|
|
*/
|
|
|
|
getMultisigInput() {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* "Guess" whether the witness is a scripthash input.
|
|
* This method is not 100% reliable.
|
|
* @returns {Boolean}
|
|
*/
|
|
|
|
isScripthashInput() {
|
|
return this.items.length > 0 && !this.isPubkeyhashInput();
|
|
}
|
|
|
|
/**
|
|
* Get P2SH redeem script if present.
|
|
* @returns {Buffer|null}
|
|
*/
|
|
|
|
getScripthashInput() {
|
|
if (!this.isScripthashInput())
|
|
return null;
|
|
return this.items[this.items.length - 1];
|
|
}
|
|
|
|
/**
|
|
* "Guess" whether the witness is an unknown/non-standard type.
|
|
* This method is not 100% reliable.
|
|
* @returns {Boolean}
|
|
*/
|
|
|
|
isUnknownInput() {
|
|
return this.getInputType() === scriptTypes.NONSTANDARD;
|
|
}
|
|
|
|
/**
|
|
* Test the witness against a bloom filter.
|
|
* @param {Bloom} filter
|
|
* @returns {Boolean}
|
|
*/
|
|
|
|
test(filter) {
|
|
for (const item of this.items) {
|
|
if (item.length === 0)
|
|
continue;
|
|
|
|
if (filter.test(item))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Grab and deserialize the redeem script from the witness.
|
|
* @returns {Script} Redeem script.
|
|
*/
|
|
|
|
getRedeem() {
|
|
if (this.items.length === 0)
|
|
return null;
|
|
|
|
const redeem = this.items[this.items.length - 1];
|
|
|
|
if (!redeem)
|
|
return null;
|
|
|
|
return Script.fromRaw(redeem);
|
|
}
|
|
|
|
/**
|
|
* Find a data element in a witness.
|
|
* @param {Buffer} data - Data element to match against.
|
|
* @returns {Number} Index (`-1` if not present).
|
|
*/
|
|
|
|
indexOf(data) {
|
|
for (let i = 0; i < this.items.length; i++) {
|
|
const item = this.items[i];
|
|
if (item.equals(data))
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Calculate size of the witness
|
|
* excluding the varint size bytes.
|
|
* @returns {Number}
|
|
*/
|
|
|
|
getSize() {
|
|
let size = 0;
|
|
|
|
for (const item of this.items)
|
|
size += encoding.sizeVarBytes(item);
|
|
|
|
return size;
|
|
}
|
|
|
|
/**
|
|
* Calculate size of the witness
|
|
* including the varint size bytes.
|
|
* @returns {Number}
|
|
*/
|
|
|
|
getVarSize() {
|
|
return encoding.sizeVarint(this.items.length) + this.getSize();
|
|
}
|
|
|
|
/**
|
|
* Write witness to a buffer writer.
|
|
* @param {BufferWriter} bw
|
|
*/
|
|
|
|
toWriter(bw) {
|
|
bw.writeVarint(this.items.length);
|
|
|
|
for (const item of this.items)
|
|
bw.writeVarBytes(item);
|
|
|
|
return bw;
|
|
}
|
|
|
|
/**
|
|
* Encode the witness to a Buffer.
|
|
* @param {String} enc - Encoding, either `'hex'` or `null`.
|
|
* @returns {Buffer|String} Serialized script.
|
|
*/
|
|
|
|
toRaw() {
|
|
const size = this.getVarSize();
|
|
return this.toWriter(bio.write(size)).render();
|
|
}
|
|
|
|
/**
|
|
* Convert witness to a hex string.
|
|
* @returns {String}
|
|
*/
|
|
|
|
toJSON() {
|
|
return this.toRaw().toString('hex');
|
|
}
|
|
|
|
/**
|
|
* Inject properties from json object.
|
|
* @private
|
|
* @param {String} json
|
|
*/
|
|
|
|
fromJSON(json) {
|
|
assert(typeof json === 'string', 'Witness must be a string.');
|
|
return this.fromRaw(Buffer.from(json, 'hex'));
|
|
}
|
|
|
|
/**
|
|
* Insantiate witness from a hex string.
|
|
* @param {String} json
|
|
* @returns {Witness}
|
|
*/
|
|
|
|
static fromJSON(json) {
|
|
return new this().fromJSON(json);
|
|
}
|
|
|
|
/**
|
|
* Inject properties from buffer reader.
|
|
* @private
|
|
* @param {BufferReader} br
|
|
*/
|
|
|
|
fromReader(br) {
|
|
const count = br.readVarint();
|
|
|
|
for (let i = 0; i < count; i++)
|
|
this.items.push(br.readVarBytes());
|
|
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Inject properties from serialized data.
|
|
* @private
|
|
* @param {Buffer} data
|
|
*/
|
|
|
|
fromRaw(data) {
|
|
return this.fromReader(bio.read(data));
|
|
}
|
|
|
|
/**
|
|
* Create a witness from a buffer reader.
|
|
* @param {BufferReader} br
|
|
*/
|
|
|
|
static fromReader(br) {
|
|
return new this().fromReader(br);
|
|
}
|
|
|
|
/**
|
|
* Create a witness from a serialized buffer.
|
|
* @param {Buffer|String} data - Serialized witness.
|
|
* @param {String?} enc - Either `"hex"` or `null`.
|
|
* @returns {Witness}
|
|
*/
|
|
|
|
static fromRaw(data, enc) {
|
|
if (typeof data === 'string')
|
|
data = Buffer.from(data, enc);
|
|
return new this().fromRaw(data);
|
|
}
|
|
|
|
/**
|
|
* Inject items from string.
|
|
* @private
|
|
* @param {String|String[]} items
|
|
*/
|
|
|
|
fromString(items) {
|
|
if (!Array.isArray(items)) {
|
|
assert(typeof items === 'string');
|
|
|
|
items = items.trim();
|
|
|
|
if (items.length === 0)
|
|
return this;
|
|
|
|
items = items.split(/\s+/);
|
|
}
|
|
|
|
for (const item of items)
|
|
this.items.push(Buffer.from(item, 'hex'));
|
|
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Parse a test script/array
|
|
* string into a witness object. _Must_
|
|
* contain only stack items (no non-push
|
|
* opcodes).
|
|
* @param {String|String[]} items - Script string.
|
|
* @returns {Witness}
|
|
* @throws Parse error.
|
|
*/
|
|
|
|
static fromString(items) {
|
|
return new this().fromString(items);
|
|
}
|
|
|
|
/**
|
|
* Test an object to see if it is a Witness.
|
|
* @param {Object} obj
|
|
* @returns {Boolean}
|
|
*/
|
|
|
|
static isWitness(obj) {
|
|
return obj instanceof Witness;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Expose
|
|
*/
|
|
|
|
module.exports = Witness;
|