Merge branch 'master' into client-fix-undefined-result

Author: holgerd77

packages/blockchain/src/index.ts

@@ -736,15 +736,16 @@ export default class Blockchain implements BlockchainInterface {
    *
    * @param name - Name of the state root head
    * @param onBlock - Function called on each block with params (block, reorg)
+   * @param maxBlocks - How many blocks to run. By default, run all unprocessed blocks in the canonical chain.
    */
-  async iterator(name: string, onBlock: OnBlock) {
-    return this._iterator(name, onBlock)
+  async iterator(name: string, onBlock: OnBlock, maxBlocks?: number) {
+    return this._iterator(name, onBlock, maxBlocks)
   }
 
   /**
    * @hidden
    */
-  private async _iterator(name: string, onBlock: OnBlock) {
+  private async _iterator(name: string, onBlock: OnBlock, maxBlocks?: number) {
     await this.initAndLock<void>(async () => {
       const blockHash = this._heads[name] || this._genesis
       let lastBlock: Block | undefined
@@ -753,11 +754,15 @@ export default class Blockchain implements BlockchainInterface {
         return
       }
 
+      if (maxBlocks && maxBlocks < 0) {
+        throw 'If maxBlocks is provided, it has to be a non-negative number'
+      }
+
       const number = await this.dbManager.hashToNumber(blockHash)
       const blockNumber = number.addn(1)
+      let blocksRanCounter = 0
 
-      // eslint-disable-next-line no-constant-condition
-      while (true) {
+      while (maxBlocks !== blocksRanCounter) {
         try {
           const block = await this._getBlock(blockNumber)
 
@@ -770,6 +775,7 @@ export default class Blockchain implements BlockchainInterface {
           lastBlock = block
           await onBlock(block, reorg)
           blockNumber.iaddn(1)
+          blocksRanCounter++
         } catch (error) {
           if (error.type !== 'NotFoundError') {
             throw error
@@ -782,6 +788,19 @@ export default class Blockchain implements BlockchainInterface {
     })
   }
 
+  /**
+   * Set header hash of a certain `tag`.
+   * When calling the iterator, the iterator will start running the first child block after the header hash currenntly stored.
+   * @param tag - The tag to save the headHash to
+   * @param headHash - The head hash to save
+   */
+  async setHead(tag: string, headHash: Buffer) {
+    await this.initAndLock<void>(async () => {
+      this._heads[tag] = headHash
+      await this._saveHeads()
+    })
+  }
+
   /* Methods regarding re-org operations */
 
   /**

packages/blockchain/test/index.ts

@@ -348,6 +348,99 @@ tape('blockchain test', (t) => {
     st.end()
   })
 
+  t.test(
+    'should iterate through maxBlocks blocks if maxBlocks parameter is provided',
+    async (st) => {
+      const { blockchain, blocks, error } = await generateBlockchain(25)
+      st.error(error, 'no error')
+      let i = 0
+      await blockchain.iterator(
+        'test',
+        (block: Block) => {
+          if (block.hash().equals(blocks[i + 1].hash())) {
+            i++
+          }
+        },
+        5
+      )
+      st.equals(i, 5)
+      st.end()
+    }
+  )
+
+  t.test(
+    'should iterate through 0 blocks in case 0 maxBlocks parameter is provided',
+    async (st) => {
+      const { blockchain, blocks, error } = await generateBlockchain(25)
+      st.error(error, 'no error')
+      let i = 0
+      await blockchain
+        .iterator(
+          'test',
+          (block: Block) => {
+            if (block.hash().equals(blocks[i + 1].hash())) {
+              i++
+            }
+          },
+          0
+        )
+        .catch(() => {
+          st.fail('Promise cannot throw when running 0 blocks')
+        })
+      st.equals(i, 0)
+      st.end()
+    }
+  )
+
+  t.test('should throw on a negative maxBlocks parameter in iterator', async (st) => {
+    const { blockchain, blocks, error } = await generateBlockchain(25)
+    st.error(error, 'no error')
+    let i = 0
+    await blockchain
+      .iterator(
+        'test',
+        (block: Block) => {
+          if (block.hash().equals(blocks[i + 1].hash())) {
+            i++
+          }
+        },
+        -1
+      )
+      .catch(() => {
+        st.end()
+      })
+    // Note: if st.end() is not called (Promise did not throw), then this test fails, as it does not end.
+  })
+
+  t.test('should test setHead method', async (st) => {
+    const { blockchain, blocks, error } = await generateBlockchain(25)
+    st.error(error, 'no error')
+
+    const headBlockIndex = 5
+
+    const headHash = blocks[headBlockIndex].hash()
+    await blockchain.setHead('myHead', headHash)
+    const currentHeadBlock = await blockchain.getHead('myHead')
+
+    st.ok(headHash.equals(currentHeadBlock.hash()), 'head hash equals the provided head hash')
+
+    let i = 0
+    // check that iterator starts from this head block
+    await blockchain.iterator(
+      'myHead',
+      (block: Block) => {
+        if (block.hash().equals(blocks[headBlockIndex + 1].hash())) {
+          i++
+        }
+      },
+      5
+    )
+
+    st.equals(i, 1)
+
+    st.end()
+  })
+
   t.test('should catch iterator func error', async (st) => {
     const { blockchain, error } = await generateBlockchain(25)
     st.error(error, 'no error')

packages/vm/README.md

@@ -130,9 +130,9 @@ Our `TypeScript` VM is implemented as an [AsyncEventEmitter](https://github.com/
 You can subscribe to the following events:
 
 - `beforeBlock`: Emits a `Block` right before running it.
-- `afterBlock`: Emits `RunBlockResult` right after running a block.
+- `afterBlock`: Emits `AfterBlockEvent` right after running a block.
 - `beforeTx`: Emits a `Transaction` right before running it.
-- `afterTx`: Emits a `RunTxResult` right after running a transaction.
+- `afterTx`: Emits a `AfterTxEvent` right after running a transaction.
 - `beforeMessage`: Emits a `Message` right after running it.
 - `afterMessage`: Emits an `EVMResult` right after running a message.
 - `step`: Emits an `InterpreterStep` right before running an EVM step.

packages/vm/lib/runBlock.ts

@@ -104,6 +104,11 @@ export interface PostByzantiumTxReceipt extends TxReceipt {
   status: 0 | 1
 }
 
+export interface AfterBlockEvent extends RunBlockResult {
+  // The block which just finished processing
+  block: Block
+}
+
 /**
  * @ignore
  */
@@ -183,14 +188,20 @@ export default async function runBlock(this: VM, opts: RunBlockOpts): Promise<Ru
 
   const { receipts, results } = result
 
+  const afterBlockEvent: AfterBlockEvent = {
+    receipts,
+    results,
+    block,
+  }
+
   /**
    * The `afterBlock` event
    *
    * @event Event: afterBlock
-   * @type {Object}
-   * @property {Object} result emits the results of processing a block
+   * @type {AfterBlockEvent}
+   * @property {AfterBlockEvent} result emits the results of processing a block
    */
-  await this._emit('afterBlock', { receipts, results })
+  await this._emit('afterBlock', afterBlockEvent)
 
   return { receipts, results }
 }

packages/vm/lib/runTx.ts

@@ -47,6 +47,13 @@ export interface RunTxResult extends EVMResult {
   gasRefund?: BN
 }
 
+export interface AfterTxEvent extends RunTxResult {
+  /**
+   * The transaction which just got finished
+   */
+  transaction: Transaction
+}
+
 /**
  * @ignore
  */
@@ -199,7 +206,8 @@ async function _runTx(this: VM, opts: RunTxOpts): Promise<RunTxResult> {
    * @type {Object}
    * @property {Object} result result of the transaction
    */
-  await this._emit('afterTx', results)
+  const event: AfterTxEvent = { transaction: tx, ...results }
+  await this._emit('afterTx', event)
 
   return results
 }