lukechilds
/
bitcoinjs-lib
mirror of https://github.com/lukechilds/bitcoinjs-lib.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Merge pull request #1293 from bitcoinjs/revertTxES6 

Revert "Merge pull request #1086 from bitcoinjs/refactorTransaction"
v4
Jonathan Underwood 6 years ago
committed by GitHub
parent
5e1ae82a5d f860d467d6
commit
293116b20f
No known key found for this signature in database GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 353 additions and 416 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 409
      src/transaction.js

409
src/transaction.js
View File

@ -16,11 +16,26 @@ function varSliceSize (someScript) {
function vectorSize (someVector) {
const length = someVector.length
return varuint.encodingLength(length) + someVector.reduce((sum, witness) => {
return varuint.encodingLength(length) + someVector.reduce(function (sum, witness) {
return sum + varSliceSize(witness)
}, 0)
}
function Transaction () {
this.version = 1
this.locktime = 0
this.ins = []
this.outs = []
}
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
const EMPTY_SCRIPT = Buffer.allocUnsafe(0)
const EMPTY_WITNESS = []
const ZERO = Buffer.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex')
@ -31,41 +46,114 @@ const BLANK_OUTPUT = {
valueBuffer: VALUE_UINT64_MAX
}
class Transaction {
constructor () {
this.version = 1
this.locktime = 0
this.ins = []
this.outs = []
Transaction.fromBuffer = function (buffer, __noStrict) {
let offset = 0
function readSlice (n) {
offset += n
return buffer.slice(offset - n, offset)
}
static get DEFAULT_SEQUENCE () {
return 0xffffffff
function readUInt32 () {
const i = buffer.readUInt32LE(offset)
offset += 4
return i
}
static get SIGHASH_ALL () {
return 0x01
function readInt32 () {
const i = buffer.readInt32LE(offset)
offset += 4
return i
}
static get SIGHASH_NONE () {
return 0x02
function readUInt64 () {
const i = bufferutils.readUInt64LE(buffer, offset)
offset += 8
return i
}
static get SIGHASH_SINGLE () {
return 0x03
function readVarInt () {
const vi = varuint.decode(buffer, offset)
offset += varuint.decode.bytes
return vi
}
static get SIGHASH_ANYONECANPAY () {
return 0x80
function readVarSlice () {
return readSlice(readVarInt())
}
static get ADVANCED_TRANSACTION_MARKER () {
return 0x00
function readVector () {
const count = readVarInt()
const vector = []
for (var i = 0; i < count; i++) vector.push(readVarSlice())
return vector
}
static get ADVANCED_TRANSACTION_FLAG () {
return 0x01
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
}
isCoinbase () {
return this.ins.length === 1 && Transaction.isCoinbaseHash(this.ins[0].hash)
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
})
}
const voutLen = readVarInt()
for (i = 0; i < voutLen; ++i) {
tx.outs.push({
value: readUInt64(),
script: readVarSlice()
})
}
addInput (hash, index, sequence, scriptSig) {
if (hasWitnesses) {
for (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 (__noStrict) return tx
if (offset !== buffer.length) throw new Error('Transaction has unexpected data')
return tx
}
Transaction.fromHex = function (hex) {
return Transaction.fromBuffer(Buffer.from(hex, 'hex'))
}
Transaction.isCoinbaseHash = function (buffer) {
typeforce(types.Hash256bit, buffer)
for (var i = 0; i < 32; ++i) {
if (buffer[i] !== 0) return false
}
return true
}
Transaction.prototype.isCoinbase = function () {
return this.ins.length === 1 && Transaction.isCoinbaseHash(this.ins[0].hash)
}
Transaction.prototype.addInput = function (hash, index, sequence, scriptSig) {
typeforce(types.tuple(
types.Hash256bit,
types.UInt32,
@ -85,9 +173,9 @@ class Transaction {
sequence: sequence,
witness: EMPTY_WITNESS
}) - 1)
}
}
addOutput (scriptPubKey, value) {
Transaction.prototype.addOutput = function (scriptPubKey, value) {
typeforce(types.tuple(types.Buffer, types.Satoshi), arguments)
// Add the output and return the output's index
@ -95,53 +183,47 @@ class Transaction {
script: scriptPubKey,
value: value
}) - 1)
}
}
hasWitnesses () {
return this.ins.some((x) => {
Transaction.prototype.hasWitnesses = function () {
return this.ins.some(function (x) {
return x.witness.length !== 0
})
}
}
weight () {
Transaction.prototype.weight = function () {
const base = this.__byteLength(false)
const total = this.__byteLength(true)
return base * 3 + total
}
}
virtualSize () {
Transaction.prototype.virtualSize = function () {
return Math.ceil(this.weight() / 4)
}
}
byteLength () {
Transaction.prototype.byteLength = function () {
return this.__byteLength(true)
}
}
__byteLength (__allowWitness) {
Transaction.prototype.__byteLength = function (__allowWitness) {
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)
}, 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)
this.ins.reduce(function (sum, input) { return sum + 40 + varSliceSize(input.script) }, 0) +
this.outs.reduce(function (sum, output) { return sum + 8 + varSliceSize(output.script) }, 0) +
(hasWitnesses ? this.ins.reduce(function (sum, input) { return sum + vectorSize(input.witness) }, 0) : 0)
)
}
}
clone () {
Transaction.prototype.clone = function () {
const newTx = new Transaction()
newTx.version = this.version
newTx.locktime = this.locktime
newTx.ins = this.ins.map((txIn) => {
newTx.ins = this.ins.map(function (txIn) {
return {
hash: txIn.hash,
index: txIn.index,
@ -151,7 +233,7 @@ class Transaction {
}
})
newTx.outs = this.outs.map((txOut) => {
newTx.outs = this.outs.map(function (txOut) {
return {
script: txOut.script,
value: txOut.value
@ -159,9 +241,9 @@ class Transaction {
})
return newTx
}
}
/**
/**
* Hash transaction for signing a specific input.
*
* Bitcoin uses a different hash for each signed transaction input.
@ -169,14 +251,14 @@ class Transaction {
* hashType, and then hashes the result.
* This hash can then be used to sign the provided transaction input.
*/
hashForSignature (inIndex, prevOutScript, hashType) {
Transaction.prototype.hashForSignature = function (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) => {
const ourScript = bscript.compile(bscript.decompile(prevOutScript).filter(function (x) {
return x !== opcodes.OP_CODESEPARATOR
}))
@ -187,7 +269,7 @@ class Transaction {
txTmp.outs = []
// ignore sequence numbers (except at inIndex)
txTmp.ins.forEach((input, i) => {
txTmp.ins.forEach(function (input, i) {
if (i === inIndex) return
input.sequence = 0
@ -207,7 +289,7 @@ class Transaction {
}
// ignore sequence numbers (except at inIndex)
txTmp.ins.forEach((input, y) => {
txTmp.ins.forEach(function (input, y) {
if (y === inIndex) return
input.sequence = 0
@ -222,9 +304,7 @@ class Transaction {
// SIGHASH_ALL: only ignore input scripts
} else {
// "blank" others input scripts
txTmp.ins.forEach((input) => {
input.script = EMPTY_SCRIPT
})
txTmp.ins.forEach(function (input) { input.script = EMPTY_SCRIPT })
txTmp.ins[inIndex].script = ourScript
}
@ -234,34 +314,20 @@ class Transaction {
txTmp.__toBuffer(buffer, 0, false)
return bcrypto.hash256(buffer)
}
}
hashForWitnessV0 (inIndex, prevOutScript, value, hashType) {
Transaction.prototype.hashForWitnessV0 = function (inIndex, prevOutScript, value, hashType) {
typeforce(types.tuple(types.UInt32, types.Buffer, types.Satoshi, types.UInt32), arguments)
let tbuffer, toffset
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 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)
}
function writeVarSlice (slice) { writeVarInt(slice.length); writeSlice(slice) }
let hashOutputs = ZERO
let hashPrevouts = ZERO
@ -271,7 +337,7 @@ class Transaction {
tbuffer = Buffer.allocUnsafe(36 * this.ins.length)
toffset = 0
this.ins.forEach((txIn) => {
this.ins.forEach(function (txIn) {
writeSlice(txIn.hash)
writeUInt32(txIn.index)
})
@ -285,7 +351,7 @@ class Transaction {
tbuffer = Buffer.allocUnsafe(4 * this.ins.length)
toffset = 0
this.ins.forEach((txIn) => {
this.ins.forEach(function (txIn) {
writeUInt32(txIn.sequence)
})
@ -294,14 +360,14 @@ class Transaction {
if ((hashType & 0x1f) !== Transaction.SIGHASH_SINGLE &&
(hashType & 0x1f) !== Transaction.SIGHASH_NONE) {
const txOutsSize = this.outs.reduce((sum, output) => {
const txOutsSize = this.outs.reduce(function (sum, output) {
return sum + 8 + varSliceSize(output.script)
}, 0)
tbuffer = Buffer.allocUnsafe(txOutsSize)
toffset = 0
this.outs.forEach((out) => {
this.outs.forEach(function (out) {
writeUInt64(out.value)
writeVarSlice(out.script)
})
@ -334,60 +400,36 @@ class Transaction {
writeUInt32(this.locktime)
writeUInt32(hashType)
return bcrypto.hash256(tbuffer)
}
}
getHash () {
Transaction.prototype.getHash = function () {
return bcrypto.hash256(this.__toBuffer(undefined, undefined, false))
}
}
getId () {
Transaction.prototype.getId = function () {
// transaction hash's are displayed in reverse order
return this.getHash().reverse().toString('hex')
}
}
toBuffer (buffer, initialOffset) {
Transaction.prototype.toBuffer = function (buffer, initialOffset) {
return this.__toBuffer(buffer, initialOffset, true)
}
}
__toBuffer (buffer, initialOffset, __allowWitness) {
Transaction.prototype.__toBuffer = function (buffer, initialOffset, __allowWitness) {
if (!buffer) buffer = Buffer.allocUnsafe(this.__byteLength(__allowWitness))
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 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)
}
function writeVarSlice (slice) { writeVarInt(slice.length); writeSlice(slice) }
function writeVector (vector) { writeVarInt(vector.length); vector.forEach(writeVarSlice) }
writeInt32(this.version)
@ -400,7 +442,7 @@ class Transaction {
writeVarInt(this.ins.length)
this.ins.forEach((txIn) => {
this.ins.forEach(function (txIn) {
writeSlice(txIn.hash)
writeUInt32(txIn.index)
writeVarSlice(txIn.script)
@ -408,7 +450,7 @@ class Transaction {
})
writeVarInt(this.outs.length)
this.outs.forEach((txOut) => {
this.outs.forEach(function (txOut) {
if (!txOut.valueBuffer) {
writeUInt64(txOut.value)
} else {
@ -419,7 +461,7 @@ class Transaction {
})
if (hasWitnesses) {
this.ins.forEach((input) => {
this.ins.forEach(function (input) {
writeVector(input.witness)
})
}
@ -429,127 +471,22 @@ class Transaction {
// avoid slicing unless necessary
if (initialOffset !== undefined) return buffer.slice(initialOffset, offset)
return buffer
}
}
toHex () {
Transaction.prototype.toHex = function () {
return this.toBuffer().toString('hex')
}
}
setInputScript (index, scriptSig) {
Transaction.prototype.setInputScript = function (index, scriptSig) {
typeforce(types.tuple(types.Number, types.Buffer), arguments)
this.ins[index].script = scriptSig
}
}
setWitness (index, witness) {
Transaction.prototype.setWitness = function (index, witness) {
typeforce(types.tuple(types.Number, [types.Buffer]), arguments)
this.ins[index].witness = witness
}
}
Transaction.fromBuffer = (buffer, __noStrict) => {
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 (var 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 (var i = 0; i < vinLen; ++i) {
tx.ins.push({
hash: readSlice(32),
index: readUInt32(),
script: readVarSlice(),
sequence: readUInt32(),
witness: EMPTY_WITNESS
})
}
const voutLen = readVarInt()
for (i = 0; i < voutLen; ++i) {
tx.outs.push({
value: readUInt64(),
script: readVarSlice()
})
}
if (hasWitnesses) {
for (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 (__noStrict) return tx
if (offset !== buffer.length) throw new Error('Transaction has unexpected data')
return tx
}
Transaction.fromHex = (hex) => {
return Transaction.fromBuffer(Buffer.from(hex, 'hex'))
}
Transaction.isCoinbaseHash = (buffer) => {
typeforce(types.Hash256bit, buffer)
for (var i = 0; i < 32; ++i) {
if (buffer[i] !== 0) return false
}
return true
}
module.exports = Transaction

Write Preview
Loading…
Cancel
Save