Gas on Optimism

This document seeks to provide an technical overview of the components that impact transaction prices on Optimism as of February 22, 2022.

Authored by Rajiv Patel-O'Connor and special thanks to Mark Tyneway for the review

OVM_GasPriceOracle.sol

OVM_GasPriceOracle is a predeploy (a pre-compile written in Solidity as opposed to native langauge) that exposes the L2 execution gas price as well as the associated L1 data fee. The reason there is an L1 data fee is because each transaction on Optimism is posted to mainnet for data availability purposes which naturally incurs a cost as calldata is not free. As such, the total cost of a transaction can be given as the sum of the L2 execution fee and associated L1 data fee.

The L2 execution fee is gasPrice * l2_tx_gas_used and the gasPrice can be updated by the owner of the GasPriceOracle.

The L1 data fee calculation is a bit more complicated but it's roughly l1BaseFee * (l1_gas_used + overhead) * scalar / decimals where scalar / decimals represents an dynamic overhead and overhead is a fixed overhead for the amortized cost of batch submission per tx. l1_gas_used is calculated as 16 gas per non-zero byte and 4 gas per zero byte of the RLP-encoded transaction. A helper for calculating L1 gas of unsigned txs is provided as part of the predeploy:

function getL1GasUsed(bytes memory _data) public view returns (uint256) {
        uint256 total = 0;
        for (uint256 i = 0; i < _data.length; i++) {
            if (_data[i] == 0) {
                total += 4;
            } else {
                total += 16;
            }
        }
        uint256 unsigned = total + overhead;
        return unsigned + (68 * 16);
    }

The 68 * 16 at the end is to account for the 68 bytes for r, s, v and their respective RLP prefixes all of which are assumed to be non-zero.

The predeploy includes a functions for updating the variables used in above equations:

    /**
     * Allows the owner to modify the l2 gas price.
     * @param _gasPrice New l2 gas price.
     */
    // slither-disable-next-line external-function
    function setGasPrice(uint256 _gasPrice) public onlyOwner {
        gasPrice = _gasPrice;
        emit GasPriceUpdated(_gasPrice);
    }

    /**
     * Allows the owner to modify the l1 base fee.
     * @param _baseFee New l1 base fee
     */
    // slither-disable-next-line external-function
    function setL1BaseFee(uint256 _baseFee) public onlyOwner {
        l1BaseFee = _baseFee;
        emit L1BaseFeeUpdated(_baseFee);
    }

    /**
     * Allows the owner to modify the overhead.
     * @param _overhead New overhead
     */
    // slither-disable-next-line external-function
    function setOverhead(uint256 _overhead) public onlyOwner {
        overhead = _overhead;
        emit OverheadUpdated(_overhead);
    }

    /**
     * Allows the owner to modify the scalar.
     * @param _scalar New scalar
     */
    // slither-disable-next-line external-function
    function setScalar(uint256 _scalar) public onlyOwner {
        scalar = _scalar;
        emit ScalarUpdated(_scalar);
    }

    /**
     * Allows the owner to modify the decimals.
     * @param _decimals New decimals
     */
    // slither-disable-next-line external-function
    function setDecimals(uint256 _decimals) public onlyOwner {
        decimals = _decimals;
        emit DecimalsUpdated(_decimals);
    }

Gas Oracle Service

Directly from the service README:

This service is responsible for sending transactions to the Sequencer to update the L2 gas price over time.

It holds the private key associated with the owner of OVM_GasPriceOracle, so it alone can make updates as per the onlyOwner modifier.

So how exactly does this work? If you peek into main.go, you'll notice there's some code to initialize the Gas Price Oracle and some code to start it.

config := oracle.NewConfig(ctx)
gpo, err := oracle.NewGasPriceOracle(config)
if err != nil {
    return err
}

if err := gpo.Start(); err != nil {
    return err
}

The Start method has the option of running two loops, one to update L1 data fee price and a second to update the L2 gas price.

Updating the L1 data fee price

The core loop code is the following:

func (g *GasPriceOracle) BaseFeeLoop() {
	timer := time.NewTicker(15 * time.Second)
	defer timer.Stop()

	updateBaseFee, err := wrapUpdateBaseFee(g.l1Backend, g.l2Backend, g.config)
	if err != nil {
		panic(err)
	}

	for {
		select {
		case <-timer.C:
			if err := updateBaseFee(); err != nil {
				log.Error("cannot update l1 base fee", "messgae", err)
			}

		case <-g.ctx.Done():
			g.Stop()
		}
	}
}

Nothing too unusual but worth noting that the updateBaseFee function is called every 15 seconds which is slighly longer than the average block time of ~13s.

updateBaseFee first gets the gas price of the last L1 block and checks to see if there is a "significant" difference between it and the value for the L1 data fee price in the OVM_GasPriceOracle contract. Significance is determined by having a percentage difference greater than a config variable whose default is set to .05 as per the README.

baseFee, err := contract.L1BaseFee(&bind.CallOpts{
	Context: context.Background(),
})
if err != nil {
    return err
}
tip, err := l1Backend.HeaderByNumber(context.Background(), nil)
if err != nil {
    return err
}
if tip.BaseFee == nil {
    return errNoBaseFee
}
if !isDifferenceSignificant(baseFee.Uint64(), tip.BaseFee.Uint64(), cfg.l1BaseFeeSignificanceFactor) {
    log.Debug("non significant base fee update", "tip", tip.BaseFee, "current", baseFee)
    return nil
}

If there is a difference, a contract call is made and the gas price is updated.

In summary, the l1 gas price updates a little less frequently than every block if there's more than a 5% change from the previous update.

Updating the L2 gas price

The main loop

func (g *GasPriceOracle) Loop() {
	timer := time.NewTicker(time.Duration(g.config.epochLengthSeconds) * time.Second)
	defer timer.Stop()
	for {
		select {
		case <-timer.C:
			log.Trace("polling", "time", time.Now())
			if err := g.Update(); err != nil {
				log.Error("cannot update gas price", "message", err)
			}

		case <-g.ctx.Done():
			g.Stop()
		}
	}
}

The default value for config.epochLengthSeconds is 10 seconds as per the README.

So what does the Update method do?

func (g *GasPriceOracle) Update() error {
	l2GasPrice, err := g.contract.GasPrice(&bind.CallOpts{
		Context: g.ctx,
	})
	if err != nil {
		return fmt.Errorf("cannot get gas price: %w", err)
	}

	if err := g.gasPriceUpdater.UpdateGasPrice(); err != nil {
		return fmt.Errorf("cannot update gas price: %w", err)
	}

	newGasPrice, err := g.contract.GasPrice(&bind.CallOpts{
		Context: g.ctx,
	})
	if err != nil {
		return fmt.Errorf("cannot get gas price: %w", err)
	}

	local := g.gasPriceUpdater.GetGasPrice()
	log.Info("Update", "original", l2GasPrice, "current", newGasPrice, "local", local)
	return nil
}

We need to dig a layer deeper into the GasPriceUpdater and the UpdateGasPrice method.

func (g *GasPriceUpdater) UpdateGasPrice() error {
	g.mu.Lock()
	defer g.mu.Unlock()

	latestBlockNumber, err := g.getLatestBlockNumberFn()
	if err != nil {
		return err
	}
	if latestBlockNumber < g.epochStartBlockNumber {
		return errors.New("Latest block number less than the last epoch's block number")
	}

	if latestBlockNumber == g.epochStartBlockNumber {
		log.Debug("latest block number is equal to epoch start block number", "number", latestBlockNumber)
		return nil
	}

	// Accumulate the amount of gas that has been used in the epoch
	totalGasUsed := uint64(0)
	for i := g.epochStartBlockNumber + 1; i <= latestBlockNumber; i++ {
		gasUsed, err := g.getGasUsedByBlockFn(new(big.Int).SetUint64(i))
		log.Trace("fetching gas used", "height", i, "gas-used", gasUsed, "total-gas", totalGasUsed)
		if err != nil {
			return err
		}
		totalGasUsed += gasUsed
	}

	averageGasPerSecond := float64(totalGasUsed) / float64(g.epochLengthSeconds)

	log.Debug("UpdateGasPrice", "average-gas-per-second", averageGasPerSecond, "current-price", g.gasPricer.curPrice)
	_, err = g.gasPricer.CompleteEpoch(averageGasPerSecond)
	if err != nil {
		return err
	}
	g.epochStartBlockNumber = latestBlockNumber
	err = g.updateL2GasPriceFn(g.gasPricer.curPrice)
	if err != nil {
		return err
	}
	return nil
}

1. It gets the latestBlockNumber and checks to see that it is greater than previously stored epochStartBlockNumber.
2. The total amount of gas used betweeen epochStartBlockNumber and the latestBlockNumber is calculated by getting the gas used in each block in the range and summing it together.
3. averageGasPerSecond is calculated by dividing the totalGasUsed by the epochLengthSeconds which is also the L2 update gas price loop length.
4. The gas pricer CompleteEpoch method is called the calculated averageGasPerSecond. More on this below.
5. epochStartBlockNumber is updated to be latestBlockNumber.
6. An update function is called which actually updates the L2 gas price.

To go a bit deeper on CompleteEpoch:

func (p *GasPricer) CompleteEpoch(avgGasPerSecondLastEpoch float64) (uint64, error) {
	gp, err := p.CalcNextEpochGasPrice(avgGasPerSecondLastEpoch)
	if err != nil {
		return gp, err
	}
	p.curPrice = gp
	p.avgGasPerSecondLastEpoch = avgGasPerSecondLastEpoch
	return gp, nil
}

Looks like we should take a peek at CalcNextEpochGasPrice:

func (p *GasPricer) CalcNextEpochGasPrice(avgGasPerSecondLastEpoch float64) (uint64, error) {
	targetGasPerSecond := p.getTargetGasPerSecond()
	if avgGasPerSecondLastEpoch < 0 {
		return 0.0, fmt.Errorf("avgGasPerSecondLastEpoch cannot be negative, got %f", avgGasPerSecondLastEpoch)
	}
	if targetGasPerSecond < 1 {
		return 0.0, fmt.Errorf("gasPerSecond cannot be less than 1, got %f", targetGasPerSecond)
	}
	// The percent difference between our current average gas & our target gas
	proportionOfTarget := avgGasPerSecondLastEpoch / targetGasPerSecond

	log.Trace("Calculating next epoch gas price", "proportionOfTarget", proportionOfTarget,
		"avgGasPerSecondLastEpoch", avgGasPerSecondLastEpoch, "targetGasPerSecond", targetGasPerSecond)

	// The percent that we should adjust the gas price to reach our target gas
	proportionToChangeBy := 0.0
	if proportionOfTarget >= 1 { // If average avgGasPerSecondLastEpoch is GREATER than our target
		proportionToChangeBy = math.Min(proportionOfTarget, 1+p.maxChangePerEpoch)
	} else {
		proportionToChangeBy = math.Max(proportionOfTarget, 1-p.maxChangePerEpoch)
	}

	updated := float64(max(1, p.curPrice)) * proportionToChangeBy
	result := max(p.floorPrice, uint64(math.Ceil(updated)))

	log.Debug("Calculated next epoch gas price", "proportionToChangeBy", proportionToChangeBy,
		"proportionOfTarget", proportionOfTarget, "result", result)

	return result, nil
}

1. Get the targetGasPerSecond. This is currently set via a config variable whose default value is 11000000.
2. Do some basic santiy checks around the previously calculated averageGasPerSecond.
3. Get the proportion difference between averageGasPerSecond and targetGasPerSecond.
4. Calculate the proportionToChangeBy (how much to change L2 gas price). This amount of possible percent change per epooch is bounded by a config variable whose default is set to .1.
5. Based on proportionToChangeBy, calculate the new L2 gas price and ensure that it's not smaller than the floorPrice which is also set via a config variable whose default is 1.
6. Return the new L2 gas price.

Moving back up toCompleteEpoch (see above), the returned gas price is stored as is the averageGasPerSecond from what will have been the previous epoch.

Zooming way back to update, logging is done (probably?) for debugging, but that's it!

Optimizing Gas Today

The price of gas on L1 is often 50K-100K times more expensive than it is on Optimism. Given that, it could make sense to minimize calldata as each byte adds extra cost to the L1 data fee. While it might not make sense for project to modify its core contracts across chains due to increased maintenance burden, there might be an interesting opportunity to write different periphery contracts that minimize calldata.

Looking forward

A non-exhaustive list of efforts that could bring meaningful reductions to gas costs on Optimism:

• EIP-4488 seeks to reduce the cost of calldata to 3 gas per byte which is much lower than the 4 gas per zero-byte and 16 gas per non-zero byte today.
• Stateless compression of tx data