txgmr,op-batcher,op-proposer: Migrate transaction creation to the txmgr

op-batcher/batcher/driver.go

@@ -314,7 +314,7 @@ func (l *BatchSubmitter) loop() {
 				}
 
 				// Record TX Status
-				if receipt, err := l.SendTransaction(l.ctx, txdata.Bytes()); err != nil {
+				if receipt, err := l.sendTransaction(l.ctx, txdata.Bytes()); err != nil {
 					l.recordFailedTx(txdata.ID(), err)
 				} else {
 					l.recordConfirmedTx(txdata.ID(), receipt)
@@ -343,31 +343,25 @@ const networkTimeout = 2 * time.Second // How long a single network request can
 // along with op-proposer changes to include the updated tx manager
 const txManagerTimeout = 2 * time.Minute // How long the tx manager can take to send a transaction.
 
-// SendTransaction creates & submits a transaction to the batch inbox address with the given `data`.
+// sendTransaction creates & submits a transaction to the batch inbox address with the given `data`.
 // It currently uses the underlying `txmgr` to handle transaction sending & price management.
 // This is a blocking method. It should not be called concurrently.
-func (l *BatchSubmitter) SendTransaction(ctx context.Context, data []byte) (*types.Receipt, error) {
+func (l *BatchSubmitter) sendTransaction(ctx context.Context, data []byte) (*types.Receipt, error) {
 	// Do the gas estimation offline. A value of 0 will cause the [txmgr] to estimate the gas limit.
 	intrinsicGas, err := core.IntrinsicGas(data, nil, false, true, true, false)
 	if err != nil {
 		return nil, fmt.Errorf("failed to calculate intrinsic gas: %w", err)
 	}
 
-	// Create the transaction
-	tx, err := l.txMgr.CraftTx(ctx, txmgr.TxCandidate{
+	// Send the transaction through the txmgr
+	ctx, cancel := context.WithTimeout(ctx, txManagerTimeout)
+	defer cancel()
+	if receipt, err := l.txMgr.Send(ctx, txmgr.TxCandidate{
 		To:       l.Rollup.BatchInboxAddress,
 		TxData:   data,
 		From:     l.From,
 		GasLimit: intrinsicGas,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("failed to create tx: %w", err)
-	}
-
-	// Send the transaction through the txmgr
-	ctx, cancel := context.WithTimeout(ctx, txManagerTimeout)
-	defer cancel()
-	if receipt, err := l.txMgr.Send(ctx, tx); err != nil {
+	}); err != nil {
 		l.log.Warn("unable to publish tx", "err", err, "data_size", len(data))
 		return nil, err
 	} else {

op-batcher/batcher/driver_test.go

@@ -73,10 +73,9 @@ func TestBatchSubmitter_SendTransaction(t *testing.T) {
 		GasUsed:           gas,
 	}
 
-	txMgr.On("CraftTx", mock.Anything, candidate).Return(tx, nil)
-	txMgr.On("Send", mock.Anything, tx).Return(&expectedReceipt, nil)
+	txMgr.On("Send", mock.Anything, candidate).Return(&expectedReceipt, nil)
 
-	receipt, err := bs.SendTransaction(context.Background(), tx.Data())
+	receipt, err := bs.sendTransaction(context.Background(), tx.Data())
 	require.NoError(t, err)
 	require.Equal(t, receipt, &expectedReceipt)
 }

op-e2e/actions/l2_proposer.go

@@ -6,11 +6,13 @@ import (
 	"math/big"
 	"time"
 
+	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/params"
 	"github.com/stretchr/testify/require"
 
 	"github.com/ethereum-optimism/optimism/op-node/sources"
@@ -27,11 +29,14 @@ type ProposerCfg struct {
 }
 
 type L2Proposer struct {
-	log     log.Logger
-	l1      *ethclient.Client
-	driver  *proposer.L2OutputSubmitter
-	address common.Address
-	lastTx  common.Hash
+	log          log.Logger
+	l1           *ethclient.Client
+	driver       *proposer.L2OutputSubmitter
+	address      common.Address
+	privKey      *ecdsa.PrivateKey
+	signer       opcrypto.SignerFn
+	contractAddr common.Address
+	lastTx       common.Hash
 }
 
 func NewL2Proposer(t Testing, log log.Logger, cfg *ProposerCfg, l1 *ethclient.Client, rollupCl *sources.RollupClient) *L2Proposer {
@@ -66,13 +71,56 @@ func NewL2Proposer(t Testing, log log.Logger, cfg *ProposerCfg, l1 *ethclient.Cl
 	require.NoError(t, err)
 
 	return &L2Proposer{
-		log:     log,
-		l1:      l1,
-		driver:  dr,
-		address: crypto.PubkeyToAddress(cfg.ProposerKey.PublicKey),
+		log:          log,
+		l1:           l1,
+		driver:       dr,
+		address:      crypto.PubkeyToAddress(cfg.ProposerKey.PublicKey),
+		privKey:      cfg.ProposerKey,
+		signer:       proposerCfg.TxManagerConfig.Signer,
+		contractAddr: cfg.OutputOracleAddr,
 	}
 }
 
+// sendTx reimplements creating & sending transactions because we need to do the final send as async in
+// the action tests while we do it synchronously in the real system.
+func (p *L2Proposer) sendTx(t Testing, data []byte) {
+	gasTipCap := big.NewInt(2 * params.GWei)
+	pendingHeader, err := p.l1.HeaderByNumber(t.Ctx(), big.NewInt(-1))
+	require.NoError(t, err, "need l1 pending header for gas price estimation")
+	gasFeeCap := new(big.Int).Add(gasTipCap, new(big.Int).Mul(pendingHeader.BaseFee, big.NewInt(2)))
+	chainID, err := p.l1.ChainID(t.Ctx())
+	require.NoError(t, err)
+	nonce, err := p.l1.NonceAt(t.Ctx(), p.address, nil)
+	require.NoError(t, err)
+
+	gasLimit, err := p.l1.EstimateGas(t.Ctx(), ethereum.CallMsg{
+		From:      p.address,
+		To:        &p.contractAddr,
+		GasFeeCap: gasFeeCap,
+		GasTipCap: gasTipCap,
+		Data:      data,
+	})
+	require.NoError(t, err)
+
+	rawTx := &types.DynamicFeeTx{
+		Nonce:     nonce,
+		To:        &p.contractAddr,
+		Data:      data,
+		GasFeeCap: gasFeeCap,
+		GasTipCap: gasTipCap,
+		Gas:       gasLimit,
+		ChainID:   chainID,
+	}
+
+	tx, err := types.SignNewTx(p.privKey, types.LatestSignerForChainID(chainID), rawTx)
+	require.NoError(t, err, "need to sign tx")
+
+	err = p.l1.SendTransaction(t.Ctx(), tx)
+	require.NoError(t, err, "need to send tx")
+
+	p.lastTx = tx.Hash()
+}
+
 func (p *L2Proposer) CanPropose(t Testing) bool {
 	_, shouldPropose, err := p.driver.FetchNextOutputInfo(t.Ctx())
 	require.NoError(t, err)
@@ -86,15 +134,12 @@ func (p *L2Proposer) ActMakeProposalTx(t Testing) {
 	}
 	require.NoError(t, err)
 
-	tx, err := p.driver.CreateProposalTx(t.Ctx(), output)
+	txData, err := p.driver.ProposeL2OutputTxData(output)
 	require.NoError(t, err)
 
 	// Note: Use L1 instead of the output submitter's transaction manager because
 	// this is non-blocking while the txmgr is blocking & deadlocks the tests
-	err = p.l1.SendTransaction(t.Ctx(), tx)
-	require.NoError(t, err)
-
-	p.lastTx = tx.Hash()
+	p.sendTx(t, txData)
 }
 
 func (p *L2Proposer) LastProposalTx() common.Hash {

op-node/testutils/random.go

@@ -245,3 +245,23 @@ func RandomBlockPrependTxs(rng *rand.Rand, txCount int, ptxs ...*types.Transacti
 	}
 	return block, receipts
 }
+
+func RandomOutputResponse(rng *rand.Rand) *eth.OutputResponse {
+	return &eth.OutputResponse{
+		Version:               eth.Bytes32(RandomHash(rng)),
+		OutputRoot:            eth.Bytes32(RandomHash(rng)),
+		BlockRef:              RandomL2BlockRef(rng),
+		WithdrawalStorageRoot: RandomHash(rng),
+		StateRoot:             RandomHash(rng),
+		Status: &eth.SyncStatus{
+			CurrentL1:          RandomBlockRef(rng),
+			CurrentL1Finalized: RandomBlockRef(rng),
+			HeadL1:             RandomBlockRef(rng),
+			SafeL1:             RandomBlockRef(rng),
+			FinalizedL1:        RandomBlockRef(rng),
+			UnsafeL2:           RandomL2BlockRef(rng),
+			SafeL2:             RandomL2BlockRef(rng),
+			FinalizedL2:        RandomL2BlockRef(rng),
+		},
+	}
+}

op-proposer/proposer/abi_test.go

@@ -0,0 +1,75 @@
+package proposer
+
+import (
+	"math/big"
+	"math/rand"
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum-optimism/optimism/op-node/testutils"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/params"
+	"github.com/stretchr/testify/require"
+)
+
+// setupL2OutputOracle deploys the L2 Output Oracle contract to a simulated backend
+func setupL2OutputOracle() (common.Address, *bind.TransactOpts, *backends.SimulatedBackend, *bindings.L2OutputOracle, error) {
+	privateKey, err := crypto.GenerateKey()
+	from := crypto.PubkeyToAddress(privateKey.PublicKey)
+	if err != nil {
+		return common.Address{}, nil, nil, nil, err
+	}
+	opts, err := bind.NewKeyedTransactorWithChainID(privateKey, big.NewInt(1337))
+	if err != nil {
+		return common.Address{}, nil, nil, nil, err
+	}
+	backend := backends.NewSimulatedBackend(core.GenesisAlloc{from: {Balance: big.NewInt(params.Ether)}}, 50_000_000)
+	_, _, contract, err := bindings.DeployL2OutputOracle(
+		opts,
+		backend,
+		big.NewInt(10),
+		big.NewInt(2),
+		big.NewInt(0),
+		big.NewInt(0),
+		from,
+		common.Address{0xdd},
+		big.NewInt(100))
+	if err != nil {
+		return common.Address{}, nil, nil, nil, err
+	}
+	return from, opts, backend, contract, nil
+}
+
+// TestManualABIPacking ensure that the manual ABI packing is the same as going through the bound contract.
+// We don't use the contract to transact because it does not fit our transaction management scheme, but
+// we want to make sure that we don't incorrectly create the transaction data.
+func TestManualABIPacking(t *testing.T) {
+	_, opts, _, contract, err := setupL2OutputOracle()
+	require.NoError(t, err)
+	rng := rand.New(rand.NewSource(1234))
+
+	abi, err := bindings.L2OutputOracleMetaData.GetAbi()
+	require.NoError(t, err)
+
+	output := testutils.RandomOutputResponse(rng)
+
+	txData, err := proposeL2OutputTxData(abi, output)
+	require.NoError(t, err)
+
+	// set a gas limit to disable gas estimation. The invariantes that the L2OO tries to uphold
+	// are not maintained in this test.
+	opts.GasLimit = 100_000
+	tx, err := contract.ProposeL2Output(
+		opts,
+		output.OutputRoot,
+		new(big.Int).SetUint64(output.BlockRef.Number),
+		output.Status.CurrentL1.Hash,
+		new(big.Int).SetUint64(output.Status.CurrentL1.Number))
+	require.NoError(t, err)
+
+	require.Equal(t, txData, tx.Data())
+}