"github.com/vapor/asset"
"github.com/vapor/blockchain/pseudohsm"
"github.com/vapor/blockchain/txfeed"
+ "github.com/vapor/common"
cfg "github.com/vapor/config"
"github.com/vapor/consensus"
"github.com/vapor/crypto/ed25519/chainkd"
"github.com/vapor/database/leveldb"
"github.com/vapor/env"
- "github.com/vapor/mining/cpuminer"
- "github.com/vapor/mining/miningpool"
+ "github.com/vapor/mining/miner"
"github.com/vapor/net/websocket"
"github.com/vapor/netsync"
"github.com/vapor/protocol"
api *api.API
chain *protocol.Chain
txfeed *txfeed.Tracker
- cpuMiner *cpuminer.CPUMiner
- miningPool *miningpool.MiningPool
- miningEnable bool
+ //cpuMiner *cpuminer.CPUMiner
+ miner *miner.Miner
+
+ miningEnable bool
newBlockCh chan *bc.Hash
}
}
initLogFile(config)
initActiveNetParams(config)
+ initConsensusConfig(config)
initCommonConfig(config)
+
util.MainchainConfig = config.MainChain
util.ValidatePegin = config.ValidatePegin
// Get store
cmn.Exit(cmn.Fmt("Failed to create chain structure: %v", err))
}
+ switch config.Consensus.Type {
+ case "dpos":
+ initDpos(chain, config)
+ }
+
var accounts *account.Manager = nil
var assets *asset.Registry = nil
var wallet *w.Wallet = nil
}
if !config.Wallet.Disable {
+ address, err := common.DecodeAddress(config.Consensus.Coinbase, &consensus.ActiveNetParams)
+ if err != nil {
+ cmn.Exit(cmn.Fmt("DecodeAddress: %v", err))
+ }
walletDB := dbm.NewDB("wallet", config.DBBackend, config.DBDir())
accounts = account.NewManager(walletDB, chain)
assets = asset.NewRegistry(walletDB, chain)
- wallet, err = w.NewWallet(walletDB, accounts, assets, hsm, chain)
+ wallet, err = w.NewWallet(walletDB, accounts, assets, hsm, chain, address)
if err != nil {
log.WithField("error", err).Error("init NewWallet")
}
}
}()
}
-
node := &Node{
config: config,
syncManager: syncManager,
notificationMgr: notificationMgr,
}
- node.cpuMiner = cpuminer.NewCPUMiner(chain, accounts, txPool, newBlockCh)
- node.miningPool = miningpool.NewMiningPool(chain, accounts, txPool, newBlockCh)
-
+ node.miner = miner.NewMiner(chain, accounts, txPool, newBlockCh)
node.BaseService = *cmn.NewBaseService(nil, "Node", node)
return node
if !exist {
cmn.Exit(cmn.Fmt("chain_id[%v] don't exist", config.ChainID))
}
- var federationRedeemXPubs []chainkd.XPub
- if fedpegXPubs := strings.Split(config.Side.FedpegXPubs, ","); len(fedpegXPubs) > 0 {
+ if config.Side.FedpegXPubs != "" {
+ var federationRedeemXPubs []chainkd.XPub
+ fedpegXPubs := strings.Split(config.Side.FedpegXPubs, ",")
for _, xpubStr := range fedpegXPubs {
var xpub chainkd.XPub
xpub.UnmarshalText([]byte(xpubStr))
federationRedeemXPubs = append(federationRedeemXPubs, xpub)
}
- }
-
- var signBlockXPubs []chainkd.XPub
- if xPubs := strings.Split(config.Side.SignBlockXPubs, ","); len(xPubs) > 0 {
- for _, xpubStr := range xPubs {
- var xpub chainkd.XPub
- xpub.UnmarshalText([]byte(xpubStr))
- signBlockXPubs = append(signBlockXPubs, xpub)
- }
+ consensus.ActiveNetParams.FedpegXPubs = federationRedeemXPubs
}
consensus.ActiveNetParams.Signer = config.Signer
- consensus.ActiveNetParams.FedpegXPubs = federationRedeemXPubs
- consensus.ActiveNetParams.SignBlockXPubs = signBlockXPubs
consensus.ActiveNetParams.PeginMinDepth = config.Side.PeginMinDepth
consensus.ActiveNetParams.ParentGenesisBlockHash = config.Side.ParentGenesisBlockHash
}
}
func (n *Node) initAndstartApiServer() {
- n.api = api.NewAPI(n.syncManager, n.wallet, n.txfeed, n.cpuMiner, n.miningPool, n.chain, n.config, n.accessTokens, n.newBlockCh, n.notificationMgr)
+ n.api = api.NewAPI(n.syncManager, n.wallet, n.txfeed, n.miner, n.chain, n.config, n.accessTokens, n.newBlockCh, n.notificationMgr)
listenAddr := env.String("LISTEN", n.config.ApiAddress)
env.Parse()
n.miningEnable = false
log.Error(err)
} else {
- n.cpuMiner.Start()
+ //n.cpuMiner.Start()
+ n.miner.Start()
}
}
if !n.config.VaultMode {
}
func (n *Node) OnStop() {
+ if err := n.chain.Engine.Finish(); err != nil {
+ log.Errorf("OnStop: %v", err)
+ }
+
n.notificationMgr.Shutdown()
n.notificationMgr.WaitForShutdown()
n.BaseService.OnStop()
if n.miningEnable {
- n.cpuMiner.Stop()
+ n.miner.Stop()
}
if !n.config.VaultMode {
n.syncManager.Stop()
return n.syncManager
}
-func (n *Node) MiningPool() *miningpool.MiningPool {
- return n.miningPool
-}
-
/**bytomdRPCCheck Check if bytomd connection via RPC is correctly working*/
func bytomdRPCCheck() bool {
type Req struct {
}
if util.ValidatePegin {
for {
- resp, err := util.CallRPC("/get-block-header", &Req{BlockHeight: 0})
+ resp, err := util.CallRPC("/get-merkle-proof", &Req{BlockHeight: 0})
if err != nil {
log.Error("Call mainchain interface get-block-header failed")
time.Sleep(time.Millisecond * 1000)
json.Unmarshal(tmp, &blockHeader)
hash := blockHeader.BlockHeader.Hash()
if strings.Compare(consensus.ActiveNetParams.ParentGenesisBlockHash, hash.String()) != 0 {
- log.Error("Invalid parent genesis block hash response via RPC. Contacting wrong parent daemon?")
+ log.Error("Invalid parent genesis block hash response via RPC. Contacting wrong parent daemon?", consensus.ActiveNetParams.ParentGenesisBlockHash, ":", hash.String())
return false
}
break
return true
}
+
+func initConsensusConfig(config *cfg.Config) {
+ if config.ConsensusConfigFile == "" {
+ // poa
+ } else {
+ //
+ file, err := os.Open(config.ConsensusConfigFile)
+ if err != nil {
+ cmn.Exit(cmn.Fmt("Failed to read consensus file: %v", err))
+ }
+ defer file.Close()
+
+ if err := json.NewDecoder(file).Decode(config); err != nil {
+ cmn.Exit(cmn.Fmt("invalid consensus file: %v", err))
+ }
+
+ for _, v := range config.Consensus.SelfVoteSigners {
+ address, err := common.DecodeAddress(v, &consensus.ActiveNetParams)
+ if err != nil {
+ cmn.Exit(cmn.Fmt("Address resolution failed: %v", err))
+ }
+ config.Consensus.Signers = append(config.Consensus.Signers, address)
+ }
+ }
+}
+
+func initDpos(chain *protocol.Chain, config *cfg.Config) {
+ header := chain.BestBlockHeader()
+ height := header.Height
+ hash := header.Hash()
+ maxSignerCount := config.Consensus.MaxSignerCount
+ period := config.Consensus.Period
+ err := chain.Engine.Init(chain, maxSignerCount, period, height, hash)
+
+ if height > 0 {
+ oldBlockHeight := chain.Engine.GetOldBlockHeight()
+ oldBlockHash := chain.Engine.GetOldBlockHash()
+ if err != nil {
+ oldBlockHeight = 0
+ header, _ = chain.GetHeaderByHeight(oldBlockHeight)
+ oldBlockHash = header.Hash()
+ }
+
+ if err := chain.RepairDPoSData(oldBlockHeight, oldBlockHash); err != nil {
+ cmn.Exit(cmn.Fmt("initVote failed: %v", err))
+ }
+ }
+}