Move Block Class from ES6 PR

src/block.ts

@@ -5,33 +5,57 @@ const typeforce = require('typeforce')
 const types = require('./types')
 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')
 
-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.prevHash = null
-  this.merkleRoot = null
     this.timestamp = 0
     this.bits = 0
     this.nonce = 0
   }
 
-Block.fromBuffer = function (buffer) {
-  if (buffer.length < 80) throw new Error('Buffer too small (< 80 bytes)')
+  static fromBuffer (buffer: Buffer): Block {
+    if (buffer.length < 80) throw errorBufferTooSmall
 
-  let offset = 0
-  function readSlice (n) {
+    let offset: number = 0
+    const readSlice = (n: number): Buffer => {
       offset += n
       return buffer.slice(offset - n, offset)
     }
 
-  function readUInt32 () {
+    const readUInt32 = (): number => {
       const i = buffer.readUInt32LE(offset)
       offset += 4
       return i
     }
 
-  function readInt32 () {
+    const readInt32 = (): number => {
       const i = buffer.readInt32LE(offset)
       offset += 4
       return i
@@ -47,13 +71,13 @@ Block.fromBuffer = function (buffer) {
 
     if (buffer.length === 80) return block
 
-  function readVarInt () {
+    const readVarInt = (): number => {
       const vi = varuint.decode(buffer, offset)
       offset += varuint.decode.bytes
       return vi
     }
 
-  function readTransaction () {
+    const readTransaction = (): any => {
       const tx = Transaction.fromBuffer(buffer.slice(offset), true)
       offset += tx.byteLength()
       return tx
@@ -67,30 +91,69 @@ Block.fromBuffer = function (buffer) {
       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
   }
 
-Block.prototype.byteLength = function (headersOnly) {
-  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) {
+  static fromHex (hex: string): Block {
     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))
   }
 
-Block.prototype.getId = function () {
-  return this.getHash().reverse().toString('hex')
+  getId (): string {
+    return Buffer.from(this.getHash().reverse()).toString('hex')
   }
 
-Block.prototype.getUTCDate = function () {
+  getUTCDate (): Date {
     const date = new Date(0) // epoch
     date.setUTCSeconds(this.timestamp)
 
@@ -98,20 +161,20 @@ Block.prototype.getUTCDate = function () {
   }
 
   // TODO: buffer, offset compatibility
-Block.prototype.toBuffer = function (headersOnly) {
-  const buffer = Buffer.allocUnsafe(this.byteLength(headersOnly))
+  toBuffer (headersOnly: boolean): Buffer {
+    const buffer: Buffer = Buffer.allocUnsafe(this.byteLength(headersOnly))
 
-  let offset = 0
-  function writeSlice (slice) {
+    let offset: number = 0
+    const writeSlice = (slice: Buffer): void => {
       slice.copy(buffer, offset)
       offset += slice.length
     }
 
-  function writeInt32 (i) {
+    const writeInt32 = (i: number): void => {
       buffer.writeInt32LE(i, offset)
       offset += 4
     }
-  function writeUInt32 (i) {
+    const writeUInt32 = (i: number): void => {
       buffer.writeUInt32LE(i, offset)
       offset += 4
     }
@@ -128,7 +191,7 @@ Block.prototype.toBuffer = function (headersOnly) {
     varuint.encode(this.transactions.length, buffer, offset)
     offset += varuint.encode.bytes
 
-  this.transactions.forEach(function (tx) {
+    this.transactions.forEach(tx => {
       const txSize = tx.byteLength() // TODO: extract from toBuffer?
       tx.toBuffer(buffer, offset)
       offset += txSize
@@ -137,42 +200,29 @@ Block.prototype.toBuffer = function (headersOnly) {
     return buffer
   }
 
-Block.prototype.toHex = function (headersOnly) {
+  toHex (headersOnly: boolean): string {
     return this.toBuffer(headersOnly).toString('hex')
   }
 
-Block.calculateTarget = function (bits) {
-  const exponent = ((bits & 0xff000000) >> 24) - 3
-  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
+  checkMerkleRoot (): boolean {
+    if (!this.transactions) throw errorMerkleNoTxes
 
     const actualMerkleRoot = Block.calculateMerkleRoot(this.transactions)
     return this.merkleRoot.compare(actualMerkleRoot) === 0
   }
 
-Block.prototype.checkProofOfWork = function () {
-  const hash = this.getHash().reverse()
+  checkWitnessCommit (): boolean {
+    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)
 
     return hash.compare(target) <= 0
   }
-
-module.exports = Block
-export {}
+}

src/index.ts

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

test/block.js

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