op-node: Add FuzzDecodeDepositTxDataToL1Info

op-node: More test cleanup

op-node/Makefile

@@ -35,6 +35,7 @@ fuzz:
 	go test -run NOTAREALTEST -v -fuzztime 10s -fuzz FuzzParseL1InfoDepositTxDataValid ./rollup/derive
 	go test -run NOTAREALTEST -v -fuzztime 10s -fuzz FuzzParseL1InfoDepositTxDataBadLength ./rollup/derive
 	go test -run NOTAREALTEST -v -fuzztime 10s -fuzz FuzzRejectCreateBlockBadTimestamp ./rollup/driver
+	go test -run NOTAREALTEST -v -fuzztime 10s -fuzz FuzzDecodeDepositTxDataToL1Info ./rollup/driver
 
 
 .PHONY: \

op-node/rollup/derive/l1_block_info_tob_test.go

@@ -28,7 +28,7 @@ func FuzzParseL1InfoDepositTxDataValid(f *testing.F) {
 
 		// Create our deposit tx from our info
 		depTx, err := L1InfoDeposit(seqNr, &l1Info, sysCfg)
-		require.NoError(t, err)
+		require.NoError(t, err, "error creating deposit tx from L1 info")
 
 		// Get our info from out deposit tx
 		res, err := L1InfoDepositTxData(depTx.Data)
@@ -42,12 +42,41 @@ func FuzzParseL1InfoDepositTxDataValid(f *testing.F) {
 		require.Equal(t, res.BlockHash, l1Info.Hash())
 		require.Equal(t, res.SequenceNumber, seqNr)
 		require.Equal(t, res.BatcherAddr, sysCfg.BatcherAddr)
-
 		require.Equal(t, res.L1FeeOverhead, sysCfg.Overhead)
 		require.Equal(t, res.L1FeeScalar, sysCfg.Scalar)
 	})
 }
 
+// Reverse of the above test. Accepts a random byte string and attempts to extract L1Info from it,
+// then attempts to convert that info back into the tx data and compare it with the original input.
+func FuzzDecodeDepositTxDataToL1Info(f *testing.F) {
+	f.Fuzz(func(t *testing.T, fuzzedData []byte) {
+		// Get our info from out deposit tx
+		res, err := L1InfoDepositTxData(fuzzedData)
+		if err != nil {
+			return
+		}
+
+		l1Info := testutils.MockBlockInfo{
+			InfoHash:    res.BlockHash,
+			InfoNum:     res.Number,
+			InfoTime:    res.Time,
+			InfoBaseFee: res.BaseFee,
+		}
+
+		sysCfg := eth.SystemConfig{
+			BatcherAddr: res.BatcherAddr,
+			Overhead:    res.L1FeeOverhead,
+			Scalar:      res.L1FeeScalar,
+			GasLimit:    uint64(0),
+		}
+
+		depTx, err := L1InfoDeposit(res.SequenceNumber, &l1Info, sysCfg)
+		require.NoError(t, err, "error creating deposit tx from L1 info")
+		require.Equal(t, depTx.Data, fuzzedData)
+	})
+}
+
 // FuzzParseL1InfoDepositTxDataBadLength is a fuzz test built from TestParseL1InfoDepositTxData, which constructs
 // random L1 deposit tx info and derives a tx from it, then derives the info back from the tx, to ensure round-trip
 // derivation is upheld. This generates "invalid" data and ensures it always throws an error where expected.

op-node/rollup/driver/state_tob_test.go

@@ -14,7 +14,6 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/prometheus/client_golang/prometheus"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -136,24 +135,21 @@ func TestRejectCreateBlockBadTimestamp(t *testing.T) {
 	if l2HeadRef.Time+cfg.BlockTime < l2l1OriginBlock.Time {
 		// If not, we expect a specific error.
 		// TODO: This isn't the cleanest, we should construct + compare the whole error message.
-		assert.NotNil(t, err)
-		assert.Contains(t, err.Error(), "cannot build L2 block on top")
-		assert.Contains(t, err.Error(), "for time")
-		assert.Contains(t, err.Error(), "before L1 origin")
+		require.NotNil(t, err)
+		require.Contains(t, err.Error(), "cannot build L2 block on top")
+		require.Contains(t, err.Error(), "for time")
+		require.Contains(t, err.Error(), "before L1 origin")
 		return
 	}
 
-	// Otherwise we should have no error.
-	assert.Nil(t, err)
-
 	// If we expected the outputter to error, capture that here
 	if outputProvider.willError {
-		assert.NotNil(t, err, "outputInterface failed to createNewBlock, so createNewL2Block should also have failed")
+		require.NotNil(t, err, "outputInterface failed to createNewBlock, so createNewL2Block should also have failed")
 		return
 	}
 
 	// Otherwise we should have no error.
-	assert.Nil(t, err)
+	require.NoError(t, err, "error raised in TestRejectCreateBlockBadTimestamp")
 }
 
 // FuzzRejectCreateBlockBadTimestamp is a property test derived from the TestRejectCreateBlockBadTimestamp unit test.
@@ -215,7 +211,7 @@ func FuzzRejectCreateBlockBadTimestamp(f *testing.F) {
 
 		// Verify the L1Origin's timestamp is greater than L1 genesis in our config.
 		if l2l1OriginBlock.Number < s.config.Genesis.L1.Number {
-			assert.Nil(t, err)
+			require.NoError(t, err)
 			return
 		}
 
@@ -231,11 +227,11 @@ func FuzzRejectCreateBlockBadTimestamp(f *testing.F) {
 		}
 
 		// Otherwise we should have no error.
-		assert.Nil(t, err)
+		require.Nil(t, err)
 
 		// If we expected the outputter to error, capture that here
 		if outputProvider.willError {
-			assert.NotNil(t, err, "outputInterface failed to createNewBlock, so createNewL2Block should also have failed")
+			require.NotNil(t, err, "outputInterface failed to createNewBlock, so createNewL2Block should also have failed")
 			return
 		}