diff options
19 files changed, 481 insertions, 88 deletions
diff --git a/cmd/gdex/dao_test.go b/cmd/gdex/dao_test.go index 22f82d4f4..648460b1d 100644 --- a/cmd/gdex/dao_test.go +++ b/cmd/gdex/dao_test.go @@ -127,7 +127,7 @@ func testDAOForkBlockNewChain(t *testing.T, test int, genesis string, expectBloc } defer db.Close() - genesisHash := common.HexToHash("0x5fc1fdb2eca492d256600c0d96a2ca7bdfd9412ac8557bcab54e05332260e26b") + genesisHash := common.HexToHash("0x48fd77589c2a011fdc764237b9f071577799b7dcc618f25a74fca05dc0b1ad2e") if genesis != "" { genesisHash = daoGenesisHash } diff --git a/core/governance.go b/core/governance.go index ea0036a0e..45594fb64 100644 --- a/core/governance.go +++ b/core/governance.go @@ -121,6 +121,14 @@ func (g *Governance) DKGMasterPublicKeys(round uint64) []*dkgTypes.MasterPublicK return headHelper.UniqueDKGMasterPublicKeys(big.NewInt(int64(round))) } +func (g *Governance) IsDKGMPKReady(round uint64) bool { + headHelper := g.GetHeadHelper() + config := g.Configuration(round) + threshold := 2*uint64(config.DKGSetSize)/3 + 1 + count := headHelper.DKGMPKReadysCount(big.NewInt(int64(round))).Uint64() + return count >= threshold +} + func (g *Governance) IsDKGFinal(round uint64) bool { headHelper := g.GetHeadHelper() config := g.Configuration(round) diff --git a/core/vm/governance.go b/core/vm/governance.go index 07f0a5479..597399dd5 100644 --- a/core/vm/governance.go +++ b/core/vm/governance.go @@ -241,6 +241,48 @@ const GovernanceABIJSON = ` "inputs": [ { "name": "", + "type": "uint256" + } + ], + "name": "dkgMPKReadysCount", + "outputs": [ + { + "name": "", + "type": "uint256" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": true, + "inputs": [ + { + "name": "", + "type": "uint256" + }, + { + "name": "", + "type": "address" + } + ], + "name": "dkgMPKReadys", + "outputs": [ + { + "name": "", + "type": "bool" + } + ], + "payable": false, + "stateMutability": "view", + "type": "function" + }, + { + "constant": true, + "inputs": [ + { + "name": "", "type": "address" }, { @@ -757,6 +799,24 @@ const GovernanceABIJSON = ` "type": "uint256" }, { + "name": "MPKReady", + "type": "bytes" + } + ], + "name": "addDKGMPKReady", + "outputs": [], + "payable": false, + "stateMutability": "nonpayable", + "type": "function" + }, + { + "constant": false, + "inputs": [ + { + "name": "Round", + "type": "uint256" + }, + { "name": "Finalize", "type": "bytes" } @@ -917,6 +977,15 @@ func RunGovernanceContract(evm *EVM, input []byte, contract *Contract) (ret []by return nil, errExecutionReverted } return g.addDKGMasterPublicKey(args.Round, args.PublicKey) + case "addDKGMPKReady": + args := struct { + Round *big.Int + MPKReady []byte + }{} + if err := method.Inputs.Unpack(&args, arguments); err != nil { + return nil, errExecutionReverted + } + return g.addDKGMPKReady(args.Round, args.MPKReady) case "addDKGFinalize": args := struct { Round *big.Int @@ -1070,6 +1139,30 @@ func RunGovernanceContract(evm *EVM, input []byte, contract *Contract) (ret []by return nil, errExecutionReverted } return res, nil + case "dkgReadys": + round, addr := new(big.Int), common.Address{} + args := []interface{}{&round, &addr} + if err := method.Inputs.Unpack(&args, arguments); err != nil { + return nil, errExecutionReverted + } + ready := g.state.DKGMPKReady(round, addr) + res, err := method.Outputs.Pack(ready) + if err != nil { + return nil, errExecutionReverted + } + return res, nil + case "dkgReadysCount": + round := new(big.Int) + if err := method.Inputs.Unpack(&round, arguments); err != nil { + return nil, errExecutionReverted + } + count := g.state.DKGMPKReadysCount(round) + res, err := method.Outputs.Pack(count) + if err != nil { + return nil, errExecutionReverted + } + return res, nil + case "dkgFinalizeds": round, addr := new(big.Int), common.Address{} args := []interface{}{&round, &addr} @@ -1228,6 +1321,8 @@ const ( crsLoc dkgMasterPublicKeysLoc dkgComplaintsLoc + dkgReadyLoc + dkgReadysCountLoc dkgFinalizedLoc dkgFinalizedsCountLoc ownerLoc @@ -1716,6 +1811,33 @@ func (s *GovernanceStateHelper) PushDKGComplaint(round *big.Int, complaint []byt s.appendTo2DByteArray(big.NewInt(dkgComplaintsLoc), round, complaint) } +// mapping(address => bool)[] public dkgReady; +func (s *GovernanceStateHelper) DKGMPKReady(round *big.Int, addr common.Address) bool { + baseLoc := new(big.Int).Add(s.getSlotLoc(big.NewInt(dkgReadyLoc)), round) + mapLoc := s.getMapLoc(baseLoc, addr.Bytes()) + return s.getStateBigInt(mapLoc).Cmp(big.NewInt(0)) != 0 +} +func (s *GovernanceStateHelper) PutDKGMPKReady(round *big.Int, addr common.Address, ready bool) { + baseLoc := new(big.Int).Add(s.getSlotLoc(big.NewInt(dkgReadyLoc)), round) + mapLoc := s.getMapLoc(baseLoc, addr.Bytes()) + res := big.NewInt(0) + if ready { + res = big.NewInt(1) + } + s.setStateBigInt(mapLoc, res) +} + +// uint256[] public dkgReadysCount; +func (s *GovernanceStateHelper) DKGMPKReadysCount(round *big.Int) *big.Int { + loc := new(big.Int).Add(s.getSlotLoc(big.NewInt(dkgReadysCountLoc)), round) + return s.getStateBigInt(loc) +} +func (s *GovernanceStateHelper) IncDKGMPKReadysCount(round *big.Int) { + loc := new(big.Int).Add(s.getSlotLoc(big.NewInt(dkgReadysCountLoc)), round) + count := s.getStateBigInt(loc) + s.setStateBigInt(loc, new(big.Int).Add(count, big.NewInt(1))) +} + // mapping(address => bool)[] public dkgFinalized; func (s *GovernanceStateHelper) DKGFinalized(round *big.Int, addr common.Address) bool { baseLoc := new(big.Int).Add(s.getSlotLoc(big.NewInt(dkgFinalizedLoc)), round) @@ -2087,6 +2209,21 @@ func (g *GovernanceContract) addDKGMasterPublicKey(round *big.Int, mpk []byte) ( return nil, errExecutionReverted } + // MPKReady caller is not allowed to propose mpk. + if g.state.DKGMPKReady(round, caller) { + return g.penalize() + } + + // Calculate 2f + threshold := new(big.Int).Mul( + big.NewInt(2), + new(big.Int).Div(g.state.DKGSetSize(), big.NewInt(3))) + + // If 2f + 1 of DKG set is mpk ready, one can not propose mpk anymore. + if g.state.DKGMPKReadysCount(round).Cmp(threshold) > 0 { + return nil, errExecutionReverted + } + var dkgMasterPK dkgTypes.MasterPublicKey if err := rlp.DecodeBytes(mpk, &dkgMasterPK); err != nil { return g.penalize() @@ -2107,6 +2244,35 @@ func (g *GovernanceContract) addDKGMasterPublicKey(round *big.Int, mpk []byte) ( return g.useGas(100000) } +func (g *GovernanceContract) addDKGMPKReady(round *big.Int, ready []byte) ([]byte, error) { + if round.Cmp(g.state.Round()) != 0 { + return g.penalize() + } + + caller := g.contract.Caller() + + var dkgReady dkgTypes.MPKReady + if err := rlp.DecodeBytes(ready, &dkgReady); err != nil { + return g.penalize() + } + + // DKGFInalize must belongs to someone in DKG set. + if !g.inDKGSet(round, dkgReady.ProposerID) { + return g.penalize() + } + + verified, _ := core.VerifyDKGMPKReadySignature(&dkgReady) + if !verified { + return g.penalize() + } + + if !g.state.DKGMPKReady(round, caller) { + g.state.PutDKGMPKReady(round, caller, true) + g.state.IncDKGMPKReadysCount(round) + } + + return g.useGas(100000) +} func (g *GovernanceContract) addDKGFinalize(round *big.Int, finalize []byte) ([]byte, error) { if round.Cmp(g.state.Round()) != 0 { return g.penalize() diff --git a/dex/governance.go b/dex/governance.go index aeb6d3fb0..bcc2cca51 100644 --- a/dex/governance.go +++ b/dex/governance.go @@ -1,3 +1,20 @@ +// Copyright 2018 The dexon-consensus Authors +// This file is part of the dexon-consensus library. +// +// The dexon-consensus library is free software: you can redistribute it +// and/or modify it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the License, +// or (at your option) any later version. +// +// The dexon-consensus library 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 Lesser +// General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the dexon-consensus library. If not, see +// <http://www.gnu.org/licenses/>. + package dex import ( @@ -195,6 +212,29 @@ func (d *DexconGovernance) AddDKGMasterPublicKey(round uint64, masterPublicKey * } } +// AddDKGMPKReady adds a DKG mpk ready message. +func (d *DexconGovernance) AddDKGMPKReady(round uint64, ready *dkgTypes.MPKReady) { + method := vm.GovernanceContractName2Method["addDKGMPKReady"] + + encoded, err := rlp.EncodeToBytes(ready) + if err != nil { + log.Error("failed to RLP encode mpk ready to bytes", "err", err) + return + } + + res, err := method.Inputs.Pack(big.NewInt(int64(round)), encoded) + if err != nil { + log.Error("failed to pack addDKGMPKReady input", "err", err) + return + } + + data := append(method.Id(), res...) + err = d.sendGovTx(context.Background(), data) + if err != nil { + log.Error("failed to send addDKGMPKReady tx", "err", err) + } +} + // AddDKGFinalize adds a DKG finalize message. func (d *DexconGovernance) AddDKGFinalize(round uint64, final *dkgTypes.Finalize) { method := vm.GovernanceContractName2Method["addDKGFinalize"] diff --git a/params/config.go b/params/config.go index 5bedf9772..5e528dda4 100644 --- a/params/config.go +++ b/params/config.go @@ -26,8 +26,8 @@ import ( // Genesis hashes to enforce below configs on. var ( - MainnetGenesisHash = common.HexToHash("0x5fc1fdb2eca492d256600c0d96a2ca7bdfd9412ac8557bcab54e05332260e26b") - TestnetGenesisHash = common.HexToHash("0x252c41c125e4a9137a39a20b810ddcd33a8023c407cac863ad2326a521375d0f") + MainnetGenesisHash = common.HexToHash("0x48fd77589c2a011fdc764237b9f071577799b7dcc618f25a74fca05dc0b1ad2e") + TestnetGenesisHash = common.HexToHash("0x3d5427dc4d3674194d217307ae4db88886a826b6343b6b903efe0b446317ee15") ) var ( diff --git a/vendor/github.com/dexon-foundation/dexon-consensus/core/agreement-mgr.go b/vendor/github.com/dexon-foundation/dexon-consensus/core/agreement-mgr.go index 4cb47b105..fb6536463 100644 --- a/vendor/github.com/dexon-foundation/dexon-consensus/core/agreement-mgr.go +++ b/vendor/github.com/dexon-foundation/dexon-consensus/core/agreement-mgr.go @@ -248,9 +248,10 @@ func (mgr *agreementMgr) processAgreementResult( "hash", result.BlockHash) mgr.network.PullBlocks(common.Hashes{result.BlockHash}) mgr.logger.Debug("Calling Governance.CRS", "round", result.Position.Round) - crs := mgr.gov.CRS(result.Position.Round) + crs := utils.GetCRSWithPanic(mgr.gov, result.Position.Round, mgr.logger) nIDs := nodes.GetSubSet( - int(mgr.gov.Configuration(result.Position.Round).NotarySetSize), + int(utils.GetConfigWithPanic( + mgr.gov, result.Position.Round, mgr.logger).NotarySetSize), types.NewNotarySetTarget(crs, result.Position.ChainID)) for key := range result.Votes { if err := agreement.processVote(&result.Votes[key]); err != nil { diff --git a/vendor/github.com/dexon-foundation/dexon-consensus/core/authenticator.go b/vendor/github.com/dexon-foundation/dexon-consensus/core/authenticator.go index 5d176cfee..8e57f719f 100644 --- a/vendor/github.com/dexon-foundation/dexon-consensus/core/authenticator.go +++ b/vendor/github.com/dexon-foundation/dexon-consensus/core/authenticator.go @@ -103,6 +103,14 @@ func (au *Authenticator) SignDKGPartialSignature( return } +// SignDKGMPKReady signs a DKG ready message. +func (au *Authenticator) SignDKGMPKReady( + ready *typesDKG.MPKReady) (err error) { + ready.ProposerID = au.proposerID + ready.Signature, err = au.prvKey.Sign(hashDKGMPKReady(ready)) + return +} + // SignDKGFinalize signs a DKG finalize message. func (au *Authenticator) SignDKGFinalize( final *typesDKG.Finalize) (err error) { diff --git a/vendor/github.com/dexon-foundation/dexon-consensus/core/compaction-chain.go b/vendor/github.com/dexon-foundation/dexon-consensus/core/compaction-chain.go index dcd99f497..14e3b265d 100644 --- a/vendor/github.com/dexon-foundation/dexon-consensus/core/compaction-chain.go +++ b/vendor/github.com/dexon-foundation/dexon-consensus/core/compaction-chain.go @@ -25,6 +25,7 @@ import ( "github.com/dexon-foundation/dexon-consensus/common" "github.com/dexon-foundation/dexon-consensus/core/crypto" "github.com/dexon-foundation/dexon-consensus/core/types" + "github.com/dexon-foundation/dexon-consensus/core/utils" ) // Errors for compaction chain module. @@ -80,7 +81,7 @@ func (cc *compactionChain) init(initBlock *types.Block) { // It's the bootstrap case, compactionChain would only deliver blocks until // tips of all chains are received. if initBlock.Finalization.Height == 0 { - cc.chainUnsynced = cc.gov.Configuration(uint64(0)).NumChains + cc.chainUnsynced = utils.GetConfigWithPanic(cc.gov, 0, nil).NumChains } } @@ -124,8 +125,6 @@ func (cc *compactionChain) processBlock(block *types.Block) error { } func (cc *compactionChain) extractBlocks() []*types.Block { - prevBlock := cc.lastDeliveredBlock() - // Check if we're synced. if !func() bool { cc.lock.RLock() @@ -134,7 +133,7 @@ func (cc *compactionChain) extractBlocks() []*types.Block { return false } // Finalization.Height == 0 is syncing from bootstrap. - if prevBlock.Finalization.Height == 0 { + if cc.prevBlock.Finalization.Height == 0 { return cc.chainUnsynced == 0 } return true @@ -144,7 +143,10 @@ func (cc *compactionChain) extractBlocks() []*types.Block { deliveringBlocks := make([]*types.Block, 0) cc.lock.Lock() defer cc.lock.Unlock() - var block *types.Block + var ( + block *types.Block + prevBlock = cc.prevBlock + ) for len(cc.pendingBlocks) > 0 && (len(cc.blockRandomness[cc.pendingBlocks[0].Hash]) != 0 || cc.pendingBlocks[0].Position.Round == 0) { diff --git a/vendor/github.com/dexon-foundation/dexon-consensus/core/configuration-chain.go b/vendor/github.com/dexon-foundation/dexon-consensus/core/configuration-chain.go index 2b3a859ed..d341cb524 100644 --- a/vendor/github.com/dexon-foundation/dexon-consensus/core/configuration-chain.go +++ b/vendor/github.com/dexon-foundation/dexon-consensus/core/configuration-chain.go @@ -105,6 +105,13 @@ func (cc *configurationChain) registerDKG(round uint64, threshold int) { cc.recv, round, threshold) + go func() { + ticker := newTicker(cc.gov, round, TickerDKG) + <-ticker.Tick() + cc.dkgLock.Lock() + defer cc.dkgLock.Unlock() + cc.dkg.proposeMPKReady() + }() } func (cc *configurationChain) runDKG(round uint64) error { @@ -126,13 +133,34 @@ func (cc *configurationChain) runDKG(round uint64) error { cc.logger.Warn("DKG already final", "round", round) return nil } + cc.logger.Debug("Calling Governance.IsDKGMPKReady", "round", round) + for !cc.gov.IsDKGMPKReady(round) { + cc.logger.Info("DKG MPKs are not ready yet. Try again later...", + "nodeID", cc.ID) + cc.dkgLock.Unlock() + time.Sleep(500 * time.Millisecond) + cc.dkgLock.Lock() + } ticker := newTicker(cc.gov, round, TickerDKG) cc.dkgLock.Unlock() <-ticker.Tick() cc.dkgLock.Lock() - // Phase 2(T = 0): Exchange DKG secret key share. + // Check if this node successfully join the protocol. cc.logger.Debug("Calling Governance.DKGMasterPublicKeys", "round", round) - cc.dkg.processMasterPublicKeys(cc.gov.DKGMasterPublicKeys(round)) + mpks := cc.gov.DKGMasterPublicKeys(round) + inProtocol := false + for _, mpk := range mpks { + if mpk.ProposerID == cc.ID { + inProtocol = true + break + } + } + if !inProtocol { + cc.logger.Warn("Failed to join DKG protocol", "round", round) + return nil + } + // Phase 2(T = 0): Exchange DKG secret key share. + cc.dkg.processMasterPublicKeys(mpks) cc.mpkReady = true for _, prvShare := range cc.pendingPrvShare { if err := cc.dkg.processPrivateShare(prvShare); err != nil { @@ -219,7 +247,7 @@ func (cc *configurationChain) runDKG(round uint64) error { return nil } -func (cc *configurationChain) isDKGReady(round uint64) bool { +func (cc *configurationChain) isDKGFinal(round uint64) bool { if !cc.gov.IsDKGFinal(round) { return false } @@ -261,7 +289,8 @@ func (cc *configurationChain) recoverDKGInfo(round uint64) error { return ErrDKGNotReady } - threshold := getDKGThreshold(cc.gov.Configuration(round)) + threshold := getDKGThreshold( + utils.GetConfigWithPanic(cc.gov, round, cc.logger)) // Restore group public key. gpk, err := NewDKGGroupPublicKey(round, cc.gov.DKGMasterPublicKeys(round), diff --git a/vendor/github.com/dexon-foundation/dexon-consensus/core/consensus.go b/vendor/github.com/dexon-foundation/dexon-consensus/core/consensus.go index 5beaf546a..e45e4be5a 100644 --- a/vendor/github.com/dexon-foundation/dexon-consensus/core/consensus.go +++ b/vendor/github.com/dexon-foundation/dexon-consensus/core/consensus.go @@ -329,6 +329,16 @@ func (recv *consensusDKGReceiver) ProposeDKGAntiNackComplaint( recv.network.BroadcastDKGPrivateShare(prv) } +// ProposeDKGMPKReady propose a DKGMPKReady message. +func (recv *consensusDKGReceiver) ProposeDKGMPKReady(ready *typesDKG.MPKReady) { + if err := recv.authModule.SignDKGMPKReady(ready); err != nil { + recv.logger.Error("Failed to sign DKG ready", "error", err) + return + } + recv.logger.Debug("Calling Governance.AddDKGMPKReady", "ready", ready) + recv.gov.AddDKGMPKReady(ready.Round, ready) +} + // ProposeDKGFinalize propose a DKGFinalize message. func (recv *consensusDKGReceiver) ProposeDKGFinalize(final *typesDKG.Finalize) { if err := recv.authModule.SignDKGFinalize(final); err != nil { @@ -400,12 +410,7 @@ func NewConsensus( } // Get configuration for genesis round. var round uint64 - logger.Debug("Calling Governance.Configuration", "round", round) - config := gov.Configuration(round) - if config == nil { - logger.Error("Unable to get configuration", "round", round) - return nil - } + config := utils.GetConfigWithPanic(gov, round, logger) // Init lattice. lattice := NewLattice( dMoment, round, config, authModule, app, debugApp, db, logger) @@ -494,12 +499,17 @@ func NewConsensusFromSyncer( db, logger) recv.cfgModule = cfgModule + // Check if the application implement Debug interface. + var debugApp Debug + if a, ok := app.(Debug); ok { + debugApp = a + } // Setup Consensus instance. con := &Consensus{ ID: ID, ccModule: newCompactionChain(gov), lattice: latticeModule, - app: app, + app: newNonBlocking(app, debugApp), gov: gov, db: db, network: networkModule, @@ -545,29 +555,19 @@ func (con *Consensus) prepare(initBlock *types.Block) error { // full node. We don't have to notify it. con.roundToNotify = initBlock.Position.Round + 1 initRound := initBlock.Position.Round - con.logger.Debug("Calling Governance.Configuration", "round", initRound) - initConfig := con.gov.Configuration(initRound) + initConfig := utils.GetConfigWithPanic(con.gov, initRound, con.logger) // Setup context. con.ccModule.init(initBlock) - // Setup agreementMgr module. - con.logger.Debug("Calling Governance.Configuration", "round", initRound) - initCfg := con.gov.Configuration(initRound) - if initCfg == nil { - return ErrConfigurationNotReady - } con.logger.Debug("Calling Governance.CRS", "round", initRound) initCRS := con.gov.CRS(initRound) if (initCRS == common.Hash{}) { return ErrCRSNotReady } - if err := con.baMgr.appendConfig(initRound, initCfg, initCRS); err != nil { + if err := con.baMgr.appendConfig(initRound, initConfig, initCRS); err != nil { return err } // Setup lattice module. - initPlusOneCfg := con.gov.Configuration(initRound + 1) - if initPlusOneCfg == nil { - return ErrConfigurationNotReady - } + initPlusOneCfg := utils.GetConfigWithPanic(con.gov, initRound+1, con.logger) if err := con.lattice.AppendConfig(initRound+1, initPlusOneCfg); err != nil { return err } @@ -576,6 +576,7 @@ func (con *Consensus) prepare(initBlock *types.Block) error { if err != nil { return err } + // TODO(jimmy): registerDKG should be called after dmoment. if _, exist := dkgSet[con.ID]; exist { con.logger.Info("Selected as DKG set", "round", initRound) con.cfgModule.registerDKG(initRound, getDKGThreshold(initConfig)) @@ -641,7 +642,7 @@ func (con *Consensus) runCRS(round uint64) { } con.logger.Debug("Calling Governance.IsDKGFinal to check if ready to run CRS", "round", round) - if con.cfgModule.isDKGReady(round) { + if con.cfgModule.isDKGFinal(round) { break } con.logger.Debug("DKG is not ready for running CRS. Retry later...", @@ -650,7 +651,8 @@ func (con *Consensus) runCRS(round uint64) { } // Start running next round CRS. con.logger.Debug("Calling Governance.CRS", "round", round) - psig, err := con.cfgModule.preparePartialSignature(round, con.gov.CRS(round)) + psig, err := con.cfgModule.preparePartialSignature( + round, utils.GetCRSWithPanic(con.gov, round, con.logger)) if err != nil { con.logger.Error("Failed to prepare partial signature", "error", err) } else if err = con.authModule.SignDKGPartialSignature(psig); err != nil { @@ -664,7 +666,8 @@ func (con *Consensus) runCRS(round uint64) { "hash", psig.Hash) con.network.BroadcastDKGPartialSignature(psig) con.logger.Debug("Calling Governance.CRS", "round", round) - crs, err := con.cfgModule.runCRSTSig(round, con.gov.CRS(round)) + crs, err := con.cfgModule.runCRSTSig( + round, utils.GetCRSWithPanic(con.gov, round, con.logger)) if err != nil { con.logger.Error("Failed to run CRS Tsig", "error", err) } else { @@ -709,12 +712,11 @@ func (con *Consensus) initialRound( time.Sleep(500 * time.Millisecond) } // Notify BA for new round. - con.logger.Debug("Calling Governance.Configuration", - "round", nextRound) - nextConfig := con.gov.Configuration(nextRound) + nextConfig := utils.GetConfigWithPanic( + con.gov, nextRound, con.logger) con.logger.Debug("Calling Governance.CRS", "round", nextRound) - nextCRS := con.gov.CRS(nextRound) + nextCRS := utils.GetCRSWithPanic(con.gov, nextRound, con.logger) if err := con.baMgr.appendConfig( nextRound, nextConfig, nextCRS); err != nil { panic(err) @@ -753,9 +755,8 @@ func (con *Consensus) initialRound( defer con.dkgReady.L.Unlock() con.dkgRunning = 0 }() - con.logger.Debug("Calling Governance.Configuration", - "round", nextRound) - nextConfig := con.gov.Configuration(nextRound) + nextConfig := utils.GetConfigWithPanic( + con.gov, nextRound, con.logger) con.runDKG(nextRound, nextConfig) }) }(round + 1) @@ -766,9 +767,7 @@ func (con *Consensus) initialRound( // Change round. // Get configuration for next round. nextRound := round + 1 - con.logger.Debug("Calling Governance.Configuration", - "round", nextRound) - nextConfig := con.gov.Configuration(nextRound) + nextConfig := utils.GetConfigWithPanic(con.gov, nextRound, con.logger) con.initialRound( startTime.Add(config.RoundInterval), nextRound, nextConfig) }) @@ -990,7 +989,7 @@ func (con *Consensus) ProcessBlockRandomnessResult( "randomness", hex.EncodeToString(rand.Randomness)) con.network.BroadcastRandomnessResult(rand) } - return nil + return con.deliverFinalizedBlocks() } // preProcessBlock performs Byzantine Agreement on the block. @@ -1021,9 +1020,7 @@ func (con *Consensus) deliverBlock(b *types.Block) { // - roundShift // - notifyGenesisRound futureRound := con.roundToNotify + 1 - con.logger.Debug("Calling Governance.Configuration", - "round", con.roundToNotify) - futureConfig := con.gov.Configuration(futureRound) + futureConfig := utils.GetConfigWithPanic(con.gov, futureRound, con.logger) con.logger.Debug("Append Config", "round", futureRound) if err := con.lattice.AppendConfig( futureRound, futureConfig); err != nil { @@ -1046,6 +1043,28 @@ func (con *Consensus) deliverBlock(b *types.Block) { } } +// deliverFinalizedBlocks extracts and delivers finalized blocks to application +// layer. +func (con *Consensus) deliverFinalizedBlocks() error { + con.lock.Lock() + defer con.lock.Unlock() + return con.deliverFinalizedBlocksWithoutLock() +} + +func (con *Consensus) deliverFinalizedBlocksWithoutLock() (err error) { + deliveredBlocks := con.ccModule.extractBlocks() + con.logger.Debug("Last blocks in compaction chain", + "delivered", con.ccModule.lastDeliveredBlock(), + "pending", con.ccModule.lastPendingBlock()) + for _, b := range deliveredBlocks { + con.deliverBlock(b) + } + if err = con.lattice.PurgeBlocks(deliveredBlocks); err != nil { + return + } + return +} + // processBlock is the entry point to submit one block to a Consensus instance. func (con *Consensus) processBlock(block *types.Block) (err error) { if err = con.db.PutBlock(*block); err != nil && err != db.ErrBlockExists { @@ -1079,14 +1098,7 @@ func (con *Consensus) processBlock(block *types.Block) (err error) { } go con.event.NotifyTime(b.Finalization.Timestamp) } - deliveredBlocks = con.ccModule.extractBlocks() - con.logger.Debug("Last blocks in compaction chain", - "delivered", con.ccModule.lastDeliveredBlock(), - "pending", con.ccModule.lastPendingBlock()) - for _, b := range deliveredBlocks { - con.deliverBlock(b) - } - if err = con.lattice.PurgeBlocks(deliveredBlocks); err != nil { + if err = con.deliverFinalizedBlocksWithoutLock(); err != nil { return } return diff --git a/vendor/github.com/dexon-foundation/dexon-consensus/core/crypto.go b/vendor/github.com/dexon-foundation/dexon-consensus/core/crypto.go index 914ca0865..d4a7f0ead 100644 --- a/vendor/github.com/dexon-foundation/dexon-consensus/core/crypto.go +++ b/vendor/github.com/dexon-foundation/dexon-consensus/core/crypto.go @@ -243,6 +243,30 @@ func verifyDKGPartialSignatureSignature( return true, nil } +func hashDKGMPKReady(ready *typesDKG.MPKReady) common.Hash { + binaryRound := make([]byte, 8) + binary.LittleEndian.PutUint64(binaryRound, ready.Round) + + return crypto.Keccak256Hash( + ready.ProposerID.Hash[:], + binaryRound, + ) +} + +// VerifyDKGMPKReadySignature verifies DKGMPKReady signature. +func VerifyDKGMPKReadySignature( + ready *typesDKG.MPKReady) (bool, error) { + hash := hashDKGMPKReady(ready) + pubKey, err := crypto.SigToPub(hash, ready.Signature) + if err != nil { + return false, err + } + if ready.ProposerID != types.NewNodeID(pubKey) { + return false, nil + } + return true, nil +} + func hashDKGFinalize(final *typesDKG.Finalize) common.Hash { binaryRound := make([]byte, 8) binary.LittleEndian.PutUint64(binaryRound, final.Round) diff --git a/vendor/github.com/dexon-foundation/dexon-consensus/core/db/level-db.go b/vendor/github.com/dexon-foundation/dexon-consensus/core/db/level-db.go index 3b5994b26..75c30372f 100644 --- a/vendor/github.com/dexon-foundation/dexon-consensus/core/db/level-db.go +++ b/vendor/github.com/dexon-foundation/dexon-consensus/core/db/level-db.go @@ -163,7 +163,7 @@ func (lvl *LevelDBBackedDB) PutCompactionChainTipInfo( if err != nil { return err } - if info.Height >= height { + if info.Height+1 != height { return ErrInvalidCompactionChainTipHeight } if err = lvl.db.Put(compactionChainTipInfoKey, marshaled, nil); err != nil { diff --git a/vendor/github.com/dexon-foundation/dexon-consensus/core/db/memory.go b/vendor/github.com/dexon-foundation/dexon-consensus/core/db/memory.go index 7393de9db..4bc08e704 100644 --- a/vendor/github.com/dexon-foundation/dexon-consensus/core/db/memory.go +++ b/vendor/github.com/dexon-foundation/dexon-consensus/core/db/memory.go @@ -149,7 +149,7 @@ func (m *MemBackedDB) PutCompactionChainTipInfo( blockHash common.Hash, height uint64) error { m.compactionChainTipLock.Lock() defer m.compactionChainTipLock.Unlock() - if m.compactionChainTipHeight >= height { + if m.compactionChainTipHeight+1 != height { return ErrInvalidCompactionChainTipHeight } m.compactionChainTipHeight = height diff --git a/vendor/github.com/dexon-foundation/dexon-consensus/core/dkg-tsig-protocol.go b/vendor/github.com/dexon-foundation/dexon-consensus/core/dkg-tsig-protocol.go index 8e03cbbda..ef12cf992 100644 --- a/vendor/github.com/dexon-foundation/dexon-consensus/core/dkg-tsig-protocol.go +++ b/vendor/github.com/dexon-foundation/dexon-consensus/core/dkg-tsig-protocol.go @@ -26,6 +26,7 @@ import ( "github.com/dexon-foundation/dexon-consensus/core/crypto/dkg" "github.com/dexon-foundation/dexon-consensus/core/types" typesDKG "github.com/dexon-foundation/dexon-consensus/core/types/dkg" + "github.com/dexon-foundation/dexon-consensus/core/utils" ) // Errors for dkg module. @@ -67,6 +68,9 @@ type dkgReceiver interface { // ProposeDKGAntiNackComplaint propose a DKGPrivateShare as an anti complaint. ProposeDKGAntiNackComplaint(prv *typesDKG.PrivateShare) + // ProposeDKGMPKReady propose a DKGMPKReady message. + ProposeDKGMPKReady(ready *typesDKG.MPKReady) + // ProposeDKGFinalize propose a DKGFinalize message. ProposeDKGFinalize(final *typesDKG.Finalize) } @@ -338,6 +342,13 @@ func (d *dkgProtocol) processPrivateShare( return nil } +func (d *dkgProtocol) proposeMPKReady() { + d.recv.ProposeDKGMPKReady(&typesDKG.MPKReady{ + ProposerID: d.ID, + Round: d.round, + }) +} + func (d *dkgProtocol) proposeFinalize() { d.recv.ProposeDKGFinalize(&typesDKG.Finalize{ ProposerID: d.ID, @@ -491,7 +502,7 @@ func (tc *TSigVerifierCache) Update(round uint64) (bool, error) { gpk, err := NewDKGGroupPublicKey(round, tc.intf.DKGMasterPublicKeys(round), tc.intf.DKGComplaints(round), - int(tc.intf.Configuration(round).DKGSetSize/3)+1) + int(utils.GetConfigWithPanic(tc.intf, round, nil).DKGSetSize/3)+1) if err != nil { return false, err } diff --git a/vendor/github.com/dexon-foundation/dexon-consensus/core/interfaces.go b/vendor/github.com/dexon-foundation/dexon-consensus/core/interfaces.go index 2ebfe8621..fc3bf09bc 100644 --- a/vendor/github.com/dexon-foundation/dexon-consensus/core/interfaces.go +++ b/vendor/github.com/dexon-foundation/dexon-consensus/core/interfaces.go @@ -130,6 +130,12 @@ type Governance interface { // DKGMasterPublicKeys gets all the DKGMasterPublicKey of round. DKGMasterPublicKeys(round uint64) []*typesDKG.MasterPublicKey + // AddDKGMPKReady adds a DKG ready message. + AddDKGMPKReady(round uint64, ready *typesDKG.MPKReady) + + // IsDKGFinal checks if DKG is ready. + IsDKGMPKReady(round uint64) bool + // AddDKGFinalize adds a DKG finalize message. AddDKGFinalize(round uint64, final *typesDKG.Finalize) diff --git a/vendor/github.com/dexon-foundation/dexon-consensus/core/ticker.go b/vendor/github.com/dexon-foundation/dexon-consensus/core/ticker.go index 3728a79e6..f8d0c67d9 100644 --- a/vendor/github.com/dexon-foundation/dexon-consensus/core/ticker.go +++ b/vendor/github.com/dexon-foundation/dexon-consensus/core/ticker.go @@ -17,7 +17,11 @@ package core -import "time" +import ( + "time" + + "github.com/dexon-foundation/dexon-consensus/core/utils" +) // TickerType is the type of ticker. type TickerType int @@ -65,11 +69,11 @@ func newTicker(gov Governance, round uint64, tickerType TickerType) (t Ticker) { var duration time.Duration switch tickerType { case TickerBA: - duration = gov.Configuration(round).LambdaBA + duration = utils.GetConfigWithPanic(gov, round, nil).LambdaBA case TickerDKG: - duration = gov.Configuration(round).LambdaDKG + duration = utils.GetConfigWithPanic(gov, round, nil).LambdaDKG case TickerCRS: - duration = gov.Configuration(round).RoundInterval / 2 + duration = utils.GetConfigWithPanic(gov, round, nil).RoundInterval / 2 } t = newDefaultTicker(duration) } diff --git a/vendor/github.com/dexon-foundation/dexon-consensus/core/types/dkg/dkg.go b/vendor/github.com/dexon-foundation/dexon-consensus/core/types/dkg/dkg.go index cecc4f16c..f021d1bfb 100644 --- a/vendor/github.com/dexon-foundation/dexon-consensus/core/types/dkg/dkg.go +++ b/vendor/github.com/dexon-foundation/dexon-consensus/core/types/dkg/dkg.go @@ -167,6 +167,27 @@ type PartialSignature struct { Signature crypto.Signature `json:"signature"` } +// MPKReady describe a dig ready message in DKG protocol. +type MPKReady struct { + ProposerID types.NodeID `json:"proposer_id"` + Round uint64 `json:"round"` + Signature crypto.Signature `json:"signature"` +} + +func (ready *MPKReady) String() string { + return fmt.Sprintf("DKGMPKReady{RP:%s Round:%d}", + ready.ProposerID.String()[:6], + ready.Round) +} + +// Equal check equality of two MPKReady instances. +func (ready *MPKReady) Equal(other *MPKReady) bool { + return ready.ProposerID.Equal(other.ProposerID) && + ready.Round == other.Round && + ready.Signature.Type == other.Signature.Type && + bytes.Compare(ready.Signature.Signature, other.Signature.Signature) == 0 +} + // Finalize describe a dig finalize message in DKG protocol. type Finalize struct { ProposerID types.NodeID `json:"proposer_id"` diff --git a/vendor/github.com/dexon-foundation/dexon-consensus/core/utils/utils.go b/vendor/github.com/dexon-foundation/dexon-consensus/core/utils/utils.go new file mode 100644 index 000000000..3e3803d06 --- /dev/null +++ b/vendor/github.com/dexon-foundation/dexon-consensus/core/utils/utils.go @@ -0,0 +1,61 @@ +// This file is part of the dexon-consensus library. +// +// The dexon-consensus library is free software: you can redistribute it +// and/or modify it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the License, +// or (at your option) any later version. +// +// The dexon-consensus library 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 Lesser +// General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with the dexon-consensus library. If not, see +// <http://www.gnu.org/licenses/>. + +package utils + +import ( + "fmt" + + "github.com/dexon-foundation/dexon-consensus/common" + "github.com/dexon-foundation/dexon-consensus/core/types" +) + +type configAccessor interface { + Configuration(round uint64) *types.Config +} + +// GetConfigWithPanic is a helper to access configs, and panic when config for +// that round is not ready yet. +func GetConfigWithPanic(accessor configAccessor, round uint64, + logger common.Logger) *types.Config { + if logger != nil { + logger.Debug("Calling Governance.Configuration", "round", round) + } + c := accessor.Configuration(round) + if c == nil { + panic(fmt.Errorf("configuration is not ready %v", round)) + } + return c +} + +type crsAccessor interface { + CRS(round uint64) common.Hash +} + +// GetCRSWithPanic is a helper to access CRS, and panic when CRS for that +// round is not ready yet. +func GetCRSWithPanic(accessor crsAccessor, round uint64, + logger common.Logger) common.Hash { + if logger != nil { + logger.Debug("Calling Governance.CRS", "round", round) + } + crs := accessor.CRS(round) + if (crs == common.Hash{}) { + panic(fmt.Errorf("CRS is not ready %v", round)) + } + return crs + +} diff --git a/vendor/vendor.json b/vendor/vendor.json index add9ce181..f524bce16 100644 --- a/vendor/vendor.json +++ b/vendor/vendor.json @@ -105,14 +105,14 @@ { "checksumSHA1": "65L1yf+f0OCiLFniljqfRxVdsQA=", "path": "github.com/dexon-foundation/dexon-consensus/common", - "revision": "99d72382687196fb15ea6ab0fcf297b9ab10ac46", - "revisionTime": "2018-12-16T06:44:15Z" + "revision": "146ed32cf841151b826eafd7d6ade188c56865bf", + "revisionTime": "2018-12-20T09:26:30Z" }, { - "checksumSHA1": "jZLh+ZsuMIiMuksK9c/5QpMQ2IM=", + "checksumSHA1": "DxtHhW/eYFodiPxgwu7opvIhJu0=", "path": "github.com/dexon-foundation/dexon-consensus/core", - "revision": "99d72382687196fb15ea6ab0fcf297b9ab10ac46", - "revisionTime": "2018-12-16T06:44:15Z" + "revision": "146ed32cf841151b826eafd7d6ade188c56865bf", + "revisionTime": "2018-12-20T09:26:30Z" }, { "checksumSHA1": "v4fKR7uhoyufi6hAVO44cFEb+tY=", @@ -123,44 +123,44 @@ { "checksumSHA1": "tQSbYCu5P00lUhKsx3IbBZCuSLY=", "path": "github.com/dexon-foundation/dexon-consensus/core/crypto", - "revision": "99d72382687196fb15ea6ab0fcf297b9ab10ac46", - "revisionTime": "2018-12-16T06:44:15Z" + "revision": "146ed32cf841151b826eafd7d6ade188c56865bf", + "revisionTime": "2018-12-20T09:26:30Z" }, { "checksumSHA1": "W2P7pkuJ+26BpJg03K4Y0nB5obI=", "path": "github.com/dexon-foundation/dexon-consensus/core/crypto/dkg", - "revision": "99d72382687196fb15ea6ab0fcf297b9ab10ac46", - "revisionTime": "2018-12-16T06:44:15Z" + "revision": "146ed32cf841151b826eafd7d6ade188c56865bf", + "revisionTime": "2018-12-20T09:26:30Z" }, { "checksumSHA1": "6Pf6caC8LTNCI7IflFmglKYnxYo=", "path": "github.com/dexon-foundation/dexon-consensus/core/crypto/ecdsa", - "revision": "99d72382687196fb15ea6ab0fcf297b9ab10ac46", - "revisionTime": "2018-12-16T06:44:15Z" + "revision": "146ed32cf841151b826eafd7d6ade188c56865bf", + "revisionTime": "2018-12-20T09:26:30Z" }, { - "checksumSHA1": "trkFVPLd7UFFUzL8bn6KuvFU9gE=", + "checksumSHA1": "PJXR1OuWwVVYrdJMK3skPr1/8ls=", "path": "github.com/dexon-foundation/dexon-consensus/core/db", - "revision": "99d72382687196fb15ea6ab0fcf297b9ab10ac46", - "revisionTime": "2018-12-16T06:44:15Z" + "revision": "146ed32cf841151b826eafd7d6ade188c56865bf", + "revisionTime": "2018-12-20T09:26:30Z" }, { "checksumSHA1": "Z079qQV+aQV9A3kSJ0LbFjx5VO4=", "path": "github.com/dexon-foundation/dexon-consensus/core/types", - "revision": "99d72382687196fb15ea6ab0fcf297b9ab10ac46", - "revisionTime": "2018-12-16T06:44:15Z" + "revision": "146ed32cf841151b826eafd7d6ade188c56865bf", + "revisionTime": "2018-12-20T09:26:30Z" }, { - "checksumSHA1": "Sn3PAYsblIXmr7gVKDzxnoBPku4=", + "checksumSHA1": "sY+2eiOoWvsNMvuPl9qQ+rlT9sA=", "path": "github.com/dexon-foundation/dexon-consensus/core/types/dkg", - "revision": "99d72382687196fb15ea6ab0fcf297b9ab10ac46", - "revisionTime": "2018-12-16T06:44:15Z" + "revision": "146ed32cf841151b826eafd7d6ade188c56865bf", + "revisionTime": "2018-12-20T09:26:30Z" }, { - "checksumSHA1": "A7UQ+7rv9FuElmFBEn/ZdhBqFKI=", + "checksumSHA1": "WEtKiyBYr0oPUSF+smv1A2LPBuI=", "path": "github.com/dexon-foundation/dexon-consensus/core/utils", - "revision": "99d72382687196fb15ea6ab0fcf297b9ab10ac46", - "revisionTime": "2018-12-16T06:44:15Z" + "revision": "146ed32cf841151b826eafd7d6ade188c56865bf", + "revisionTime": "2018-12-20T09:26:30Z" }, { "checksumSHA1": "TAkwduKZqLyimyTPPWIllZWYFuE=", |