452 lines
16 KiB
JavaScript
452 lines
16 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const bufferutils = require("./bufferutils");
|
|
const bufferutils_1 = require("./bufferutils");
|
|
const bcrypto = require("./crypto");
|
|
const bscript = require("./script");
|
|
const script_1 = require("./script");
|
|
const types = require("./types");
|
|
const typeforce = require('typeforce');
|
|
const varuint = require('varuint-bitcoin');
|
|
function varSliceSize(someScript) {
|
|
const length = someScript.length;
|
|
return varuint.encodingLength(length) + length;
|
|
}
|
|
function vectorSize(someVector) {
|
|
const length = someVector.length;
|
|
return (varuint.encodingLength(length) +
|
|
someVector.reduce((sum, witness) => {
|
|
return sum + varSliceSize(witness);
|
|
}, 0));
|
|
}
|
|
const EMPTY_SCRIPT = Buffer.allocUnsafe(0);
|
|
const EMPTY_WITNESS = [];
|
|
const ZERO = Buffer.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex');
|
|
const ONE = Buffer.from('0000000000000000000000000000000000000000000000000000000000000001', 'hex');
|
|
const VALUE_UINT64_MAX = Buffer.from('ffffffffffffffff', 'hex');
|
|
const BLANK_OUTPUT = {
|
|
script: EMPTY_SCRIPT,
|
|
valueBuffer: VALUE_UINT64_MAX,
|
|
};
|
|
function isOutput(out) {
|
|
return out.value !== undefined;
|
|
}
|
|
class Transaction {
|
|
constructor() {
|
|
this.version = 1;
|
|
this.locktime = 0;
|
|
this.ins = [];
|
|
this.outs = [];
|
|
}
|
|
static fromBuffer(buffer, _NO_STRICT) {
|
|
let offset = 0;
|
|
function readSlice(n) {
|
|
offset += n;
|
|
return buffer.slice(offset - n, offset);
|
|
}
|
|
function readUInt32() {
|
|
const i = buffer.readUInt32LE(offset);
|
|
offset += 4;
|
|
return i;
|
|
}
|
|
function readInt32() {
|
|
const i = buffer.readInt32LE(offset);
|
|
offset += 4;
|
|
return i;
|
|
}
|
|
function readUInt64() {
|
|
const i = bufferutils.readUInt64LE(buffer, offset);
|
|
offset += 8;
|
|
return i;
|
|
}
|
|
function readVarInt() {
|
|
const vi = varuint.decode(buffer, offset);
|
|
offset += varuint.decode.bytes;
|
|
return vi;
|
|
}
|
|
function readVarSlice() {
|
|
return readSlice(readVarInt());
|
|
}
|
|
function readVector() {
|
|
const count = readVarInt();
|
|
const vector = [];
|
|
for (let i = 0; i < count; i++)
|
|
vector.push(readVarSlice());
|
|
return vector;
|
|
}
|
|
const tx = new Transaction();
|
|
tx.version = readInt32();
|
|
const marker = buffer.readUInt8(offset);
|
|
const flag = buffer.readUInt8(offset + 1);
|
|
let hasWitnesses = false;
|
|
if (marker === Transaction.ADVANCED_TRANSACTION_MARKER &&
|
|
flag === Transaction.ADVANCED_TRANSACTION_FLAG) {
|
|
offset += 2;
|
|
hasWitnesses = true;
|
|
}
|
|
const vinLen = readVarInt();
|
|
for (let i = 0; i < vinLen; ++i) {
|
|
tx.ins.push({
|
|
hash: readSlice(32),
|
|
index: readUInt32(),
|
|
script: readVarSlice(),
|
|
sequence: readUInt32(),
|
|
witness: EMPTY_WITNESS,
|
|
});
|
|
}
|
|
const voutLen = readVarInt();
|
|
for (let i = 0; i < voutLen; ++i) {
|
|
tx.outs.push({
|
|
value: readUInt64(),
|
|
script: readVarSlice(),
|
|
});
|
|
}
|
|
if (hasWitnesses) {
|
|
for (let i = 0; i < vinLen; ++i) {
|
|
tx.ins[i].witness = readVector();
|
|
}
|
|
// was this pointless?
|
|
if (!tx.hasWitnesses())
|
|
throw new Error('Transaction has superfluous witness data');
|
|
}
|
|
tx.locktime = readUInt32();
|
|
if (_NO_STRICT)
|
|
return tx;
|
|
if (offset !== buffer.length)
|
|
throw new Error('Transaction has unexpected data');
|
|
return tx;
|
|
}
|
|
static fromHex(hex) {
|
|
return Transaction.fromBuffer(Buffer.from(hex, 'hex'), false);
|
|
}
|
|
static isCoinbaseHash(buffer) {
|
|
typeforce(types.Hash256bit, buffer);
|
|
for (let i = 0; i < 32; ++i) {
|
|
if (buffer[i] !== 0)
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
isCoinbase() {
|
|
return (this.ins.length === 1 && Transaction.isCoinbaseHash(this.ins[0].hash));
|
|
}
|
|
addInput(hash, index, sequence, scriptSig) {
|
|
typeforce(types.tuple(types.Hash256bit, types.UInt32, types.maybe(types.UInt32), types.maybe(types.Buffer)), arguments);
|
|
if (types.Null(sequence)) {
|
|
sequence = Transaction.DEFAULT_SEQUENCE;
|
|
}
|
|
// Add the input and return the input's index
|
|
return (this.ins.push({
|
|
hash,
|
|
index,
|
|
script: scriptSig || EMPTY_SCRIPT,
|
|
sequence: sequence,
|
|
witness: EMPTY_WITNESS,
|
|
}) - 1);
|
|
}
|
|
addOutput(scriptPubKey, value) {
|
|
typeforce(types.tuple(types.Buffer, types.Satoshi), arguments);
|
|
// Add the output and return the output's index
|
|
return (this.outs.push({
|
|
script: scriptPubKey,
|
|
value,
|
|
}) - 1);
|
|
}
|
|
hasWitnesses() {
|
|
return this.ins.some(x => {
|
|
return x.witness.length !== 0;
|
|
});
|
|
}
|
|
weight() {
|
|
const base = this.__byteLength(false);
|
|
const total = this.__byteLength(true);
|
|
return base * 3 + total;
|
|
}
|
|
virtualSize() {
|
|
return Math.ceil(this.weight() / 4);
|
|
}
|
|
byteLength() {
|
|
return this.__byteLength(true);
|
|
}
|
|
clone() {
|
|
const newTx = new Transaction();
|
|
newTx.version = this.version;
|
|
newTx.locktime = this.locktime;
|
|
newTx.ins = this.ins.map(txIn => {
|
|
return {
|
|
hash: txIn.hash,
|
|
index: txIn.index,
|
|
script: txIn.script,
|
|
sequence: txIn.sequence,
|
|
witness: txIn.witness,
|
|
};
|
|
});
|
|
newTx.outs = this.outs.map(txOut => {
|
|
return {
|
|
script: txOut.script,
|
|
value: txOut.value,
|
|
};
|
|
});
|
|
return newTx;
|
|
}
|
|
/**
|
|
* Hash transaction for signing a specific input.
|
|
*
|
|
* Bitcoin uses a different hash for each signed transaction input.
|
|
* This method copies the transaction, makes the necessary changes based on the
|
|
* hashType, and then hashes the result.
|
|
* This hash can then be used to sign the provided transaction input.
|
|
*/
|
|
hashForSignature(inIndex, prevOutScript, hashType) {
|
|
typeforce(types.tuple(types.UInt32, types.Buffer, /* types.UInt8 */ types.Number), arguments);
|
|
// https://github.com/bitcoin/bitcoin/blob/master/src/test/sighash_tests.cpp#L29
|
|
if (inIndex >= this.ins.length)
|
|
return ONE;
|
|
// ignore OP_CODESEPARATOR
|
|
const ourScript = bscript.compile(bscript.decompile(prevOutScript).filter(x => {
|
|
return x !== script_1.OPS.OP_CODESEPARATOR;
|
|
}));
|
|
const txTmp = this.clone();
|
|
// SIGHASH_NONE: ignore all outputs? (wildcard payee)
|
|
if ((hashType & 0x1f) === Transaction.SIGHASH_NONE) {
|
|
txTmp.outs = [];
|
|
// ignore sequence numbers (except at inIndex)
|
|
txTmp.ins.forEach((input, i) => {
|
|
if (i === inIndex)
|
|
return;
|
|
input.sequence = 0;
|
|
});
|
|
// SIGHASH_SINGLE: ignore all outputs, except at the same index?
|
|
}
|
|
else if ((hashType & 0x1f) === Transaction.SIGHASH_SINGLE) {
|
|
// https://github.com/bitcoin/bitcoin/blob/master/src/test/sighash_tests.cpp#L60
|
|
if (inIndex >= this.outs.length)
|
|
return ONE;
|
|
// truncate outputs after
|
|
txTmp.outs.length = inIndex + 1;
|
|
// "blank" outputs before
|
|
for (let i = 0; i < inIndex; i++) {
|
|
txTmp.outs[i] = BLANK_OUTPUT;
|
|
}
|
|
// ignore sequence numbers (except at inIndex)
|
|
txTmp.ins.forEach((input, y) => {
|
|
if (y === inIndex)
|
|
return;
|
|
input.sequence = 0;
|
|
});
|
|
}
|
|
// SIGHASH_ANYONECANPAY: ignore inputs entirely?
|
|
if (hashType & Transaction.SIGHASH_ANYONECANPAY) {
|
|
txTmp.ins = [txTmp.ins[inIndex]];
|
|
txTmp.ins[0].script = ourScript;
|
|
// SIGHASH_ALL: only ignore input scripts
|
|
}
|
|
else {
|
|
// "blank" others input scripts
|
|
txTmp.ins.forEach(input => {
|
|
input.script = EMPTY_SCRIPT;
|
|
});
|
|
txTmp.ins[inIndex].script = ourScript;
|
|
}
|
|
// serialize and hash
|
|
const buffer = Buffer.allocUnsafe(txTmp.__byteLength(false) + 4);
|
|
buffer.writeInt32LE(hashType, buffer.length - 4);
|
|
txTmp.__toBuffer(buffer, 0, false);
|
|
return bcrypto.hash256(buffer);
|
|
}
|
|
hashForWitnessV0(inIndex, prevOutScript, value, hashType) {
|
|
typeforce(types.tuple(types.UInt32, types.Buffer, types.Satoshi, types.UInt32), arguments);
|
|
let tbuffer = Buffer.from([]);
|
|
let toffset = 0;
|
|
function writeSlice(slice) {
|
|
toffset += slice.copy(tbuffer, toffset);
|
|
}
|
|
function writeUInt32(i) {
|
|
toffset = tbuffer.writeUInt32LE(i, toffset);
|
|
}
|
|
function writeUInt64(i) {
|
|
toffset = bufferutils.writeUInt64LE(tbuffer, i, toffset);
|
|
}
|
|
function writeVarInt(i) {
|
|
varuint.encode(i, tbuffer, toffset);
|
|
toffset += varuint.encode.bytes;
|
|
}
|
|
function writeVarSlice(slice) {
|
|
writeVarInt(slice.length);
|
|
writeSlice(slice);
|
|
}
|
|
let hashOutputs = ZERO;
|
|
let hashPrevouts = ZERO;
|
|
let hashSequence = ZERO;
|
|
if (!(hashType & Transaction.SIGHASH_ANYONECANPAY)) {
|
|
tbuffer = Buffer.allocUnsafe(36 * this.ins.length);
|
|
toffset = 0;
|
|
this.ins.forEach(txIn => {
|
|
writeSlice(txIn.hash);
|
|
writeUInt32(txIn.index);
|
|
});
|
|
hashPrevouts = bcrypto.hash256(tbuffer);
|
|
}
|
|
if (!(hashType & Transaction.SIGHASH_ANYONECANPAY) &&
|
|
(hashType & 0x1f) !== Transaction.SIGHASH_SINGLE &&
|
|
(hashType & 0x1f) !== Transaction.SIGHASH_NONE) {
|
|
tbuffer = Buffer.allocUnsafe(4 * this.ins.length);
|
|
toffset = 0;
|
|
this.ins.forEach(txIn => {
|
|
writeUInt32(txIn.sequence);
|
|
});
|
|
hashSequence = bcrypto.hash256(tbuffer);
|
|
}
|
|
if ((hashType & 0x1f) !== Transaction.SIGHASH_SINGLE &&
|
|
(hashType & 0x1f) !== Transaction.SIGHASH_NONE) {
|
|
const txOutsSize = this.outs.reduce((sum, output) => {
|
|
return sum + 8 + varSliceSize(output.script);
|
|
}, 0);
|
|
tbuffer = Buffer.allocUnsafe(txOutsSize);
|
|
toffset = 0;
|
|
this.outs.forEach(out => {
|
|
writeUInt64(out.value);
|
|
writeVarSlice(out.script);
|
|
});
|
|
hashOutputs = bcrypto.hash256(tbuffer);
|
|
}
|
|
else if ((hashType & 0x1f) === Transaction.SIGHASH_SINGLE &&
|
|
inIndex < this.outs.length) {
|
|
const output = this.outs[inIndex];
|
|
tbuffer = Buffer.allocUnsafe(8 + varSliceSize(output.script));
|
|
toffset = 0;
|
|
writeUInt64(output.value);
|
|
writeVarSlice(output.script);
|
|
hashOutputs = bcrypto.hash256(tbuffer);
|
|
}
|
|
tbuffer = Buffer.allocUnsafe(156 + varSliceSize(prevOutScript));
|
|
toffset = 0;
|
|
const input = this.ins[inIndex];
|
|
writeUInt32(this.version);
|
|
writeSlice(hashPrevouts);
|
|
writeSlice(hashSequence);
|
|
writeSlice(input.hash);
|
|
writeUInt32(input.index);
|
|
writeVarSlice(prevOutScript);
|
|
writeUInt64(value);
|
|
writeUInt32(input.sequence);
|
|
writeSlice(hashOutputs);
|
|
writeUInt32(this.locktime);
|
|
writeUInt32(hashType);
|
|
return bcrypto.hash256(tbuffer);
|
|
}
|
|
getHash(forWitness) {
|
|
// wtxid for coinbase is always 32 bytes of 0x00
|
|
if (forWitness && this.isCoinbase())
|
|
return Buffer.alloc(32, 0);
|
|
return bcrypto.hash256(this.__toBuffer(undefined, undefined, forWitness));
|
|
}
|
|
getId() {
|
|
// transaction hash's are displayed in reverse order
|
|
return bufferutils_1.reverseBuffer(this.getHash(false)).toString('hex');
|
|
}
|
|
toBuffer(buffer, initialOffset) {
|
|
return this.__toBuffer(buffer, initialOffset, true);
|
|
}
|
|
toHex() {
|
|
return this.toBuffer(undefined, undefined).toString('hex');
|
|
}
|
|
setInputScript(index, scriptSig) {
|
|
typeforce(types.tuple(types.Number, types.Buffer), arguments);
|
|
this.ins[index].script = scriptSig;
|
|
}
|
|
setWitness(index, witness) {
|
|
typeforce(types.tuple(types.Number, [types.Buffer]), arguments);
|
|
this.ins[index].witness = witness;
|
|
}
|
|
__byteLength(_ALLOW_WITNESS) {
|
|
const hasWitnesses = _ALLOW_WITNESS && this.hasWitnesses();
|
|
return ((hasWitnesses ? 10 : 8) +
|
|
varuint.encodingLength(this.ins.length) +
|
|
varuint.encodingLength(this.outs.length) +
|
|
this.ins.reduce((sum, input) => {
|
|
return sum + 40 + varSliceSize(input.script);
|
|
}, 0) +
|
|
this.outs.reduce((sum, output) => {
|
|
return sum + 8 + varSliceSize(output.script);
|
|
}, 0) +
|
|
(hasWitnesses
|
|
? this.ins.reduce((sum, input) => {
|
|
return sum + vectorSize(input.witness);
|
|
}, 0)
|
|
: 0));
|
|
}
|
|
__toBuffer(buffer, initialOffset, _ALLOW_WITNESS) {
|
|
if (!buffer)
|
|
buffer = Buffer.allocUnsafe(this.__byteLength(_ALLOW_WITNESS));
|
|
let offset = initialOffset || 0;
|
|
function writeSlice(slice) {
|
|
offset += slice.copy(buffer, offset);
|
|
}
|
|
function writeUInt8(i) {
|
|
offset = buffer.writeUInt8(i, offset);
|
|
}
|
|
function writeUInt32(i) {
|
|
offset = buffer.writeUInt32LE(i, offset);
|
|
}
|
|
function writeInt32(i) {
|
|
offset = buffer.writeInt32LE(i, offset);
|
|
}
|
|
function writeUInt64(i) {
|
|
offset = bufferutils.writeUInt64LE(buffer, i, offset);
|
|
}
|
|
function writeVarInt(i) {
|
|
varuint.encode(i, buffer, offset);
|
|
offset += varuint.encode.bytes;
|
|
}
|
|
function writeVarSlice(slice) {
|
|
writeVarInt(slice.length);
|
|
writeSlice(slice);
|
|
}
|
|
function writeVector(vector) {
|
|
writeVarInt(vector.length);
|
|
vector.forEach(writeVarSlice);
|
|
}
|
|
writeInt32(this.version);
|
|
const hasWitnesses = _ALLOW_WITNESS && this.hasWitnesses();
|
|
if (hasWitnesses) {
|
|
writeUInt8(Transaction.ADVANCED_TRANSACTION_MARKER);
|
|
writeUInt8(Transaction.ADVANCED_TRANSACTION_FLAG);
|
|
}
|
|
writeVarInt(this.ins.length);
|
|
this.ins.forEach(txIn => {
|
|
writeSlice(txIn.hash);
|
|
writeUInt32(txIn.index);
|
|
writeVarSlice(txIn.script);
|
|
writeUInt32(txIn.sequence);
|
|
});
|
|
writeVarInt(this.outs.length);
|
|
this.outs.forEach(txOut => {
|
|
if (isOutput(txOut)) {
|
|
writeUInt64(txOut.value);
|
|
}
|
|
else {
|
|
writeSlice(txOut.valueBuffer);
|
|
}
|
|
writeVarSlice(txOut.script);
|
|
});
|
|
if (hasWitnesses) {
|
|
this.ins.forEach(input => {
|
|
writeVector(input.witness);
|
|
});
|
|
}
|
|
writeUInt32(this.locktime);
|
|
// avoid slicing unless necessary
|
|
if (initialOffset !== undefined)
|
|
return buffer.slice(initialOffset, offset);
|
|
return buffer;
|
|
}
|
|
}
|
|
Transaction.DEFAULT_SEQUENCE = 0xffffffff;
|
|
Transaction.SIGHASH_ALL = 0x01;
|
|
Transaction.SIGHASH_NONE = 0x02;
|
|
Transaction.SIGHASH_SINGLE = 0x03;
|
|
Transaction.SIGHASH_ANYONECANPAY = 0x80;
|
|
Transaction.ADVANCED_TRANSACTION_MARKER = 0x00;
|
|
Transaction.ADVANCED_TRANSACTION_FLAG = 0x01;
|
|
exports.Transaction = Transaction;
|