mirror of
https://github.com/ethereum/go-ethereum.git
synced 2026-05-10 18:16:39 +00:00
a15778c52f
This PR addresses one of the biggest performance issue with binary tries: storing each internal node individually bloats the index, the disk, and triggers a lot of write amplifications. To fix this issue, this PR serializes groups of nodes together. Because we are still looking for the ideal group size, the "depth" of the group tree is made a parameter, but that will be removed in the future, once the perfect size is known. This is a rebase of #33658 --------- Co-authored-by: Copilot <copilot@github.com>
414 lines
12 KiB
Go
414 lines
12 KiB
Go
// Copyright 2014 The go-ethereum Authors
|
|
// This file is part of go-ethereum.
|
|
//
|
|
// go-ethereum is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// go-ethereum 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 General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
// geth is a command-line client for Ethereum.
|
|
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"slices"
|
|
"sort"
|
|
"time"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts"
|
|
"github.com/ethereum/go-ethereum/cmd/utils"
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/console/prompt"
|
|
"github.com/ethereum/go-ethereum/eth/downloader"
|
|
"github.com/ethereum/go-ethereum/ethclient"
|
|
"github.com/ethereum/go-ethereum/internal/debug"
|
|
"github.com/ethereum/go-ethereum/internal/flags"
|
|
"github.com/ethereum/go-ethereum/log"
|
|
"github.com/ethereum/go-ethereum/node"
|
|
"go.uber.org/automaxprocs/maxprocs"
|
|
|
|
// Force-load the tracer engines to trigger registration
|
|
_ "github.com/ethereum/go-ethereum/eth/tracers/js"
|
|
_ "github.com/ethereum/go-ethereum/eth/tracers/live"
|
|
_ "github.com/ethereum/go-ethereum/eth/tracers/native"
|
|
|
|
"github.com/urfave/cli/v2"
|
|
)
|
|
|
|
const (
|
|
clientIdentifier = "geth" // Client identifier to advertise over the network
|
|
)
|
|
|
|
var (
|
|
// flags that configure the node
|
|
nodeFlags = slices.Concat([]cli.Flag{
|
|
utils.IdentityFlag,
|
|
utils.UnlockedAccountFlag,
|
|
utils.PasswordFileFlag,
|
|
utils.BootnodesFlag,
|
|
utils.MinFreeDiskSpaceFlag,
|
|
utils.KeyStoreDirFlag,
|
|
utils.ExternalSignerFlag,
|
|
utils.NoUSBFlag, // deprecated
|
|
utils.USBFlag,
|
|
utils.SmartCardDaemonPathFlag,
|
|
utils.OverrideOsaka,
|
|
utils.OverrideBPO1,
|
|
utils.OverrideBPO2,
|
|
utils.OverrideUBT,
|
|
utils.OverrideGenesisFlag,
|
|
utils.EnablePersonal, // deprecated
|
|
utils.TxPoolLocalsFlag,
|
|
utils.TxPoolNoLocalsFlag,
|
|
utils.TxPoolJournalFlag,
|
|
utils.TxPoolRejournalFlag,
|
|
utils.TxPoolPriceLimitFlag,
|
|
utils.TxPoolPriceBumpFlag,
|
|
utils.TxPoolAccountSlotsFlag,
|
|
utils.TxPoolGlobalSlotsFlag,
|
|
utils.TxPoolAccountQueueFlag,
|
|
utils.TxPoolGlobalQueueFlag,
|
|
utils.TxPoolLifetimeFlag,
|
|
utils.BlobPoolDataDirFlag,
|
|
utils.BlobPoolDataCapFlag,
|
|
utils.BlobPoolPriceBumpFlag,
|
|
utils.SyncModeFlag,
|
|
utils.SyncTargetFlag,
|
|
utils.ExitWhenSyncedFlag,
|
|
utils.GCModeFlag,
|
|
utils.SnapshotFlag,
|
|
utils.TxLookupLimitFlag, // deprecated
|
|
utils.TransactionHistoryFlag,
|
|
utils.ChainHistoryFlag,
|
|
utils.LogHistoryFlag,
|
|
utils.LogNoHistoryFlag,
|
|
utils.LogExportCheckpointsFlag,
|
|
utils.StateHistoryFlag,
|
|
utils.TrienodeHistoryFlag,
|
|
utils.TrienodeHistoryFullValueCheckpointFlag,
|
|
utils.BinTrieGroupDepthFlag,
|
|
utils.LightKDFFlag,
|
|
utils.EthRequiredBlocksFlag,
|
|
utils.LegacyWhitelistFlag, // deprecated
|
|
utils.CacheFlag,
|
|
utils.CacheDatabaseFlag,
|
|
utils.CacheTrieFlag,
|
|
utils.CacheTrieJournalFlag, // deprecated
|
|
utils.CacheTrieRejournalFlag, // deprecated
|
|
utils.CacheGCFlag,
|
|
utils.CacheSnapshotFlag,
|
|
utils.CacheNoPrefetchFlag,
|
|
utils.CachePreimagesFlag,
|
|
utils.CacheLogSizeFlag,
|
|
utils.FDLimitFlag,
|
|
utils.CryptoKZGFlag,
|
|
utils.ListenPortFlag,
|
|
utils.DiscoveryPortFlag,
|
|
utils.MaxPeersFlag,
|
|
utils.MaxPendingPeersFlag,
|
|
utils.MiningEnabledFlag, // deprecated
|
|
utils.MinerGasLimitFlag,
|
|
utils.MinerGasPriceFlag,
|
|
utils.MinerEtherbaseFlag, // deprecated
|
|
utils.MinerExtraDataFlag,
|
|
utils.MinerMaxBlobsFlag,
|
|
utils.MinerRecommitIntervalFlag,
|
|
utils.MinerPendingFeeRecipientFlag,
|
|
utils.MinerNewPayloadTimeoutFlag, // deprecated
|
|
utils.NATFlag,
|
|
utils.NoDiscoverFlag,
|
|
utils.DiscoveryV4Flag,
|
|
utils.DiscoveryV5Flag,
|
|
utils.LegacyDiscoveryV5Flag, // deprecated
|
|
utils.NetrestrictFlag,
|
|
utils.NodeKeyFileFlag,
|
|
utils.NodeKeyHexFlag,
|
|
utils.DNSDiscoveryFlag,
|
|
utils.DeveloperFlag,
|
|
utils.DeveloperGasLimitFlag,
|
|
utils.DeveloperPeriodFlag,
|
|
utils.VMEnableDebugFlag,
|
|
utils.VMTraceFlag,
|
|
utils.VMTraceJsonConfigFlag,
|
|
utils.VMWitnessStatsFlag,
|
|
utils.VMStatelessSelfValidationFlag,
|
|
utils.NetworkIdFlag,
|
|
utils.EthStatsURLFlag,
|
|
utils.GpoBlocksFlag,
|
|
utils.GpoPercentileFlag,
|
|
utils.GpoMaxGasPriceFlag,
|
|
utils.GpoIgnoreGasPriceFlag,
|
|
configFileFlag,
|
|
utils.LogDebugFlag,
|
|
utils.LogBacktraceAtFlag,
|
|
utils.BeaconApiFlag,
|
|
utils.BeaconApiHeaderFlag,
|
|
utils.BeaconThresholdFlag,
|
|
utils.BeaconNoFilterFlag,
|
|
utils.BeaconConfigFlag,
|
|
utils.BeaconGenesisRootFlag,
|
|
utils.BeaconGenesisTimeFlag,
|
|
utils.BeaconCheckpointFlag,
|
|
utils.BeaconCheckpointFileFlag,
|
|
utils.LogSlowBlockFlag,
|
|
}, utils.NetworkFlags, utils.DatabaseFlags)
|
|
|
|
rpcFlags = []cli.Flag{
|
|
utils.HTTPEnabledFlag,
|
|
utils.HTTPListenAddrFlag,
|
|
utils.HTTPPortFlag,
|
|
utils.HTTPCORSDomainFlag,
|
|
utils.AuthListenFlag,
|
|
utils.AuthPortFlag,
|
|
utils.AuthVirtualHostsFlag,
|
|
utils.JWTSecretFlag,
|
|
utils.HTTPVirtualHostsFlag,
|
|
utils.GraphQLEnabledFlag,
|
|
utils.GraphQLCORSDomainFlag,
|
|
utils.GraphQLVirtualHostsFlag,
|
|
utils.HTTPApiFlag,
|
|
utils.HTTPPathPrefixFlag,
|
|
utils.WSEnabledFlag,
|
|
utils.WSListenAddrFlag,
|
|
utils.WSPortFlag,
|
|
utils.WSApiFlag,
|
|
utils.WSAllowedOriginsFlag,
|
|
utils.WSPathPrefixFlag,
|
|
utils.IPCDisabledFlag,
|
|
utils.IPCPathFlag,
|
|
utils.InsecureUnlockAllowedFlag,
|
|
utils.RPCGlobalGasCapFlag,
|
|
utils.RPCGlobalEVMTimeoutFlag,
|
|
utils.RPCGlobalTxFeeCapFlag,
|
|
utils.RPCGlobalLogQueryLimit,
|
|
utils.AllowUnprotectedTxs,
|
|
utils.BatchRequestLimit,
|
|
utils.BatchResponseMaxSize,
|
|
utils.RPCTxSyncDefaultTimeoutFlag,
|
|
utils.RPCTxSyncMaxTimeoutFlag,
|
|
utils.RPCGlobalRangeLimitFlag,
|
|
utils.RPCTelemetryFlag,
|
|
utils.RPCTelemetryEndpointFlag,
|
|
utils.RPCTelemetryUserFlag,
|
|
utils.RPCTelemetryPasswordFlag,
|
|
utils.RPCTelemetryInstanceIDFlag,
|
|
utils.RPCTelemetryTagsFlag,
|
|
utils.RPCTelemetrySampleRatioFlag,
|
|
}
|
|
|
|
metricsFlags = []cli.Flag{
|
|
utils.MetricsEnabledFlag,
|
|
utils.MetricsEnabledExpensiveFlag,
|
|
utils.MetricsHTTPFlag,
|
|
utils.MetricsPortFlag,
|
|
utils.MetricsEnableInfluxDBFlag,
|
|
utils.MetricsInfluxDBEndpointFlag,
|
|
utils.MetricsInfluxDBDatabaseFlag,
|
|
utils.MetricsInfluxDBUsernameFlag,
|
|
utils.MetricsInfluxDBPasswordFlag,
|
|
utils.MetricsInfluxDBTagsFlag,
|
|
utils.MetricsInfluxDBIntervalFlag,
|
|
utils.MetricsEnableInfluxDBV2Flag,
|
|
utils.MetricsInfluxDBTokenFlag,
|
|
utils.MetricsInfluxDBBucketFlag,
|
|
utils.MetricsInfluxDBOrganizationFlag,
|
|
utils.StateSizeTrackingFlag,
|
|
}
|
|
)
|
|
|
|
var app = flags.NewApp("the go-ethereum command line interface")
|
|
|
|
func init() {
|
|
// Initialize the CLI app and start Geth
|
|
app.Action = geth
|
|
app.Commands = []*cli.Command{
|
|
// See chaincmd.go:
|
|
initCommand,
|
|
importCommand,
|
|
exportCommand,
|
|
importHistoryCommand,
|
|
exportHistoryCommand,
|
|
importPreimagesCommand,
|
|
removedbCommand,
|
|
dumpCommand,
|
|
dumpGenesisCommand,
|
|
pruneHistoryCommand,
|
|
downloadEraCommand,
|
|
// See accountcmd.go:
|
|
accountCommand,
|
|
walletCommand,
|
|
// See consolecmd.go:
|
|
consoleCommand,
|
|
attachCommand,
|
|
javascriptCommand,
|
|
// See misccmd.go:
|
|
versionCommand,
|
|
licenseCommand,
|
|
// See config.go
|
|
dumpConfigCommand,
|
|
// see dbcmd.go
|
|
dbCommand,
|
|
// See cmd/utils/flags_legacy.go
|
|
utils.ShowDeprecated,
|
|
// See snapshot.go
|
|
snapshotCommand,
|
|
// See bintrie_convert.go
|
|
bintrieCommand,
|
|
}
|
|
if logTestCommand != nil {
|
|
app.Commands = append(app.Commands, logTestCommand)
|
|
}
|
|
sort.Sort(cli.CommandsByName(app.Commands))
|
|
|
|
app.Flags = slices.Concat(
|
|
nodeFlags,
|
|
rpcFlags,
|
|
consoleFlags,
|
|
debug.Flags,
|
|
metricsFlags,
|
|
)
|
|
flags.AutoEnvVars(app.Flags, "GETH")
|
|
|
|
app.Before = func(ctx *cli.Context) error {
|
|
maxprocs.Set() // Automatically set GOMAXPROCS to match Linux container CPU quota.
|
|
flags.MigrateGlobalFlags(ctx)
|
|
if err := debug.Setup(ctx); err != nil {
|
|
return err
|
|
}
|
|
flags.CheckEnvVars(ctx, app.Flags, "GETH")
|
|
return nil
|
|
}
|
|
app.After = func(ctx *cli.Context) error {
|
|
debug.Exit()
|
|
prompt.Stdin.Close() // Resets terminal mode.
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func main() {
|
|
if err := app.Run(os.Args); err != nil {
|
|
fmt.Fprintln(os.Stderr, err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
// prepare manipulates memory cache allowance and setups metric system.
|
|
// This function should be called before launching devp2p stack.
|
|
func prepare(ctx *cli.Context) {
|
|
// If we're running a known preset, log it for convenience.
|
|
switch {
|
|
case ctx.IsSet(utils.SepoliaFlag.Name):
|
|
log.Info("Starting Geth on Sepolia testnet...")
|
|
|
|
case ctx.IsSet(utils.HoleskyFlag.Name):
|
|
log.Info("Starting Geth on Holesky testnet...")
|
|
|
|
case ctx.IsSet(utils.HoodiFlag.Name):
|
|
log.Info("Starting Geth on Hoodi testnet...")
|
|
|
|
case !ctx.IsSet(utils.NetworkIdFlag.Name):
|
|
log.Info("Starting Geth on Ethereum mainnet...")
|
|
}
|
|
}
|
|
|
|
// geth is the main entry point into the system if no special subcommand is run.
|
|
// It creates a default node based on the command line arguments and runs it in
|
|
// blocking mode, waiting for it to be shut down.
|
|
func geth(ctx *cli.Context) error {
|
|
if args := ctx.Args().Slice(); len(args) > 0 {
|
|
return fmt.Errorf("invalid command: %q", args[0])
|
|
}
|
|
|
|
prepare(ctx)
|
|
stack := makeFullNode(ctx)
|
|
defer stack.Close()
|
|
|
|
startNode(ctx, stack, false)
|
|
stack.Wait()
|
|
return nil
|
|
}
|
|
|
|
// startNode boots up the system node and all registered protocols, after which
|
|
// it starts the RPC/IPC interfaces and the miner.
|
|
func startNode(ctx *cli.Context, stack *node.Node, isConsole bool) {
|
|
// Start up the node itself
|
|
utils.StartNode(ctx, stack, isConsole)
|
|
|
|
if ctx.IsSet(utils.UnlockedAccountFlag.Name) {
|
|
log.Warn(`The "unlock" flag has been deprecated and has no effect`)
|
|
}
|
|
|
|
// Register wallet event handlers to open and auto-derive wallets
|
|
events := make(chan accounts.WalletEvent, 16)
|
|
stack.AccountManager().Subscribe(events)
|
|
|
|
// Create a client to interact with local geth node.
|
|
rpcClient := stack.Attach()
|
|
ethClient := ethclient.NewClient(rpcClient)
|
|
|
|
go func() {
|
|
// Open any wallets already attached
|
|
for _, wallet := range stack.AccountManager().Wallets() {
|
|
if err := wallet.Open(""); err != nil {
|
|
log.Warn("Failed to open wallet", "url", wallet.URL(), "err", err)
|
|
}
|
|
}
|
|
// Listen for wallet event till termination
|
|
for event := range events {
|
|
switch event.Kind {
|
|
case accounts.WalletArrived:
|
|
if err := event.Wallet.Open(""); err != nil {
|
|
log.Warn("New wallet appeared, failed to open", "url", event.Wallet.URL(), "err", err)
|
|
}
|
|
case accounts.WalletOpened:
|
|
status, _ := event.Wallet.Status()
|
|
log.Info("New wallet appeared", "url", event.Wallet.URL(), "status", status)
|
|
|
|
var derivationPaths []accounts.DerivationPath
|
|
if event.Wallet.URL().Scheme == "ledger" {
|
|
derivationPaths = append(derivationPaths, accounts.LegacyLedgerBaseDerivationPath)
|
|
}
|
|
derivationPaths = append(derivationPaths, accounts.DefaultBaseDerivationPath)
|
|
|
|
event.Wallet.SelfDerive(derivationPaths, ethClient)
|
|
|
|
case accounts.WalletDropped:
|
|
log.Info("Old wallet dropped", "url", event.Wallet.URL())
|
|
event.Wallet.Close()
|
|
}
|
|
}
|
|
}()
|
|
|
|
// Spawn a standalone goroutine for status synchronization monitoring,
|
|
// close the node when synchronization is complete if user required.
|
|
if ctx.Bool(utils.ExitWhenSyncedFlag.Name) {
|
|
go func() {
|
|
sub := stack.EventMux().Subscribe(downloader.DoneEvent{})
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
event := <-sub.Chan()
|
|
if event == nil {
|
|
continue
|
|
}
|
|
done, ok := event.Data.(downloader.DoneEvent)
|
|
if !ok {
|
|
continue
|
|
}
|
|
if timestamp := time.Unix(int64(done.Latest.Time), 0); time.Since(timestamp) < 10*time.Minute {
|
|
log.Info("Synchronisation completed", "latestnum", done.Latest.Number, "latesthash", done.Latest.Hash(),
|
|
"age", common.PrettyAge(timestamp))
|
|
stack.Close()
|
|
}
|
|
}
|
|
}()
|
|
}
|
|
}
|