hsd
Version:
Cryptocurrency bike-shed
2,097 lines (1,642 loc) • 49.3 kB
JavaScript
/*!
* tx.js - transaction object for hsd
* Copyright (c) 2017-2018, Christopher Jeffrey (MIT License).
* https://github.com/handshake-org/hsd
*/
'use strict';
const assert = require('bsert');
const bio = require('bufio');
const blake2b = require('bcrypto/lib/blake2b');
const secp256k1 = require('bcrypto/lib/secp256k1');
const {BufferSet} = require('buffer-map');
const util = require('../utils/util');
const Amount = require('../ui/amount');
const Network = require('../protocol/network');
const Script = require('../script/script');
const Input = require('./input');
const Output = require('./output');
const Outpoint = require('./outpoint');
const rules = require('../covenants/rules');
const InvItem = require('./invitem');
const consensus = require('../protocol/consensus');
const policy = require('../protocol/policy');
const ScriptError = require('../script/scripterror');
const {OwnershipProof} = require('../covenants/ownership');
const AirdropProof = require('../primitives/airdropproof');
const {encoding} = bio;
const {hashType} = Script;
/** @typedef {import('@handshake-org/bfilter').BloomFilter} BloomFilter */
/** @typedef {import('../types').SighashType} SighashType */
/** @typedef {import('../types').Hash} Hash */
/** @typedef {import('../types').Amount} AmountValue */
/** @typedef {import('../types').Rate} Rate */
/** @typedef {import('../types').VerifyFlags} VerifyFlags */
/** @typedef {import('../types').HexHash} HexHash */
/** @typedef {import('../types').BufioWriter} BufioWriter */
/** @typedef {import('../blockchain/chainentry')} ChainEntry */
/** @typedef {import('../covenants/ownership').OwnershipProof} OwnershipProof */
/** @typedef {import('../workers/workerpool')} WorkerPool */
/** @typedef {import('../coins/coinview')} CoinView */
/** @typedef {import('./covenant')} Covenant */
/** @typedef {import('./coin')} Coin */
/** @typedef {import('./address')} Address */
/**
* TX
* A static transaction object.
* @alias module:primitives.TX
* @property {Number} version
* @property {Input[]} inputs
* @property {Output[]} outputs
* @property {Number} locktime
*/
class TX extends bio.Struct {
/**
* Create a transaction.
* @constructor
* @param {Object?} [options]
*/
constructor(options) {
super();
this.version = 0;
/** @type {Input[]} */
this.inputs = [];
/** @type {Output[]} */
this.outputs = [];
this.locktime = 0;
this.mutable = false;
/** @type {Hash?} */
this._hash = null;
/** @type {Hash?} */
this._wdhash = null;
/** @type {Hash?} */
this._whash = null;
/** @type {Buffer?} */
this._raw = null;
/** @type {Sizes?} */
this._sizes = null;
/** @type {Hash?} */
this._hashPrevouts = null;
/** @type {Hash?} */
this._hashSequence = null;
/** @type {Hash?} */
this._hashOutputs = null;
if (options)
this.fromOptions(options);
}
/**
* Inject properties from options object.
* @param {Object} options
*/
fromOptions(options) {
assert(options, 'TX data is required.');
if (options.version != null) {
assert((options.version >>> 0) === options.version,
'Version must be a uint32.');
this.version = options.version;
}
if (options.inputs) {
assert(Array.isArray(options.inputs), 'Inputs must be an array.');
for (const input of options.inputs)
this.inputs.push(new Input(input));
}
if (options.outputs) {
assert(Array.isArray(options.outputs), 'Outputs must be an array.');
for (const output of options.outputs)
this.outputs.push(new Output(output));
}
if (options.locktime != null) {
assert((options.locktime >>> 0) === options.locktime,
'Locktime must be a uint32.');
this.locktime = options.locktime;
}
return this;
}
/**
* Inject properties from tx.
* Used for cloning.
* @param {this} tx
* @returns {this}
*/
inject(tx) {
this.version = tx.version;
for (const input of tx.inputs)
this.inputs.push(input.clone());
for (const output of tx.outputs)
this.outputs.push(output.clone());
this.locktime = tx.locktime;
return this;
}
/**
* Clear any cached values.
*/
refresh() {
this._hash = null;
this._wdhash = null;
this._whash = null;
this._raw = null;
this._sizes = null;
this._hashPrevouts = null;
this._hashSequence = null;
this._hashOutputs = null;
return this;
}
/**
* Hash the transaction with the non-witness serialization.
* @returns {Hash}
*/
hash() {
if (this.mutable)
return this.left();
if (!this._hash)
this._hash = this.left();
return this._hash;
}
/**
* Hash the transaction with the witness
* serialization, return the wtxid (normal
* hash if no witness is present, all zeroes
* if coinbase).
* @returns {Hash} hash
*/
witnessHash() {
if (this.mutable)
return this.root();
if (!this._whash)
this._whash = this.root();
return this._whash;
}
/**
* Calculate the virtual size of the transaction.
* Note that this is cached.
* @returns {Number} vsize
*/
getVirtualSize() {
const scale = consensus.WITNESS_SCALE_FACTOR;
return (this.getWeight() + scale - 1) / scale | 0;
}
/**
* Calculate the virtual size of the transaction
* (weighted against bytes per sigop cost).
* @param {Number} sigops - Sigops cost.
* @returns {Number} vsize
*/
getSigopsSize(sigops) {
const scale = consensus.WITNESS_SCALE_FACTOR;
const bytes = policy.BYTES_PER_SIGOP;
const weight = Math.max(this.getWeight(), sigops * bytes);
return (weight + scale - 1) / scale | 0;
}
/**
* Calculate the weight of the transaction.
* Note that this is cached.
* @returns {Number} weight
*/
getWeight() {
const sizes = this.getSizes();
return sizes.getWeight();
}
/**
* Calculate the real size of the transaction
* with the witness included.
* @returns {Number} size
*/
getSize() {
const {base, witness} = this.getSizes();
return base + witness;
}
/**
* Calculate the size of the transaction
* without the witness.
* with the witness included.
* @returns {Number} size
*/
getBaseSize() {
const {base} = this.getSizes();
return base;
}
/**
* Test whether the transaction has a non-empty witness.
* @returns {Boolean}
*/
hasWitness() {
for (const {witness} of this.inputs) {
if (witness.items.length > 0)
return true;
}
return false;
}
/**
* Get the signature hash of the transaction for signing verifying.
* @param {Number} index - Index of input being signed/verified.
* @param {Script} prev - Previous output script or redeem script
* (in the case of witnesspubkeyhash, this should be the generated
* p2pkh script).
* @param {AmountValue} value - Previous output value.
* @param {SighashType} type - Sighash type.
* @returns {Buffer} Signature hash.
*/
signatureHash(index, prev, value, type) {
assert(index >= 0 && index < this.inputs.length);
assert(prev instanceof Script);
assert(typeof value === 'number');
assert(typeof type === 'number');
let input = this.inputs[index];
let prevouts = consensus.ZERO_HASH;
let sequences = consensus.ZERO_HASH;
let outputs = consensus.ZERO_HASH;
// SIGHASH_NOINPUT does not commit to "this input's data", meaning the
// outpoint and sequence of this input (only this input) is malleable.
// However, our implementation neglects to also nullify the `prevouts`
// and `sequences` values as specified in the original SIGHASH_NOINPUT BIP
// https://blockstream.com/eltoo.pdf (appendix A).
// This means that our NOINPUT is not useful by itself, because even though
// it removes this input's outpoint from one part of the signed data, it
// leaves it in place in a different part, so it is still committed to by
// the signature.
// Note that eltoo's NOINPUT and it's successor BIP-118 also make committing
// to the witness script optional (in our code that value is called `prev`).
if (type & hashType.NOINPUT)
input = new Input();
if (!(type & hashType.ANYONECANPAY)) {
if (this._hashPrevouts) {
prevouts = this._hashPrevouts;
} else {
const bw = bio.pool(this.inputs.length * 36);
for (const input of this.inputs)
input.prevout.write(bw);
prevouts = blake2b.digest(bw.render());
if (!this.mutable)
this._hashPrevouts = prevouts;
}
}
if (!(type & hashType.ANYONECANPAY)
&& (type & 0x1f) !== hashType.SINGLE
&& (type & 0x1f) !== hashType.SINGLEREVERSE
&& (type & 0x1f) !== hashType.NONE) {
if (this._hashSequence) {
sequences = this._hashSequence;
} else {
const bw = bio.pool(this.inputs.length * 4);
for (const input of this.inputs)
bw.writeU32(input.sequence);
sequences = blake2b.digest(bw.render());
if (!this.mutable)
this._hashSequence = sequences;
}
}
if ((type & 0x1f) !== hashType.SINGLE
&& (type & 0x1f) !== hashType.SINGLEREVERSE
&& (type & 0x1f) !== hashType.NONE) {
if (this._hashOutputs) {
outputs = this._hashOutputs;
} else {
let size = 0;
for (const output of this.outputs)
size += output.getSize();
const bw = bio.pool(size);
for (const output of this.outputs)
output.write(bw);
outputs = blake2b.digest(bw.render());
if (!this.mutable)
this._hashOutputs = outputs;
}
} else if ((type & 0x1f) === hashType.SINGLE) {
if (index < this.outputs.length) {
const output = this.outputs[index];
outputs = blake2b.digest(output.encode());
}
} else if ((type & 0x1f) === hashType.SINGLEREVERSE) {
if (index < this.outputs.length) {
const output = this.outputs[(this.outputs.length - 1) - index];
outputs = blake2b.digest(output.encode());
}
}
const size = 156 + prev.getVarSize();
const bw = bio.pool(size);
bw.writeU32(this.version);
bw.writeBytes(prevouts);
bw.writeBytes(sequences);
bw.writeHash(input.prevout.hash);
bw.writeU32(input.prevout.index);
bw.writeVarBytes(prev.encode());
bw.writeU64(value);
bw.writeU32(input.sequence);
bw.writeBytes(outputs);
bw.writeU32(this.locktime);
bw.writeU32(type);
return blake2b.digest(bw.render());
}
/**
* Verify signature.
* @param {Number} index
* @param {Script} prev
* @param {AmountValue} value
* @param {Buffer} sig
* @param {Buffer} key
* @returns {Boolean}
*/
checksig(index, prev, value, sig, key) {
if (sig.length === 0)
return false;
const type = sig[sig.length - 1];
const hash = this.signatureHash(index, prev, value, type);
return secp256k1.verify(hash, sig.slice(0, -1), key);
}
/**
* Create a signature suitable for inserting into scriptSigs/witnesses.
* @param {Number} index - Index of input being signed.
* @param {Script} prev - Previous output script or redeem script
* (in the case of witnesspubkeyhash, this should be the generated
* p2pkh script).
* @param {AmountValue} value - Previous output value.
* @param {Buffer} key
* @param {SighashType} type
* @returns {Buffer} Signature in DER format.
*/
signature(index, prev, value, key, type) {
if (type == null)
type = hashType.ALL;
const hash = this.signatureHash(index, prev, value, type);
const sig = secp256k1.sign(hash, key);
const bw = bio.write(65);
bw.writeBytes(sig);
bw.writeU8(type);
return bw.render();
}
/**
* Verify all transaction inputs.
* @param {CoinView} view
* @param {VerifyFlags?} [flags=STANDARD_VERIFY_FLAGS]
* @throws {ScriptError} on invalid inputs
*/
check(view, flags) {
if (this.inputs.length === 0)
throw new ScriptError('UNKNOWN_ERROR', 'No inputs.');
if (this.isCoinbase()) {
for (let i = 1; i < this.inputs.length; i++) {
const {witness} = this.inputs[i];
if (witness.items.length !== 1)
throw new ScriptError('UNKNOWN_ERROR', 'Invalid claim proof.');
if (i >= this.outputs.length)
throw new ScriptError('UNKNOWN_ERROR', 'Invalid claim proof.');
const output = this.outputs[i];
if (!output.covenant.isClaim()) {
assert(output.covenant.isNone());
let proof;
try {
proof = AirdropProof.decode(witness.items[0]);
} catch (e) {
throw new ScriptError('UNKNOWN_ERROR', 'Invalid airdrop proof.');
}
if (!proof.isSane())
throw new ScriptError('UNKNOWN_ERROR', 'Non-sane airdrop proof.');
if (!proof.verify()) {
throw new ScriptError('UNKNOWN_ERROR',
'Invalid airdrop signature.');
}
if (output.value !== proof.getValue() - proof.fee
|| output.address.version !== proof.version
|| !output.address.hash.equals(proof.address)) {
throw new ScriptError('UNKNOWN_ERROR', 'Invalid airdrop output.');
}
continue;
}
/** @type {OwnershipProof} */
let proof;
try {
proof = OwnershipProof.decode(witness.items[0]);
} catch (e) {
throw new ScriptError('UNKNOWN_ERROR', 'Invalid claim proof.');
}
if (!proof.isSane())
throw new ScriptError('UNKNOWN_ERROR', 'Non-sane claim proof.');
if (!proof.verifySignatures())
throw new ScriptError('UNKNOWN_ERROR', 'Invalid claim signatures.');
}
return;
}
for (let i = 0; i < this.inputs.length; i++) {
const {prevout} = this.inputs[i];
const coin = view.getOutput(prevout);
if (!coin)
throw new ScriptError('UNKNOWN_ERROR', 'No coin available.');
this.checkInput(i, coin, flags);
}
}
/**
* Verify a transaction input.
* @param {Number} index - Index of output being
* verified.
* @param {Coin|Output} coin - Previous output.
* @param {VerifyFlags} [flags=STANDARD_VERIFY_FLAGS]
* @throws {ScriptError} on invalid input
*/
checkInput(index, coin, flags) {
const input = this.inputs[index];
assert(input, 'Input does not exist.');
assert(coin, 'No coin passed.');
Script.verify(
input.witness,
coin.address,
this,
index,
coin.value,
flags
);
}
/**
* Verify the transaction inputs on the worker pool
* (if workers are enabled).
* @param {CoinView} view
* @param {VerifyFlags?} [flags=STANDARD_VERIFY_FLAGS]
* @param {WorkerPool?} [pool]
* @returns {Promise}
*/
async checkAsync(view, flags, pool) {
if (this.inputs.length === 0)
throw new ScriptError('UNKNOWN_ERROR', 'No inputs.');
if (!pool) {
this.check(view, flags);
return undefined;
}
return pool.check(this, view, flags);
}
/**
* Verify a transaction input asynchronously.
* @param {Number} index - Index of output being
* verified.
* @param {Coin|Output} coin - Previous output.
* @param {VerifyFlags} [flags=STANDARD_VERIFY_FLAGS]
* @param {WorkerPool?} [pool]
* @returns {Promise}
*/
async checkInputAsync(index, coin, flags, pool) {
const input = this.inputs[index];
assert(input, 'Input does not exist.');
assert(coin, 'No coin passed.');
if (!pool) {
this.checkInput(index, coin, flags);
return undefined;
}
return pool.checkInput(this, index, coin, flags);
}
/**
* Verify all transaction inputs.
* @param {CoinView} view
* @param {VerifyFlags?} [flags=STANDARD_VERIFY_FLAGS]
* @returns {Boolean} Whether the inputs are valid.
*/
verify(view, flags) {
try {
this.check(view, flags);
} catch (e) {
if (e.type === 'ScriptError')
return false;
throw e;
}
return true;
}
/**
* Verify a transaction input.
* @param {Number} index - Index of output being
* verified.
* @param {Coin|Output} coin - Previous output.
* @param {VerifyFlags} [flags=STANDARD_VERIFY_FLAGS]
* @returns {Boolean} Whether the input is valid.
*/
verifyInput(index, coin, flags) {
try {
this.checkInput(index, coin, flags);
} catch (e) {
if (e.type === 'ScriptError')
return false;
throw e;
}
return true;
}
/**
* Verify the transaction inputs on the worker pool
* (if workers are enabled).
* @param {CoinView} view
* @param {VerifyFlags?} [flags=STANDARD_VERIFY_FLAGS]
* @param {WorkerPool?} [pool]
* @returns {Promise}
*/
async verifyAsync(view, flags, pool) {
try {
await this.checkAsync(view, flags, pool);
} catch (e) {
if (e.type === 'ScriptError')
return false;
throw e;
}
return true;
}
/**
* Verify a transaction input asynchronously.
* @param {Number} index - Index of output being
* verified.
* @param {Coin|Output} coin - Previous output.
* @param {VerifyFlags} [flags=STANDARD_VERIFY_FLAGS]
* @param {WorkerPool?} [pool]
* @returns {Promise}
*/
async verifyInputAsync(index, coin, flags, pool) {
try {
await this.checkInputAsync(index, coin, flags, pool);
} catch (e) {
if (e.type === 'ScriptError')
return false;
throw e;
}
return true;
}
/**
* Test whether the transaction is a coinbase
* by examining the inputs.
* @returns {Boolean}
*/
isCoinbase() {
return this.inputs.length > 0 && this.inputs[0].prevout.isNull();
}
/**
* Calculate the fee for the transaction.
* @param {CoinView} view
* @returns {AmountValue} fee (zero if not all coins are available).
*/
getFee(view) {
if (!this.hasCoins(view))
return 0;
return this.getInputValue(view) - this.getOutputValue();
}
/**
* Calculate the total input value.
* @param {CoinView} view
* @returns {AmountValue} value
*/
getInputValue(view) {
let total = 0;
for (const {prevout} of this.inputs) {
const coin = view.getOutput(prevout);
if (!coin)
return 0;
total += coin.value;
}
return total;
}
/**
* Calculate the total output value.
* @returns {AmountValue} value
*/
getOutputValue() {
let total = 0;
for (const output of this.outputs)
total += output.value;
return total;
}
/**
* Get all input addresses.
* @private
* @param {CoinView} view
* @returns {Array} [addrs, table]
*/
_getInputAddresses(view) {
const table = new BufferSet();
const addrs = [];
if (this.isCoinbase())
return [addrs, table];
for (const input of this.inputs) {
const coin = view ? view.getOutputFor(input) : null;
const addr = input.getAddress(coin);
if (!addr)
continue;
const hash = addr.getHash();
if (!table.has(hash)) {
table.add(hash);
addrs.push(addr);
}
}
return [addrs, table];
}
/**
* Get all output addresses.
* @private
* @returns {Array} [addrs, table]
*/
_getOutputAddresses() {
const table = new BufferSet();
const addrs = [];
for (const output of this.outputs) {
const addr = output.getAddress();
if (!addr)
continue;
const hash = addr.getHash();
if (!table.has(hash)) {
table.add(hash);
addrs.push(addr);
}
}
return [addrs, table];
}
/**
* Get all addresses.
* @private
* @param {CoinView} view
* @returns {Array} [addrs, table]
*/
_getAddresses(view) {
const [addrs, table] = this._getInputAddresses(view);
const output = this.getOutputAddresses();
for (const addr of output) {
const hash = addr.getHash();
if (!table.has(hash)) {
table.add(hash);
addrs.push(addr);
}
}
return [addrs, table];
}
/**
* Get all input addresses.
* @param {CoinView|null} view
* @returns {Address[]} addresses
*/
getInputAddresses(view) {
const [addrs] = this._getInputAddresses(view);
return addrs;
}
/**
* Get all output addresses.
* @returns {Address[]} addresses
*/
getOutputAddresses() {
const [addrs] = this._getOutputAddresses();
return addrs;
}
/**
* Get all addresses.
* @param {CoinView|null} view
* @returns {Address[]} addresses
*/
getAddresses(view) {
const [addrs] = this._getAddresses(view);
return addrs;
}
/**
* Get all input address hashes.
* @param {CoinView|null} view
* @returns {Hash[]} hashes
*/
getInputHashes(view) {
const [, table] = this._getInputAddresses(view);
return table.toArray();
}
/**
* Get all output address hashes.
* @returns {Hash[]} hashes
*/
getOutputHashes() {
const [, table] = this._getOutputAddresses();
return table.toArray();
}
/**
* Get all address hashes.
* @param {CoinView|null} view
* @returns {Hash[]} hashes
*/
getHashes(view) {
const [, table] = this._getAddresses(view);
return table.toArray();
}
/**
* Test whether the transaction has
* all coins available.
* @param {CoinView} view
* @returns {Boolean}
*/
hasCoins(view) {
if (this.inputs.length === 0)
return false;
for (const {prevout} of this.inputs) {
if (!view.hasEntry(prevout))
return false;
}
return true;
}
/**
* Check finality of transaction by examining
* nLocktime and nSequence values.
* @example
* tx.isFinal(chain.height + 1, network.now());
* @param {Number} height - Height at which to test. This
* is usually the chain height, or the chain height + 1
* when the transaction entered the mempool.
* @param {Number} time - Time at which to test. This is
* usually the chain tip's parent's median time, or the
* time at which the transaction entered the mempool. If
* MEDIAN_TIME_PAST is enabled this will be the median
* time of the chain tip's previous entry's median time.
* @returns {Boolean}
*/
isFinal(height, time) {
const FLAG = consensus.LOCKTIME_FLAG;
const MASK = consensus.LOCKTIME_MASK;
const MULT = consensus.LOCKTIME_MULT;
if (this.locktime === 0)
return true;
if (this.locktime & FLAG) {
const locktime = this.locktime & MASK;
if ((locktime * MULT) < time)
return true;
} else {
if (this.locktime < height)
return true;
}
for (const input of this.inputs) {
if (input.sequence !== 0xffffffff)
return false;
}
return true;
}
/**
* Verify the absolute locktime of a transaction.
* Called by OP_CHECKLOCKTIMEVERIFY.
* @param {Number} index - Index of input being verified.
* @param {Number} predicate - Locktime to verify against.
* @returns {Boolean}
*/
verifyLocktime(index, predicate) {
const FLAG = consensus.LOCKTIME_FLAG;
const MASK = consensus.LOCKTIME_MASK;
const input = this.inputs[index];
assert(input, 'Input does not exist.');
assert(predicate >= 0, 'Locktime must be non-negative.');
// Locktimes must be of the same type (blocks or seconds).
if ((this.locktime & FLAG) !== (predicate & FLAG))
return false;
if ((predicate & MASK) > (this.locktime & MASK))
return false;
if (input.sequence === 0xffffffff)
return false;
return true;
}
/**
* Verify the relative locktime of an input.
* Called by OP_CHECKSEQUENCEVERIFY.
* @param {Number} index - Index of input being verified.
* @param {Number} predicate - Relative locktime to verify against.
* @returns {Boolean}
*/
verifySequence(index, predicate) {
const DISABLE_FLAG = consensus.SEQUENCE_DISABLE_FLAG;
const TYPE_FLAG = consensus.SEQUENCE_TYPE_FLAG;
const MASK = consensus.SEQUENCE_MASK;
const input = this.inputs[index];
assert(input, 'Input does not exist.');
assert(predicate >= 0, 'Locktime must be non-negative.');
// For future softfork capability.
if (predicate & DISABLE_FLAG)
return true;
// Cannot use the disable flag without
// the predicate also having the disable
// flag (for future softfork capability).
if (input.sequence & DISABLE_FLAG)
return false;
// Locktimes must be of the same type (blocks or seconds).
if ((input.sequence & TYPE_FLAG) !== (predicate & TYPE_FLAG))
return false;
if ((predicate & MASK) > (input.sequence & MASK))
return false;
return true;
}
/**
* Calculate sigops.
* @param {CoinView} view
* @returns {Number}
*/
getSigops(view) {
if (this.isCoinbase())
return 0;
let total = 0;
for (const input of this.inputs) {
const coin = view.getOutputFor(input);
if (!coin)
continue;
total += coin.address.getSigops(input.witness);
}
return total;
}
/**
* Non-contextual sanity checks for the transaction.
* Will mostly verify coin and output values.
* @see CheckTransaction()
* @returns {Array} [result, reason, score]
*/
isSane() {
const [valid] = this.checkSanity();
return valid;
}
/**
* Non-contextual sanity checks for the transaction.
* Will mostly verify coin and output values.
* @see CheckTransaction()
* @returns {Array} [valid, reason, score]
*/
checkSanity() {
if (this.inputs.length === 0)
return [false, 'bad-txns-vin-empty', 100];
if (this.outputs.length === 0)
return [false, 'bad-txns-vout-empty', 100];
if (this.getBaseSize() > consensus.MAX_TX_SIZE)
return [false, 'bad-txns-oversize', 100];
if (this.getWeight() > consensus.MAX_TX_WEIGHT)
return [false, 'bad-txns-overweight', 100];
// Single TX should not exceed consensus block limits.
if (rules.countOpens(this) > consensus.MAX_BLOCK_OPENS)
return [false, 'bad-txns-opens', 100];
if (rules.countUpdates(this) > consensus.MAX_BLOCK_UPDATES)
return [false, 'bad-txns-updates', 100];
if (rules.countRenewals(this) > consensus.MAX_BLOCK_RENEWALS)
return [false, 'bad-txns-renewals', 100];
let total = 0;
for (const output of this.outputs) {
if (output.value < 0)
return [false, 'bad-txns-vout-negative', 100];
if (output.value > consensus.MAX_MONEY)
return [false, 'bad-txns-vout-toolarge', 100];
total += output.value;
if (total < 0 || total > consensus.MAX_MONEY)
return [false, 'bad-txns-txouttotal-toolarge', 100];
if (!output.address.isValid())
return [false, 'bad-txns-address-size', 100];
}
if (this.isCoinbase()) {
if (!this.inputs[0].prevout.isNull())
return [false, 'bad-cb-outpoint', 100];
const size = this.inputs[0].witness.getSize();
if (size > 1000)
return [false, 'bad-cb-length', 100];
for (let i = 1; i < this.inputs.length; i++) {
const input = this.inputs[i];
if (!input.prevout.isNull())
return [false, 'bad-cb-outpoint', 100];
if (input.witness.items.length !== 1)
return [false, 'bad-cb-witness', 100];
const size = input.witness.items[0].length;
if (size > 10000)
return [false, 'bad-cb-length', 100];
}
} else {
const prevout = new BufferSet();
for (const input of this.inputs) {
const key = input.prevout.toKey();
if (prevout.has(key))
return [false, 'bad-txns-inputs-duplicate', 100];
prevout.add(key);
}
for (const input of this.inputs) {
if (input.prevout.isNull())
return [false, 'bad-txns-prevout-null', 10];
}
}
if (!this.hasSaneCovenants())
return [false, 'bad-txns-covenants', 100];
return [true, 'valid', 0];
}
/**
* Test whether the transaction violates
* any basic covenants rules.
* @returns {Boolean}
*/
hasSaneCovenants() {
return rules.hasSaneCovenants(this);
}
/**
* Non-contextual checks to determine whether the
* transaction has all standard output script
* types and standard input script size with only
* pushdatas in the code.
* Will mostly verify coin and output values.
* @see IsStandardTx()
* @returns {Array} [valid, reason, score]
*/
isStandard() {
const [valid] = this.checkStandard();
return valid;
}
/**
* Non-contextual checks to determine whether the
* transaction has all standard output script
* types and standard input script size with only
* pushdatas in the code.
* Will mostly verify coin and output values.
* @see IsStandardTx()
* @returns {Array} [valid, reason, score]
*/
checkStandard() {
if (this.version > policy.MAX_TX_VERSION)
return [false, 'version', 0];
if (this.getWeight() > policy.MAX_TX_WEIGHT)
return [false, 'tx-size', 0];
let nulldata = 0;
for (const output of this.outputs) {
if (output.address.isUnknown())
return [false, 'address', 0];
if (output.address.isNulldata()) {
nulldata += 1;
continue;
}
if (output.covenant.isUnknown())
return [false, 'covenant', 0];
if (output.isDust(policy.MIN_RELAY))
return [false, 'dust', 0];
}
if (nulldata > 1)
return [false, 'multi-op-return', 0];
return [true, 'valid', 0];
}
/**
* Perform contextual checks to verify coin and input
* script standardness (including the redeem script).
* @see AreInputsStandard()
* @param {CoinView} view
* @returns {Boolean}
*/
hasStandardInputs(view) {
if (this.isCoinbase())
return true;
for (const input of this.inputs) {
const witness = input.witness;
const coin = view.getOutputFor(input);
if (!coin)
continue;
if (witness.items.length === 0)
continue;
const addr = coin.address;
if (addr.isPubkeyhash()) {
if (witness.items.length !== 2)
return false;
if (witness.items[0].length !== 65)
return false;
if (witness.items[1].length !== 33)
return false;
continue;
}
if (addr.isScripthash()) {
if (witness.items.length - 1 > policy.MAX_P2WSH_STACK)
return false;
for (let i = 0; i < witness.items.length - 1; i++) {
const item = witness.items[i];
if (item.length > policy.MAX_P2WSH_PUSH)
return false;
}
const raw = witness.items[witness.items.length - 1];
if (raw.length > policy.MAX_P2WSH_SIZE)
return false;
const redeem = Script.decode(raw);
if (redeem.isPubkey()) {
if (witness.items.length - 1 !== 1)
return false;
if (witness.items[0].length !== 65)
return false;
continue;
}
if (redeem.isPubkeyhash()) {
if (input.witness.items.length - 1 !== 2)
return false;
if (witness.items[0].length !== 65)
return false;
if (witness.items[1].length !== 33)
return false;
continue;
}
const [m] = redeem.getMultisig();
if (m !== -1) {
if (witness.items.length - 1 !== m + 1)
return false;
if (witness.items[0].length !== 0)
return false;
for (let i = 1; i < witness.items.length - 1; i++) {
const item = witness.items[i];
if (item.length !== 65)
return false;
}
}
continue;
}
if (witness.items.length > policy.MAX_P2WSH_STACK)
return false;
for (const item of witness.items) {
if (item.length > policy.MAX_P2WSH_PUSH)
return false;
}
}
return true;
}
/**
* Perform contextual checks to verify input, output,
* and fee values, as well as coinbase spend maturity
* (coinbases can only be spent 100 blocks or more
* after they're created). Note that this function is
* consensus critical.
* @param {CoinView} view
* @param {Number} height - Height at which the
* transaction is being spent. In the mempool this is
* the chain height plus one at the time it entered the pool.
* @param {Network} network
* @returns {Boolean}
*/
verifyInputs(view, height, network) {
const [fee] = this.checkInputs(view, height, network);
return fee !== -1;
}
/**
* Perform contextual checks to verify input, output,
* and fee values, as well as coinbase spend maturity
* (coinbases can only be spent 100 blocks or more
* after they're created). Note that this function is
* consensus critical.
* @param {CoinView} view
* @param {Number} height - Height at which the
* transaction is being spent. In the mempool this is
* the chain height plus one at the time it entered the pool.
* @param {Network} network
* @returns {Array} [fee, reason, score]
*/
checkInputs(view, height, network) {
assert(typeof height === 'number');
assert(network instanceof Network);
if (this.isCoinbase()) {
const conjured = this.verifyCovenants(view, height, network);
if (conjured === -1)
return [-1, 'bad-txns-claims', 100];
return [conjured, 'valid', 0];
}
let total = 0;
for (const {prevout} of this.inputs) {
const entry = view.getEntry(prevout);
if (!entry)
return [-1, 'bad-txns-inputs-missingorspent', 0];
if (entry.coinbase) {
if (height - entry.height < network.coinbaseMaturity)
return [-1, 'bad-txns-premature-spend-of-coinbase', 0];
}
const coin = view.getOutput(prevout);
assert(coin);
if (coin.value < 0 || coin.value > consensus.MAX_MONEY)
return [-1, 'bad-txns-inputvalues-outofrange', 100];
total += coin.value;
if (total < 0 || total > consensus.MAX_MONEY)
return [-1, 'bad-txns-inputvalues-outofrange', 100];
}
// Overflows already checked in `isSane()`.
const value = this.getOutputValue();
if (total < value)
return [-1, 'bad-txns-in-belowout', 100];
const fee = total - value;
if (fee < 0)
return [-1, 'bad-txns-fee-negative', 100];
if (fee > consensus.MAX_MONEY)
return [-1, 'bad-txns-fee-outofrange', 100];
const conjured = this.verifyCovenants(view, height, network);
if (conjured === -1)
return [-1, 'bad-txns-covenants', 100];
assert(conjured === 0);
return [fee, 'valid', 0];
}
/**
* Test whether the transaction violates
* any contextual covenants rules.
* @param {CoinView} view
* @param {Number} height
* @param {Network} network
* @returns {Number}
*/
verifyCovenants(view, height, network) {
return rules.verifyCovenants(this, view, height, network);
}
/**
* Calculate the modified size of the transaction. This
* is used in the mempool for calculating priority.
* @param {Number?} size - The size to modify. If not present,
* virtual size will be used.
* @returns {Number} Modified size.
*/
getModifiedSize(size) {
if (size == null)
size = this.getVirtualSize();
for (const input of this.inputs) {
const offset = 45 + Math.min(100, input.witness.getSize());
if (size > offset)
size -= offset;
}
return size;
}
/**
* Calculate the transaction priority.
* @param {CoinView} view
* @param {Number} height
* @param {Number?} [size] - Size to calculate priority
* based on. If not present, virtual size will be used.
* @returns {Number}
*/
getPriority(view, height, size) {
assert(typeof height === 'number', 'Must pass in height.');
if (this.isCoinbase())
return 0;
if (size == null)
size = this.getVirtualSize();
let sum = 0;
for (const {prevout} of this.inputs) {
const coin = view.getOutput(prevout);
if (!coin)
continue;
const coinHeight = view.getHeight(prevout);
if (coinHeight === -1)
continue;
if (coinHeight <= height) {
const age = height - coinHeight;
sum += coin.value * age;
}
}
return Math.floor(sum / size);
}
/**
* Calculate the transaction's on-chain value.
* @param {CoinView} view
* @returns {Number}
*/
getChainValue(view) {
if (this.isCoinbase())
return 0;
let value = 0;
for (const {prevout} of this.inputs) {
const coin = view.getOutput(prevout);
if (!coin)
continue;
const height = view.getHeight(prevout);
if (height === -1)
continue;
value += coin.value;
}
return value;
}
/**
* Determine whether the transaction is above the
* free threshold in priority. A transaction which
* passed this test is most likely relayable
* without a fee.
* @param {CoinView} view
* @param {Number} height - If not present, tx
* height or network height will be used.
* @param {Number?} [size] - If not present, modified
* size will be calculated and used.
* @returns {Boolean}
*/
isFree(view, height, size) {
const priority = this.getPriority(view, height, size);
return priority > policy.FREE_THRESHOLD;
}
/**
* Calculate minimum fee in order for the transaction
* to be relayable (not the constant min relay fee).
* @param {Number?} [size] - If not present, max size
* estimation will be calculated and used.
* @param {Rate?} [rate] - Rate of dollarydoo per kB.
* @returns {AmountValue} fee
*/
getMinFee(size, rate) {
if (size == null)
size = this.getVirtualSize();
return policy.getMinFee(size, rate);
}
/**
* Calculate the minimum fee in order for the transaction
* to be relayable, but _round to the nearest kilobyte
* when taking into account size.
* @param {Number?} [size] - If not present, max size
* estimation will be calculated and used.
* @param {Rate?} [rate] - Rate of dollarydoo per kB.
* @returns {AmountValue} fee
*/
getRoundFee(size, rate) {
if (size == null)
size = this.getVirtualSize();
return policy.getRoundFee(size, rate);
}
/**
* Calculate the transaction's rate based on size
* and fees. Size will be calculated if not present.
* @param {CoinView} view
* @param {Number?} [size]
* @returns {Rate}
*/
getRate(view, size) {
const fee = this.getFee(view);
if (fee < 0)
return 0;
if (size == null)
size = this.getVirtualSize();
return policy.getRate(size, fee);
}
/**
* Get all unique outpoint hashes.
* @returns {Hash[]} Outpoint hashes.
*/
getPrevout() {
if (this.isCoinbase())
return [];
const prevout = new BufferSet();
for (const input of this.inputs)
prevout.add(input.prevout.hash);
return prevout.toArray();
}
/**
* Test a transaction against a bloom filter.
* @param {BloomFilter} filter
* @returns {Boolean}
*/
test(filter) {
if (filter.test(this.hash()))
return true;
for (let i = 0; i < this.outputs.length; i++) {
const {address, covenant} = this.outputs[i];
if (filter.test(address.hash) || covenant.test(filter))
return true;
}
for (const {prevout} of this.inputs) {
if (filter.test(prevout.encode()))
return true;
}
return false;
}
/**
* Test a transaction against a bloom filter.
* @param {BloomFilter} filter
* @returns {Boolean}
*/
testAndMaybeUpdate(filter) {
let found = false;
if (filter.test(this.hash()))
found = true;
for (let i = 0; i < this.outputs.length; i++) {
const {address, covenant} = this.outputs[i];
if (filter.test(address.hash) || covenant.test(filter)) {
const prevout = Outpoint.fromTX(this, i);
filter.add(prevout.encode());
found = true;
}
}
if (found)
return found;
for (const {prevout} of this.inputs) {
if (filter.test(prevout.encode()))
return true;
}
return false;
}
/**
* Get little-endian tx hash.
* @returns {HexHash}
*/
txid() {
return this.hash().toString('hex');
}
/**
* Get little-endian wtx hash.
* @returns {HexHash}
*/
wtxid() {
return this.witnessHash().toString('hex');
}
/**
* Create outpoint from output index.
* @param {Number} index
* @returns {Outpoint}
*/
outpoint(index) {
return new Outpoint(this.hash(), index);
}
/**
* Get input from index.
* @param {Number} index
* @returns {Input|null}
*/
input(index) {
if (index >= this.inputs.length)
return null;
return this.inputs[index];
}
/**
* Get output from index.
* @param {Number} index
* @returns {Output|null}
*/
output(index) {
if (index >= this.outputs.length)
return null;
return this.outputs[index];
}
/**
* Get covenant from index.
* @param {Number} index
* @returns {Covenant|null}
*/
covenant(index) {
if (index >= this.outputs.length)
return null;
return this.outputs[index].covenant;
}
/**
* Convert the tx to an inv item.
* @returns {InvItem}
*/
toInv() {
return new InvItem(InvItem.types.TX, this.hash());
}
/**
* Inspect the transaction and return a more
* user-friendly representation of the data.
* @param {CoinView?} [view]
* @param {ChainEntry?} [entry]
* @param {Number?} [index]
* @returns {Object}
*/
format(view, entry, index) {
let rate = 0;
let fee = 0;
let height = -1;
let block = null;
let time = 0;
let date = null;
if (view) {
fee = this.getFee(view);
rate = this.getRate(view);
// Rate can exceed 53 bits in testing.
if (!Number.isSafeInteger(rate))
rate = 0;
}
if (entry) {
height = entry.height;
block = entry.hash.toString('hex');
time = entry.time;
date = util.date(time);
}
if (index == null)
index = -1;
return {
hash: this.txid(),
witnessHash: this.wtxid(),
size: this.getSize(),
virtualSize: this.getVirtualSize(),
value: Amount.coin(this.getOutputValue()),
fee: Amount.coin(fee),
rate: Amount.coin(rate),
minFee: Amount.coin(this.getMinFee()),
height: height,
block: block,
time: time,
date: date,
index: index,
version: this.version,
inputs: this.inputs.map((input) => {
const coin = view ? view.getOutputFor(input) : null;
return input.format(coin);
}),
outputs: this.outputs,
locktime: this.locktime
};
}
/**
* Convert the transaction to an object suitable
* for JSON serialization.
* @param {Network} [network]
* @param {CoinView} [view]
* @param {ChainEntry} [entry]
* @param {Number} [index]
* @returns {Object}
*/
getJSON(network, view, entry, index) {
let rate, fee, height, block, time, date;
if (view) {
fee = this.getFee(view);
rate = this.getRate(view);
// Rate can exceed 53 bits in testing.
if (!Number.isSafeInteger(rate))
rate = 0;
}
if (entry) {
height = entry.height;
block = entry.hash.toString('hex');
time = entry.time;
date = util.date(time);
}
network = Network.get(network);
return {
hash: this.txid(),
witnessHash: this.wtxid(),
fee: fee,
rate: rate,
mtime: util.now(),
height: height,
block: block,
time: time,
date: date,
index: index,
version: this.version,
inputs: this.inputs.map((input) => {
const coin = view ? view.getCoinFor(input) : null;
const path = view ? view.getPathFor(input) : null;
return input.getJSON(network, coin, path);
}),
outputs: this.outputs.map((output) => {
return output.getJSON(network);
}),
locktime: this.locktime,
hex: this.toHex()
};
}
/**
* Inject properties from a json object.
* @param {Object} json
*/
fromJSON(json) {
assert(json, 'TX data is required.');
assert((json.version >>> 0) === json.version, 'Version must be a uint32.');
assert(Array.isArray(json.inputs), 'Inputs must be an array.');
assert(Array.isArray(json.outputs), 'Outputs must be an array.');
assert((json.locktime >>> 0) === json.locktime,
'Locktime must be a uint32.');
this.version = json.version;
for (const input of json.inputs)
this.inputs.push(Input.fromJSON(input));
for (const output of json.outputs)
this.outputs.push(Output.fromJSON(output));
this.locktime = json.locktime;
return this;
}
/**
* Inject properties from serialized
* buffer reader (witness serialization).
* @param {bio.BufferReader} br
*/
read(br) {
br.start();
this.version = br.readU32();
const inCount = br.readVarint();
for (let i = 0; i < inCount; i++)
this.inputs.push(Input.read(br));
const outCount = br.readVarint();
for (let i = 0; i < outCount; i++)
this.outputs.push(Output.read(br));
this.locktime = br.readU32();
const start = br.offset;
for (let i = 0; i < inCount; i++) {
const input = this.inputs[i];
input.witness.read(br);
}
const witness = br.offset - start;
if (!this.mutable) {
const raw = br.endData();
const base = raw.length - witness;
this._raw = raw;
this._sizes = new Sizes(base, witness);
} else {
br.end();
}
return this;
}
/**
* Calculate the real size of the transaction
* with the witness included.
* @returns {Sizes}
*/
getSizes() {
if (this._sizes)
return this._sizes;
let base = 0;
let witness = 0;
base += 4;
base += encoding.sizeVarint(this.inputs.length);
for (const input of this.inputs) {
base += 40;
witness += input.witness.getVarSize();
}
base += encoding.sizeVarint(this.outputs.length);
for (const output of this.outputs)
base += output.getSize();
base += 4;
const sizes = new Sizes(base, witness);
if (!this.mutable)
this._sizes = sizes;
return sizes;
}
/**
* Serialize transaction with witness. Calculates the witness
* size as it is framing (exposed on return value as `witness`).
* @param {BufioWriter} bw
* @returns {BufioWriter}
*/
write(bw) {
if (this._raw) {
bw.writeBytes(this._raw);
return bw;
}
bw.writeU32(this.version);
bw.writeVarint(this.inputs.length);
for (const input of this.inputs)
input.write(bw);
bw.writeVarint(this.outputs.length);
for (const output of this.outputs)
output.write(bw);
bw.writeU32(this.locktime);
for (const input of this.inputs)
input.witness.write(bw);
return bw;
}
/**
* Serialize transaction.
* @returns {Buffer}
*/
encode() {
if (this.mutable)
return super.encode();
if (!this._raw)
this._raw = super.encode();
return this._raw;
}
/**
* Calculate left hash.
* @returns {Buffer}
*/
left() {
return this.hashes()[0];
}
/**
* Calculate right hash.
* @returns {Buffer}
*/
right() {
return this.hashes()[1];
}
/**
* Calculate root hash.
* @returns {Buffer}
*/
root() {
return this.hashes()[2];
}
/**
* Calculate all three transaction hashes.
* @private
* @returns {Buffer[]}
*/
hashes() {
if (this._hash && this._wdhash && this._whash)
return [this._hash, this._wdhash, this._whash];
const {base, witness} = this.getSizes();
const raw = this.encode();
assert(raw.length === base + witness);
// Normal data.
const ndata = raw.slice(0, base);
// Witness data.
const wdata = raw.slice(base, base + witness);
// Left = HASH(normal-data) = normal txid
const hash = blake2b.digest(ndata);
// Right = HASH(witness-data)
const wdhash = blake2b.digest(wdata);
// WTXID = HASH(normal-txid || witness-data-hash)
const whash = blake2b.root(hash, wdhash);
if (!this.mutable) {
this._hash = hash;
this._wdhash = wdhash;
this._whash = whash;
}
return [hash, wdhash, whash];
}
/**
* Test whether an object is a TX.
* @param {Object} obj
* @returns {Boolean}
*/
static isTX(obj) {
return obj instanceof TX;
}
}
/*
* Helpers
*/
class Sizes {
constructor(base, witness) {
this.base = base;
this.witness = witness;
}
getWeight() {
const total = this.base + this.witness;
return this.base * (consensus.WITNESS_SCALE_FACTOR - 1) + total;
}
}
/*
* Expose
*/
module.exports = TX;