style: apply prettier
This commit is contained in:
d-yokoi
parent
c74ab67ccf
commit
03632f1507
24 changed files with 2321 additions and 1958 deletions
ts_src
|
|
@ -1,282 +1,311 @@
|
|||
import * as bcrypto from './crypto'
|
||||
import * as bscript from './script'
|
||||
import * as types from './types'
|
||||
import * as bufferutils from './bufferutils'
|
||||
import { reverseBuffer } from './bufferutils'
|
||||
import { OPS as opcodes } from './script'
|
||||
import * as bcrypto from './crypto';
|
||||
import * as bscript from './script';
|
||||
import * as types from './types';
|
||||
import * as bufferutils from './bufferutils';
|
||||
import { reverseBuffer } from './bufferutils';
|
||||
import { OPS as opcodes } from './script';
|
||||
|
||||
const typeforce = require('typeforce')
|
||||
const varuint = require('varuint-bitcoin')
|
||||
const typeforce = require('typeforce');
|
||||
const varuint = require('varuint-bitcoin');
|
||||
|
||||
function varSliceSize (someScript: Buffer): number {
|
||||
const length = someScript.length
|
||||
function varSliceSize(someScript: Buffer): number {
|
||||
const length = someScript.length;
|
||||
|
||||
return varuint.encodingLength(length) + length
|
||||
return varuint.encodingLength(length) + length;
|
||||
}
|
||||
|
||||
function vectorSize (someVector: Array<Buffer>): number {
|
||||
const length = someVector.length
|
||||
function vectorSize(someVector: Array<Buffer>): number {
|
||||
const length = someVector.length;
|
||||
|
||||
return varuint.encodingLength(length) + someVector.reduce((sum, witness) => {
|
||||
return sum + varSliceSize(witness)
|
||||
}, 0)
|
||||
return (
|
||||
varuint.encodingLength(length) +
|
||||
someVector.reduce((sum, witness) => {
|
||||
return sum + varSliceSize(witness);
|
||||
}, 0)
|
||||
);
|
||||
}
|
||||
|
||||
const EMPTY_SCRIPT: Buffer = Buffer.allocUnsafe(0)
|
||||
const EMPTY_WITNESS: Array<Buffer> = []
|
||||
const ZERO: Buffer = Buffer.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex')
|
||||
const ONE: Buffer = Buffer.from('0000000000000000000000000000000000000000000000000000000000000001', 'hex')
|
||||
const VALUE_UINT64_MAX: Buffer = Buffer.from('ffffffffffffffff', 'hex')
|
||||
const EMPTY_SCRIPT: Buffer = Buffer.allocUnsafe(0);
|
||||
const EMPTY_WITNESS: Array<Buffer> = [];
|
||||
const ZERO: Buffer = Buffer.from(
|
||||
'0000000000000000000000000000000000000000000000000000000000000000',
|
||||
'hex',
|
||||
);
|
||||
const ONE: Buffer = Buffer.from(
|
||||
'0000000000000000000000000000000000000000000000000000000000000001',
|
||||
'hex',
|
||||
);
|
||||
const VALUE_UINT64_MAX: Buffer = Buffer.from('ffffffffffffffff', 'hex');
|
||||
const BLANK_OUTPUT: BlankOutput = {
|
||||
script: EMPTY_SCRIPT,
|
||||
valueBuffer: VALUE_UINT64_MAX
|
||||
}
|
||||
valueBuffer: VALUE_UINT64_MAX,
|
||||
};
|
||||
|
||||
function isOutput(out: Output | BlankOutput): out is Output {
|
||||
return (<Output>out).value !== undefined
|
||||
return (<Output>out).value !== undefined;
|
||||
}
|
||||
|
||||
export type BlankOutput = {
|
||||
script: Buffer
|
||||
valueBuffer: Buffer
|
||||
}
|
||||
script: Buffer;
|
||||
valueBuffer: Buffer;
|
||||
};
|
||||
|
||||
export type Output = {
|
||||
script: Buffer
|
||||
value: number
|
||||
}
|
||||
script: Buffer;
|
||||
value: number;
|
||||
};
|
||||
|
||||
export type Input = {
|
||||
hash: Buffer
|
||||
index: number
|
||||
script: Buffer
|
||||
sequence: number
|
||||
witness: Array<Buffer>
|
||||
}
|
||||
hash: Buffer;
|
||||
index: number;
|
||||
script: Buffer;
|
||||
sequence: number;
|
||||
witness: Array<Buffer>;
|
||||
};
|
||||
|
||||
export class Transaction {
|
||||
version: number
|
||||
locktime: number
|
||||
ins: Array<Input>
|
||||
outs: Array<Output | BlankOutput>
|
||||
version: number;
|
||||
locktime: number;
|
||||
ins: Array<Input>;
|
||||
outs: Array<Output | BlankOutput>;
|
||||
|
||||
static readonly DEFAULT_SEQUENCE = 0xffffffff
|
||||
static readonly SIGHASH_ALL = 0x01
|
||||
static readonly SIGHASH_NONE = 0x02
|
||||
static readonly SIGHASH_SINGLE = 0x03
|
||||
static readonly SIGHASH_ANYONECANPAY = 0x80
|
||||
static readonly ADVANCED_TRANSACTION_MARKER = 0x00
|
||||
static readonly ADVANCED_TRANSACTION_FLAG = 0x01
|
||||
static readonly DEFAULT_SEQUENCE = 0xffffffff;
|
||||
static readonly SIGHASH_ALL = 0x01;
|
||||
static readonly SIGHASH_NONE = 0x02;
|
||||
static readonly SIGHASH_SINGLE = 0x03;
|
||||
static readonly SIGHASH_ANYONECANPAY = 0x80;
|
||||
static readonly ADVANCED_TRANSACTION_MARKER = 0x00;
|
||||
static readonly ADVANCED_TRANSACTION_FLAG = 0x01;
|
||||
|
||||
constructor () {
|
||||
this.version = 1
|
||||
this.locktime = 0
|
||||
this.ins = []
|
||||
this.outs = []
|
||||
constructor() {
|
||||
this.version = 1;
|
||||
this.locktime = 0;
|
||||
this.ins = [];
|
||||
this.outs = [];
|
||||
}
|
||||
|
||||
static fromBuffer (buffer: Buffer, __noStrict?: boolean): Transaction {
|
||||
let offset: number = 0
|
||||
static fromBuffer(buffer: Buffer, __noStrict?: boolean): Transaction {
|
||||
let offset: number = 0;
|
||||
|
||||
function readSlice (n: number): Buffer {
|
||||
offset += n
|
||||
return buffer.slice(offset - n, offset)
|
||||
function readSlice(n: number): Buffer {
|
||||
offset += n;
|
||||
return buffer.slice(offset - n, offset);
|
||||
}
|
||||
|
||||
function readUInt32 (): number {
|
||||
const i = buffer.readUInt32LE(offset)
|
||||
offset += 4
|
||||
return i
|
||||
function readUInt32(): number {
|
||||
const i = buffer.readUInt32LE(offset);
|
||||
offset += 4;
|
||||
return i;
|
||||
}
|
||||
|
||||
function readInt32 (): number {
|
||||
const i = buffer.readInt32LE(offset)
|
||||
offset += 4
|
||||
return i
|
||||
function readInt32(): number {
|
||||
const i = buffer.readInt32LE(offset);
|
||||
offset += 4;
|
||||
return i;
|
||||
}
|
||||
|
||||
function readUInt64 (): number {
|
||||
const i = bufferutils.readUInt64LE(buffer, offset)
|
||||
offset += 8
|
||||
return i
|
||||
function readUInt64(): number {
|
||||
const i = bufferutils.readUInt64LE(buffer, offset);
|
||||
offset += 8;
|
||||
return i;
|
||||
}
|
||||
|
||||
function readVarInt (): number {
|
||||
const vi = varuint.decode(buffer, offset)
|
||||
offset += varuint.decode.bytes
|
||||
return vi
|
||||
function readVarInt(): number {
|
||||
const vi = varuint.decode(buffer, offset);
|
||||
offset += varuint.decode.bytes;
|
||||
return vi;
|
||||
}
|
||||
|
||||
function readVarSlice (): Buffer {
|
||||
return readSlice(readVarInt())
|
||||
function readVarSlice(): Buffer {
|
||||
return readSlice(readVarInt());
|
||||
}
|
||||
|
||||
function readVector (): Array<Buffer> {
|
||||
const count = readVarInt()
|
||||
const vector: Array<Buffer> = []
|
||||
for (var i = 0; i < count; i++) vector.push(readVarSlice())
|
||||
return vector
|
||||
function readVector(): Array<Buffer> {
|
||||
const count = readVarInt();
|
||||
const vector: Array<Buffer> = [];
|
||||
for (var i = 0; i < count; i++) vector.push(readVarSlice());
|
||||
return vector;
|
||||
}
|
||||
|
||||
const tx = new Transaction()
|
||||
tx.version = readInt32()
|
||||
const tx = new Transaction();
|
||||
tx.version = readInt32();
|
||||
|
||||
const marker = buffer.readUInt8(offset)
|
||||
const flag = buffer.readUInt8(offset + 1)
|
||||
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
|
||||
let hasWitnesses = false;
|
||||
if (
|
||||
marker === Transaction.ADVANCED_TRANSACTION_MARKER &&
|
||||
flag === Transaction.ADVANCED_TRANSACTION_FLAG
|
||||
) {
|
||||
offset += 2;
|
||||
hasWitnesses = true;
|
||||
}
|
||||
|
||||
const vinLen = readVarInt()
|
||||
const vinLen = readVarInt();
|
||||
for (var i = 0; i < vinLen; ++i) {
|
||||
tx.ins.push({
|
||||
hash: readSlice(32),
|
||||
index: readUInt32(),
|
||||
script: readVarSlice(),
|
||||
sequence: readUInt32(),
|
||||
witness: EMPTY_WITNESS
|
||||
})
|
||||
witness: EMPTY_WITNESS,
|
||||
});
|
||||
}
|
||||
|
||||
const voutLen = readVarInt()
|
||||
const voutLen = readVarInt();
|
||||
for (i = 0; i < voutLen; ++i) {
|
||||
tx.outs.push({
|
||||
value: readUInt64(),
|
||||
script: readVarSlice()
|
||||
})
|
||||
script: readVarSlice(),
|
||||
});
|
||||
}
|
||||
|
||||
if (hasWitnesses) {
|
||||
for (i = 0; i < vinLen; ++i) {
|
||||
tx.ins[i].witness = readVector()
|
||||
tx.ins[i].witness = readVector();
|
||||
}
|
||||
|
||||
// was this pointless?
|
||||
if (!tx.hasWitnesses()) throw new Error('Transaction has superfluous witness data')
|
||||
if (!tx.hasWitnesses())
|
||||
throw new Error('Transaction has superfluous witness data');
|
||||
}
|
||||
|
||||
tx.locktime = readUInt32()
|
||||
tx.locktime = readUInt32();
|
||||
|
||||
if (__noStrict) return tx
|
||||
if (offset !== buffer.length) throw new Error('Transaction has unexpected data')
|
||||
if (__noStrict) return tx;
|
||||
if (offset !== buffer.length)
|
||||
throw new Error('Transaction has unexpected data');
|
||||
|
||||
return tx
|
||||
return tx;
|
||||
}
|
||||
|
||||
static fromHex (hex: string): Transaction {
|
||||
return Transaction.fromBuffer(Buffer.from(hex, 'hex'), false)
|
||||
static fromHex(hex: string): Transaction {
|
||||
return Transaction.fromBuffer(Buffer.from(hex, 'hex'), false);
|
||||
}
|
||||
|
||||
static isCoinbaseHash (buffer: Buffer): boolean {
|
||||
typeforce(types.Hash256bit, buffer)
|
||||
static isCoinbaseHash(buffer: Buffer): boolean {
|
||||
typeforce(types.Hash256bit, buffer);
|
||||
for (var i = 0; i < 32; ++i) {
|
||||
if (buffer[i] !== 0) return false
|
||||
if (buffer[i] !== 0) return false;
|
||||
}
|
||||
return true
|
||||
return true;
|
||||
}
|
||||
|
||||
isCoinbase (): boolean {
|
||||
return this.ins.length === 1 && Transaction.isCoinbaseHash(this.ins[0].hash)
|
||||
isCoinbase(): boolean {
|
||||
return (
|
||||
this.ins.length === 1 && Transaction.isCoinbaseHash(this.ins[0].hash)
|
||||
);
|
||||
}
|
||||
|
||||
addInput (hash: Buffer, index: number, sequence?: number, scriptSig?: Buffer): number {
|
||||
typeforce(types.tuple(
|
||||
types.Hash256bit,
|
||||
types.UInt32,
|
||||
types.maybe(types.UInt32),
|
||||
types.maybe(types.Buffer)
|
||||
), arguments)
|
||||
addInput(
|
||||
hash: Buffer,
|
||||
index: number,
|
||||
sequence?: number,
|
||||
scriptSig?: Buffer,
|
||||
): number {
|
||||
typeforce(
|
||||
types.tuple(
|
||||
types.Hash256bit,
|
||||
types.UInt32,
|
||||
types.maybe(types.UInt32),
|
||||
types.maybe(types.Buffer),
|
||||
),
|
||||
arguments,
|
||||
);
|
||||
|
||||
if (types.Null(sequence)) {
|
||||
sequence = Transaction.DEFAULT_SEQUENCE
|
||||
sequence = Transaction.DEFAULT_SEQUENCE;
|
||||
}
|
||||
|
||||
// Add the input and return the input's index
|
||||
return (this.ins.push({
|
||||
hash: hash,
|
||||
index: index,
|
||||
script: scriptSig || EMPTY_SCRIPT,
|
||||
sequence: <number>sequence,
|
||||
witness: EMPTY_WITNESS
|
||||
}) - 1)
|
||||
return (
|
||||
this.ins.push({
|
||||
hash: hash,
|
||||
index: index,
|
||||
script: scriptSig || EMPTY_SCRIPT,
|
||||
sequence: <number>sequence,
|
||||
witness: EMPTY_WITNESS,
|
||||
}) - 1
|
||||
);
|
||||
}
|
||||
|
||||
addOutput (scriptPubKey: Buffer, value: number): number {
|
||||
typeforce(types.tuple(types.Buffer, types.Satoshi), arguments)
|
||||
addOutput(scriptPubKey: Buffer, value: number): number {
|
||||
typeforce(types.tuple(types.Buffer, types.Satoshi), arguments);
|
||||
|
||||
// Add the output and return the output's index
|
||||
return (this.outs.push({
|
||||
script: scriptPubKey,
|
||||
value: value
|
||||
}) - 1)
|
||||
return (
|
||||
this.outs.push({
|
||||
script: scriptPubKey,
|
||||
value: value,
|
||||
}) - 1
|
||||
);
|
||||
}
|
||||
|
||||
hasWitnesses (): boolean {
|
||||
return this.ins.some((x) => {
|
||||
return x.witness.length !== 0
|
||||
})
|
||||
hasWitnesses(): boolean {
|
||||
return this.ins.some(x => {
|
||||
return x.witness.length !== 0;
|
||||
});
|
||||
}
|
||||
|
||||
weight (): number {
|
||||
const base = this.__byteLength(false)
|
||||
const total = this.__byteLength(true)
|
||||
return base * 3 + total
|
||||
weight(): number {
|
||||
const base = this.__byteLength(false);
|
||||
const total = this.__byteLength(true);
|
||||
return base * 3 + total;
|
||||
}
|
||||
|
||||
virtualSize (): number {
|
||||
return Math.ceil(this.weight() / 4)
|
||||
virtualSize(): number {
|
||||
return Math.ceil(this.weight() / 4);
|
||||
}
|
||||
|
||||
byteLength (): number {
|
||||
return this.__byteLength(true)
|
||||
byteLength(): number {
|
||||
return this.__byteLength(true);
|
||||
}
|
||||
|
||||
private __byteLength (__allowWitness: boolean): number {
|
||||
const hasWitnesses = __allowWitness && this.hasWitnesses()
|
||||
private __byteLength(__allowWitness: boolean): number {
|
||||
const hasWitnesses = __allowWitness && 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)
|
||||
return sum + 40 + varSliceSize(input.script);
|
||||
}, 0) +
|
||||
this.outs.reduce((sum, output) => {
|
||||
return sum + 8 + varSliceSize(output.script)
|
||||
return sum + 8 + varSliceSize(output.script);
|
||||
}, 0) +
|
||||
(hasWitnesses ? this.ins.reduce((sum, input) => {
|
||||
return sum + vectorSize(input.witness)
|
||||
}, 0) : 0)
|
||||
)
|
||||
(hasWitnesses
|
||||
? this.ins.reduce((sum, input) => {
|
||||
return sum + vectorSize(input.witness);
|
||||
}, 0)
|
||||
: 0)
|
||||
);
|
||||
}
|
||||
|
||||
clone (): Transaction {
|
||||
const newTx = new Transaction()
|
||||
newTx.version = this.version
|
||||
newTx.locktime = this.locktime
|
||||
clone(): Transaction {
|
||||
const newTx = new Transaction();
|
||||
newTx.version = this.version;
|
||||
newTx.locktime = this.locktime;
|
||||
|
||||
newTx.ins = this.ins.map((txIn) => {
|
||||
newTx.ins = this.ins.map(txIn => {
|
||||
return {
|
||||
hash: txIn.hash,
|
||||
index: txIn.index,
|
||||
script: txIn.script,
|
||||
sequence: txIn.sequence,
|
||||
witness: txIn.witness
|
||||
}
|
||||
})
|
||||
witness: txIn.witness,
|
||||
};
|
||||
});
|
||||
|
||||
newTx.outs = this.outs.map((txOut) => {
|
||||
newTx.outs = this.outs.map(txOut => {
|
||||
return {
|
||||
script: txOut.script,
|
||||
value: (<Output>txOut).value
|
||||
}
|
||||
})
|
||||
value: (<Output>txOut).value,
|
||||
};
|
||||
});
|
||||
|
||||
return newTx
|
||||
return newTx;
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -287,284 +316,313 @@ export class Transaction {
|
|||
* hashType, and then hashes the result.
|
||||
* This hash can then be used to sign the provided transaction input.
|
||||
*/
|
||||
hashForSignature (inIndex: number, prevOutScript: Buffer, hashType: number): Buffer {
|
||||
typeforce(types.tuple(types.UInt32, types.Buffer, /* types.UInt8 */ types.Number), arguments)
|
||||
hashForSignature(
|
||||
inIndex: number,
|
||||
prevOutScript: Buffer,
|
||||
hashType: number,
|
||||
): Buffer {
|
||||
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
|
||||
if (inIndex >= this.ins.length) return ONE;
|
||||
|
||||
// ignore OP_CODESEPARATOR
|
||||
const ourScript = bscript.compile(bscript.decompile(prevOutScript)!.filter((x) => {
|
||||
return x !== opcodes.OP_CODESEPARATOR
|
||||
}))
|
||||
const ourScript = bscript.compile(
|
||||
bscript.decompile(prevOutScript)!.filter(x => {
|
||||
return x !== opcodes.OP_CODESEPARATOR;
|
||||
}),
|
||||
);
|
||||
|
||||
const txTmp = this.clone()
|
||||
const txTmp = this.clone();
|
||||
|
||||
// SIGHASH_NONE: ignore all outputs? (wildcard payee)
|
||||
if ((hashType & 0x1f) === Transaction.SIGHASH_NONE) {
|
||||
txTmp.outs = []
|
||||
txTmp.outs = [];
|
||||
|
||||
// ignore sequence numbers (except at inIndex)
|
||||
txTmp.ins.forEach((input, i) => {
|
||||
if (i === inIndex) return
|
||||
if (i === inIndex) return;
|
||||
|
||||
input.sequence = 0
|
||||
})
|
||||
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
|
||||
if (inIndex >= this.outs.length) return ONE;
|
||||
|
||||
// truncate outputs after
|
||||
txTmp.outs.length = inIndex + 1
|
||||
txTmp.outs.length = inIndex + 1;
|
||||
|
||||
// "blank" outputs before
|
||||
for (var i = 0; i < inIndex; i++) {
|
||||
txTmp.outs[i] = BLANK_OUTPUT
|
||||
txTmp.outs[i] = BLANK_OUTPUT;
|
||||
}
|
||||
|
||||
// ignore sequence numbers (except at inIndex)
|
||||
txTmp.ins.forEach((input, y) => {
|
||||
if (y === inIndex) return
|
||||
if (y === inIndex) return;
|
||||
|
||||
input.sequence = 0
|
||||
})
|
||||
input.sequence = 0;
|
||||
});
|
||||
}
|
||||
|
||||
// SIGHASH_ANYONECANPAY: ignore inputs entirely?
|
||||
if (hashType & Transaction.SIGHASH_ANYONECANPAY) {
|
||||
txTmp.ins = [txTmp.ins[inIndex]]
|
||||
txTmp.ins[0].script = ourScript
|
||||
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
|
||||
txTmp.ins.forEach(input => {
|
||||
input.script = EMPTY_SCRIPT;
|
||||
});
|
||||
txTmp.ins[inIndex].script = ourScript;
|
||||
}
|
||||
|
||||
// serialize and hash
|
||||
const buffer: Buffer = Buffer.allocUnsafe(txTmp.__byteLength(false) + 4)
|
||||
buffer.writeInt32LE(hashType, buffer.length - 4)
|
||||
txTmp.__toBuffer(buffer, 0, false)
|
||||
const buffer: Buffer = Buffer.allocUnsafe(txTmp.__byteLength(false) + 4);
|
||||
buffer.writeInt32LE(hashType, buffer.length - 4);
|
||||
txTmp.__toBuffer(buffer, 0, false);
|
||||
|
||||
return bcrypto.hash256(buffer)
|
||||
return bcrypto.hash256(buffer);
|
||||
}
|
||||
|
||||
hashForWitnessV0 (inIndex: number, prevOutScript: Buffer, value: number, hashType: number): Buffer {
|
||||
typeforce(types.tuple(types.UInt32, types.Buffer, types.Satoshi, types.UInt32), arguments)
|
||||
hashForWitnessV0(
|
||||
inIndex: number,
|
||||
prevOutScript: Buffer,
|
||||
value: number,
|
||||
hashType: number,
|
||||
): Buffer {
|
||||
typeforce(
|
||||
types.tuple(types.UInt32, types.Buffer, types.Satoshi, types.UInt32),
|
||||
arguments,
|
||||
);
|
||||
|
||||
let tbuffer: Buffer = Buffer.from([])
|
||||
let toffset: number = 0
|
||||
let tbuffer: Buffer = Buffer.from([]);
|
||||
let toffset: number = 0;
|
||||
|
||||
function writeSlice (slice: Buffer): void {
|
||||
toffset += slice.copy(tbuffer, toffset)
|
||||
function writeSlice(slice: Buffer): void {
|
||||
toffset += slice.copy(tbuffer, toffset);
|
||||
}
|
||||
|
||||
function writeUInt32 (i: number): void {
|
||||
toffset = tbuffer.writeUInt32LE(i, toffset)
|
||||
function writeUInt32(i: number): void {
|
||||
toffset = tbuffer.writeUInt32LE(i, toffset);
|
||||
}
|
||||
|
||||
function writeUInt64 (i: number): void {
|
||||
toffset = bufferutils.writeUInt64LE(tbuffer, i, toffset)
|
||||
function writeUInt64(i: number): void {
|
||||
toffset = bufferutils.writeUInt64LE(tbuffer, i, toffset);
|
||||
}
|
||||
|
||||
function writeVarInt (i: number): void {
|
||||
varuint.encode(i, tbuffer, toffset)
|
||||
toffset += varuint.encode.bytes
|
||||
function writeVarInt(i: number): void {
|
||||
varuint.encode(i, tbuffer, toffset);
|
||||
toffset += varuint.encode.bytes;
|
||||
}
|
||||
|
||||
function writeVarSlice (slice: Buffer): void {
|
||||
writeVarInt(slice.length)
|
||||
writeSlice(slice)
|
||||
function writeVarSlice(slice: Buffer): void {
|
||||
writeVarInt(slice.length);
|
||||
writeSlice(slice);
|
||||
}
|
||||
|
||||
let hashOutputs = ZERO
|
||||
let hashPrevouts = ZERO
|
||||
let hashSequence = ZERO
|
||||
let hashOutputs = ZERO;
|
||||
let hashPrevouts = ZERO;
|
||||
let hashSequence = ZERO;
|
||||
|
||||
if (!(hashType & Transaction.SIGHASH_ANYONECANPAY)) {
|
||||
tbuffer = Buffer.allocUnsafe(36 * this.ins.length)
|
||||
toffset = 0
|
||||
tbuffer = Buffer.allocUnsafe(36 * this.ins.length);
|
||||
toffset = 0;
|
||||
|
||||
this.ins.forEach((txIn) => {
|
||||
writeSlice(txIn.hash)
|
||||
writeUInt32(txIn.index)
|
||||
})
|
||||
this.ins.forEach(txIn => {
|
||||
writeSlice(txIn.hash);
|
||||
writeUInt32(txIn.index);
|
||||
});
|
||||
|
||||
hashPrevouts = bcrypto.hash256(tbuffer)
|
||||
hashPrevouts = bcrypto.hash256(tbuffer);
|
||||
}
|
||||
|
||||
if (!(hashType & Transaction.SIGHASH_ANYONECANPAY) &&
|
||||
if (
|
||||
!(hashType & Transaction.SIGHASH_ANYONECANPAY) &&
|
||||
(hashType & 0x1f) !== Transaction.SIGHASH_SINGLE &&
|
||||
(hashType & 0x1f) !== Transaction.SIGHASH_NONE) {
|
||||
tbuffer = Buffer.allocUnsafe(4 * this.ins.length)
|
||||
toffset = 0
|
||||
(hashType & 0x1f) !== Transaction.SIGHASH_NONE
|
||||
) {
|
||||
tbuffer = Buffer.allocUnsafe(4 * this.ins.length);
|
||||
toffset = 0;
|
||||
|
||||
this.ins.forEach((txIn) => {
|
||||
writeUInt32(txIn.sequence)
|
||||
})
|
||||
this.ins.forEach(txIn => {
|
||||
writeUInt32(txIn.sequence);
|
||||
});
|
||||
|
||||
hashSequence = bcrypto.hash256(tbuffer)
|
||||
hashSequence = bcrypto.hash256(tbuffer);
|
||||
}
|
||||
|
||||
if ((hashType & 0x1f) !== Transaction.SIGHASH_SINGLE &&
|
||||
(hashType & 0x1f) !== Transaction.SIGHASH_NONE) {
|
||||
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)
|
||||
return sum + 8 + varSliceSize(output.script);
|
||||
}, 0);
|
||||
|
||||
tbuffer = Buffer.allocUnsafe(txOutsSize)
|
||||
toffset = 0
|
||||
tbuffer = Buffer.allocUnsafe(txOutsSize);
|
||||
toffset = 0;
|
||||
|
||||
this.outs.forEach((out) => {
|
||||
writeUInt64((<Output>out).value)
|
||||
writeVarSlice(out.script)
|
||||
})
|
||||
this.outs.forEach(out => {
|
||||
writeUInt64((<Output>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]
|
||||
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>output).value)
|
||||
writeVarSlice(output.script)
|
||||
tbuffer = Buffer.allocUnsafe(8 + varSliceSize(output.script));
|
||||
toffset = 0;
|
||||
writeUInt64((<Output>output).value);
|
||||
writeVarSlice(output.script);
|
||||
|
||||
hashOutputs = bcrypto.hash256(tbuffer)
|
||||
hashOutputs = bcrypto.hash256(tbuffer);
|
||||
}
|
||||
|
||||
tbuffer = Buffer.allocUnsafe(156 + varSliceSize(prevOutScript))
|
||||
toffset = 0
|
||||
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)
|
||||
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?: boolean): Buffer {
|
||||
getHash(forWitness?: boolean): Buffer {
|
||||
// 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))
|
||||
if (forWitness && this.isCoinbase()) return Buffer.alloc(32, 0);
|
||||
return bcrypto.hash256(this.__toBuffer(undefined, undefined, forWitness));
|
||||
}
|
||||
|
||||
getId (): string {
|
||||
getId(): string {
|
||||
// transaction hash's are displayed in reverse order
|
||||
return reverseBuffer(this.getHash(false)).toString('hex')
|
||||
return reverseBuffer(this.getHash(false)).toString('hex');
|
||||
}
|
||||
|
||||
toBuffer (buffer?: Buffer, initialOffset?: number): Buffer {
|
||||
return this.__toBuffer(buffer, initialOffset, true)
|
||||
toBuffer(buffer?: Buffer, initialOffset?: number): Buffer {
|
||||
return this.__toBuffer(buffer, initialOffset, true);
|
||||
}
|
||||
|
||||
private __toBuffer (buffer?: Buffer, initialOffset?: number, __allowWitness?: boolean): Buffer {
|
||||
if (!buffer) buffer = <Buffer> Buffer.allocUnsafe(this.__byteLength(__allowWitness!))
|
||||
private __toBuffer(
|
||||
buffer?: Buffer,
|
||||
initialOffset?: number,
|
||||
__allowWitness?: boolean,
|
||||
): Buffer {
|
||||
if (!buffer)
|
||||
buffer = <Buffer>Buffer.allocUnsafe(this.__byteLength(__allowWitness!));
|
||||
|
||||
let offset = initialOffset || 0
|
||||
let offset = initialOffset || 0;
|
||||
|
||||
function writeSlice (slice: Buffer): void {
|
||||
offset += slice.copy(buffer!, offset)
|
||||
function writeSlice(slice: Buffer): void {
|
||||
offset += slice.copy(buffer!, offset);
|
||||
}
|
||||
|
||||
function writeUInt8 (i: number) {
|
||||
offset = (buffer!).writeUInt8(i, offset)
|
||||
function writeUInt8(i: number) {
|
||||
offset = buffer!.writeUInt8(i, offset);
|
||||
}
|
||||
|
||||
function writeUInt32 (i: number) {
|
||||
offset = (buffer!).writeUInt32LE(i, offset)
|
||||
function writeUInt32(i: number) {
|
||||
offset = buffer!.writeUInt32LE(i, offset);
|
||||
}
|
||||
|
||||
function writeInt32 (i: number) {
|
||||
offset = (buffer!).writeInt32LE(i, offset)
|
||||
function writeInt32(i: number) {
|
||||
offset = buffer!.writeInt32LE(i, offset);
|
||||
}
|
||||
|
||||
function writeUInt64 (i: number) {
|
||||
offset = bufferutils.writeUInt64LE(buffer!, i, offset)
|
||||
function writeUInt64(i: number) {
|
||||
offset = bufferutils.writeUInt64LE(buffer!, i, offset);
|
||||
}
|
||||
|
||||
function writeVarInt (i: number) {
|
||||
varuint.encode(i, buffer, offset)
|
||||
offset += varuint.encode.bytes
|
||||
function writeVarInt(i: number) {
|
||||
varuint.encode(i, buffer, offset);
|
||||
offset += varuint.encode.bytes;
|
||||
}
|
||||
|
||||
function writeVarSlice (slice: Buffer) {
|
||||
writeVarInt(slice.length)
|
||||
writeSlice(slice)
|
||||
function writeVarSlice(slice: Buffer) {
|
||||
writeVarInt(slice.length);
|
||||
writeSlice(slice);
|
||||
}
|
||||
|
||||
function writeVector (vector: Array<Buffer>) {
|
||||
writeVarInt(vector.length)
|
||||
vector.forEach(writeVarSlice)
|
||||
function writeVector(vector: Array<Buffer>) {
|
||||
writeVarInt(vector.length);
|
||||
vector.forEach(writeVarSlice);
|
||||
}
|
||||
|
||||
writeInt32(this.version)
|
||||
writeInt32(this.version);
|
||||
|
||||
const hasWitnesses = __allowWitness && this.hasWitnesses()
|
||||
const hasWitnesses = __allowWitness && this.hasWitnesses();
|
||||
|
||||
if (hasWitnesses) {
|
||||
writeUInt8(Transaction.ADVANCED_TRANSACTION_MARKER)
|
||||
writeUInt8(Transaction.ADVANCED_TRANSACTION_FLAG)
|
||||
writeUInt8(Transaction.ADVANCED_TRANSACTION_MARKER);
|
||||
writeUInt8(Transaction.ADVANCED_TRANSACTION_FLAG);
|
||||
}
|
||||
|
||||
writeVarInt(this.ins.length)
|
||||
writeVarInt(this.ins.length);
|
||||
|
||||
this.ins.forEach((txIn) => {
|
||||
writeSlice(txIn.hash)
|
||||
writeUInt32(txIn.index)
|
||||
writeVarSlice(txIn.script)
|
||||
writeUInt32(txIn.sequence)
|
||||
})
|
||||
this.ins.forEach(txIn => {
|
||||
writeSlice(txIn.hash);
|
||||
writeUInt32(txIn.index);
|
||||
writeVarSlice(txIn.script);
|
||||
writeUInt32(txIn.sequence);
|
||||
});
|
||||
|
||||
writeVarInt(this.outs.length)
|
||||
this.outs.forEach((txOut) => {
|
||||
writeVarInt(this.outs.length);
|
||||
this.outs.forEach(txOut => {
|
||||
if (isOutput(txOut)) {
|
||||
writeUInt64(txOut.value)
|
||||
writeUInt64(txOut.value);
|
||||
} else {
|
||||
writeSlice(txOut.valueBuffer)
|
||||
writeSlice(txOut.valueBuffer);
|
||||
}
|
||||
|
||||
writeVarSlice(txOut.script)
|
||||
})
|
||||
writeVarSlice(txOut.script);
|
||||
});
|
||||
|
||||
if (hasWitnesses) {
|
||||
this.ins.forEach((input) => {
|
||||
writeVector(input.witness)
|
||||
})
|
||||
this.ins.forEach(input => {
|
||||
writeVector(input.witness);
|
||||
});
|
||||
}
|
||||
|
||||
writeUInt32(this.locktime)
|
||||
writeUInt32(this.locktime);
|
||||
|
||||
// avoid slicing unless necessary
|
||||
if (initialOffset !== undefined) return buffer.slice(initialOffset, offset)
|
||||
return buffer
|
||||
if (initialOffset !== undefined) return buffer.slice(initialOffset, offset);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
toHex () {
|
||||
return this.toBuffer(undefined, undefined).toString('hex')
|
||||
toHex() {
|
||||
return this.toBuffer(undefined, undefined).toString('hex');
|
||||
}
|
||||
|
||||
setInputScript (index: number, scriptSig: Buffer) {
|
||||
typeforce(types.tuple(types.Number, types.Buffer), arguments)
|
||||
setInputScript(index: number, scriptSig: Buffer) {
|
||||
typeforce(types.tuple(types.Number, types.Buffer), arguments);
|
||||
|
||||
this.ins[index].script = scriptSig
|
||||
this.ins[index].script = scriptSig;
|
||||
}
|
||||
|
||||
setWitness (index: number, witness: Array<Buffer>) {
|
||||
typeforce(types.tuple(types.Number, [types.Buffer]), arguments)
|
||||
setWitness(index: number, witness: Array<Buffer>) {
|
||||
typeforce(types.tuple(types.Number, [types.Buffer]), arguments);
|
||||
|
||||
this.ins[index].witness = witness
|
||||
this.ins[index].witness = witness;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue