func main() {
logger.AddLogSystem(logger.NewStdLogSystem(os.Stdout, log.LstdFlags, logger.InfoLevel))
// Generate the peer identity
key, err := crypto.GenerateKey()
if err != nil {
fmt.Printf("Failed to generate peer key: %v.\n", err)
os.Exit(-1)
}
name := common.MakeName("whisper-go", "1.0")
shh := whisper.New()
// Create an Ethereum peer to communicate through
server := p2p.Server{
PrivateKey: key,
MaxPeers: 10,
Name: name,
Protocols: []p2p.Protocol{shh.Protocol()},
ListenAddr: ":30300",
NAT: nat.Any(),
}
fmt.Println("Starting Ethereum peer...")
if err := server.Start(); err != nil {
fmt.Printf("Failed to start Ethereum peer: %v.\n", err)
os.Exit(1)
}
// Send a message to self to check that something works
payload := fmt.Sprintf("Hello world, this is %v. In case you're wondering, the time is %v", name, time.Now())
if err := selfSend(shh, []byte(payload)); err != nil {
fmt.Printf("Failed to self message: %v.\n", err)
os.Exit(-1)
}
}
// New creates a Ethereum client, pre-configured to one of the supported networks.
func New(datadir string, network EthereumNetwork) (*Geth, error) {
// Tag the data dir with the network name
switch network {
case MainNet:
datadir = filepath.Join(datadir, "mainnet")
case TestNet:
datadir = filepath.Join(datadir, "testnet")
default:
return nil, fmt.Errorf("unsupported network: %v", network)
}
// Select the bootstrap nodes based on the network
bootnodes := utils.FrontierBootNodes
if network == TestNet {
bootnodes = utils.TestNetBootNodes
}
// Configure the node's service container
stackConf := &node.Config{
DataDir: datadir,
Name: common.MakeName(NodeName, NodeVersion),
BootstrapNodes: bootnodes,
ListenAddr: fmt.Sprintf(":%d", NodePort),
MaxPeers: NodeMaxPeers,
}
// Configure the bare-bone Ethereum service
keystore := crypto.NewKeyStorePassphrase(filepath.Join(datadir, "keystore"), crypto.StandardScryptN, crypto.StandardScryptP)
ethConf := ð.Config{
FastSync: true,
DatabaseCache: 64,
NetworkId: int(network),
AccountManager: accounts.NewManager(keystore),
// Blatantly initialize the gas oracle to the defaults from go-ethereum
GpoMinGasPrice: new(big.Int).Mul(big.NewInt(50), common.Shannon),
GpoMaxGasPrice: new(big.Int).Mul(big.NewInt(500), common.Shannon),
GpoFullBlockRatio: 80,
GpobaseStepDown: 10,
GpobaseStepUp: 100,
GpobaseCorrectionFactor: 110,
}
// Override any default configs in the test network
if network == TestNet {
ethConf.NetworkId = 2
ethConf.Genesis = core.TestNetGenesisBlock()
state.StartingNonce = 1048576 // (2**20)
}
// Assemble and return the protocol stack
stack, err := node.New(stackConf)
if err != nil {
return nil, fmt.Errorf("protocol stack: %v", err)
}
if err := stack.Register(func(ctx *node.ServiceContext) (node.Service, error) { return eth.New(ctx, ethConf) }); err != nil {
return nil, fmt.Errorf("ethereum service: %v", err)
}
return &Geth{
stack: stack,
keystore: keystore,
}, nil
}
// MakeNodeName creates a node name from a base set and the command line flags.
func MakeNodeName(client, version string, ctx *cli.Context) string {
name := common.MakeName(client, version)
if identity := ctx.GlobalString(IdentityFlag.Name); len(identity) > 0 {
name += "/" + identity
}
if ctx.GlobalBool(VMEnableJitFlag.Name) {
name += "/JIT"
}
return name
}