Block library refactoring

packages/block/src/block.ts

@@ -1,7 +1,7 @@
 import { BaseTrie as Trie } from 'merkle-patricia-tree'
 import { BN, rlp, keccak256, KECCAK256_RLP, baToJSON } from 'ethereumjs-util'
 import Common from '@ethereumjs/common'
-import { Transaction } from '@ethereumjs/tx'
+import { Transaction, TxOptions } from '@ethereumjs/tx'
 import { BlockHeader } from './header'
 import { Blockchain, BlockData, BlockOptions } from './types'
 
@@ -16,6 +16,73 @@ export class Block {
 
   private readonly _common: Common
 
+  public static fromBlockData(blockData: BlockData, opts: BlockOptions = {}) {
+    // Checking at runtime, to prevent errors down the path for JavaScript consumers.
+    if (blockData === null) {
+      blockData = {}
+    }
+
+    const headerData = blockData.header || {}
+    const txsData = blockData.transactions || []
+    const uncleHeadersData = blockData.uncleHeaders || []
+
+    const header = BlockHeader.fromHeaderData(headerData, opts)
+
+    // parse transactions
+    let transactions = []
+    for (const txData of txsData) {
+      transactions.push(Transaction.fromTxData(txData, opts as TxOptions))
+    }
+
+    // parse uncle headers
+    let uncleHeaders = []
+    for (const uncleHeaderData of uncleHeadersData) {
+      uncleHeaders.push(BlockHeader.fromHeaderData(uncleHeaderData, opts))
+    }
+
+    return new Block(header, transactions, uncleHeaders, opts)
+  }
+
+  public static fromRLPSerializedBlock(serialized: Buffer, opts: BlockOptions = {}) {
+    // We do this to silence a TS error. We know that after this statement, data is
+    // a [Buffer[], Buffer[][], Buffer[][]]
+    let values = (rlp.decode(serialized) as any) as [Buffer[], Buffer[][], Buffer[][]]
+    if (!Array.isArray(values)) {
+      throw new Error('Invalid serialized block input. Must be array')
+    }
+
+    return Block.fromValuesArray(values, opts)
+  }
+
+  public static fromValuesArray(
+    values: [Buffer[], Buffer[][], Buffer[][]],
+    opts: BlockOptions = {},
+  ) {
+    if (values.length > 3) {
+      throw new Error('invalid block. More values than expected were received')
+    }
+
+    const headerArray = values[0] || []
+    const txsData = values[1] || []
+    const uncleHeadersData = values[2] || []
+
+    const header = BlockHeader.fromValuesArray(headerArray, opts)
+
+    // parse transactions
+    let transactions = []
+    for (const txData of txsData) {
+      transactions.push(Transaction.fromValuesArray(txData as Buffer[], opts as TxOptions))
+    }
+
+    // parse uncle headers
+    let uncleHeaders = []
+    for (const uncleHeaderData of uncleHeadersData) {
+      uncleHeaders.push(BlockHeader.fromValuesArray(uncleHeaderData as Buffer[], opts))
+    }
+
+    return new Block(header, transactions, uncleHeaders, opts)
+  }
+
   /**
    * Creates a new block object
    *
@@ -27,50 +94,16 @@ export class Block {
    * @param options - The options for this block (like the chain setup)
    */
   constructor(
-    data: Buffer | [Buffer[], Buffer[], Buffer[]] | BlockData = {},
-    options: BlockOptions = {},
+    header: BlockHeader,
+    transactions: Transaction[],
+    uncleHeaders: BlockHeader[],
+    //data: Buffer | [Buffer[], Buffer[], Buffer[]] | BlockData = {},
+    opts: BlockOptions = {},
   ) {
-    // Checking at runtime, to prevent errors down the path for JavaScript consumers.
-    if (data === null) {
-      data = {}
-    }
-
-    let rawTransactions
-    let rawUncleHeaders
-
-    if (Buffer.isBuffer(data)) {
-      // We do this to silence a TS error. We know that after this statement, data is
-      // a [Buffer[], Buffer[], Buffer[]]
-      const dataAsAny = rlp.decode(data) as any
-      data = dataAsAny as [Buffer[], Buffer[], Buffer[]]
-    }
-
-    // Initialize the block header
-    if (Array.isArray(data)) {
-      this.header = new BlockHeader(data[0], options)
-      rawTransactions = data[1]
-      rawUncleHeaders = data[2]
-    } else {
-      this.header = new BlockHeader(data.header, options)
-      rawTransactions = data.transactions || []
-      rawUncleHeaders = data.uncleHeaders || []
-    }
+    this.header = header
+    this.transactions = transactions
+    this.uncleHeaders = uncleHeaders
     this._common = this.header._common
-
-    // parse uncle headers
-    for (let i = 0; i < rawUncleHeaders.length; i++) {
-      this.uncleHeaders.push(new BlockHeader(rawUncleHeaders[i], options))
-    }
-
-    // parse transactions
-    const txOpts = { common: this._common }
-    for (let i = 0; i < rawTransactions.length; i++) {
-      const txData = rawTransactions[i]
-      const tx = Array.isArray(txData)
-        ? Transaction.fromValuesArray(txData as Buffer[], txOpts)
-        : Transaction.fromRlpSerializedTx(txData as Buffer, txOpts)
-      this.transactions.push(tx)
-    }
   }
 
   get raw(): [Buffer[], Buffer[], Buffer[]] {
@@ -103,9 +136,9 @@ export class Block {
   serialize(rlpEncode: false): [Buffer[], Buffer[], Buffer[]]
   serialize(rlpEncode = true) {
     const raw = [
-      this.header.raw,
+      this.header.raw(),
       this.transactions.map((tx) => tx.serialize()),
-      this.uncleHeaders.map((uh) => uh.raw),
+      this.uncleHeaders.map((uh) => uh.raw()),
     ]
 
     return rlpEncode ? rlp.encode(raw) : raw
@@ -184,7 +217,7 @@ export class Block {
    * Validates the uncle's hash
    */
   validateUnclesHash(): boolean {
-    const raw = rlp.encode(this.uncleHeaders.map((uh) => uh.raw))
+    const raw = rlp.encode(this.uncleHeaders.map((uh) => uh.raw()))
 
     return keccak256(raw).equals(this.header.uncleHash)
   }

packages/block/src/from-rpc.ts

@@ -16,17 +16,10 @@ export default function blockFromRpc(blockParams: any, uncles?: any[], options?:
 
   const header = blockHeaderFromRpc(blockParams, options)
 
-  const block = new Block(
-    {
-      header: header.toJSON(true),
-      transactions: [],
-      uncleHeaders: uncles.map((uh) => blockHeaderFromRpc(uh, options).toJSON(true)),
-    },
-    options,
-  )
+  const transactions: TxData[] = []
 
   if (blockParams.transactions) {
-    const txOpts = { common: (<any>block)._common }
+    const txOpts = { common: header._common }
 
     for (const _txParams of blockParams.transactions) {
       const txParams = normalizeTxParams(_txParams)
@@ -47,10 +40,16 @@ export default function blockFromRpc(blockParams: any, uncles?: any[], options?:
         return toBuffer(txParams.hash)
       }
 
-      block.transactions.push(fakeTx)
+      transactions.push(fakeTx)
     }
   }
 
+  const block = Block.fromBlockData({
+    header,
+    transactions,
+    uncleHeaders: uncles.map((uh) => blockHeaderFromRpc(uh, options)),
+  })
+
   return block
 }
 

packages/block/src/header-from-rpc.ts

@@ -9,7 +9,7 @@ import { BlockOptions } from './types'
  * @param chainOptions - An object describing the blockchain
  */
 export default function blockHeaderFromRpc(blockParams: any, options?: BlockOptions) {
-  const blockHeader = new BlockHeader(
+  const blockHeader = BlockHeader.fromHeaderData(
     {
       parentHash: blockParams.parentHash,
       uncleHash: blockParams.sha3Uncles,
@@ -30,10 +30,10 @@ export default function blockHeaderFromRpc(blockParams: any, options?: BlockOpti
     options,
   )
 
-  // override hash in case something was missing
-  blockHeader.hash = function () {
-    return toBuffer(blockParams.hash)
-  }
+  // override hash in case something was missing TODO: why do we need this?
+  //blockHeader.hash = function () {
+  //  return toBuffer(blockParams.hash)
+  //}
 
   return blockHeader
 }