feat(op-acceptance-tests): base; deposit flow (#15979)

* feat(op-acceptance-tests): base; deposit flow

* feat(op-acceptance-tests): do not expose private key

* feat(op-acceptance-tests): unused finality check

Author: serpixel

op-acceptance-tests/tests/base/deposit/deposit_test.go

@@ -0,0 +1,79 @@
+package deposit
+
+import (
+	"math/big"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/ethereum-optimism/optimism/op-devstack/devtest"
+	"github.com/ethereum-optimism/optimism/op-devstack/presets"
+	"github.com/ethereum-optimism/optimism/op-service/eth"
+	"github.com/ethereum-optimism/optimism/op-service/txplan"
+	supervisorTypes "github.com/ethereum-optimism/optimism/op-supervisor/supervisor/types"
+	"github.com/lmittmann/w3"
+)
+
+func TestMain(m *testing.M) {
+	presets.DoMain(m, presets.WithMinimal())
+}
+
+func TestL1ToL2Deposit(gt *testing.T) {
+	// Create a test environment using op-devstack
+	t := devtest.SerialT(gt)
+	sys := presets.NewMinimal(t)
+
+	// Wait for L1 node to be responsive
+	sys.L1Network.WaitForOnline()
+
+	// Fund Alice on L1
+	fundingAmount := eth.ThousandEther
+	alice := sys.FunderL1.NewFundedEOA(fundingAmount)
+	alice.VerifyBalanceExact(fundingAmount)
+
+	alicel2 := alice.AsEL(sys.L2EL)
+
+	// Get the optimism portal address
+	rollupConfig := sys.L2Chain.Escape().RollupConfig()
+	portalAddr := rollupConfig.DepositContractAddress
+
+	depositAmount := eth.OneEther
+
+	// Define the deposit function and encode arguments
+	// TODO: Redo this when the new DSL (#16079) is merged
+	funcDeposit := w3.MustNewFunc(`depositTransaction(address,uint256,uint64,bool,bytes)`, "")
+	args, err := funcDeposit.EncodeArgs(
+		alice.Address(),       // _to
+		depositAmount.ToBig(), // _value
+		uint64(300_000),       // _gasLimit
+		false,                 // _isCreation
+		[]byte{},              // _data
+	)
+	require.NoError(t, err)
+
+	// Create and confirm the transaction (awaits tx inclusion and checks success status)
+	tx := alice.Transact(
+		alice.Plan(),
+		txplan.WithGasLimit(500_000),
+		txplan.WithTo(&portalAddr),
+		txplan.WithData(args),
+		txplan.WithValue(depositAmount.ToBig()))
+
+	receipt := tx.Included.Value()
+	gasPrice := receipt.EffectiveGasPrice // bugfix: use the exact price that was charged
+
+	// Verify the deposit was successful
+	gasCost := new(big.Int).Mul(new(big.Int).SetUint64(receipt.GasUsed), gasPrice)
+	expectedFinalL1 := new(big.Int).Sub(fundingAmount.ToBig(), depositAmount.ToBig())
+	expectedFinalL1.Sub(expectedFinalL1, gasCost)
+
+	alice.VerifyBalanceExact(eth.WeiBig(expectedFinalL1))
+
+	// Wait for the sequencer to process the deposit
+	t.Require().Eventually(func() bool {
+		head := sys.L2CL.HeadBlockRef(supervisorTypes.LocalUnsafe)
+		return head.L1Origin.Number >= receipt.BlockNumber.Uint64()
+	}, time.Second*10, time.Second, "awaiting deposit to be processed by L2")
+	alicel2.VerifyBalanceExact(depositAmount)
+}

op-acceptance-tests/tests/base/init_test.go

@@ -9,5 +9,4 @@ import (
 // TestMain creates the test-setups against the shared backend
 func TestMain(m *testing.M) {
 	presets.DoMain(m, presets.WithMinimal())
-
 }

op-devstack/dsl/el.go

@@ -33,26 +33,46 @@ func (el *elNode) ChainID() eth.ChainID {
 }
 
 func (el *elNode) WaitForBlock() eth.BlockRef {
+	return el.waitForNextBlock(1)
+}
+
+func (el *elNode) WaitForOnline() {
+	el.require.Eventually(func() bool {
+		el.log.Info("Waiting for online")
+		_, err := el.inner.EthClient().InfoByLabel(el.ctx, eth.Unsafe)
+		return err == nil
+	}, 10*time.Second, 500*time.Millisecond, "Expected to be online")
+}
+
+// waitForNextBlockWithTimeout waits until the specified block number is present
+func (el *elNode) waitForNextBlock(blocksFromNow uint64) eth.BlockRef {
 	initial, err := el.inner.EthClient().InfoByLabel(el.ctx, eth.Unsafe)
 	el.require.NoError(err, "Expected to get latest block from execution client")
+	targetBlock := initial.NumberU64() + blocksFromNow
 	initialRef := eth.InfoToL1BlockRef(initial)
 	var newRef eth.BlockRef
+
 	err = wait.For(el.ctx, 500*time.Millisecond, func() (bool, error) {
 		newBlock, err := el.inner.EthClient().InfoByLabel(el.ctx, eth.Unsafe)
 		if err != nil {
 			return false, err
 		}
 
 		newRef = eth.InfoToL1BlockRef(newBlock)
+		if newBlock.NumberU64() >= targetBlock {
+			el.log.Info("Target block reached", "block", newRef)
+			return true, nil
+		}
+
 		if initialRef == newRef {
 			el.log.Info("Still same block detected as initial", "block", initialRef)
 			return false, nil
+		} else {
+			el.log.Info("New block detected", "new_block", newRef, "prev_block", initialRef)
 		}
-
-		el.log.Info("New block detected", "new_block", newRef, "prev_block", initialRef)
-		return true, nil
+		return false, nil
 	})
-	el.require.NoError(err, "Expected to get latest block from execution client for comparison")
+	el.require.NoError(err, "Expected to reach target block")
 	return newRef
 }
 

op-devstack/dsl/eoa.go

@@ -36,6 +36,10 @@ func NewEOA(key *Key, el ELNode) *EOA {
 	}
 }
 
+func (u *EOA) AsEL(el ELNode) *EOA {
+	return NewEOA(u.key, el)
+}
+
 func (u *EOA) String() string {
 	return fmt.Sprintf("EOA(%s @ %s)", u.key.Address(), u.el.ChainID())
 }

op-devstack/dsl/l1_network.go

@@ -59,3 +59,7 @@ func (n *L1Network) PrintChain() {
 	n.log.Info("Printing block hashes and parent hashes", "network", n.String(), "chain", n.ChainID())
 	spew.Dump(entries)
 }
+
+func (n *L1Network) WaitForOnline() {
+	NewL1ELNode(n.inner.L1ELNode(match.FirstL1EL)).WaitForOnline()
+}

op-devstack/presets/interop.go

@@ -40,11 +40,13 @@ type SimpleInterop struct {
 
 	Wallet *dsl.HDWallet
 
-	FaucetA *dsl.Faucet
-	FaucetB *dsl.Faucet
+	FaucetA  *dsl.Faucet
+	FaucetB  *dsl.Faucet
+	FaucetL1 *dsl.Faucet
 
-	FunderA *dsl.Funder
-	FunderB *dsl.Funder
+	FunderL1 *dsl.Funder
+	FunderA  *dsl.Funder
+	FunderB  *dsl.Funder
 }
 
 func (s *SimpleInterop) L2Networks() []*dsl.L2Network {
@@ -94,6 +96,8 @@ func NewSimpleInterop(t devtest.T) *SimpleInterop {
 		L2BatcherA:    dsl.NewL2Batcher(l2A.L2Batcher(match.Assume(t, match.FirstL2Batcher))),
 		L2BatcherB:    dsl.NewL2Batcher(l2B.L2Batcher(match.Assume(t, match.FirstL2Batcher))),
 	}
+	out.FaucetL1 = dsl.NewFaucet(out.L1Network.Escape().Faucet(match.Assume(t, match.FirstFaucet)))
+	out.FunderL1 = dsl.NewFunder(out.Wallet, out.FaucetL1, out.L1EL)
 	out.FunderA = dsl.NewFunder(out.Wallet, out.FaucetA, out.L2ELA)
 	out.FunderB = dsl.NewFunder(out.Wallet, out.FaucetB, out.L2ELB)
 	return out

op-devstack/presets/minimal.go

@@ -18,6 +18,7 @@ type Minimal struct {
 	ControlPlane stack.ControlPlane
 
 	L1Network *dsl.L1Network
+	L1EL      *dsl.L1ELNode
 
 	L2Chain   *dsl.L2Network
 	L2Batcher *dsl.L2Batcher
@@ -28,8 +29,10 @@ type Minimal struct {
 
 	Wallet *dsl.HDWallet
 
-	Faucet *dsl.Faucet
-	Funder *dsl.Funder
+	FaucetL1 *dsl.Faucet
+	Faucet   *dsl.Faucet
+	FunderL1 *dsl.Funder
+	Funder   *dsl.Funder
 }
 
 func (m *Minimal) L2Networks() []*dsl.L2Network {
@@ -49,12 +52,14 @@ func NewMinimal(t devtest.T) *Minimal {
 
 	t.Gate().Equal(len(system.TestSequencers()), 1, "expected exactly one test sequencer")
 
+	l1Net := system.L1Network(match.FirstL1Network)
 	l2 := system.L2Network(match.Assume(t, match.L2ChainA))
 	out := &Minimal{
 		Log:           t.Logger(),
 		T:             t,
 		ControlPlane:  orch.ControlPlane(),
 		L1Network:     dsl.NewL1Network(system.L1Network(match.FirstL1Network)),
+		L1EL:          dsl.NewL1ELNode(l1Net.L1ELNode(match.Assume(t, match.FirstL1EL))),
 		L2Chain:       dsl.NewL2Network(l2),
 		L2Batcher:     dsl.NewL2Batcher(l2.L2Batcher(match.Assume(t, match.FirstL2Batcher))),
 		L2EL:          dsl.NewL2ELNode(l2.L2ELNode(match.Assume(t, match.FirstL2EL))),
@@ -63,6 +68,8 @@ func NewMinimal(t devtest.T) *Minimal {
 		Wallet:        dsl.NewHDWallet(t, devkeys.TestMnemonic, 30),
 		Faucet:        dsl.NewFaucet(l2.Faucet(match.Assume(t, match.FirstFaucet))),
 	}
+	out.FaucetL1 = dsl.NewFaucet(out.L1Network.Escape().Faucet(match.Assume(t, match.FirstFaucet)))
+	out.FunderL1 = dsl.NewFunder(out.Wallet, out.FaucetL1, out.L1EL)
 	out.Funder = dsl.NewFunder(out.Wallet, out.Faucet, out.L2EL)
 	return out
 }