github.com/energicryptocurrency/go-energi@v1.1.7/mobile/geth.go (about) 1 // Copyright 2018 The Energi Core Authors 2 // Copyright 2016 The go-ethereum Authors 3 // This file is part of the Energi Core library. 4 // 5 // The Energi Core library is free software: you can redistribute it and/or modify 6 // it under the terms of the GNU Lesser General Public License as published by 7 // the Free Software Foundation, either version 3 of the License, or 8 // (at your option) any later version. 9 // 10 // The Energi Core library is distributed in the hope that it will be useful, 11 // but WITHOUT ANY WARRANTY; without even the implied warranty of 12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 // GNU Lesser General Public License for more details. 14 // 15 // You should have received a copy of the GNU Lesser General Public License 16 // along with the Energi Core library. If not, see <http://www.gnu.org/licenses/>. 17 18 // Contains all the wrappers from the node package to support client side node 19 // management on mobile platforms. 20 21 package geth 22 23 import ( 24 "encoding/json" 25 "fmt" 26 "path/filepath" 27 28 "github.com/energicryptocurrency/go-energi/core" 29 "github.com/energicryptocurrency/go-energi/eth" 30 "github.com/energicryptocurrency/go-energi/eth/downloader" 31 "github.com/energicryptocurrency/go-energi/ethclient" 32 "github.com/energicryptocurrency/go-energi/ethstats" 33 "github.com/energicryptocurrency/go-energi/internal/debug" 34 "github.com/energicryptocurrency/go-energi/les" 35 "github.com/energicryptocurrency/go-energi/node" 36 "github.com/energicryptocurrency/go-energi/p2p" 37 "github.com/energicryptocurrency/go-energi/p2p/nat" 38 "github.com/energicryptocurrency/go-energi/params" 39 whisper "github.com/energicryptocurrency/go-energi/whisper/whisperv6" 40 ) 41 42 // NodeConfig represents the collection of configuration values to fine tune the Geth 43 // node embedded into a mobile process. The available values are a subset of the 44 // entire API provided by go-ethereum to reduce the maintenance surface and dev 45 // complexity. 46 type NodeConfig struct { 47 // Bootstrap nodes used to establish connectivity with the rest of the network. 48 BootstrapNodes *Enodes 49 50 // MaxPeers is the maximum number of peers that can be connected. If this is 51 // set to zero, then only the configured static and trusted peers can connect. 52 MaxPeers int 53 54 // EthereumEnabled specifies whether the node should run the Ethereum protocol. 55 EthereumEnabled bool 56 57 // EthereumNetworkID is the network identifier used by the Ethereum protocol to 58 // decide if remote peers should be accepted or not. 59 EthereumNetworkID int64 // uint64 in truth, but Java can't handle that... 60 61 // EthereumGenesis is the genesis JSON to use to seed the blockchain with. An 62 // empty genesis state is equivalent to using the mainnet's state. 63 EthereumGenesis string 64 65 // EthereumDatabaseCache is the system memory in MB to allocate for database caching. 66 // A minimum of 16MB is always reserved. 67 EthereumDatabaseCache int 68 69 // EthereumNetStats is a netstats connection string to use to report various 70 // chain, transaction and node stats to a monitoring server. 71 // 72 // It has the form "nodename:secret@host:port" 73 EthereumNetStats string 74 75 // WhisperEnabled specifies whether the node should run the Whisper protocol. 76 WhisperEnabled bool 77 78 // Listening address of pprof server. 79 PprofAddress string 80 } 81 82 // defaultNodeConfig contains the default node configuration values to use if all 83 // or some fields are missing from the user's specified list. 84 var defaultNodeConfig = &NodeConfig{ 85 BootstrapNodes: FoundationBootnodes(), 86 MaxPeers: 25, 87 EthereumEnabled: true, 88 EthereumNetworkID: 39797, 89 EthereumDatabaseCache: 16, 90 } 91 92 // NewNodeConfig creates a new node option set, initialized to the default values. 93 func NewNodeConfig() *NodeConfig { 94 config := *defaultNodeConfig 95 return &config 96 } 97 98 // Node represents a Geth Ethereum node instance. 99 type Node struct { 100 node *node.Node 101 } 102 103 // NewNode creates and configures a new Geth node. 104 func NewNode(datadir string, config *NodeConfig) (stack *Node, _ error) { 105 // If no or partial configurations were specified, use defaults 106 if config == nil { 107 config = NewNodeConfig() 108 } 109 if config.MaxPeers == 0 { 110 config.MaxPeers = defaultNodeConfig.MaxPeers 111 } 112 if config.BootstrapNodes == nil || config.BootstrapNodes.Size() == 0 { 113 config.BootstrapNodes = defaultNodeConfig.BootstrapNodes 114 } 115 116 if config.PprofAddress != "" { 117 debug.StartPProf(config.PprofAddress) 118 } 119 120 // Create the empty networking stack 121 nodeConf := &node.Config{ 122 Name: clientIdentifier, 123 Version: params.VersionWithMeta, 124 DataDir: datadir, 125 KeyStoreDir: filepath.Join(datadir, "keystore"), // Mobile should never use internal keystores! 126 P2P: p2p.Config{ 127 NoDiscovery: true, 128 DiscoveryV5: true, 129 BootstrapNodesV5: config.BootstrapNodes.nodes, 130 ListenAddr: ":0", 131 NAT: nat.Any(), 132 MaxPeers: config.MaxPeers, 133 }, 134 } 135 rawStack, err := node.New(nodeConf) 136 if err != nil { 137 return nil, err 138 } 139 140 debug.Memsize.Add("node", rawStack) 141 142 var genesis *core.Genesis 143 if config.EthereumGenesis != "" { 144 // Parse the user supplied genesis spec if not mainnet 145 genesis = new(core.Genesis) 146 if err := json.Unmarshal([]byte(config.EthereumGenesis), genesis); err != nil { 147 return nil, fmt.Errorf("invalid genesis spec: %v", err) 148 } 149 // If we have the testnet, hard code the chain configs too 150 if config.EthereumGenesis == TestnetGenesis() { 151 genesis.Config = params.TestnetChainConfig 152 if config.EthereumNetworkID == 1 { 153 config.EthereumNetworkID = 3 154 } 155 } 156 } 157 // Register the Ethereum protocol if requested 158 if config.EthereumEnabled { 159 ethConf := eth.DefaultConfig 160 ethConf.Genesis = genesis 161 ethConf.SyncMode = downloader.LightSync 162 ethConf.NetworkId = uint64(config.EthereumNetworkID) 163 ethConf.DatabaseCache = config.EthereumDatabaseCache 164 if err := rawStack.Register(func(ctx *node.ServiceContext) (node.Service, error) { 165 return les.New(ctx, ðConf) 166 }); err != nil { 167 return nil, fmt.Errorf("ethereum init: %v", err) 168 } 169 // If netstats reporting is requested, do it 170 if config.EthereumNetStats != "" { 171 if err := rawStack.Register(func(ctx *node.ServiceContext) (node.Service, error) { 172 var lesServ *les.LightEthereum 173 ctx.Service(&lesServ) 174 175 return ethstats.New(config.EthereumNetStats, nil, lesServ) 176 }); err != nil { 177 return nil, fmt.Errorf("netstats init: %v", err) 178 } 179 } 180 } 181 // Register the Whisper protocol if requested 182 if config.WhisperEnabled { 183 if err := rawStack.Register(func(*node.ServiceContext) (node.Service, error) { 184 return whisper.New(&whisper.DefaultConfig), nil 185 }); err != nil { 186 return nil, fmt.Errorf("whisper init: %v", err) 187 } 188 } 189 return &Node{rawStack}, nil 190 } 191 192 // Start creates a live P2P node and starts running it. 193 func (n *Node) Start() error { 194 return n.node.Start() 195 } 196 197 // Stop terminates a running node along with all it's services. If the node was 198 // not started, an error is returned. 199 func (n *Node) Stop() error { 200 return n.node.Stop() 201 } 202 203 // GetEthereumClient retrieves a client to access the Ethereum subsystem. 204 func (n *Node) GetEthereumClient() (client *EthereumClient, _ error) { 205 rpc, err := n.node.Attach() 206 if err != nil { 207 return nil, err 208 } 209 return &EthereumClient{ethclient.NewClient(rpc)}, nil 210 } 211 212 // GetNodeInfo gathers and returns a collection of metadata known about the host. 213 func (n *Node) GetNodeInfo() *NodeInfo { 214 return &NodeInfo{n.node.Server().NodeInfo()} 215 } 216 217 // GetPeersInfo returns an array of metadata objects describing connected peers. 218 func (n *Node) GetPeersInfo() *PeerInfos { 219 return &PeerInfos{n.node.Server().PeersInfo()} 220 }