Move Block Class from ES6 PR

This commit is contained in:
junderw 2018-12-27 17:49:53 +09:00
parent 91d3037cf3
commit 2eb9534939
No known key found for this signature in database
GPG key ID: B256185D3A971908
3 changed files with 198 additions and 148 deletions

View file

@ -5,33 +5,57 @@ const typeforce = require('typeforce')
const types = require('./types') const types = require('./types')
const varuint = require('varuint-bitcoin') const varuint = require('varuint-bitcoin')
const errorMerkleNoTxes = new TypeError('Cannot compute merkle root for zero transactions')
const errorWitnessNotSegwit = new TypeError('Cannot compute witness commit for non-segwit block')
const errorBufferTooSmall = new Error('Buffer too small (< 80 bytes)')
function txesHaveWitness (transactions: Array<any>): boolean {
return transactions !== undefined &&
transactions instanceof Array &&
transactions[0] &&
transactions[0].ins &&
transactions[0].ins instanceof Array &&
transactions[0].ins[0] &&
transactions[0].ins[0].witness &&
transactions[0].ins[0].witness instanceof Array &&
transactions[0].ins[0].witness.length > 0
}
const Transaction = require('./transaction') const Transaction = require('./transaction')
function Block () { export class Block {
version: number
prevHash: Buffer
merkleRoot: Buffer
timestamp: number
witnessCommit: Buffer
bits: number
nonce: number
transactions: Array<any>
constructor () {
this.version = 1 this.version = 1
this.prevHash = null
this.merkleRoot = null
this.timestamp = 0 this.timestamp = 0
this.bits = 0 this.bits = 0
this.nonce = 0 this.nonce = 0
} }
Block.fromBuffer = function (buffer) { static fromBuffer (buffer: Buffer): Block {
if (buffer.length < 80) throw new Error('Buffer too small (< 80 bytes)') if (buffer.length < 80) throw errorBufferTooSmall
let offset = 0 let offset: number = 0
function readSlice (n) { const readSlice = (n: number): Buffer => {
offset += n offset += n
return buffer.slice(offset - n, offset) return buffer.slice(offset - n, offset)
} }
function readUInt32 () { const readUInt32 = (): number => {
const i = buffer.readUInt32LE(offset) const i = buffer.readUInt32LE(offset)
offset += 4 offset += 4
return i return i
} }
function readInt32 () { const readInt32 = (): number => {
const i = buffer.readInt32LE(offset) const i = buffer.readInt32LE(offset)
offset += 4 offset += 4
return i return i
@ -47,13 +71,13 @@ Block.fromBuffer = function (buffer) {
if (buffer.length === 80) return block if (buffer.length === 80) return block
function readVarInt () { const readVarInt = (): number => {
const vi = varuint.decode(buffer, offset) const vi = varuint.decode(buffer, offset)
offset += varuint.decode.bytes offset += varuint.decode.bytes
return vi return vi
} }
function readTransaction () { const readTransaction = (): any => {
const tx = Transaction.fromBuffer(buffer.slice(offset), true) const tx = Transaction.fromBuffer(buffer.slice(offset), true)
offset += tx.byteLength() offset += tx.byteLength()
return tx return tx
@ -67,30 +91,69 @@ Block.fromBuffer = function (buffer) {
block.transactions.push(tx) block.transactions.push(tx)
} }
// This Block contains a witness commit
if (block.hasWitnessCommit()) {
// The merkle root for the witness data is in an OP_RETURN output.
// There is no rule for the index of the output, so use filter to find it.
// The root is prepended with 0xaa21a9ed so check for 0x6a24aa21a9ed
// If multiple commits are found, the output with highest index is assumed.
let witnessCommits = block.transactions[0].outs
.filter(out => out.script.slice(0, 6).equals(Buffer.from('6a24aa21a9ed', 'hex')))
.map(out => out.script.slice(6, 38))
// Use the commit with the highest output (should only be one though)
block.witnessCommit = witnessCommits[witnessCommits.length - 1]
}
return block return block
} }
Block.prototype.byteLength = function (headersOnly) { static fromHex (hex: string): Block {
if (headersOnly || !this.transactions) return 80
return 80 + varuint.encodingLength(this.transactions.length) + this.transactions.reduce(function (a, x) {
return a + x.byteLength()
}, 0)
}
Block.fromHex = function (hex) {
return Block.fromBuffer(Buffer.from(hex, 'hex')) return Block.fromBuffer(Buffer.from(hex, 'hex'))
} }
Block.prototype.getHash = function () { static calculateTarget (bits: number): Buffer {
const exponent = ((bits & 0xff000000) >> 24) - 3
const mantissa = bits & 0x007fffff
const target = Buffer.alloc(32, 0)
target.writeUIntBE(mantissa, 29 - exponent, 3)
return target
}
static calculateMerkleRoot (transactions: Array<any>, forWitness: boolean | void): Buffer {
typeforce([{ getHash: types.Function }], transactions)
if (transactions.length === 0) throw errorMerkleNoTxes
if (forWitness && !txesHaveWitness(transactions)) throw errorWitnessNotSegwit
const hashes = transactions.map(transaction => transaction.getHash(forWitness))
const rootHash = fastMerkleRoot(hashes, bcrypto.hash256)
return forWitness
? bcrypto.hash256(Buffer.concat([rootHash, transactions[0].ins[0].witness[0]]))
: rootHash
}
hasWitnessCommit (): boolean {
return txesHaveWitness(this.transactions)
}
byteLength (headersOnly: boolean): number {
if (headersOnly || !this.transactions) return 80
return 80 + varuint.encodingLength(this.transactions.length) +
this.transactions.reduce((a, x) => a + x.byteLength(), 0)
}
getHash (): Buffer {
return bcrypto.hash256(this.toBuffer(true)) return bcrypto.hash256(this.toBuffer(true))
} }
Block.prototype.getId = function () { getId (): string {
return this.getHash().reverse().toString('hex') return Buffer.from(this.getHash().reverse()).toString('hex')
} }
Block.prototype.getUTCDate = function () { getUTCDate (): Date {
const date = new Date(0) // epoch const date = new Date(0) // epoch
date.setUTCSeconds(this.timestamp) date.setUTCSeconds(this.timestamp)
@ -98,20 +161,20 @@ Block.prototype.getUTCDate = function () {
} }
// TODO: buffer, offset compatibility // TODO: buffer, offset compatibility
Block.prototype.toBuffer = function (headersOnly) { toBuffer (headersOnly: boolean): Buffer {
const buffer = Buffer.allocUnsafe(this.byteLength(headersOnly)) const buffer: Buffer = Buffer.allocUnsafe(this.byteLength(headersOnly))
let offset = 0 let offset: number = 0
function writeSlice (slice) { const writeSlice = (slice: Buffer): void => {
slice.copy(buffer, offset) slice.copy(buffer, offset)
offset += slice.length offset += slice.length
} }
function writeInt32 (i) { const writeInt32 = (i: number): void => {
buffer.writeInt32LE(i, offset) buffer.writeInt32LE(i, offset)
offset += 4 offset += 4
} }
function writeUInt32 (i) { const writeUInt32 = (i: number): void => {
buffer.writeUInt32LE(i, offset) buffer.writeUInt32LE(i, offset)
offset += 4 offset += 4
} }
@ -128,7 +191,7 @@ Block.prototype.toBuffer = function (headersOnly) {
varuint.encode(this.transactions.length, buffer, offset) varuint.encode(this.transactions.length, buffer, offset)
offset += varuint.encode.bytes offset += varuint.encode.bytes
this.transactions.forEach(function (tx) { this.transactions.forEach(tx => {
const txSize = tx.byteLength() // TODO: extract from toBuffer? const txSize = tx.byteLength() // TODO: extract from toBuffer?
tx.toBuffer(buffer, offset) tx.toBuffer(buffer, offset)
offset += txSize offset += txSize
@ -137,42 +200,29 @@ Block.prototype.toBuffer = function (headersOnly) {
return buffer return buffer
} }
Block.prototype.toHex = function (headersOnly) { toHex (headersOnly: boolean): string {
return this.toBuffer(headersOnly).toString('hex') return this.toBuffer(headersOnly).toString('hex')
} }
Block.calculateTarget = function (bits) { checkMerkleRoot (): boolean {
const exponent = ((bits & 0xff000000) >> 24) - 3 if (!this.transactions) throw errorMerkleNoTxes
const mantissa = bits & 0x007fffff
const target = Buffer.alloc(32, 0)
target.writeUIntBE(mantissa, 29 - exponent, 3)
return target
}
Block.calculateMerkleRoot = function (transactions) {
typeforce([{ getHash: types.Function }], transactions)
if (transactions.length === 0) throw TypeError('Cannot compute merkle root for zero transactions')
const hashes = transactions.map(function (transaction) {
return transaction.getHash()
})
return fastMerkleRoot(hashes, bcrypto.hash256)
}
Block.prototype.checkMerkleRoot = function () {
if (!this.transactions) return false
const actualMerkleRoot = Block.calculateMerkleRoot(this.transactions) const actualMerkleRoot = Block.calculateMerkleRoot(this.transactions)
return this.merkleRoot.compare(actualMerkleRoot) === 0 return this.merkleRoot.compare(actualMerkleRoot) === 0
} }
Block.prototype.checkProofOfWork = function () { checkWitnessCommit (): boolean {
const hash = this.getHash().reverse() if (!this.transactions) throw errorMerkleNoTxes
if (!this.hasWitnessCommit()) throw errorWitnessNotSegwit
const actualWitnessCommit = Block.calculateMerkleRoot(this.transactions, true)
return this.witnessCommit.compare(actualWitnessCommit) === 0
}
checkProofOfWork (): boolean {
const hash: Buffer = Buffer.from(this.getHash().reverse())
const target = Block.calculateTarget(this.bits) const target = Block.calculateTarget(this.bits)
return hash.compare(target) <= 0 return hash.compare(target) <= 0
} }
}
module.exports = Block
export {}

View file

@ -1,6 +1,6 @@
const opcodes = require('bitcoin-ops') const opcodes = require('bitcoin-ops')
import * as Block from './block' import { Block } from './block'
import * as ECPair from './ecpair' import * as ECPair from './ecpair'
import * as Transaction from './transaction' import * as Transaction from './transaction'
import * as TransactionBuilder from './transaction_builder' import * as TransactionBuilder from './transaction_builder'

View file

@ -1,6 +1,6 @@
const { describe, it, beforeEach } = require('mocha') const { describe, it, beforeEach } = require('mocha')
const assert = require('assert') const assert = require('assert')
const Block = require('../dist/src/block') const Block = require('..').Block
const fixtures = require('./fixtures/block') const fixtures = require('./fixtures/block')