mirror of
https://github.com/ethereum/go-ethereum.git
synced 2026-06-28 17:27:36 +00:00
cda717581d
This PR drops support for v0 blob sidecar in blobpool. Since the osaka fork activation time has passed, these code paths are now unused. It is assumed that only v1 transactions exist in the blobpool.
98 lines
3.6 KiB
Go
98 lines
3.6 KiB
Go
// Copyright 2023 The go-ethereum Authors
|
|
// This file is part of the go-ethereum library.
|
|
//
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package blobpool
|
|
|
|
import (
|
|
"github.com/ethereum/go-ethereum/params"
|
|
"github.com/holiman/billy"
|
|
)
|
|
|
|
// tryMigrate checks if the billy needs to be migrated and migrates if needed.
|
|
// Returns a slotter that can be used for the database.
|
|
func tryMigrate(config *params.ChainConfig, slotter billy.SlotSizeFn, datadir string) (billy.SlotSizeFn, error) {
|
|
// Check if we need to migrate our blob db to the new slotter.
|
|
if config.OsakaTime != nil {
|
|
// Open the store using the version slotter to see if any version has been
|
|
// written.
|
|
var version int
|
|
index := func(_ uint64, _ uint32, blob []byte) {
|
|
version = max(version, parseSlotterVersion(blob))
|
|
}
|
|
store, err := billy.Open(billy.Options{Path: datadir}, newVersionSlotter(), index)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
store.Close()
|
|
|
|
// If the version found is less than the currently configured store version,
|
|
// perform a migration then write the updated version of the store.
|
|
if version < storeVersion {
|
|
newSlotter := newSlotterEIP7594(params.BlobTxMaxBlobs)
|
|
if err := billy.Migrate(billy.Options{Path: datadir, Repair: true}, slotter, newSlotter); err != nil {
|
|
return nil, err
|
|
}
|
|
store, err = billy.Open(billy.Options{Path: datadir}, newVersionSlotter(), nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
writeSlotterVersion(store, storeVersion)
|
|
store.Close()
|
|
}
|
|
// Set the slotter to the format now that the Osaka is active.
|
|
slotter = newSlotterEIP7594(params.BlobTxMaxBlobs)
|
|
}
|
|
return slotter, nil
|
|
}
|
|
|
|
// newSlotterEIP7594 creates a different slotter for EIP-7594 transactions.
|
|
// EIP-7594 (PeerDAS) changes the average transaction size which means the current
|
|
// static 4KB average size is not enough anymore.
|
|
// This slotter adds a dynamic overhead component to the slotter, which also
|
|
// captures the notion that blob transactions with more blobs are also more likely to
|
|
// to have more calldata.
|
|
func newSlotterEIP7594(maxBlobsPerTransaction int) billy.SlotSizeFn {
|
|
slotsize := uint32(txAvgSize)
|
|
slotsize -= uint32(blobSize) + txBlobOverhead // underflows, it's ok, will overflow back in the first return
|
|
|
|
return func() (size uint32, done bool) {
|
|
slotsize += blobSize + txBlobOverhead
|
|
finished := slotsize > uint32(maxBlobsPerTransaction)*(blobSize+txBlobOverhead)+txMaxSize
|
|
|
|
return slotsize, finished
|
|
}
|
|
}
|
|
|
|
// newVersionSlotter creates a slotter with a single 8 byte shelf to store
|
|
// version metadata in.
|
|
func newVersionSlotter() billy.SlotSizeFn {
|
|
return func() (size uint32, done bool) {
|
|
return 8, true
|
|
}
|
|
}
|
|
|
|
// parseSlotterVersion will parse the slotter's version from a given data blob.
|
|
func parseSlotterVersion(blob []byte) int {
|
|
if len(blob) > 0 {
|
|
return int(blob[0])
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// writeSlotterVersion writes the current slotter version into the store.
|
|
func writeSlotterVersion(store billy.Database, version int) {
|
|
store.Put([]byte{byte(version)})
|
|
}
|