forked from cerc-io/plugeth
bc14d12fd7
The old approach of getting state tries involved instantiating a new state database and using it to instantiate a trie. What we didn't realize was that state database needed to have Close() called on it, which we didn't offer a way for plugins to do, resulting in memory leaking. This approach reuses the primary trie database associated with the blockchain object, albeit a bit indirectly. This will allow access to recent tries that are stored in memory, where previously only tries that had been committed to disk were accessible.
503 lines
15 KiB
Go
503 lines
15 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 the official command-line client for Ethereum.
|
|
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts"
|
|
"github.com/ethereum/go-ethereum/accounts/keystore"
|
|
"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"
|
|
"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/ethapi"
|
|
"github.com/ethereum/go-ethereum/internal/flags"
|
|
"github.com/ethereum/go-ethereum/log"
|
|
"github.com/ethereum/go-ethereum/metrics"
|
|
"github.com/ethereum/go-ethereum/node"
|
|
"go.uber.org/automaxprocs/maxprocs"
|
|
|
|
"github.com/ethereum/go-ethereum/plugins"
|
|
"github.com/ethereum/go-ethereum/plugins/wrappers/backendwrapper"
|
|
|
|
// Force-load the tracer engines to trigger registration
|
|
_ "github.com/ethereum/go-ethereum/eth/tracers/js"
|
|
_ "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 = flags.Merge([]cli.Flag{
|
|
//begin PluGeth code injection
|
|
utils.PluginsDirFlag,
|
|
//end PluGeth code injection
|
|
utils.IdentityFlag,
|
|
utils.UnlockedAccountFlag,
|
|
utils.PasswordFileFlag,
|
|
utils.BootnodesFlag,
|
|
utils.MinFreeDiskSpaceFlag,
|
|
utils.KeyStoreDirFlag,
|
|
utils.ExternalSignerFlag,
|
|
utils.NoUSBFlag,
|
|
utils.USBFlag,
|
|
utils.SmartCardDaemonPathFlag,
|
|
utils.OverrideCancun,
|
|
utils.OverrideVerkle,
|
|
utils.EnablePersonal,
|
|
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,
|
|
utils.TransactionHistoryFlag,
|
|
utils.StateHistoryFlag,
|
|
utils.LightServeFlag,
|
|
utils.LightIngressFlag,
|
|
utils.LightEgressFlag,
|
|
utils.LightMaxPeersFlag,
|
|
utils.LightNoPruneFlag,
|
|
utils.LightKDFFlag,
|
|
utils.LightNoSyncServeFlag,
|
|
utils.EthRequiredBlocksFlag,
|
|
utils.LegacyWhitelistFlag,
|
|
utils.BloomFilterSizeFlag,
|
|
utils.CacheFlag,
|
|
utils.CacheDatabaseFlag,
|
|
utils.CacheTrieFlag,
|
|
utils.CacheTrieJournalFlag,
|
|
utils.CacheTrieRejournalFlag,
|
|
utils.CacheGCFlag,
|
|
utils.CacheSnapshotFlag,
|
|
utils.CacheNoPrefetchFlag,
|
|
utils.CachePreimagesFlag,
|
|
utils.CacheLogSizeFlag,
|
|
utils.FDLimitFlag,
|
|
utils.CryptoKZGFlag,
|
|
utils.ListenPortFlag,
|
|
utils.DiscoveryPortFlag,
|
|
utils.MaxPeersFlag,
|
|
utils.MaxPendingPeersFlag,
|
|
utils.MiningEnabledFlag,
|
|
utils.MinerGasLimitFlag,
|
|
utils.MinerGasPriceFlag,
|
|
utils.MinerEtherbaseFlag,
|
|
utils.MinerExtraDataFlag,
|
|
utils.MinerRecommitIntervalFlag,
|
|
utils.MinerNewPayloadTimeout,
|
|
utils.NATFlag,
|
|
utils.NoDiscoverFlag,
|
|
utils.DiscoveryV4Flag,
|
|
utils.DiscoveryV5Flag,
|
|
utils.LegacyDiscoveryV5Flag,
|
|
utils.NetrestrictFlag,
|
|
utils.NodeKeyFileFlag,
|
|
utils.NodeKeyHexFlag,
|
|
utils.DNSDiscoveryFlag,
|
|
utils.DeveloperFlag,
|
|
utils.DeveloperGasLimitFlag,
|
|
utils.DeveloperPeriodFlag,
|
|
utils.VMEnableDebugFlag,
|
|
utils.NetworkIdFlag,
|
|
utils.EthStatsURLFlag,
|
|
utils.NoCompactionFlag,
|
|
utils.GpoBlocksFlag,
|
|
utils.GpoPercentileFlag,
|
|
utils.GpoMaxGasPriceFlag,
|
|
utils.GpoIgnoreGasPriceFlag,
|
|
configFileFlag,
|
|
}, 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.AllowUnprotectedTxs,
|
|
utils.BatchRequestLimit,
|
|
utils.BatchResponseMaxSize,
|
|
}
|
|
|
|
metricsFlags = []cli.Flag{
|
|
utils.MetricsEnabledFlag,
|
|
utils.MetricsEnabledExpensiveFlag,
|
|
utils.MetricsHTTPFlag,
|
|
utils.MetricsPortFlag,
|
|
utils.MetricsEnableInfluxDBFlag,
|
|
utils.MetricsInfluxDBEndpointFlag,
|
|
utils.MetricsInfluxDBDatabaseFlag,
|
|
utils.MetricsInfluxDBUsernameFlag,
|
|
utils.MetricsInfluxDBPasswordFlag,
|
|
utils.MetricsInfluxDBTagsFlag,
|
|
utils.MetricsEnableInfluxDBV2Flag,
|
|
utils.MetricsInfluxDBTokenFlag,
|
|
utils.MetricsInfluxDBBucketFlag,
|
|
utils.MetricsInfluxDBOrganizationFlag,
|
|
}
|
|
)
|
|
|
|
var app = flags.NewApp("the go-ethereum command line interface")
|
|
|
|
func init() {
|
|
// Initialize the CLI app and start Geth
|
|
app.Action = geth
|
|
app.Copyright = "Copyright 2013-2023 The go-ethereum Authors"
|
|
app.Commands = []*cli.Command{
|
|
// See chaincmd.go:
|
|
initCommand,
|
|
importCommand,
|
|
exportCommand,
|
|
importPreimagesCommand,
|
|
exportPreimagesCommand,
|
|
removedbCommand,
|
|
dumpCommand,
|
|
dumpGenesisCommand,
|
|
// See accountcmd.go:
|
|
accountCommand,
|
|
walletCommand,
|
|
// See consolecmd.go:
|
|
consoleCommand,
|
|
attachCommand,
|
|
javascriptCommand,
|
|
// See misccmd.go:
|
|
versionCommand,
|
|
versionCheckCommand,
|
|
licenseCommand,
|
|
// See config.go
|
|
dumpConfigCommand,
|
|
// see dbcmd.go
|
|
dbCommand,
|
|
// See cmd/utils/flags_legacy.go
|
|
utils.ShowDeprecated,
|
|
// See snapshot.go
|
|
snapshotCommand,
|
|
// See verkle.go
|
|
verkleCommand,
|
|
}
|
|
sort.Sort(cli.CommandsByName(app.Commands))
|
|
|
|
app.Flags = flags.Merge(
|
|
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.GoerliFlag.Name):
|
|
log.Info("Starting Geth on Görli testnet...")
|
|
|
|
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.DeveloperFlag.Name):
|
|
log.Info("Starting Geth in ephemeral dev mode...")
|
|
log.Warn(`You are running Geth in --dev mode. Please note the following:
|
|
|
|
1. This mode is only intended for fast, iterative development without assumptions on
|
|
security or persistence.
|
|
2. The database is created in memory unless specified otherwise. Therefore, shutting down
|
|
your computer or losing power will wipe your entire block data and chain state for
|
|
your dev environment.
|
|
3. A random, pre-allocated developer account will be available and unlocked as
|
|
eth.coinbase, which can be used for testing. The random dev account is temporary,
|
|
stored on a ramdisk, and will be lost if your machine is restarted.
|
|
4. Mining is enabled by default. However, the client will only seal blocks if transactions
|
|
are pending in the mempool. The miner's minimum accepted gas price is 1.
|
|
5. Networking is disabled; there is no listen-address, the maximum number of peers is set
|
|
to 0, and discovery is disabled.
|
|
`)
|
|
|
|
case !ctx.IsSet(utils.NetworkIdFlag.Name):
|
|
log.Info("Starting Geth on Ethereum mainnet...")
|
|
}
|
|
// If we're a full node on mainnet without --cache specified, bump default cache allowance
|
|
if ctx.String(utils.SyncModeFlag.Name) != "light" && !ctx.IsSet(utils.CacheFlag.Name) && !ctx.IsSet(utils.NetworkIdFlag.Name) {
|
|
// Make sure we're not on any supported preconfigured testnet either
|
|
if !ctx.IsSet(utils.HoleskyFlag.Name) &&
|
|
!ctx.IsSet(utils.SepoliaFlag.Name) &&
|
|
!ctx.IsSet(utils.GoerliFlag.Name) &&
|
|
!ctx.IsSet(utils.DeveloperFlag.Name) {
|
|
// Nope, we're really on mainnet. Bump that cache up!
|
|
log.Info("Bumping default cache on mainnet", "provided", ctx.Int(utils.CacheFlag.Name), "updated", 4096)
|
|
ctx.Set(utils.CacheFlag.Name, strconv.Itoa(4096))
|
|
}
|
|
}
|
|
// If we're running a light client on any network, drop the cache to some meaningfully low amount
|
|
if ctx.String(utils.SyncModeFlag.Name) == "light" && !ctx.IsSet(utils.CacheFlag.Name) {
|
|
log.Info("Dropping default light client cache", "provided", ctx.Int(utils.CacheFlag.Name), "updated", 128)
|
|
ctx.Set(utils.CacheFlag.Name, strconv.Itoa(128))
|
|
}
|
|
|
|
// Start metrics export if enabled
|
|
utils.SetupMetrics(ctx)
|
|
|
|
// Start system runtime metrics collection
|
|
go metrics.CollectProcessMetrics(3 * time.Second)
|
|
}
|
|
|
|
// 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 {
|
|
//begin PluGeth code injection
|
|
var pluginsDir string
|
|
if ctx.IsSet(utils.PluginsDirFlag.Name) {
|
|
pluginsDir = ctx.String(utils.PluginsDirFlag.Name)
|
|
} else {
|
|
pluginsDir = filepath.Join(ctx.String(utils.DataDirFlag.Name), "plugins")
|
|
}
|
|
|
|
if err := plugins.Initialize(pluginsDir, ctx); err != nil {
|
|
return err
|
|
}
|
|
prepare(ctx)
|
|
if !plugins.ParseFlags(ctx.Args().Slice()) {
|
|
if args := ctx.Args().Slice(); len(args) > 0 {
|
|
return fmt.Errorf("invalid command: %q", args[0])
|
|
}
|
|
}
|
|
|
|
stack, backend := makeFullNode(ctx)
|
|
wrapperBackend := backendwrapper.NewBackend(backend)
|
|
|
|
pluginsInitializeNode(stack, wrapperBackend)
|
|
if ok, err := plugins.RunSubcommand(ctx); ok {
|
|
stack.Close()
|
|
return err
|
|
}
|
|
defer stack.Close()
|
|
defer pluginsOnShutdown()
|
|
stack.RegisterAPIs(pluginGetAPIs(stack, wrapperBackend))
|
|
startNode(ctx, stack, backend, false)
|
|
pluginBlockChain()
|
|
//end PluGeth code injection
|
|
stack.Wait()
|
|
return nil
|
|
}
|
|
|
|
// startNode boots up the system node and all registered protocols, after which
|
|
// it unlocks any requested accounts, and starts the RPC/IPC interfaces and the
|
|
// miner.
|
|
func startNode(ctx *cli.Context, stack *node.Node, backend ethapi.Backend, isConsole bool) {
|
|
debug.Memsize.Add("node", stack)
|
|
|
|
// Start up the node itself
|
|
utils.StartNode(ctx, stack, isConsole)
|
|
|
|
// Unlock any account specifically requested
|
|
unlockAccounts(ctx, stack)
|
|
|
|
// 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()
|
|
}
|
|
}
|
|
}()
|
|
}
|
|
|
|
// Start auxiliary services if enabled
|
|
if ctx.Bool(utils.MiningEnabledFlag.Name) {
|
|
// Mining only makes sense if a full Ethereum node is running
|
|
if ctx.String(utils.SyncModeFlag.Name) == "light" {
|
|
utils.Fatalf("Light clients do not support mining")
|
|
}
|
|
ethBackend, ok := backend.(*eth.EthAPIBackend)
|
|
if !ok {
|
|
utils.Fatalf("Ethereum service not running")
|
|
}
|
|
// Set the gas price to the limits from the CLI and start mining
|
|
gasprice := flags.GlobalBig(ctx, utils.MinerGasPriceFlag.Name)
|
|
ethBackend.TxPool().SetGasTip(gasprice)
|
|
if err := ethBackend.StartMining(); err != nil {
|
|
utils.Fatalf("Failed to start mining: %v", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// unlockAccounts unlocks any account specifically requested.
|
|
func unlockAccounts(ctx *cli.Context, stack *node.Node) {
|
|
var unlocks []string
|
|
inputs := strings.Split(ctx.String(utils.UnlockedAccountFlag.Name), ",")
|
|
for _, input := range inputs {
|
|
if trimmed := strings.TrimSpace(input); trimmed != "" {
|
|
unlocks = append(unlocks, trimmed)
|
|
}
|
|
}
|
|
// Short circuit if there is no account to unlock.
|
|
if len(unlocks) == 0 {
|
|
return
|
|
}
|
|
// If insecure account unlocking is not allowed if node's APIs are exposed to external.
|
|
// Print warning log to user and skip unlocking.
|
|
if !stack.Config().InsecureUnlockAllowed && stack.Config().ExtRPCEnabled() {
|
|
utils.Fatalf("Account unlock with HTTP access is forbidden!")
|
|
}
|
|
backends := stack.AccountManager().Backends(keystore.KeyStoreType)
|
|
if len(backends) == 0 {
|
|
log.Warn("Failed to unlock accounts, keystore is not available")
|
|
return
|
|
}
|
|
ks := backends[0].(*keystore.KeyStore)
|
|
passwords := utils.MakePasswordList(ctx)
|
|
for i, account := range unlocks {
|
|
unlockAccount(ks, account, i, passwords)
|
|
}
|
|
}
|