github.com/ethereum-optimism/optimism@v1.7.2/op-node/rollup/derive/span_batch_tx_test.go (about)

     1  package derive
     2  
     3  import (
     4  	"math/big"
     5  	"math/rand"
     6  	"testing"
     7  
     8  	"github.com/ethereum-optimism/optimism/op-service/testutils"
     9  	"github.com/ethereum/go-ethereum/core/types"
    10  	"github.com/stretchr/testify/assert"
    11  	"github.com/stretchr/testify/require"
    12  )
    13  
    14  type spanBatchTxTest struct {
    15  	name      string
    16  	trials    int
    17  	mkTx      func(rng *rand.Rand, signer types.Signer) *types.Transaction
    18  	protected bool
    19  }
    20  
    21  func TestSpanBatchTxConvert(t *testing.T) {
    22  	cases := []spanBatchTxTest{
    23  		{"unprotected legacy tx", 32, testutils.RandomLegacyTx, false},
    24  		{"legacy tx", 32, testutils.RandomLegacyTx, true},
    25  		{"access list tx", 32, testutils.RandomAccessListTx, true},
    26  		{"dynamic fee tx", 32, testutils.RandomDynamicFeeTx, true},
    27  	}
    28  
    29  	for i, testCase := range cases {
    30  		t.Run(testCase.name, func(t *testing.T) {
    31  			rng := rand.New(rand.NewSource(int64(0x1331 + i)))
    32  			chainID := big.NewInt(rng.Int63n(1000))
    33  			signer := types.NewLondonSigner(chainID)
    34  			if !testCase.protected {
    35  				signer = types.HomesteadSigner{}
    36  			}
    37  
    38  			for txIdx := 0; txIdx < testCase.trials; txIdx++ {
    39  				tx := testCase.mkTx(rng, signer)
    40  
    41  				v, r, s := tx.RawSignatureValues()
    42  				sbtx, err := newSpanBatchTx(*tx)
    43  				require.NoError(t, err)
    44  
    45  				tx2, err := sbtx.convertToFullTx(tx.Nonce(), tx.Gas(), tx.To(), chainID, v, r, s)
    46  				require.NoError(t, err)
    47  
    48  				// compare after marshal because we only need inner field of transaction
    49  				txEncoded, err := tx.MarshalBinary()
    50  				require.NoError(t, err)
    51  				tx2Encoded, err := tx2.MarshalBinary()
    52  				require.NoError(t, err)
    53  
    54  				assert.Equal(t, txEncoded, tx2Encoded)
    55  			}
    56  		})
    57  	}
    58  }
    59  
    60  func TestSpanBatchTxRoundTrip(t *testing.T) {
    61  	cases := []spanBatchTxTest{
    62  		{"unprotected legacy tx", 32, testutils.RandomLegacyTx, false},
    63  		{"legacy tx", 32, testutils.RandomLegacyTx, true},
    64  		{"access list tx", 32, testutils.RandomAccessListTx, true},
    65  		{"dynamic fee tx", 32, testutils.RandomDynamicFeeTx, true},
    66  	}
    67  
    68  	for i, testCase := range cases {
    69  		t.Run(testCase.name, func(t *testing.T) {
    70  			rng := rand.New(rand.NewSource(int64(0x1332 + i)))
    71  			chainID := big.NewInt(rng.Int63n(1000))
    72  			signer := types.NewLondonSigner(chainID)
    73  			if !testCase.protected {
    74  				signer = types.HomesteadSigner{}
    75  			}
    76  
    77  			for txIdx := 0; txIdx < testCase.trials; txIdx++ {
    78  				tx := testCase.mkTx(rng, signer)
    79  
    80  				sbtx, err := newSpanBatchTx(*tx)
    81  				require.NoError(t, err)
    82  
    83  				sbtxEncoded, err := sbtx.MarshalBinary()
    84  				require.NoError(t, err)
    85  
    86  				var sbtx2 spanBatchTx
    87  				err = sbtx2.UnmarshalBinary(sbtxEncoded)
    88  				require.NoError(t, err)
    89  
    90  				assert.Equal(t, sbtx, &sbtx2)
    91  			}
    92  		})
    93  	}
    94  }
    95  
    96  type spanBatchDummyTxData struct{}
    97  
    98  func (txData *spanBatchDummyTxData) txType() byte { return types.DepositTxType }
    99  
   100  func TestSpanBatchTxInvalidTxType(t *testing.T) {
   101  	// span batch never contain deposit tx
   102  	depositTx := types.NewTx(&types.DepositTx{})
   103  	_, err := newSpanBatchTx(*depositTx)
   104  	require.ErrorContains(t, err, "invalid tx type")
   105  
   106  	var sbtx spanBatchTx
   107  	sbtx.inner = &spanBatchDummyTxData{}
   108  	_, err = sbtx.convertToFullTx(0, 0, nil, nil, nil, nil, nil)
   109  	require.ErrorContains(t, err, "invalid tx type")
   110  }
   111  
   112  func TestSpanBatchTxDecodeInvalid(t *testing.T) {
   113  	var sbtx spanBatchTx
   114  	_, err := sbtx.decodeTyped([]byte{})
   115  	require.ErrorIs(t, err, ErrTypedTxTooShort)
   116  
   117  	tx := types.NewTx(&types.LegacyTx{})
   118  	txEncoded, err := tx.MarshalBinary()
   119  	require.NoError(t, err)
   120  
   121  	// legacy tx is not typed tx
   122  	_, err = sbtx.decodeTyped(txEncoded)
   123  	require.EqualError(t, err, types.ErrTxTypeNotSupported.Error())
   124  
   125  	tx2 := types.NewTx(&types.AccessListTx{})
   126  	tx2Encoded, err := tx2.MarshalBinary()
   127  	require.NoError(t, err)
   128  
   129  	tx2Encoded[0] = types.DynamicFeeTxType
   130  	_, err = sbtx.decodeTyped(tx2Encoded)
   131  	require.ErrorContains(t, err, "failed to decode spanBatchDynamicFeeTxData")
   132  
   133  	tx3 := types.NewTx(&types.DynamicFeeTx{})
   134  	tx3Encoded, err := tx3.MarshalBinary()
   135  	require.NoError(t, err)
   136  
   137  	tx3Encoded[0] = types.AccessListTxType
   138  	_, err = sbtx.decodeTyped(tx3Encoded)
   139  	require.ErrorContains(t, err, "failed to decode spanBatchAccessListTxData")
   140  
   141  	invalidLegacyTxDecoded := []byte{0xFF, 0xFF}
   142  	err = sbtx.UnmarshalBinary(invalidLegacyTxDecoded)
   143  	require.ErrorContains(t, err, "failed to decode spanBatchLegacyTxData")
   144  }