1868 lines
43 KiB
JavaScript
1868 lines
43 KiB
JavaScript
/**
|
|
* tx.js - transaction object for bcoin
|
|
* Copyright (c) 2014-2015, Fedor Indutny (MIT License)
|
|
* https://github.com/indutny/bcoin
|
|
*/
|
|
|
|
var bn = require('bn.js');
|
|
|
|
var bcoin = require('../bcoin');
|
|
var utils = bcoin.utils;
|
|
var assert = utils.assert;
|
|
var constants = bcoin.protocol.constants;
|
|
|
|
/**
|
|
* TX
|
|
*/
|
|
|
|
function TX(data, block) {
|
|
if (!(this instanceof TX))
|
|
return new TX(data, block);
|
|
|
|
if (!data)
|
|
data = {};
|
|
|
|
this.type = 'tx';
|
|
this.version = data.version || 1;
|
|
this.inputs = [];
|
|
this.outputs = [];
|
|
this.locktime = data.locktime || 0;
|
|
this.ts = data.ts || 0;
|
|
this.block = data.block || null;
|
|
this._hash = null;
|
|
|
|
// Legacy
|
|
if (data.lock != null)
|
|
this.locktime = data.lock;
|
|
|
|
this._raw = data._raw || null;
|
|
this._size = data._size || 0;
|
|
|
|
this.network = data.network || false;
|
|
this.relayedBy = data.relayedBy || '0.0.0.0';
|
|
|
|
this._chain = data.chain;
|
|
|
|
if (data.inputs) {
|
|
assert(this.inputs.length === 0);
|
|
data.inputs.forEach(function(input) {
|
|
this.addInput(input);
|
|
}, this);
|
|
}
|
|
|
|
if (data.outputs) {
|
|
assert(this.outputs.length === 0);
|
|
data.outputs.forEach(function(output) {
|
|
this.addOutput(output);
|
|
}, this);
|
|
}
|
|
|
|
if (block && block.subtype === 'merkleblock') {
|
|
if (!data.ts && block && block.hasTX(this.hash('hex'))) {
|
|
this.ts = block.ts;
|
|
this.block = block.hash('hex');
|
|
}
|
|
}
|
|
|
|
this.unspent = data.unspent || null;
|
|
this.hardFee = data.hardFee || null;
|
|
this.subtractFee = data.subtractFee || null;
|
|
this.changeAddress = data.changeAddress || null;
|
|
this.changeIndex = data.changeIndex != null ? data.changeIndex : -1;
|
|
this.total = data.total || null;
|
|
|
|
// ps = Pending Since
|
|
this.ps = this.ts === 0 ? utils.now() : 0;
|
|
}
|
|
|
|
// Legacy
|
|
TX.prototype.__defineSetter__('lock', function(locktime) {
|
|
return this.locktime = locktime;
|
|
});
|
|
|
|
TX.prototype.__defineGetter__('lock', function() {
|
|
return this.locktime;
|
|
});
|
|
|
|
TX.prototype.__defineSetter__('lockTime', function(locktime) {
|
|
return this.locktime = locktime;
|
|
});
|
|
|
|
TX.prototype.__defineGetter__('lockTime', function() {
|
|
return this.locktime;
|
|
});
|
|
|
|
TX.prototype.clone = function clone() {
|
|
return new TX(this);
|
|
};
|
|
|
|
TX.prototype.hash = function hash(enc, force) {
|
|
var h = utils.dsha256(this.render(force));
|
|
return enc === 'hex' ? utils.toHex(h) : h;
|
|
};
|
|
|
|
TX.prototype.render = function render(force) {
|
|
if (!force && this.network && this._raw)
|
|
return utils.toArray(this._raw).slice();
|
|
return bcoin.protocol.framer.tx(this);
|
|
};
|
|
|
|
TX.prototype.getSize = function getSize() {
|
|
return this._size || this.render().length;
|
|
};
|
|
|
|
TX.prototype.size = TX.prototype.getSize;
|
|
|
|
TX.prototype.addInput = function addInput(i, index) {
|
|
this._addInput(i, index);
|
|
return this;
|
|
};
|
|
|
|
TX.prototype.input = TX.prototype.addInput;
|
|
|
|
// tx._addInput(tx, index)
|
|
// tx._addInput(hash, index)
|
|
// tx._addInput(input)
|
|
// tx._addInput({ hash: hash, index: index })
|
|
// tx._addInput({ tx: tx, index: index })
|
|
TX.prototype._addInput = function _addInput(obj, index) {
|
|
var options, hash, input, ex, i, prevout;
|
|
|
|
if (obj instanceof TX)
|
|
options = { tx: obj, index: index };
|
|
else if (typeof obj === 'string' || utils.isBuffer(obj))
|
|
options = { hash: obj, index: index };
|
|
else
|
|
options = obj;
|
|
|
|
prevout = options.prevout || options.out;
|
|
|
|
if (options.tx)
|
|
hash = options.tx.hash('hex');
|
|
else if (prevout)
|
|
hash = prevout.hash;
|
|
else
|
|
hash = options.hash;
|
|
|
|
if (typeof hash !== 'string')
|
|
hash = utils.toHex(hash);
|
|
|
|
input = bcoin.input({
|
|
tx: this,
|
|
prevout: {
|
|
tx: prevout ? prevout.tx : options.tx,
|
|
hash: hash,
|
|
index: prevout ? prevout.index : options.index
|
|
},
|
|
script: options.script,
|
|
sequence: options.sequence || options.seq
|
|
});
|
|
|
|
// Try modifying existing input first
|
|
i = this._inputIndex(input.prevout.hash, input.prevout.index);
|
|
if (i !== -1) {
|
|
ex = this.inputs[i];
|
|
input.prevout.tx = input.prevout.tx || ex.prevout.tx;
|
|
input.sequence = input.sequence || ex.sequence;
|
|
input.script = input.script.length ? input.script : ex.script;
|
|
this.inputs[i] = input;
|
|
} else {
|
|
this.inputs.push(input);
|
|
i = this.inputs.length - 1;
|
|
}
|
|
|
|
return i;
|
|
};
|
|
|
|
TX.prototype._input = TX.prototype._addInput;
|
|
|
|
TX.prototype._inputIndex = function _inputIndex(hash, index) {
|
|
var i, ex;
|
|
|
|
if (hash instanceof TX)
|
|
hash = hash.hash('hex');
|
|
|
|
for (i = 0; i < this.inputs.length; i++) {
|
|
ex = this.inputs[i];
|
|
if (ex.prevout.hash === hash && ex.prevout.index === index)
|
|
return i;
|
|
}
|
|
|
|
return -1;
|
|
};
|
|
|
|
TX.prototype.scriptInput = function scriptInput(index, pub, redeem) {
|
|
var input, s, n, i;
|
|
|
|
if (typeof index !== 'number')
|
|
index = this.inputs.indexOf(index);
|
|
|
|
// Get the input
|
|
input = this.inputs[index];
|
|
assert(input);
|
|
|
|
// Already has a script template (at least)
|
|
// if (input.script.length)
|
|
// return;
|
|
|
|
// We should have previous outputs by now.
|
|
assert(input.prevout.tx);
|
|
|
|
// Get the previous output's subscript
|
|
s = input.prevout.tx.getSubscript(input.prevout.index);
|
|
|
|
// P2SH
|
|
if (bcoin.script.isScripthash(s)) {
|
|
if (!redeem)
|
|
return false;
|
|
s = bcoin.script.getSubscript(bcoin.script.decode(redeem));
|
|
} else {
|
|
redeem = null;
|
|
}
|
|
|
|
if (bcoin.script.isPubkey(s)) {
|
|
// P2PK
|
|
if (!utils.isEqual(s[0], pub))
|
|
return false;
|
|
// Already has a script template (at least)
|
|
if (input.script.length)
|
|
return true;
|
|
input.script = [[]];
|
|
} else if (bcoin.script.isPubkeyhash(s)) {
|
|
// P2PKH
|
|
if (!utils.isEqual(s[2], bcoin.wallet.key2hash(pub)))
|
|
return false;
|
|
// Already has a script template (at least)
|
|
if (input.script.length)
|
|
return true;
|
|
input.script = [[], pub];
|
|
} else if (bcoin.script.isMultisig(s)) {
|
|
// Multisig
|
|
for (i = 0; i < s.length; i++) {
|
|
if (utils.isEqual(s[i], pub))
|
|
break;
|
|
}
|
|
|
|
if (i === s.length)
|
|
return false;
|
|
|
|
// Already has a script template (at least)
|
|
if (input.script.length)
|
|
return true;
|
|
|
|
// Technically we should create m signature slots,
|
|
// but we create n signature slots so we can order
|
|
// the signatures properly.
|
|
input.script = [[]];
|
|
|
|
// Grab `n` value (number of keys).
|
|
n = s[s.length - 2];
|
|
|
|
// Fill script with `n` signature slots.
|
|
for (i = 0; i < n; i++)
|
|
input.script[i + 1] = [];
|
|
} else {
|
|
for (i = 0; i < s.length; i++) {
|
|
if (utils.isEqual(s[i], pub))
|
|
break;
|
|
}
|
|
|
|
if (i === s.length)
|
|
return false;
|
|
|
|
// Already has a script template (at least)
|
|
if (input.script.length)
|
|
return true;
|
|
|
|
// Likely a non-standard scripthash multisig
|
|
// input. Determine n value by counting keys.
|
|
// Also, only allow nonstandard types for
|
|
// scripthash.
|
|
if (redeem) {
|
|
input.script = [[]];
|
|
// Fill script with `n` signature slots.
|
|
for (i = 0; i < s.length; i++) {
|
|
if (bcoin.script.isKey(s[i]))
|
|
input.script.push([]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// P2SH requires the redeem script after signatures
|
|
if (redeem) {
|
|
input.script.push(redeem);
|
|
// The fee can be calculated more accurately
|
|
// now that the redeem script is available.
|
|
this._recalculateFee();
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
TX.prototype.createSignature = function createSignature(index, key, type) {
|
|
var input, s, hash, signature;
|
|
|
|
if (typeof index !== 'number')
|
|
index = this.inputs.indexOf(index);
|
|
|
|
if (type == null)
|
|
type = 'all';
|
|
|
|
if (typeof type === 'string')
|
|
type = constants.hashType[type];
|
|
|
|
// Get the input
|
|
input = this.inputs[index];
|
|
assert(input);
|
|
|
|
// We should have previous outputs by now.
|
|
assert(input.prevout.tx);
|
|
|
|
// Get the previous output's subscript
|
|
s = input.prevout.tx.getSubscript(input.prevout.index);
|
|
|
|
// We need to grab the redeem script when
|
|
// signing p2sh transactions.
|
|
if (bcoin.script.isScripthash(s)) {
|
|
s = bcoin.script.decode(input.script[input.script.length - 1]);
|
|
s = bcoin.script.getSubscript(s);
|
|
}
|
|
|
|
// Get the hash of the current tx, minus the other
|
|
// inputs, plus the sighash type.
|
|
hash = this.signatureHash(index, s, type);
|
|
|
|
// Sign the transaction with our one input
|
|
signature = bcoin.script.sign(hash, key, type);
|
|
|
|
// Something is broken if this doesn't work:
|
|
assert(bcoin.script.checksig(hash, signature, key));
|
|
|
|
return signature;
|
|
};
|
|
|
|
// Legacy
|
|
TX.prototype.signature = TX.prototype.createSignature;
|
|
|
|
// Sign the now-built scriptSigs
|
|
TX.prototype.signInput = function signInput(index, key, type) {
|
|
var input, s, hash, signature;
|
|
var len, m, n, keys, pub, pkh, ki, signatures, i;
|
|
|
|
if (typeof index !== 'number')
|
|
index = this.inputs.indexOf(index);
|
|
|
|
// Get the input
|
|
input = this.inputs[index];
|
|
assert(input);
|
|
|
|
// We should have previous outputs by now.
|
|
assert(input.prevout.tx);
|
|
|
|
// Create our signature.
|
|
signature = this.createSignature(index, key, type);
|
|
|
|
// Get the previous output's subscript
|
|
s = input.prevout.tx.getSubscript(input.prevout.index);
|
|
|
|
// Script length, needed for multisig
|
|
len = input.script.length;
|
|
|
|
// We need to grab the redeem script when
|
|
// signing p2sh transactions.
|
|
if (bcoin.script.isScripthash(s)) {
|
|
s = bcoin.script.decode(input.script[input.script.length - 1]);
|
|
s = bcoin.script.getSubscript(s);
|
|
// Decrement `len` to avoid the redeem script
|
|
len--;
|
|
}
|
|
|
|
// Get pubkey and pubkey hash.
|
|
pub = key.getPublic(true, 'array');
|
|
pkh = bcoin.wallet.key2hash(pub);
|
|
|
|
// Add signatures.
|
|
if (bcoin.script.isPubkey(s)) {
|
|
// P2PK
|
|
|
|
// Something is wrong. Abort.
|
|
if (!Array.isArray(input.script[0]))
|
|
return false;
|
|
|
|
// Already signed.
|
|
if (input.script[0].length)
|
|
return true;
|
|
|
|
// Make sure the pubkey is ours.
|
|
if (!utils.isEqual(pub, s[0]))
|
|
return false;
|
|
|
|
input.script[0] = signature;
|
|
|
|
return true;
|
|
}
|
|
|
|
if (bcoin.script.isPubkeyhash(s)) {
|
|
// P2PKH
|
|
|
|
// Something is wrong. Abort.
|
|
if (!Array.isArray(input.script[0]))
|
|
return false;
|
|
|
|
// Already signed.
|
|
if (input.script[0].length)
|
|
return true;
|
|
|
|
// Make sure the pubkey hash is ours.
|
|
if (!utils.isEqual(pkh, s[2]))
|
|
return false;
|
|
|
|
input.script[0] = signature;
|
|
|
|
return true;
|
|
}
|
|
|
|
if (bcoin.script.isMultisig(s)) {
|
|
// Multisig
|
|
|
|
// Grab the redeem script's keys to figure
|
|
// out where our key should go.
|
|
keys = s.slice(1, -2);
|
|
|
|
// Grab `m` value (number of sigs required).
|
|
m = s[0];
|
|
|
|
// Grab `n` value (number of keys).
|
|
n = s[s.length - 2];
|
|
} else {
|
|
// Only allow non-standard signing for
|
|
// scripthash.
|
|
if (len !== input.script.length - 1)
|
|
return false;
|
|
|
|
keys = [];
|
|
|
|
for (i = 0; i < s.length; i++) {
|
|
if (bcoin.script.isKey(s[i]))
|
|
keys.push(s[i]);
|
|
}
|
|
|
|
n = keys.length;
|
|
m = n;
|
|
}
|
|
|
|
// Something is very wrong here. Abort.
|
|
if (len - 1 > n)
|
|
return false;
|
|
|
|
// Count the number of current signatures.
|
|
signatures = 0;
|
|
for (i = 1; i < len; i++) {
|
|
if (bcoin.script.isSignature(input.script[i]))
|
|
signatures++;
|
|
}
|
|
|
|
// Signatures are already finalized.
|
|
if (signatures === m && len - 1 === m)
|
|
return true;
|
|
|
|
// This can happen in a case where another
|
|
// implementation adds signatures willy-nilly
|
|
// or by `m`. Add some signature slots for
|
|
// us to use.
|
|
while (len - 1 < n) {
|
|
input.script.splice(len, 0, []);
|
|
len++;
|
|
}
|
|
|
|
// Find the key index so we can place
|
|
// the signature in the same index.
|
|
for (ki = 0; ki < keys.length; ki++) {
|
|
if (utils.isEqual(pub, keys[ki]))
|
|
break;
|
|
}
|
|
|
|
// Our public key is not in the prev_out
|
|
// script. We tried to sign a transaction
|
|
// that is not redeemable by us.
|
|
if (ki === keys.length)
|
|
return false;
|
|
|
|
// Offset key index by one to turn it into
|
|
// "sig index". Accounts for OP_0 byte at
|
|
// the start.
|
|
ki++;
|
|
|
|
// Add our signature to the correct slot
|
|
// and increment the total number of
|
|
// signatures.
|
|
if (ki < len && signatures < m) {
|
|
if (bcoin.script.isDummy(input.script[ki])) {
|
|
input.script[ki] = signature;
|
|
signatures++;
|
|
}
|
|
}
|
|
|
|
// All signatures added. Finalize.
|
|
if (signatures >= m) {
|
|
// Remove empty slots left over.
|
|
for (i = len - 1; i >= 1; i--) {
|
|
if (bcoin.script.isDummy(input.script[i])) {
|
|
input.script.splice(i, 1);
|
|
len--;
|
|
}
|
|
}
|
|
|
|
// Remove signatures which are not required.
|
|
// This should never happen except when dealing
|
|
// with implementations that potentially handle
|
|
// signature slots differently.
|
|
while (signatures > m) {
|
|
input.script.splice(len - 1, 1);
|
|
signatures--;
|
|
len--;
|
|
}
|
|
|
|
// Sanity checks.
|
|
assert.equal(signatures, m);
|
|
assert.equal(len - 1, m);
|
|
}
|
|
|
|
return signatures === m;
|
|
};
|
|
|
|
TX.prototype.scriptSig = function scriptSig(index, key, pub, redeem, type) {
|
|
var input;
|
|
|
|
if (index && typeof index === 'object')
|
|
index = this.inputs.indexOf(index);
|
|
|
|
input = this.inputs[index];
|
|
assert(input);
|
|
|
|
// Build script for input
|
|
if (!this.scriptInput(index, pub, redeem))
|
|
return false;
|
|
|
|
// Sign input
|
|
if (!this.signInput(index, key, type))
|
|
return false;
|
|
|
|
return input.script;
|
|
};
|
|
|
|
TX.prototype.isSigned = function isSigned(index, required) {
|
|
var i, input, s, len, m, j, total;
|
|
|
|
if (index && typeof index === 'object')
|
|
index = this.inputs.indexOf(index);
|
|
|
|
if (index != null)
|
|
assert(this.inputs[index]);
|
|
|
|
for (i = 0; i < this.inputs.length; i++) {
|
|
input = this.inputs[i];
|
|
|
|
if (index != null && i !== index)
|
|
continue;
|
|
|
|
// We can't check for signatures unless
|
|
// we have the previous output.
|
|
assert(input.prevout.tx);
|
|
|
|
// Get the prevout's subscript
|
|
s = input.prevout.tx.getSubscript(input.prevout.index);
|
|
|
|
// Script length, needed for multisig
|
|
len = input.script.length;
|
|
|
|
// Grab the redeem script if P2SH
|
|
if (bcoin.script.isScripthash(s)) {
|
|
s = bcoin.script.getRedeem(input.script);
|
|
// Decrement `len` to avoid the redeem script
|
|
len--;
|
|
}
|
|
|
|
// Check for signatures.
|
|
// P2PK
|
|
if (bcoin.script.isPubkey(s)) {
|
|
if (!bcoin.script.isSignature(input.script[0]))
|
|
return false;
|
|
continue;
|
|
}
|
|
|
|
// P2PK
|
|
if (bcoin.script.isPubkeyhash(s)) {
|
|
if (!bcoin.script.isSignature(input.script[0]))
|
|
return false;
|
|
continue;
|
|
}
|
|
|
|
// Multisig
|
|
if (bcoin.script.isMultisig(s)) {
|
|
// Grab `m` value (number of required sigs).
|
|
m = s[0];
|
|
if (Array.isArray(m))
|
|
m = m[0] || 0;
|
|
|
|
// Ensure all members are signatures.
|
|
for (j = 1; j < len; j++) {
|
|
if (!bcoin.script.isSignature(input.script[j]))
|
|
return false;
|
|
}
|
|
|
|
// Ensure we have the correct number
|
|
// of required signatures.
|
|
if (len - 1 !== m)
|
|
return false;
|
|
|
|
continue;
|
|
}
|
|
|
|
// Unknown
|
|
total = 0;
|
|
for (j = 0; j < input.script.length; j++) {
|
|
if (bcoin.script.isSignatureEncoding(input.script[j]))
|
|
total++;
|
|
}
|
|
|
|
if (total !== required)
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
TX.prototype.addOutput = function addOutput(obj, value) {
|
|
var options, output;
|
|
|
|
if (obj instanceof bcoin.wallet)
|
|
obj = obj.getAddress();
|
|
|
|
if (typeof obj === 'string') {
|
|
options = {
|
|
address: obj,
|
|
value: value
|
|
};
|
|
} else {
|
|
options = obj;
|
|
}
|
|
|
|
output = bcoin.output({
|
|
tx: this,
|
|
value: options.value,
|
|
script: options.script
|
|
});
|
|
|
|
this.outputs.push(output);
|
|
|
|
this.scriptOutput(this.outputs.length - 1, options);
|
|
|
|
return this;
|
|
};
|
|
|
|
TX.prototype.out = TX.prototype.addOutput;
|
|
TX.prototype.output = TX.prototype.addOutput;
|
|
|
|
TX.prototype.scriptOutput = function scriptOutput(index, options) {
|
|
var output, script, keys, m, n, hash, flags;
|
|
|
|
if (typeof index !== 'number')
|
|
index = this.outputs.indexOf(index);
|
|
|
|
output = this.outputs[index];
|
|
assert(output);
|
|
|
|
if (!options)
|
|
options = output;
|
|
|
|
script = output.script;
|
|
|
|
if (options instanceof bcoin.output) {
|
|
options = Object.keys(options).reduce(function(out, key) {
|
|
out[key] = options[key];
|
|
return out;
|
|
}, {});
|
|
}
|
|
|
|
if (options.addr) {
|
|
options.address = options.addr;
|
|
delete options.addr;
|
|
}
|
|
|
|
if (Array.isArray(options.address)) {
|
|
options.keys = options.address.map(function(address) {
|
|
return bcoin.wallet.addr2hash(address, 'pubkeyhash');
|
|
});
|
|
delete options.address;
|
|
}
|
|
|
|
if (options.minSignatures) {
|
|
options.m = options.minSignatures;
|
|
delete options.minSignatures;
|
|
}
|
|
|
|
if (options.color) {
|
|
options.flags = options.color;
|
|
delete options.color;
|
|
}
|
|
|
|
if (Array.isArray(options.keys)) {
|
|
// Bare Multisig Transaction
|
|
// https://github.com/bitcoin/bips/blob/master/bip-0010.mediawiki
|
|
// https://github.com/bitcoin/bips/blob/master/bip-0011.mediawiki
|
|
// https://github.com/bitcoin/bips/blob/master/bip-0019.mediawiki
|
|
// m [key1] [key2] ... n checkmultisig
|
|
keys = options.keys.map(utils.toBuffer);
|
|
|
|
m = options.m || keys.length;
|
|
n = options.n || keys.length;
|
|
|
|
if (!(m >= 1 && m <= n))
|
|
return;
|
|
|
|
if (!(n >= 1 && n <= (options.scripthash ? 15 : 3)))
|
|
return;
|
|
|
|
script = bcoin.script.createMultisig(keys, m, n);
|
|
} else if (bcoin.address.validate(options.address, 'scripthash')) {
|
|
// P2SH Transaction
|
|
// https://github.com/bitcoin/bips/blob/master/bip-0016.mediawiki
|
|
// hash160 [20-byte-redeemscript-hash] equal
|
|
script = bcoin.script.createScripthash(
|
|
bcoin.wallet.addr2hash(options.address, 'scripthash')
|
|
);
|
|
} else if (options.address) {
|
|
// P2PKH Transaction
|
|
// dup hash160 [pubkey-hash] equalverify checksig
|
|
script = bcoin.script.createPubkeyhash(
|
|
bcoin.wallet.addr2hash(options.address, 'pubkeyhash')
|
|
);
|
|
} else if (options.key) {
|
|
// P2PK Transaction
|
|
// [pubkey] checksig
|
|
script = [
|
|
utils.toBuffer(options.key),
|
|
'checksig'
|
|
];
|
|
} else if (options.flags) {
|
|
// Nulldata Transaction
|
|
// return [data]
|
|
flags = options.flags;
|
|
if (typeof flags === 'string')
|
|
flags = utils.ascii2array(flags);
|
|
assert(utils.isBuffer(flags));
|
|
assert(flags.length <= constants.script.maxOpReturn);
|
|
script = bcoin.script.createNulldata(flags);
|
|
}
|
|
|
|
// P2SH Transaction
|
|
// hash160 [hash] eq
|
|
if (options.scripthash) {
|
|
if (options.locktime != null) {
|
|
script = [
|
|
bcoin.script.array(options.locktime),
|
|
'checklocktimeverify',
|
|
'drop',
|
|
'codeseparator'
|
|
].concat(script);
|
|
}
|
|
hash = utils.ripesha(bcoin.script.encode(script));
|
|
script = bcoin.script.createScripthash(hash);
|
|
}
|
|
|
|
output.script = script;
|
|
};
|
|
|
|
TX.prototype.getSubscript = function getSubscript(index) {
|
|
var script;
|
|
|
|
if (typeof index !== 'number')
|
|
index = this.outputs.indexOf(index);
|
|
|
|
assert(this.outputs[index]);
|
|
|
|
script = this.outputs[index].script;
|
|
|
|
return bcoin.script.getSubscript(script);
|
|
};
|
|
|
|
TX.prototype.signatureHash = function signatureHash(index, s, type) {
|
|
var copy = this.clone();
|
|
var i, msg, hash;
|
|
|
|
if (!Array.isArray(s)) {
|
|
type = s;
|
|
s = this.inputs[index].prevout.tx.getSubscript(this.inputs[index].prevout.index);
|
|
if (bcoin.script.isScripthash(s)) {
|
|
s = this.inputs[index].script[this.inputs[index.script.length - 1]];
|
|
s = bcoin.script.getSubscript(bcoin.script.decode(s));
|
|
}
|
|
}
|
|
|
|
if (typeof index !== 'number')
|
|
index = this.inputs.indexOf(index);
|
|
|
|
if (typeof type === 'string')
|
|
type = constants.hashType[type];
|
|
|
|
assert(index >= 0 && index < copy.inputs.length)
|
|
assert(Array.isArray(s));
|
|
|
|
// Disable this for now. We allow null hash types
|
|
// because bitcoind allows empty signatures. On
|
|
// another note, we allow all weird sighash types
|
|
// if strictenc is not enabled.
|
|
// assert(utils.isFinite(type));
|
|
|
|
// Remove code separators.
|
|
// s = script.getSubscript(s);
|
|
|
|
// Remove all signatures.
|
|
for (i = 0; i < copy.inputs.length; i++)
|
|
copy.inputs[i].script = [];
|
|
|
|
// Set our input to previous output's script
|
|
copy.inputs[index].script = s;
|
|
|
|
if ((type & 0x1f) === constants.hashType.none) {
|
|
// Drop all outputs. We don't want to sign them.
|
|
copy.outputs = [];
|
|
|
|
// Allow input sequence updates for other inputs.
|
|
for (i = 0; i < copy.inputs.length; i++) {
|
|
if (i !== index)
|
|
copy.inputs[i].sequence = 0;
|
|
}
|
|
} else if ((type & 0x1f) === constants.hashType.single) {
|
|
// Bitcoind used to return 1 as an error code:
|
|
// it ended up being treated like a hash.
|
|
if (index >= copy.outputs.length)
|
|
return constants.oneHash.slice();
|
|
|
|
// Drop all the outputs after the input index.
|
|
copy.outputs.length = index + 1;
|
|
|
|
// Null outputs that are not the at current input index.
|
|
for (i = 0; i < copy.outputs.length; i++) {
|
|
if (i !== index) {
|
|
copy.outputs[i].script = [];
|
|
copy.outputs[i].value = new bn('ffffffffffffffff', 'hex');
|
|
}
|
|
}
|
|
|
|
// Allow input sequence updates for other inputs.
|
|
for (i = 0; i < copy.inputs.length; i++) {
|
|
if (i !== index)
|
|
copy.inputs[i].sequence = 0;
|
|
}
|
|
}
|
|
|
|
// Only sign our input. Allows anyone to add inputs.
|
|
if (type & constants.hashType.anyonecanpay) {
|
|
copy.inputs[0] = copy.inputs[index];
|
|
copy.inputs.length = 1;
|
|
}
|
|
|
|
msg = copy.render(true);
|
|
|
|
utils.writeU32(msg, type, msg.length);
|
|
|
|
hash = utils.dsha256(msg);
|
|
|
|
return hash;
|
|
};
|
|
|
|
TX.prototype.tbsHash = function tbsHash(enc, force) {
|
|
var copy = this.clone();
|
|
var i;
|
|
|
|
if (this.isCoinbase())
|
|
return this.hash(enc);
|
|
|
|
if (!this._tbsHash || force) {
|
|
for (i = 0; i < copy.inputs.length; i++) {
|
|
if (!copy.isCoinbase())
|
|
copy.inputs[i].script = [];
|
|
}
|
|
|
|
this._tbsHash = utils.dsha256(copy.render(true));
|
|
}
|
|
|
|
return enc === 'hex'
|
|
? utils.toHex(this._tbsHash)
|
|
: this._tbsHash.slice();
|
|
};
|
|
|
|
TX.prototype.verify = function verify(index, force, flags) {
|
|
// Valid if included in block
|
|
if (!force && this.ts !== 0)
|
|
return true;
|
|
|
|
if (this.inputs.length === 0)
|
|
return false;
|
|
|
|
if (index && typeof index === 'object')
|
|
index = this.inputs.indexOf(index);
|
|
|
|
if (index != null)
|
|
assert(this.inputs[index]);
|
|
|
|
return this.inputs.every(function(input, i) {
|
|
var output;
|
|
|
|
if (index != null && i !== index)
|
|
return true;
|
|
|
|
if (!input.prevout.tx)
|
|
return false;
|
|
|
|
// Somethis is very wrong if this is
|
|
// not the case.
|
|
assert.equal(input.prevout.tx.hash('hex'), input.prevout.hash);
|
|
|
|
// Grab the previous output.
|
|
output = input.prevout.tx.outputs[input.prevout.index];
|
|
|
|
// Transaction is referencing an output
|
|
// that does not exist.
|
|
if (!output)
|
|
return false;
|
|
|
|
// Transaction cannot reference itself.
|
|
if (input.prevout.hash === this.hash('hex'))
|
|
return false;
|
|
|
|
return bcoin.script.verify(input.script, output.script, this, i, flags);
|
|
}, this);
|
|
};
|
|
|
|
TX.prototype.isCoinbase = function isCoinbase() {
|
|
return this.inputs.length === 1 && +this.inputs[0].prevout.hash === 0;
|
|
};
|
|
|
|
TX.prototype.maxSize = function maxSize() {
|
|
var copy = this.clone();
|
|
var i, j, input, total, size, s, m, n;
|
|
|
|
// Create copy with 0-script inputs
|
|
for (i = 0; i < copy.inputs.length; i++)
|
|
copy.inputs[i].script = [];
|
|
|
|
total = copy.render().length;
|
|
|
|
// Add size for signatures and public keys
|
|
for (i = 0; i < copy.inputs.length; i++) {
|
|
input = copy.inputs[i];
|
|
size = 0;
|
|
|
|
// Get the previous output's subscript
|
|
s = input.prevout.tx.getSubscript(input.prevout.index);
|
|
|
|
// If we have access to the redeem script,
|
|
// we can use it to calculate size much easier.
|
|
if (this.inputs[i].script.length && bcoin.script.isScripthash(s)) {
|
|
s = this.inputs[i].script[this.inputs[i].script.length - 1];
|
|
// Need to add the redeem script size
|
|
// here since it will be ignored by
|
|
// the isMultisig clause.
|
|
// OP_PUSHDATA2 [redeem]
|
|
size += 3 + s.length;
|
|
s = bcoin.script.getSubscript(bcoin.script.decode(s));
|
|
}
|
|
|
|
if (bcoin.script.isPubkey(s)) {
|
|
// P2PK
|
|
// OP_PUSHDATA0 [signature]
|
|
size += 1 + 73;
|
|
} else if (bcoin.script.isPubkeyhash(s)) {
|
|
// P2PKH
|
|
// OP_PUSHDATA0 [signature]
|
|
size += 1 + 73;
|
|
// OP_PUSHDATA0 [key]
|
|
size += 1 + 65;
|
|
} else if (bcoin.script.isMultisig(s)) {
|
|
// Bare Multisig
|
|
// Get the previous m value:
|
|
m = s[0];
|
|
// OP_0
|
|
size += 1;
|
|
// OP_PUSHDATA0 [signature] ...
|
|
size += (1 + 73) * m;
|
|
} else if (bcoin.script.isScripthash(s)) {
|
|
// P2SH Multisig
|
|
// This technically won't work well for other
|
|
// kinds of P2SH. It will also over-estimate
|
|
// the fee by a lot (at least 10000 satoshis
|
|
// since we don't have access to the m and n
|
|
// values), which will be recalculated later.
|
|
// If fee turns out to be smaller later, we
|
|
// simply add more of the fee to the change
|
|
// output.
|
|
// m value
|
|
m = 15;
|
|
// n value
|
|
n = 15;
|
|
// OP_0
|
|
size += 1;
|
|
// OP_PUSHDATA0 [signature] ...
|
|
size += (1 + 73) * m;
|
|
// OP_PUSHDATA2 [redeem]
|
|
size += 3;
|
|
// m value
|
|
size += 1;
|
|
// OP_PUSHDATA0 [key] ...
|
|
size += (1 + 65) * n;
|
|
// n value
|
|
size += 1;
|
|
// OP_CHECKMULTISIG
|
|
size += 1;
|
|
} else {
|
|
// OP_PUSHDATA0 [signature]
|
|
for (j = 0; j < s.length; j++) {
|
|
if (bcoin.script.isKey(s[j]))
|
|
size += 1 + 73;
|
|
}
|
|
}
|
|
|
|
// Byte for varint size of input script
|
|
if (size < 0xfd)
|
|
size += 0;
|
|
else if (size <= 0xffff)
|
|
size += 2;
|
|
else if (size <= 0xffffffff)
|
|
size += 4;
|
|
else
|
|
size += 8;
|
|
|
|
total += size;
|
|
}
|
|
|
|
return total;
|
|
};
|
|
|
|
TX.prototype.getInputs = function getInputs(unspent, address, fee) {
|
|
var tx = this.clone();
|
|
var cost = tx.getFunds('output');
|
|
var totalkb = 1;
|
|
var total = cost.addn(constants.tx.fee);
|
|
var inputs = [];
|
|
var lastAdded = 0;
|
|
var size, newkb, change;
|
|
|
|
if (fee) {
|
|
total = cost.add(fee);
|
|
this.hardFee = fee;
|
|
}
|
|
|
|
function addInput(unspent) {
|
|
// Add new inputs until TX will have enough
|
|
// funds to cover both minimum post cost
|
|
// and fee.
|
|
var index = tx._addInput(unspent);
|
|
inputs.push(tx.inputs[index]);
|
|
lastAdded++;
|
|
return tx.getFunds('input').cmp(total) < 0;
|
|
}
|
|
|
|
// Transfer `total` funds maximum.
|
|
unspent.every(addInput);
|
|
|
|
if (!fee) {
|
|
// Add dummy output (for `change`) to
|
|
// calculate maximum TX size.
|
|
tx.addOutput({
|
|
address: address,
|
|
value: new bn(0)
|
|
});
|
|
|
|
// if (this.subtractFee) {
|
|
// var f = new bn((Math.ceil(tx.maxSize() / 1024) - 1) * constants.tx.fee);
|
|
// for (var j = 0; j < this.outputs.length; j++) {
|
|
// if (this.outputs[j].value.cmp(f.addn(constants.tx.dust)) >= 0) {
|
|
// this.outputs[j].value = this.outputs[j].value.sub(f);
|
|
// break;
|
|
// }
|
|
// }
|
|
// total = tx.getFunds('output');
|
|
// }
|
|
|
|
// Change fee value if it is more than 1024
|
|
// bytes (10000 satoshi for every 1024 bytes).
|
|
do {
|
|
// Calculate max possible size after signing.
|
|
size = tx.maxSize();
|
|
|
|
newkb = Math.ceil(size / 1024) - totalkb;
|
|
total.iaddn(newkb * constants.tx.fee);
|
|
totalkb += newkb;
|
|
|
|
// Failed to get enough funds, add more inputs.
|
|
if (tx.getFunds('input').cmp(total) < 0)
|
|
unspent.slice(lastAdded).every(addInput);
|
|
} while (tx.getFunds('input').cmp(total) < 0 && lastAdded < unspent.length);
|
|
}
|
|
|
|
if (tx.getFunds('input').cmp(total) < 0) {
|
|
// Still failing to get enough funds.
|
|
inputs = null;
|
|
} else {
|
|
// How much money is left after filling outputs.
|
|
change = tx.getFunds('input').sub(total);
|
|
}
|
|
|
|
// Return necessary inputs and change.
|
|
return {
|
|
inputs: inputs,
|
|
change: change,
|
|
cost: cost,
|
|
fee: total.sub(cost),
|
|
total: total,
|
|
kb: totalkb
|
|
};
|
|
};
|
|
|
|
TX.prototype.fill = function fill(unspent, address, fee) {
|
|
var result;
|
|
|
|
if (unspent)
|
|
this.unspent = unspent;
|
|
|
|
if (address)
|
|
this.changeAddress = address;
|
|
|
|
if (fee)
|
|
this.hardFee = fee;
|
|
|
|
assert(this.changeAddress);
|
|
|
|
result = this.getInputs(this.unspent, this.changeAddress, this.hardFee);
|
|
|
|
this.total = result.total;
|
|
|
|
if (!result.inputs)
|
|
return result;
|
|
|
|
result.inputs.forEach(function(input) {
|
|
this.addInput(input);
|
|
}, this);
|
|
|
|
if (result.change.cmpn(constants.tx.dust) < 0) {
|
|
// Do nothing. Change is added to fee.
|
|
assert.equal(
|
|
this.getFee().toNumber(),
|
|
result.fee.add(result.change).toNumber()
|
|
);
|
|
this.changeIndex = -1;
|
|
} else {
|
|
this.addOutput({
|
|
address: this.changeAddress,
|
|
value: result.change
|
|
});
|
|
|
|
this.changeIndex = this.outputs.length - 1;
|
|
}
|
|
|
|
return result;
|
|
};
|
|
|
|
// https://github.com/bitcoin/bips/blob/master/bip-0069.mediawiki
|
|
TX.prototype.sortMembers = function sortMembers() {
|
|
var changeOutput;
|
|
|
|
if (this.changeIndex !== -1) {
|
|
changeOutput = this.outputs[this.changeIndex];
|
|
assert(changeOutput);
|
|
}
|
|
|
|
this.inputs = this.inputs.slice().sort(function(a, b) {
|
|
var res = new bn(a.prevout.hash, 'hex').cmp(new bn(b.prevout.hash, 'hex'));
|
|
if (res !== 0)
|
|
return res;
|
|
|
|
return a.prevout.index - b.prevout.index;
|
|
});
|
|
|
|
this.outputs = this.outputs.slice().sort(function(a, b) {
|
|
var res = a.value.cmp(b.value);
|
|
if (res !== 0)
|
|
return res;
|
|
|
|
a = bcoin.script.encode(a.script);
|
|
b = bcoin.script.encode(b.script);
|
|
|
|
return new bn(a).cmp(b);
|
|
});
|
|
|
|
if (this.changeIndex !== -1) {
|
|
this.changeIndex = this.outputs.indexOf(changeOutput);
|
|
assert(this.changeIndex !== -1);
|
|
}
|
|
};
|
|
|
|
// Legacy
|
|
TX.prototype.fillUnspent = TX.prototype.fill;
|
|
TX.prototype.fillInputs = TX.prototype.fill;
|
|
|
|
TX.prototype._recalculateFee = function recalculateFee() {
|
|
var output = this.outputs[this.changeIndex];
|
|
var size, real, fee;
|
|
|
|
if (this.hardFee)
|
|
return;
|
|
|
|
if (!output) {
|
|
this.addOutput({
|
|
address: this.changeAddress,
|
|
value: new bn(0)
|
|
});
|
|
output = this.outputs[this.outputs.length - 1];
|
|
}
|
|
|
|
size = this.maxSize();
|
|
real = Math.ceil(size / 1024) * constants.tx.fee;
|
|
fee = this.getFee().toNumber();
|
|
|
|
// if (this.hardFee)
|
|
// real = this.hardFee;
|
|
|
|
if (real === fee) {
|
|
if (this.changeIndex === -1)
|
|
this.outputs.pop();
|
|
return;
|
|
}
|
|
|
|
if (real > fee) {
|
|
if (output.value.cmpn(real - fee) < 0) {
|
|
this.outputs.pop();
|
|
this.changeIndex = -1;
|
|
return;
|
|
}
|
|
output.value.isubn(real - fee);
|
|
} else {
|
|
output.value.iaddn(fee - real);
|
|
}
|
|
|
|
if (output.value.cmpn(constants.tx.dust) < 0) {
|
|
this.outputs.pop();
|
|
this.changeIndex = -1;
|
|
return;
|
|
}
|
|
|
|
this.changeIndex = this.outputs.indexOf(output);
|
|
};
|
|
|
|
TX.prototype.getFee = function getFee() {
|
|
if (this.getFunds('input').cmp(this.getFunds('output')) < 0)
|
|
return new bn(0);
|
|
|
|
return this.getFunds('input').sub(this.getFunds('output'));
|
|
};
|
|
|
|
TX.prototype.getFunds = function getFunds(side) {
|
|
var acc = new bn(0);
|
|
var inputs;
|
|
|
|
if (side === 'in' || side === 'input') {
|
|
inputs = this.inputs.filter(function(input) {
|
|
return input.prevout.tx;
|
|
});
|
|
|
|
if (inputs.length === 0)
|
|
return acc;
|
|
|
|
inputs.reduce(function(acc, input) {
|
|
return acc.iadd(input.prevout.tx.outputs[input.prevout.index].value);
|
|
}, acc);
|
|
|
|
return acc;
|
|
}
|
|
|
|
// Output
|
|
if (this.outputs.length === 0)
|
|
return acc;
|
|
|
|
this.outputs.reduce(function(acc, output) {
|
|
return acc.iadd(output.value);
|
|
}, acc);
|
|
|
|
return acc;
|
|
};
|
|
|
|
// Legacy
|
|
TX.prototype.funds = TX.prototype.getFunds;
|
|
|
|
TX.prototype.getTargetLocktime = function getTargetLocktime() {
|
|
var bestValue = 0;
|
|
var i, locktime, bestType;
|
|
|
|
for (i = 0; i < this.inputs.length; i++) {
|
|
locktime = this.inputs[i].getLocktime();
|
|
|
|
if (!locktime)
|
|
continue;
|
|
|
|
// Incompatible types
|
|
if (bestType && bestType !== locktime.type)
|
|
return;
|
|
|
|
bestType = locktime.type;
|
|
|
|
if (locktime.value < bestValue)
|
|
continue;
|
|
|
|
bestValue = locktime.value;
|
|
}
|
|
|
|
return {
|
|
type: bestType || 'height',
|
|
value: bestValue
|
|
};
|
|
};
|
|
|
|
TX.prototype.testInputs = function testInputs(addressTable, index, collect) {
|
|
var inputs = [];
|
|
var i, input, prev, data, j;
|
|
|
|
if (typeof addressTable === 'string')
|
|
addressTable = [addressTable];
|
|
|
|
if (Array.isArray(addressTable)) {
|
|
addressTable = addressTable.reduce(function(address) {
|
|
out[address] = true;
|
|
return out;
|
|
}, {});
|
|
}
|
|
|
|
if (index && typeof index === 'object')
|
|
index = this.inputs.indexOf(index);
|
|
|
|
if (index != null)
|
|
assert(this.inputs[index]);
|
|
|
|
for (i = 0; i < this.inputs.length; i++) {
|
|
if (index != null && i !== index)
|
|
continue;
|
|
|
|
input = this.inputs[i];
|
|
|
|
if (input.prevout.tx)
|
|
prev = input.prevout.tx.outputs[input.prevout.index].script;
|
|
else
|
|
prev = null;
|
|
|
|
data = bcoin.script.getInputData(input.script, prev);
|
|
|
|
if (data.addresses) {
|
|
for (j = 0; j < data.addresses.length; j++) {
|
|
if (addressTable[data.addresses[j]] != null) {
|
|
if (!collect)
|
|
return true;
|
|
inputs.push(input);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (data.scriptAddress) {
|
|
if (addressTable[data.scriptAddress] != null) {
|
|
if (!collect)
|
|
return true;
|
|
inputs.push(input);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!collect)
|
|
return false;
|
|
|
|
if (inputs.length === 0)
|
|
return false;
|
|
|
|
return inputs;
|
|
};
|
|
|
|
TX.prototype.testOutputs = function testOutputs(addressTable, index, collect) {
|
|
var outputs = [];
|
|
var i, output, data, j;
|
|
|
|
if (typeof addressTable === 'string')
|
|
addressTable = [addressTable];
|
|
|
|
if (Array.isArray(addressTable)) {
|
|
addressTable = addressTable.reduce(function(address) {
|
|
out[address] = true;
|
|
return out;
|
|
}, {});
|
|
}
|
|
|
|
if (index && typeof index === 'object')
|
|
index = this.outputs.indexOf(index);
|
|
|
|
if (index != null)
|
|
assert(this.outputs[index]);
|
|
|
|
for (i = 0; i < this.outputs.length; i++) {
|
|
if (index != null && i !== index)
|
|
continue;
|
|
|
|
output = this.outputs[i];
|
|
|
|
data = bcoin.script.getOutputData(output.script);
|
|
|
|
if (data.addresses) {
|
|
for (j = 0; j < data.addresses.length; j++) {
|
|
if (addressTable[data.addresses[j]] != null) {
|
|
if (!collect)
|
|
return true;
|
|
outputs.push(output);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (data.scriptAddress) {
|
|
if (addressTable[data.scriptAddress] != null) {
|
|
if (!collect)
|
|
return true;
|
|
outputs.push(output);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!collect)
|
|
return false;
|
|
|
|
if (outputs.length === 0)
|
|
return false;
|
|
|
|
return outputs;
|
|
};
|
|
|
|
TX.prototype.avoidFeeSnipping = function avoidFeeSnipping() {
|
|
if (!this.chain)
|
|
return;
|
|
|
|
this.setLocktime(this.chain.height());
|
|
|
|
if ((Math.random() * 10 | 0) === 0)
|
|
this.setLocktime(Math.max(0, this.locktime - (Math.random() * 100 | 0)));
|
|
};
|
|
|
|
TX.prototype.setLocktime = function setLocktime(locktime) {
|
|
var i, input;
|
|
|
|
this.locktime = locktime;
|
|
|
|
for (i = 0; i < this.inputs.length; i++) {
|
|
input = this.inputs[i];
|
|
if (input.sequence === 0xffffffff)
|
|
input.sequence = 0;
|
|
}
|
|
};
|
|
|
|
TX.prototype.increaseFee = function increaseFee(fee) {
|
|
var i, input;
|
|
|
|
this.hardFee = fee || this.getFee().add(new bn(10000));
|
|
this.fill();
|
|
|
|
for (i = 0; i < this.inputs.length; i++) {
|
|
input = this.inputs[i];
|
|
input.sequence = 0xffffffff - 1;
|
|
}
|
|
};
|
|
|
|
TX.prototype.isFull = function isFull() {
|
|
if (this.inputs.length === 0)
|
|
return false;
|
|
return this.inputs.every(function(input) {
|
|
return !!input.prevout.tx;
|
|
});
|
|
};
|
|
|
|
TX.prototype.fillPrevout = function fillPrevout(txs) {
|
|
var inputs;
|
|
|
|
if (txs instanceof bcoin.txPool)
|
|
txs = txs._all;
|
|
else if (txs instanceof bcoin.wallet)
|
|
txs = txs.tx._all;
|
|
|
|
if (Array.isArray(txs)) {
|
|
txs = txs.reduce(function(out, tx) {
|
|
out[tx.hash('hex')] = tx;
|
|
return out;
|
|
}, {});
|
|
}
|
|
|
|
inputs = this.inputs.filter(function(input) {
|
|
if (!input.prevout.tx && txs[input.prevout.hash])
|
|
input.prevout.tx = txs[input.prevout.hash];
|
|
return !!input.prevout.tx;
|
|
}, this);
|
|
|
|
return inputs.length === this.inputs.length;
|
|
};
|
|
|
|
// Used for verifyContext/ContextualBlockCheck and miner isFinalTx call.
|
|
// BIP113 will require that time-locked transactions have nLockTime set to
|
|
// less than the median time of the previous block they're contained in.
|
|
TX.prototype.isFinalBlock = function isFinalBlock(block, prev, useMedian) {
|
|
var height = prev.height + 1;
|
|
var ts = useMedian ? prev.getMedianTime() : block.ts;
|
|
return this.isFinal(height, ts);
|
|
};
|
|
|
|
// Used in AcceptToMemoryPool
|
|
TX.prototype.isFinalMempool = function isFinalMempool(useMedian) {
|
|
var height, ts;
|
|
|
|
if (!this.chain)
|
|
return true;
|
|
|
|
height = this.chain.height() + 1;
|
|
ts = useMedian
|
|
? this.chain.getTip().getMedianTime()
|
|
: utils.now();
|
|
|
|
return this.isFinal(height, ts);
|
|
};
|
|
|
|
// Used in the original bitcoind code for AcceptBlock
|
|
TX.prototype.isFinalLegacy = function isFinalLegacy(block) {
|
|
var ts, height;
|
|
|
|
if (!this.chain)
|
|
return true;
|
|
|
|
ts = block ? block.ts : utils.now();
|
|
height = this.chain.height();
|
|
|
|
return this.isFinal(height, ts);
|
|
};
|
|
|
|
TX.prototype.isFinal = function isFinal(height, ts) {
|
|
var threshold = constants.locktimeThreshold;
|
|
var i;
|
|
|
|
if (!this.chain)
|
|
return true;
|
|
|
|
if (this.locktime === 0)
|
|
return true;
|
|
|
|
if (this.locktime < (this.locktime < threshold ? height : ts))
|
|
return true;
|
|
|
|
for (i = 0; i < this.inputs.length; i++) {
|
|
if (this.inputs[i].sequence !== 0xffffffff)
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
TX.prototype.getSigops = function getSigops(scriptHash, accurate) {
|
|
var n = 0;
|
|
this.inputs.forEach(function(input) {
|
|
n += bcoin.script.getSigops(input.script, accurate);
|
|
if (scriptHash && !this.isCoinbase())
|
|
n += bcoin.script.getScripthashSigops(input.script);
|
|
}, this);
|
|
this.outputs.forEach(function(output) {
|
|
n += bcoin.script.getSigops(output.script, accurate);
|
|
}, this);
|
|
return n;
|
|
};
|
|
|
|
TX.prototype.isStandard = function isStandard() {
|
|
var i, input, output, type;
|
|
var nulldata = 0;
|
|
|
|
if (this.version > constants.tx.version || this.version < 1)
|
|
return false;
|
|
|
|
if (this.getSize() > constants.tx.maxSize)
|
|
return false;
|
|
|
|
for (i = 0; i < this.inputs.length; i++) {
|
|
input = this.inputs[i];
|
|
|
|
if (bcoin.script.getSize(input.script) > 1650)
|
|
return false;
|
|
|
|
if (!bcoin.script.isPushOnly(input.script))
|
|
return false;
|
|
}
|
|
|
|
for (i = 0; i < this.outputs.length; i++) {
|
|
output = this.outputs[i];
|
|
type = bcoin.script.getType(output.script);
|
|
|
|
if (!bcoin.script.isStandard(output.script))
|
|
return false;
|
|
|
|
if (!type)
|
|
return false;
|
|
|
|
if (type === 'nulldata') {
|
|
nulldata++;
|
|
continue;
|
|
}
|
|
|
|
if (type === 'multisig' && !constants.tx.bareMultisig)
|
|
return false;
|
|
|
|
if (output.value.cmpn(constants.tx.dust) < 0)
|
|
return false;
|
|
}
|
|
|
|
if (nulldata > 1)
|
|
return false;
|
|
|
|
return true;
|
|
};
|
|
|
|
TX.prototype.isStandardInputs = function isStandardInputs(flags) {
|
|
var i, input, prev, args, stack, res, s, targs;
|
|
|
|
if (this.isCoinbase())
|
|
return true;
|
|
|
|
for (i = 0; i < this.inputs.length; i++) {
|
|
input = this.inputs[i];
|
|
|
|
if (!input.prevout.tx)
|
|
return false;
|
|
|
|
prev = input.prevout.tx.outputs[input.prevout.index];
|
|
|
|
if (!prev)
|
|
return false;
|
|
|
|
args = bcoin.script.getArgs(prev.script);
|
|
|
|
if (args < 0)
|
|
return false;
|
|
|
|
stack = [];
|
|
|
|
res = bcoin.script.execute(input.script, stack, this, i, flags);
|
|
|
|
if (!res)
|
|
return false;
|
|
|
|
if (bcoin.script.isScripthash(prev.script)) {
|
|
if (stack.length === 0)
|
|
return false;
|
|
|
|
s = stack[stack.length - 1];
|
|
|
|
if (!Array.isArray(s))
|
|
return false;
|
|
|
|
s = bcoin.script.getSubscript(bcoin.script.decode(s));
|
|
|
|
if (bcoin.script.getType(s) !== 'unknown') {
|
|
targs = bcoin.script.getArgs(s);
|
|
if (targs < 0)
|
|
return false;
|
|
args += targs;
|
|
} else {
|
|
return script.getSigops(s, true) <= constants.script.maxScripthashSigops;
|
|
}
|
|
}
|
|
|
|
if (stack.length !== args)
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
TX.prototype.getPriority = function getPriority() {
|
|
var size, value, i, input, output, age;
|
|
|
|
size = this.maxSize();
|
|
value = new bn(0);
|
|
|
|
for (i = 0; i < this.inputs.length; i++) {
|
|
input = this.inputs[i];
|
|
|
|
if (!input.prevout.tx)
|
|
return constants.tx.freeThreshold.clone();
|
|
|
|
output = input.prevout.tx.outputs[input.prevout.index];
|
|
age = input.prevout.tx.getConfirmations();
|
|
|
|
if (age === -1)
|
|
age = 0;
|
|
|
|
if (age !== 0)
|
|
age += 1;
|
|
|
|
value.iadd(output.value.muln(age));
|
|
}
|
|
|
|
return priority.divn(size);
|
|
};
|
|
|
|
TX.prototype.isFree = function isFree() {
|
|
var size = this.maxSize();
|
|
var priority;
|
|
|
|
if (size >= constants.tx.maxFreeSize)
|
|
return false;
|
|
|
|
priority = this.getPriority();
|
|
|
|
return priority.cmp(constants.tx.freeThreshold) > 0;
|
|
};
|
|
|
|
TX.prototype.getHeight = function getHeight() {
|
|
if (!this.chain)
|
|
return -1;
|
|
return this.block ? this.chain.getHeight(this.block) : -1;
|
|
};
|
|
|
|
TX.prototype.getConfirmations = function getConfirmations() {
|
|
var top, height;
|
|
|
|
if (!this.chain)
|
|
return 0;
|
|
|
|
top = this.chain.height();
|
|
height = this.getHeight();
|
|
|
|
if (height === -1)
|
|
return 0;
|
|
|
|
return top - height + 1;
|
|
};
|
|
|
|
TX.prototype.getValue = function getValue() {
|
|
return this.getFunds('output');
|
|
};
|
|
|
|
TX.prototype.__defineGetter__('chain', function() {
|
|
return this._chain || bcoin.chain.global;
|
|
});
|
|
|
|
TX.prototype.__defineGetter__('rblock', function() {
|
|
return this.block
|
|
? utils.revHex(this.block)
|
|
: null;
|
|
});
|
|
|
|
TX.prototype.__defineGetter__('rhash', function() {
|
|
return utils.revHex(this.hash('hex'));
|
|
});
|
|
|
|
TX.prototype.__defineGetter__('fee', function() {
|
|
return this.getFee();
|
|
});
|
|
|
|
TX.prototype.__defineGetter__('value', function() {
|
|
return this.getValue();
|
|
});
|
|
|
|
TX.prototype.__defineGetter__('height', function() {
|
|
return this.getHeight();
|
|
});
|
|
|
|
TX.prototype.__defineGetter__('confirmations', function() {
|
|
return this.getConfirmations();
|
|
});
|
|
|
|
TX.prototype.__defineGetter__('priority', function() {
|
|
return this.getPriority();
|
|
});
|
|
|
|
TX.prototype.inspect = function inspect() {
|
|
var copy = bcoin.tx(this);
|
|
copy.__proto__ = null;
|
|
if (this.block)
|
|
copy.block = this.block;
|
|
delete copy._raw;
|
|
delete copy._chain;
|
|
delete copy.unspent;
|
|
copy.hash = this.hash('hex');
|
|
copy.rhash = this.rhash;
|
|
copy.rblock = this.rblock;
|
|
copy.value = utils.btc(this.getValue());
|
|
copy.fee = utils.btc(this.getFee());
|
|
copy.height = this.getHeight();
|
|
copy.confirmations = this.getConfirmations();
|
|
// copy.priority = this.getPriority().toString(10);
|
|
copy.date = new Date((copy.ts || 0) * 1000).toISOString();
|
|
if (copy.hardFee)
|
|
copy.hardFee = utils.btc(copy.hardFee);
|
|
return copy;
|
|
};
|
|
|
|
TX.prototype.toJSON = function toJSON() {
|
|
// Compact representation
|
|
return {
|
|
v: 1,
|
|
type: 'tx',
|
|
ts: this.ts,
|
|
ps: this.ps,
|
|
block: this.block,
|
|
network: this.network,
|
|
relayedBy: this.relayedBy,
|
|
changeAddress: this.changeAddress,
|
|
changeIndex: this.changeIndex,
|
|
hardFee: this.hardFee ? utils.btc(this.hardFee) : null,
|
|
tx: utils.toHex(this.render())
|
|
};
|
|
};
|
|
|
|
TX.fromJSON = function fromJSON(json) {
|
|
var raw, data, tx;
|
|
|
|
assert.equal(json.v, 1);
|
|
assert.equal(json.type, 'tx');
|
|
|
|
raw = utils.toArray(json.tx, 'hex');
|
|
data = new bcoin.protocol.parser().parseTX(raw);
|
|
|
|
data.network = json.network;
|
|
data.relayedBy = json.relayedBy;
|
|
|
|
data.changeAddress = json.changeAddress;
|
|
data.changeIndex = json.changeIndex;
|
|
|
|
if (json.hardFee)
|
|
data.hardFee = utils.satoshi(json.hardFee);
|
|
|
|
data._raw = raw;
|
|
data._size = raw.length;
|
|
|
|
tx = new TX(data);
|
|
tx.ts = json.ts;
|
|
tx.block = json.block || null;
|
|
tx.ps = json.ps;
|
|
|
|
return tx;
|
|
};
|
|
|
|
TX.prototype.toRaw = function toRaw(enc) {
|
|
var raw = this.render();
|
|
|
|
if (enc === 'hex')
|
|
return utils.toHex(raw);
|
|
|
|
return raw;
|
|
};
|
|
|
|
TX.fromRaw = function fromRaw(raw, enc) {
|
|
if (enc === 'hex')
|
|
raw = utils.toArray(raw, 'hex');
|
|
return new bcoin.tx(new bcoin.protocol.parser().parseTX(raw));
|
|
};
|
|
|
|
/**
|
|
* Expose
|
|
*/
|
|
|
|
module.exports = TX;
|