Refactor tx lib

packages/account/test/index.spec.ts

@@ -98,13 +98,8 @@ tape('serialize', function (tester) {
       codeHash: '0xc5d2461236f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470',
     }
     const account = new Account(raw)
-    t.equals(
-      Buffer.compare(
-        account.serialize(),
-        rlp.encode([raw.nonce, raw.balance, raw.stateRoot, raw.codeHash]),
-      ),
-      0,
-    )
+    const accountRlp = rlp.encode([raw.nonce, raw.balance, raw.stateRoot, raw.codeHash])
+    t.ok(account.serialize().equals(accountRlp))
     t.end()
   })
 })

packages/block/src/block.ts

@@ -1,7 +1,7 @@
 import { BaseTrie as Trie } from 'merkle-patricia-tree'
 import Common from '@ethereumjs/common'
 import { BN, rlp, keccak256, KECCAK256_RLP, baToJSON } from 'ethereumjs-util'
-import { Transaction, TransactionOptions } from '@ethereumjs/tx'
+import { Transaction } from '@ethereumjs/tx'
 import { BlockHeader } from './header'
 import { Blockchain, BlockData, ChainOptions } from './types'
 
@@ -41,7 +41,7 @@ export class Block {
       this._common = chainOptions.common
     } else {
       const chain = chainOptions.chain ? chainOptions.chain : 'mainnet'
-      // TODO: Compute the hardfork based on this block's number. It can be implemented right now
+      // TODO: Compute the hardfork based on this block's number. It can't be implemented right now
       // because the block number is not immutable, so the Common can get out of sync.
       const hardfork = chainOptions.hardfork ? chainOptions.hardfork : null
       this._common = new Common(chain, hardfork)
@@ -73,10 +73,29 @@ export class Block {
     }
 
     // parse transactions
+
+    // get common based on block's number
+    // since hardfork param may not be set
+    // (see TODO above)
+    let common = this._common
+    if (!common.hardfork()) {
+      const blockNumber = parseInt(this.header.number.toString('hex'), 16)
+      const chainId = this._common.chainId()
+      if (blockNumber) {
+        const hfs = this._common.activeHardforks(blockNumber)
+        const hf = hfs[hfs.length - 1].name
+        common = new Common(chainId, hf)
+      } else {
+        // fall back to default hf
+        common = new Common(chainId, 'petersburg')
+      }
+    }
+
     for (let i = 0; i < rawTransactions.length; i++) {
-      // TODO: Pass the common object instead of the options. It can't be implemented right now
-      // because the hardfork may be `null`. Read the above TODO for more info.
-      const tx = new Transaction(rawTransactions[i], chainOptions as TransactionOptions)
+      const txData = rawTransactions[i]
+      const tx = Array.isArray(txData)
+        ? Transaction.fromValuesArray(txData as Buffer[], common)
+        : Transaction.fromRlpSerializedTx(txData as Buffer, common)
       this.transactions.push(tx)
     }
   }
@@ -119,7 +138,7 @@ export class Block {
   serialize(rlpEncode = true) {
     const raw = [
       this.header.raw,
-      this.transactions.map((tx) => tx.raw),
+      this.transactions.map((tx) => tx.serialize()),
       this.uncleHeaders.map((uh) => uh.raw),
     ]
 
@@ -141,11 +160,11 @@ export class Block {
    * Validates the transaction trie
    */
   validateTransactionsTrie(): boolean {
-    const txT = this.header.transactionsTrie.toString('hex')
+    const txT = this.header.transactionsTrie
     if (this.transactions.length) {
-      return txT === this.txTrie.root.toString('hex')
+      return txT.equals(this.txTrie.root)
     } else {
-      return txT === KECCAK256_RLP.toString('hex')
+      return txT.equals(KECCAK256_RLP)
     }
   }
 
@@ -243,7 +262,7 @@ export class Block {
     if (labeled) {
       return {
         header: this.header.toJSON(true),
-        transactions: this.transactions.map((tx) => tx.toJSON(true)),
+        transactions: this.transactions.map((tx) => tx.toJSON()),
         uncleHeaders: this.uncleHeaders.forEach((uh) => uh.toJSON(true)),
       }
     } else {

packages/block/src/from-rpc.ts

@@ -1,4 +1,5 @@
-import { FakeTransaction, TransactionOptions } from '@ethereumjs/tx'
+import { Transaction, TxData, Address } from '@ethereumjs/tx'
+import Common from '@ethereumjs/common'
 import { toBuffer, setLengthLeft } from 'ethereumjs-util'
 import { Block, ChainOptions } from './index'
 
@@ -32,19 +33,30 @@ export default function blockFromRpc(
   if (blockParams.transactions) {
     for (const _txParams of blockParams.transactions) {
       const txParams = normalizeTxParams(_txParams)
+
       // override from address
-      const fromAddress = toBuffer(txParams.from)
+      const fromAddress = new Address(toBuffer(txParams.from))
       delete txParams.from
 
-      const tx = new FakeTransaction(txParams, chainOptions as TransactionOptions)
-      tx.from = fromAddress
+      // get common based on block's number
+      // since hardfork param may not be set
+      // (see TODO in block.constructor)
+      const blockNumber = parseInt(block.header.number.toString('hex'), 16)
+      const hfs = (block as any)._common.activeHardforks(blockNumber)
+      const hf = hfs[hfs.length - 1].name
+      const common = new Common((block as any)._common.chainId(), hf)
+
+      const frozenTx = Transaction.fromTxData(txParams as TxData, common)
+      const tx = Object.create(frozenTx)
+
+      // override getSenderAddress
       tx.getSenderAddress = function () {
         return fromAddress
       }
+
       // override hash
-      const txHash = toBuffer(txParams.hash)
       tx.hash = function () {
-        return txHash
+        return toBuffer(txParams.hash)
       }
 
       block.transactions.push(tx)
@@ -55,9 +67,10 @@ export default function blockFromRpc(
 
 function normalizeTxParams(_txParams: any) {
   const txParams = Object.assign({}, _txParams)
-  // hot fix for https://github.com/ethereumjs/ethereumjs-util/issues/40
+
   txParams.gasLimit = txParams.gasLimit === undefined ? txParams.gas : txParams.gasLimit
   txParams.data = txParams.data === undefined ? txParams.input : txParams.data
+
   // strict byte length checking
   txParams.to = txParams.to ? setLengthLeft(toBuffer(txParams.to), 20) : null
 

packages/block/test/from-rpc.spec.ts

@@ -15,7 +15,8 @@ tape('[fromRPC]: block #2924874', function (t) {
 
   t.test('should create a block header with the correct hash', function (st) {
     const block = blockHeaderFromRpc(blockData)
-    st.ok(block.hash().compare(Buffer.from(blockData.hash)))
+    const hash = Buffer.from(blockData.hash.slice(2), 'hex')
+    st.ok(block.hash().equals(hash))
     st.end()
   })
 

packages/blockchain/test/util.ts

@@ -56,7 +56,9 @@ export const isConsecutive = (blocks: Block[]) => {
     if (index === 0) {
       return false
     }
-    return Buffer.compare(block.header.parentHash, blocks[index - 1].hash()) !== 0
+    const { parentHash } = block.header
+    const lastBlockHash = blocks[index - 1].hash()
+    return !parentHash.equals(lastBlockHash)
   })
 }
 

packages/tx/README.md

@@ -1,4 +1,4 @@
-# ethereumjs-tx
+# @ethereumjs/tx
 
 [![NPM Package][tx-npm-badge]][tx-npm-link]
 [![GitHub Issues][tx-issues-badge]][tx-issues-link]
@@ -10,18 +10,14 @@
 
 # INSTALL
 
-`npm install ethereumjs-tx`
+`npm install @ethereumjs/tx`
 
 # USAGE
 
-- [example](https://github.com/ethereumjs/ethereumjs-tx/blob/master/examples/transactions.ts)
+- [Example](./examples/transactions.ts)
 
 ```javascript
-const EthereumTx = require('@ethereumjs/tx').Transaction
-const privateKey = Buffer.from(
-  'e331b6d69882b4cb4ea581d88e0b604039a3de5967688d3dcffdd2270c0fd109',
-  'hex',
-)
+import Transaction from '@ethereumjs/tx'
 
 const txParams = {
   nonce: '0x00',
@@ -32,21 +28,22 @@ const txParams = {
   data: '0x7f7465737432000000000000000000000000000000000000000000000000000000600057',
 }
 
-// The second parameter is not necessary if these values are used
-const tx = new EthereumTx(txParams, { chain: 'mainnet', hardfork: 'petersburg' })
-tx.sign(privateKey)
-const serializedTx = tx.serialize()
-```
+const common = new Common('mainnet', 'petersburg')
+const tx = Transaction.fromTxData(txParams, common)
 
-# Chain and Hardfork Support
+const privateKey = Buffer.from(
+  'e331b6d69882b4cb4ea581d88e0b604039a3de5967688d3dcffdd2270c0fd109',
+  'hex',
+)
 
-The `Transaction` and `FakeTransaction` constructors receives a second parameter that lets you specify the chain and hardfork
-to be used. By default, `mainnet` and `petersburg` will be used.
+const signedTx = tx.sign(privateKey)
 
-There are two ways of customizing these. The first one, as shown in the previous section, is by
-using an object with `chain` and `hardfork` names. You can see en example of this in [./examples/ropsten-tx.ts](./examples/ropsten-tx.ts).
+const serializedTx = signedTx.serialize()
+```
+
+# Chain and Hardfork Support
 
-The second option is by passing the option `common` set to an instance of [@ethereumjs/common](https://github.com/ethereumjs/ethereumjs-common)' Common. This is specially useful for custom networks or chains/hardforks not yet supported by `ethereumjs-common`. You can see en example of this in [./examples/custom-chain-tx.ts](./examples/custom-chain-tx.ts).
+The `Transaction` constructor receives a second parameter of an [`@ethereumjs/common`](https://github.com/ethereumjs/ethereumjs-vm/blob/master/packages/common) object that lets you specify the chain and hardfork to be used. By default, `mainnet` and `petersburg` will be used.
 
 ## MuirGlacier Support
 
@@ -60,8 +57,7 @@ along with the `v2.1.1` release.
 
 # EIP-155 support
 
-`EIP-155` replay protection is activated since the `spuriousDragon` hardfork. To disable it, set the
-hardfork in the `Transaction`'s constructor.
+`EIP-155` replay protection is activated since the `spuriousDragon` hardfork. To disable it, set the hardfork to one earlier than `spuriousDragon`.
 
 # API
 

packages/tx/examples/custom-chain-tx.ts

@@ -1,6 +1,6 @@
 import { Transaction } from '../src'
 import Common from '@ethereumjs/common'
-import { bufferToHex, privateToAddress } from 'ethereumjs-util'
+import { privateToAddress } from 'ethereumjs-util'
 
 // In this example we create a transaction for a custom network.
 //
@@ -18,14 +18,14 @@ const customCommon = Common.forCustomChain(
 
 // We pass our custom Common object whenever we create a transaction
 
-const tx = new Transaction(
+const tx = Transaction.fromTxData(
   {
     nonce: 0,
     gasPrice: 100,
     gasLimit: 1000000000,
     value: 100000,
   },
-  { common: customCommon },
+  customCommon,
 )
 
 // Once we created the transaction using the custom Common object, we can use it as a normal tx.
@@ -36,15 +36,15 @@ const privateKey = Buffer.from(
   'hex',
 )
 
-tx.sign(privateKey)
+const signedTx = tx.sign(privateKey)
 
 if (
-  tx.validate() &&
-  bufferToHex(tx.getSenderAddress()) === bufferToHex(privateToAddress(privateKey))
+  signedTx.validate() &&
+  signedTx.getSenderAddress().toBuffer().equals(privateToAddress(privateKey))
 ) {
   console.log('Valid signature')
 } else {
   console.log('Invalid signature')
 }
 
-console.log("The transaction's chain id is", tx.getChainId())
+console.log("The transaction's chain id is ", signedTx.getChainId())

packages/tx/examples/ropsten-tx.ts

@@ -1,14 +1,16 @@
 import { Transaction } from '../src'
-import { bufferToHex } from 'ethereumjs-util'
+import { toBuffer } from 'ethereumjs-util'
+import Common from '@ethereumjs/common'
 
-const tx = new Transaction(
+const txData = toBuffer(
   '0xf9010b82930284d09dc30083419ce0942d18de92e0f9aee1a29770c3b15c6cf8ac5498e580b8a42f43f4fb0000000000000000000000000000000000000000000000000000016b78998da900000000000000000000000000000000000000000000000000000000000cb1b70000000000000000000000000000000000000000000000000000000000000fa00000000000000000000000000000000000000000000000000000000001363e4f00000000000000000000000000000000000000000000000000000000000186a029a0fac36e66d329af0e831b2e61179b3ec8d7c7a8a2179e303cfed3364aff2bc3e4a07cb73d56e561ccbd838818dd3dea5fa0b5158577ffc61c0e6ec1f0ed55716891',
-  { chain: 'ropsten', hardfork: 'petersburg' },
 )
 
+const tx = Transaction.fromRlpSerializedTx(txData, new Common('ropsten', 'petersburg'))
+
 if (
   tx.validate() &&
-  bufferToHex(tx.getSenderAddress()) === '0x9dfd2d2b2ed960923f7bf2e8883d73f213f3b24b'
+  tx.getSenderAddress().toString() === '0x9dfd2d2b2ed960923f7bf2e8883d73f213f3b24b'
 ) {
   console.log('Correctly created the tx')
 } else {