Merge branch 'master' into checkpoint-trie-cache

Author: holgerd77

packages/tx/src/transaction.ts

@@ -59,17 +59,19 @@ export default class Transaction {
 
     const [nonce, gasPrice, gasLimit, to, value, data, v, r, s] = values
 
+    const emptyBuffer = Buffer.from([])
+
     return new Transaction(
       {
         nonce: new BN(nonce),
         gasPrice: new BN(gasPrice),
         gasLimit: new BN(gasLimit),
         to: to && to.length > 0 ? new Address(to) : undefined,
         value: new BN(value),
-        data: data || Buffer.from([]),
-        v: v ? new BN(v) : undefined,
-        r: r ? new BN(r) : undefined,
-        s: s ? new BN(s) : undefined,
+        data: data ?? emptyBuffer,
+        v: !v?.equals(emptyBuffer) ? new BN(v) : undefined,
+        r: !r?.equals(emptyBuffer) ? new BN(r) : undefined,
+        s: !s?.equals(emptyBuffer) ? new BN(s) : undefined,
       },
       opts
     )
@@ -89,9 +91,9 @@ export default class Transaction {
     this.to = to ? new Address(toBuffer(to)) : undefined
     this.value = new BN(toBuffer(value))
     this.data = toBuffer(data)
-    this.v = new BN(toBuffer(v))
-    this.r = new BN(toBuffer(r))
-    this.s = new BN(toBuffer(s))
+    this.v = v ? new BN(toBuffer(v)) : undefined
+    this.r = r ? new BN(toBuffer(r)) : undefined
+    this.s = s ? new BN(toBuffer(s)) : undefined
 
     const validateCannotExceedMaxInteger = {
       nonce: this.nonce,

packages/tx/test/api.ts

@@ -335,6 +335,43 @@ tape('[Transaction]: Basic functions', function (t) {
     st.end()
   })
 
+  t.test('returns correct values for isSigned', function (st) {
+    let tx = Transaction.fromTxData({})
+    st.notOk(tx.isSigned())
+
+    const txData: TxData = {
+      data: '0x7cf5dab00000000000000000000000000000000000000000000000000000000000000005',
+      gasLimit: '0x15f90',
+      gasPrice: '0x1',
+      nonce: '0x01',
+      to: '0xd9024df085d09398ec76fbed18cac0e1149f50dc',
+      value: '0x0',
+    }
+    const privateKey = Buffer.from(
+      '4646464646464646464646464646464646464646464646464646464646464646',
+      'hex'
+    )
+    tx = Transaction.fromTxData(txData)
+    st.notOk(tx.isSigned())
+    tx = tx.sign(privateKey)
+    st.ok(tx.isSigned())
+
+    tx = new Transaction(txData)
+    st.notOk(tx.isSigned())
+    const rawUnsigned = tx.serialize()
+    tx = tx.sign(privateKey)
+    const rawSigned = tx.serialize()
+    st.ok(tx.isSigned())
+
+    tx = Transaction.fromRlpSerializedTx(rawUnsigned)
+    st.notOk(tx.isSigned())
+    tx = tx.sign(privateKey)
+    st.ok(tx.isSigned())
+    tx = Transaction.fromRlpSerializedTx(rawSigned)
+    st.ok(tx.isSigned())
+    st.end()
+  })
+
   t.test(
     'throws when creating a a transaction with incompatible chainid and v value',
     function (st) {

packages/vm/lib/runTx.ts

@@ -27,6 +27,12 @@ export interface RunTxOpts {
    * If true, skips the balance check
    */
   skipBalance?: boolean
+
+  /**
+   * If true, skips the validation of the tx's gas limit
+   * agains the block's gas limit.
+   */
+  skipBlockGasLimitValidation?: boolean
 }
 
 /**
@@ -66,7 +72,10 @@ export default async function runTx(this: VM, opts: RunTxOpts): Promise<RunTxRes
   // create a reasonable default if no block is given
   opts.block = opts.block ?? Block.fromBlockData({}, { common: opts.tx.common })
 
-  if (opts.block.header.gasLimit.lt(opts.tx.gasLimit)) {
+  if (
+    opts.skipBlockGasLimitValidation !== true &&
+    opts.block.header.gasLimit.lt(opts.tx.gasLimit)
+  ) {
     throw new Error('tx has a higher gas limit than the block')
   }
 

packages/vm/tests/api/runTx.spec.ts

@@ -1,5 +1,6 @@
 import tape from 'tape'
-import { Address, BN, MAX_INTEGER } from 'ethereumjs-util'
+import { Account, Address, BN, MAX_INTEGER } from 'ethereumjs-util'
+import { Block } from '@ethereumjs/block'
 import Common from '@ethereumjs/common'
 import { Transaction } from '@ethereumjs/tx'
 import VM from '../../lib'
@@ -32,7 +33,7 @@ tape('runTx', (t) => {
   t.test('should fail to run without signature', async (st) => {
     const tx = getTransaction(false)
     shouldFail(st, suite.runTx({ tx }), (e: Error) =>
-      st.ok(e.message.includes('Invalid Signature'), 'should fail with appropriate error')
+      st.ok(e.message.includes('not signed'), 'should fail with appropriate error')
     )
     st.end()
   })
@@ -144,6 +145,48 @@ tape('should clear storage cache after every transaction', async (t) => {
   t.end()
 })
 
+tape('should be possible to disable the block gas limit validation', async (t) => {
+  const vm = new VM()
+
+  const privateKey = Buffer.from(
+    'e331b6d69882b4cb4ea581d88e0b604039a3de5967688d3dcffdd2270c0fd109',
+    'hex'
+  )
+  const address = Address.fromPrivateKey(privateKey)
+  const initialBalance = new BN(10).pow(new BN(18))
+
+  const account = await vm.stateManager.getAccount(address)
+  await vm.stateManager.putAccount(
+    address,
+    Account.fromAccountData({ ...account, balance: initialBalance })
+  )
+
+  const transferCost = 21000
+
+  const unsignedTx = Transaction.fromTxData({
+    to: address,
+    gasLimit: transferCost,
+    gasPrice: 1,
+    nonce: 0,
+  })
+
+  const tx = unsignedTx.sign(privateKey)
+
+  const block = Block.fromBlockData({
+    header: { gasLimit: transferCost - 1 },
+  })
+
+  const result = await vm.runTx({
+    tx,
+    block,
+    skipBlockGasLimitValidation: true,
+  })
+
+  t.equals(result.execResult.exceptionError, undefined)
+
+  t.end()
+})
+
 // The following test tries to verify that running a tx
 // would work, even when stateManager is not using a cache.
 // It fails at the moment, and has been therefore commented.