Tx: fix transaction tester (#3942)

* tx: transaction runner: update tester to correctly test

* tx: 7702 add check which bans nested lists inside authority items

* tx: add fork to test name

* tx: fix test runner v2

Author: jochem-brouwer

packages/tx/src/capabilities/eip7702.ts

@@ -36,6 +36,17 @@ export function verifyAuthorizationList(tx: EIP7702CompatibleTx) {
         'Invalid EIP-7702 transaction: authorization list item should have 6 elements',
       )
     }
+
+    for (const member of item) {
+      // This checks if the `member` is a list, not bytes
+      // This checks that the authority list does not have any embedded lists in it
+      if (Array.isArray(member)) {
+        throw EthereumJSErrorWithoutCode(
+          'Invalid EIP-7702 transaction: authority list element is a list, not bytes',
+        )
+      }
+    }
+
     const [chainId, address, nonce, yParity, r, s] = item
 
     validateNoLeadingZeroes({ yParity, r, s, nonce, chainId })

packages/tx/test/transactionRunner.spec.ts

@@ -1,5 +1,5 @@
 import { Common, Mainnet } from '@ethereumjs/common'
-import { bytesToHex, hexToBytes } from '@ethereumjs/util'
+import { EthereumJSErrorWithoutCode, bytesToHex, hexToBytes } from '@ethereumjs/util'
 import minimist from 'minimist'
 import { assert, describe, it } from 'vitest'
 
@@ -62,47 +62,49 @@ describe('TransactionTests', async () => {
       testName: string,
       testData: OfficialTransactionTestData,
     ) => {
-      it(testName, () => {
-        for (const forkName of forkNames) {
-          if (testData.result[forkName] === undefined) {
-            continue
-          }
+      for (const forkName of forkNames) {
+        if (testData.result[forkName] === undefined) {
+          continue
+        }
+        it(`${testName} - [${forkName}]`, () => {
           const forkTestData = testData.result[forkName]
           const shouldBeInvalid = forkTestData.exception !== undefined
 
-          try {
-            const rawTx = hexToBytes(testData.txbytes as PrefixedHexString)
-            const hardfork = forkNameMap[forkName]
-            const common = new Common({ chain: Mainnet, hardfork })
-            const activateEIPs = EIPs[forkName]
-            if (activateEIPs !== undefined) {
-              common.setEIPs(activateEIPs)
-            }
-            const tx = createTxFromRLP(rawTx, { common })
-            const sender = tx.getSenderAddress().toString()
-            const hash = bytesToHex(tx.hash())
-            const txIsValid = tx.isValid()
-            const senderIsCorrect = forkTestData.sender === sender
-            const hashIsCorrect = forkTestData.hash === hash
+          const rawTx = hexToBytes(testData.txbytes as PrefixedHexString)
+          const hardfork = forkNameMap[forkName]
+          const common = new Common({ chain: Mainnet, hardfork })
+          const activateEIPs = EIPs[forkName]
+          if (activateEIPs !== undefined) {
+            common.setEIPs(activateEIPs)
+          }
 
-            const hashAndSenderAreCorrect = senderIsCorrect && hashIsCorrect
-            if (shouldBeInvalid) {
-              assert.isFalse(txIsValid, `Transaction should be invalid on ${forkName}`)
-            } else {
-              assert.isTrue(
-                hashAndSenderAreCorrect && txIsValid,
-                `Transaction should be valid on ${forkName}`,
-              )
+          let tx
+          let sender
+          let hash
+          let isValid
+          try {
+            tx = createTxFromRLP(rawTx, { common })
+            sender = tx.getSenderAddress().toString()
+            hash = bytesToHex(tx.hash())
+            if (!tx.isValid()) {
+              throw EthereumJSErrorWithoutCode('Tx is invalid')
             }
+            isValid = true
           } catch {
-            if (shouldBeInvalid) {
-              assert.isTrue(shouldBeInvalid, `Transaction should be invalid on ${forkName}`)
-            } else {
-              assert.fail(`Transaction should be valid on ${forkName}`)
+            if (!shouldBeInvalid) {
+              assert.fail('Tx creation threw an error, but should be valid')
             }
+            // Tx is correctly marked as "invalid", so test has passed
+            return
           }
-        }
-      }, 120000)
+
+          const senderIsCorrect = forkTestData.sender === sender
+          const hashIsCorrect = forkTestData.hash === hash
+          assert.isTrue(isValid, 'tx is valid')
+          assert.isTrue(senderIsCorrect, 'sender is correct')
+          assert.isTrue(hashIsCorrect, 'hash is correct')
+        }, 120000)
+      }
     },
     fileFilterRegex,
     undefined,