Account for Optimism gas in PVG (#185)

Author: hazim-j

internal/config/constants.go

@@ -7,4 +7,6 @@ var (
 	GoerliChainID         = big.NewInt(5)
 	ArbitrumOneChainID    = big.NewInt(42161)
 	ArbitrumGoerliChainID = big.NewInt(421613)
+	OptimismChainID       = big.NewInt(10)
+	OptimismGoerliChainID = big.NewInt(420)
 )

internal/start/private.go

@@ -61,6 +61,11 @@ func PrivateMode() {
 	if chain.Cmp(config.ArbitrumOneChainID) == 0 || chain.Cmp(config.ArbitrumGoerliChainID) == 0 {
 		ov.SetCalcPreVerificationGasFunc(gas.CalcArbitrumPVGWithEthClient(rpc, conf.SupportedEntryPoints[0]))
 	}
+	if chain.Cmp(config.OptimismChainID) == 0 || chain.Cmp(config.OptimismGoerliChainID) == 0 {
+		ov.SetCalcPreVerificationGasFunc(
+			gas.CalcOptimismPVGWithEthClient(rpc, chain, conf.SupportedEntryPoints[0]),
+		)
+	}
 
 	mem, err := mempool.New(db)
 	if err != nil {

pkg/entrypoint/transaction/handleops.go

@@ -139,6 +139,15 @@ func CreateRawHandleOps(
 	}
 	auth.GasLimit = gas
 	auth.NoSend = true
+	if baseFee != nil {
+		tip, err := eth.SuggestGasTipCap(context.Background())
+		if err != nil {
+			return "", err
+		}
+
+		auth.GasTipCap = tip
+		auth.GasFeeCap = big.NewInt(0).Add(baseFee, tip)
+	}
 
 	tx, err := ep.HandleOps(auth, toAbiType(batch), beneficiary)
 	if err != nil {

pkg/gas/pvg.go

@@ -1,15 +1,20 @@
 package gas
 
 import (
+	"context"
+	"math"
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/stackup-wallet/stackup-bundler/pkg/arbitrum/nodeinterface"
 	"github.com/stackup-wallet/stackup-bundler/pkg/entrypoint"
 	"github.com/stackup-wallet/stackup-bundler/pkg/entrypoint/methods"
+	"github.com/stackup-wallet/stackup-bundler/pkg/entrypoint/transaction"
+	"github.com/stackup-wallet/stackup-bundler/pkg/optimism/gaspriceoracle"
 	"github.com/stackup-wallet/stackup-bundler/pkg/signer"
 	"github.com/stackup-wallet/stackup-bundler/pkg/userop"
 )
@@ -76,3 +81,70 @@ func CalcArbitrumPVGWithEthClient(
 		return big.NewInt(0).Add(static, big.NewInt(int64(gas.GasEstimateForL1))), nil
 	}
 }
+
+// CalcOptimismPVGWithEthClient uses Optimism's Gas Price Oracle precompile to get an estimate for
+// preVerificationGas that takes into account the L1 gas component.
+func CalcOptimismPVGWithEthClient(
+	rpc *rpc.Client,
+	chainID *big.Int,
+	entryPoint common.Address,
+) CalcPreVerificationGasFunc {
+	pk, _ := crypto.GenerateKey()
+	dummy, _ := signer.New(hexutil.Encode(crypto.FromECDSA(pk))[2:])
+	return func(op *userop.UserOperation, static *big.Int) (*big.Int, error) {
+		// Create Raw HandleOps Transaction
+		eth := ethclient.NewClient(rpc)
+		head, err := eth.HeaderByNumber(context.Background(), nil)
+		if err != nil {
+			return nil, err
+		}
+		tx, err := transaction.CreateRawHandleOps(
+			dummy,
+			eth,
+			chainID,
+			entryPoint,
+			[]*userop.UserOperation{op},
+			dummy.Address,
+			math.MaxUint64,
+			head.BaseFee,
+		)
+		if err != nil {
+			return nil, err
+		}
+
+		// Encode function data for GetL1Fee
+		data, err := hexutil.Decode(tx)
+		if err != nil {
+			return nil, err
+		}
+		ge, err := gaspriceoracle.GetL1FeeMethod.Inputs.Pack(data)
+		if err != nil {
+			return nil, err
+		}
+
+		// Use eth_call to call the Gas Price Oracle precompile
+		req := map[string]any{
+			"from": common.HexToAddress("0x"),
+			"to":   gaspriceoracle.PrecompileAddress,
+			"data": hexutil.Encode(append(gaspriceoracle.GetL1FeeMethod.ID, ge...)),
+		}
+		var out any
+		if err := rpc.Call(&out, "eth_call", &req, "latest"); err != nil {
+			return nil, err
+		}
+
+		// Get L1Fee and L2Price
+		l1fee, err := gaspriceoracle.DecodeGetL1FeeMethodOutput(out)
+		if err != nil {
+			return nil, err
+		}
+		l2price := op.MaxFeePerGas
+		l2priority := big.NewInt(0).Add(op.MaxPriorityFeePerGas, head.BaseFee)
+		if l2priority.Cmp(l2price) == -1 {
+			l2price = l2priority
+		}
+
+		// Return static + L1 buffer as PVG. L1 buffer is equal to L1Fee/L2Price.
+		return big.NewInt(0).Add(static, big.NewInt(0).Div(l1fee, l2price)), nil
+	}
+}

pkg/optimism/gaspriceoracle/constants.go

@@ -0,0 +1,7 @@
+package gaspriceoracle
+
+import "github.com/ethereum/go-ethereum/common"
+
+var (
+	PrecompileAddress = common.HexToAddress("0x420000000000000000000000000000000000000F")
+)

pkg/optimism/gaspriceoracle/methods.go

@@ -0,0 +1,48 @@
+package gaspriceoracle
+
+import (
+	"errors"
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common/hexutil"
+)
+
+var (
+	bytesT, _   = abi.NewType("bytes", "", nil)
+	uint256T, _ = abi.NewType("uint256", "", nil)
+
+	GetL1FeeMethod = abi.NewMethod(
+		"getL1Fee",
+		"getL1Fee",
+		abi.Function,
+		"",
+		false,
+		false,
+		abi.Arguments{
+			{Name: "data", Type: bytesT},
+		},
+		abi.Arguments{
+			{Name: "fee", Type: uint256T},
+		},
+	)
+)
+
+func DecodeGetL1FeeMethodOutput(out any) (*big.Int, error) {
+	hex, ok := out.(string)
+	if !ok {
+		return nil, errors.New("getL1Fee: cannot assert type: hex is not of type string")
+	}
+	data, err := hexutil.Decode(hex)
+	if err != nil {
+		return nil, fmt.Errorf("getL1Fee: %s", err)
+	}
+
+	args, err := GetL1FeeMethod.Outputs.Unpack(data)
+	if err != nil {
+		return nil, fmt.Errorf("getL1Fee: %s", err)
+	}
+
+	return args[0].(*big.Int), nil
+}