speed up bridge e2e tests by pre-emptively conducting a deposit & withdrawal on setup

indexer/e2e_test/bridge_e2e_test.go

@@ -7,14 +7,18 @@ import (
 	"time"
 
 	"github.com/ethereum-optimism/optimism/indexer/processor"
+
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
+	op_e2e "github.com/ethereum-optimism/optimism/op-e2e"
 	e2eutils "github.com/ethereum-optimism/optimism/op-e2e/e2eutils"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
+
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/params"
+
 	"github.com/stretchr/testify/require"
 )
 
@@ -23,48 +27,59 @@ func TestE2EBridge(t *testing.T) {
 
 	l1Client := testSuite.OpSys.Clients["l1"]
 	l2Client := testSuite.OpSys.Clients["sequencer"]
-	aliceAddr := testSuite.OpCfg.Secrets.Addresses().Alice
 
 	l1StandardBridge, err := bindings.NewL1StandardBridge(predeploys.DevL1StandardBridgeAddr, l1Client)
 	require.NoError(t, err)
 
-	_, err = bindings.NewL2StandardBridge(predeploys.L2StandardBridgeAddr, l2Client)
+	l2StandardBridge, err := bindings.NewL2StandardBridge(predeploys.L2StandardBridgeAddr, l2Client)
 	require.NoError(t, err)
 
-	_, err = bindings.NewOptimismPortal(predeploys.DevOptimismPortalAddr, l1Client)
-	require.NoError(t, err)
-
-	t.Run("indexes ETH deposits", func(t *testing.T) {
-		testCtx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
+	// pre-emptively conduct a deposit & withdrawal to speed up the test
+	setupCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
 
-		// pause L2Processor so that we can test for finalization seperately
-		testSuite.Indexer.L2Processor.PauseForTest()
+	aliceAddr := testSuite.OpCfg.Secrets.Addresses().Alice
 
 	l1Opts, err := bind.NewKeyedTransactorWithChainID(testSuite.OpCfg.Secrets.Alice, testSuite.OpCfg.L1ChainIDBig())
 	require.NoError(t, err)
+	l2Opts, err := bind.NewKeyedTransactorWithChainID(testSuite.OpCfg.Secrets.Alice, testSuite.OpCfg.L2ChainIDBig())
+	require.NoError(t, err)
 
-		// Deposit 1 ETH (add some extra data for fun)
 	l1Opts.Value = big.NewInt(params.Ether)
-		tx, err := l1StandardBridge.DepositETH(l1Opts, 200_000, []byte{byte(1)})
+	l2Opts.Value = big.NewInt(params.Ether)
+
+	depositTx, err := l1StandardBridge.DepositETH(l1Opts, 200_000, []byte{byte(1)})
 	require.NoError(t, err)
 
-		// (1) Test Deposit Initiation
+	withdrawTx, err := l2StandardBridge.Withdraw(l2Opts, processor.EthAddress, big.NewInt(params.Ether), 200_000, []byte{byte(1)})
+	require.NoError(t, err)
 
-		// wait for deposit to be included & processor catchup
-		depositReceipt, err := e2eutils.WaitReceiptOK(testCtx, l1Client, tx.Hash())
+	depositReceipt, err := e2eutils.WaitReceiptOK(setupCtx, l1Client, depositTx.Hash())
 	require.NoError(t, err)
-		l1Height, err := l1Client.BlockNumber(testCtx)
+
+	withdrawalReceipt, err := e2eutils.WaitReceiptOK(setupCtx, l2Client, withdrawTx.Hash())
 	require.NoError(t, err)
+
+	t.Run("indexes ETH deposits", func(t *testing.T) {
+		testCtx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
+		defer cancel()
+
+		// Pause the L2Processor so that we can test for finalization seperately. A pause is
+		// required since deposit inclusion is apart of the L2 block derivation process
+		testSuite.Indexer.L2Processor.PauseForTest()
+
+		// (1) Test Deposit Initiation
+
+		// wait for processor catchup
 		require.NoError(t, e2eutils.WaitFor(testCtx, 500*time.Millisecond, func() (bool, error) {
 			l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
-			return l1Header != nil && l1Header.Number.Uint64() >= l1Height, nil
+			return l1Header != nil && l1Header.Number.Uint64() >= depositReceipt.BlockNumber.Uint64(), nil
 		}))
 
 		aliceDeposits, err := testSuite.DB.Bridge.DepositsByAddress(aliceAddr)
 		require.NoError(t, err)
 		require.Len(t, aliceDeposits, 1)
-		require.Equal(t, tx.Hash(), aliceDeposits[0].L1TransactionHash)
+		require.Equal(t, depositTx.Hash(), aliceDeposits[0].L1TransactionHash)
 		require.Empty(t, aliceDeposits[0].FinalizedL2TransactionHash)
 
 		deposit := aliceDeposits[0].Deposit
@@ -77,24 +92,21 @@ func TestE2EBridge(t *testing.T) {
 		require.Equal(t, byte(1), deposit.Tx.Data[0])
 
 		// (2) Test Deposit Finalization
-
 		testSuite.Indexer.L2Processor.ResumeForTest()
 
 		// finalization hash can be deterministically derived from TransactionDeposited log
-		var txHash common.Hash
+		var depositTxHash common.Hash
 		for _, log := range depositReceipt.Logs {
-			if len(log.Topics) == 0 || log.Topics[0] != derive.DepositEventABIHash {
-				continue
-			}
-
-			depLog, err := derive.UnmarshalDepositLogEvent(log)
+			if log.Topics[0] == derive.DepositEventABIHash {
+				deposit, err := derive.UnmarshalDepositLogEvent(log)
 				require.NoError(t, err)
-			tx := types.NewTx(depLog)
-			txHash = tx.Hash()
+				depositTxHash = types.NewTx(deposit).Hash()
+				break
+			}
 		}
 
 		// wait for the l2 processor to catch this deposit in the derivation process
-		_, err = e2eutils.WaitReceiptOK(testCtx, l2Client, txHash)
+		_, err = e2eutils.WaitReceiptOK(testCtx, l2Client, depositTxHash)
 		require.NoError(t, err)
 		l2Height, err := l2Client.BlockNumber(testCtx)
 		require.NoError(t, err)
@@ -105,9 +117,64 @@ func TestE2EBridge(t *testing.T) {
 
 		aliceDeposits, err = testSuite.DB.Bridge.DepositsByAddress(aliceAddr)
 		require.NoError(t, err)
-		require.Equal(t, txHash, aliceDeposits[0].FinalizedL2TransactionHash)
+		require.Equal(t, depositTxHash, aliceDeposits[0].FinalizedL2TransactionHash)
 		require.NotNil(t, aliceDeposits[0].Deposit.FinalizedL2EventGUID)
 	})
 
-	t.Run("indexes ETH withdrawals", func(t *testing.T) {})
+	t.Run("indexes ETH withdrawals", func(t *testing.T) {
+		testCtx, cancel := context.WithTimeout(context.Background(), 1*time.Minute)
+		defer cancel()
+
+		// (1) Test Withdrawal Initiation
+
+		// wait for processor catchup
+		require.NoError(t, e2eutils.WaitFor(testCtx, 500*time.Millisecond, func() (bool, error) {
+			l2Header := testSuite.Indexer.L2Processor.LatestProcessedHeader()
+			return l2Header != nil && l2Header.Number.Uint64() >= withdrawalReceipt.BlockNumber.Uint64(), nil
+		}))
+
+		aliceWithdrawals, err := testSuite.DB.Bridge.WithdrawalsByAddress(aliceAddr)
+		require.NoError(t, err)
+		require.Len(t, aliceWithdrawals, 1)
+		require.Equal(t, withdrawTx.Hash(), aliceWithdrawals[0].L2TransactionHash)
+		require.Empty(t, aliceWithdrawals[0].ProvenL1TransactionHash)
+		require.Empty(t, aliceWithdrawals[0].FinalizedL1TransactionHash)
+
+		withdrawal := aliceWithdrawals[0].Withdrawal
+		require.Nil(t, withdrawal.ProvenL1EventGUID)
+		require.Nil(t, withdrawal.FinalizedL1EventGUID)
+		require.Equal(t, processor.EthAddress, withdrawal.TokenPair.L1TokenAddress)
+		require.Equal(t, processor.EthAddress, withdrawal.TokenPair.L2TokenAddress)
+		require.Equal(t, big.NewInt(params.Ether), withdrawal.Tx.Amount.Int)
+		require.Equal(t, aliceAddr, withdrawal.Tx.FromAddress)
+		require.Equal(t, aliceAddr, withdrawal.Tx.ToAddress)
+		require.Equal(t, byte(1), withdrawal.Tx.Data[0])
+
+		// (2) Test Withdrawal Proven
+
+		// prove & wait for processor catchup
+		withdrawParams, proveReceipt := op_e2e.ProveWithdrawal(t, *testSuite.OpCfg, l1Client, testSuite.OpSys.Nodes["sequencer"], testSuite.OpCfg.Secrets.Alice, withdrawalReceipt)
+		require.NoError(t, e2eutils.WaitFor(testCtx, 500*time.Millisecond, func() (bool, error) {
+			l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
+			return l1Header != nil && l1Header.Number.Uint64() >= proveReceipt.BlockNumber.Uint64(), nil
+		}))
+
+		aliceWithdrawals, err = testSuite.DB.Bridge.WithdrawalsByAddress(aliceAddr)
+		require.NoError(t, err)
+		require.Empty(t, aliceWithdrawals[0].FinalizedL1TransactionHash)
+		require.Equal(t, proveReceipt.TxHash, aliceWithdrawals[0].ProvenL1TransactionHash)
+
+		// (3) Test Withdrawal Finalization
+
+		// finalize & wait for processor catchup
+		finalizeReceipt := op_e2e.FinalizeWithdrawal(t, *testSuite.OpCfg, l1Client, testSuite.OpCfg.Secrets.Alice, withdrawalReceipt, withdrawParams)
+		require.NoError(t, e2eutils.WaitFor(testCtx, 500*time.Millisecond, func() (bool, error) {
+			l1Header := testSuite.Indexer.L1Processor.LatestProcessedHeader()
+			return l1Header != nil && l1Header.Number.Uint64() >= finalizeReceipt.BlockNumber.Uint64(), nil
+		}))
+
+		aliceWithdrawals, err = testSuite.DB.Bridge.WithdrawalsByAddress(aliceAddr)
+		require.NoError(t, err)
+		require.Equal(t, finalizeReceipt.TxHash, aliceWithdrawals[0].FinalizedL1TransactionHash)
+	})
 }