From 70ab62c1b72c6fef8dd2c8e405d7f9823f70f475 Mon Sep 17 00:00:00 2001 From: Mission Liao Date: Tue, 18 Dec 2018 10:02:30 +0800 Subject: vendor: sync to latest core (#91) - Implement new methods in db to cache DKG private key. - Implement new methods in db to cache compaction chain tip. --- core/rawdb/accessors_core_chain_tip.go | 49 ++++++ core/rawdb/accessors_core_dkg_private_key.go | 48 ++++++ core/rawdb/schema.go | 12 +- dex/backend.go | 4 +- dex/blockdb/db.go | 71 --------- dex/db/db.go | 107 +++++++++++++ dex/handler.go | 4 +- .../dexon-consensus/core/configuration-chain.go | 109 +++++++++---- .../dexon-consensus/core/consensus.go | 25 +-- .../dexon-consensus/core/crypto/dkg/utils.go | 21 +++ .../dexon-consensus/core/db/interfaces.go | 23 +++ .../dexon-consensus/core/db/level-db.go | 176 ++++++++++++++++++--- .../dexon-consensus/core/db/memory.go | 92 +++++++++-- .../dexon-consensus/core/dkg-tsig-protocol.go | 13 +- .../dexon-foundation/dexon-consensus/core/utils.go | 4 + vendor/vendor.json | 42 ++--- 16 files changed, 623 insertions(+), 177 deletions(-) create mode 100644 core/rawdb/accessors_core_chain_tip.go create mode 100644 core/rawdb/accessors_core_dkg_private_key.go delete mode 100644 dex/blockdb/db.go create mode 100644 dex/db/db.go diff --git a/core/rawdb/accessors_core_chain_tip.go b/core/rawdb/accessors_core_chain_tip.go new file mode 100644 index 000000000..95fa8854f --- /dev/null +++ b/core/rawdb/accessors_core_chain_tip.go @@ -0,0 +1,49 @@ +package rawdb + +import ( + "bytes" + + coreCommon "github.com/dexon-foundation/dexon-consensus/common" + "github.com/dexon-foundation/dexon/log" + "github.com/dexon-foundation/dexon/rlp" +) + +func ReadCoreCompactionChainTipRLP(db DatabaseReader) (rlp.RawValue, error) { + return db.Get(coreCompactionChainTipKey) +} + +func WriteCoreCompactionChainTipRLP(db DatabaseWriter, rlp rlp.RawValue) error { + if err := db.Put(coreCompactionChainTipKey, rlp); err != nil { + log.Crit("Failed to store core compaction chain tip") + return err + } + return nil +} + +func ReadCoreCompactionChainTip(db DatabaseReader) (coreCommon.Hash, uint64) { + data, err := ReadCoreCompactionChainTipRLP(db) + if err != nil { + return coreCommon.Hash{}, 0 + } + v := struct { + Height uint64 + Hash coreCommon.Hash + }{} + if err := rlp.Decode(bytes.NewReader(data), &v); err != nil { + log.Error("Invalid core compaction chain tip RLP", "err", err) + return coreCommon.Hash{}, 0 + } + return v.Hash, v.Height +} + +func WriteCoreCompactionChainTip(db DatabaseWriter, hash coreCommon.Hash, height uint64) error { + data, err := rlp.EncodeToBytes(&struct { + Height uint64 + Hash coreCommon.Hash + }{height, hash}) + if err != nil { + log.Crit("Failed to RLP encode core compaction chain tip", "err", err) + return err + } + return WriteCoreCompactionChainTipRLP(db, data) +} diff --git a/core/rawdb/accessors_core_dkg_private_key.go b/core/rawdb/accessors_core_dkg_private_key.go new file mode 100644 index 000000000..ac51ca5ec --- /dev/null +++ b/core/rawdb/accessors_core_dkg_private_key.go @@ -0,0 +1,48 @@ +package rawdb + +import ( + "bytes" + + coreDKG "github.com/dexon-foundation/dexon-consensus/core/crypto/dkg" + "github.com/dexon-foundation/dexon/log" + "github.com/dexon-foundation/dexon/rlp" +) + +func ReadCoreDKGPrivateKeyRLP(db DatabaseReader, round uint64) rlp.RawValue { + data, _ := db.Get(coreDKGPrivateKeyKey(round)) + return data +} + +func WriteCoreDKGPrivateKeyRLP(db DatabaseWriter, round uint64, rlp rlp.RawValue) error { + err := db.Put(coreDKGPrivateKeyKey(round), rlp) + if err != nil { + log.Crit("Failed to store core DKG private key", "err", err, "round", round) + } + return err +} + +func HasCoreDKGPrivateKey(db DatabaseReader, round uint64) (bool, error) { + return db.Has(coreDKGPrivateKeyKey(round)) +} + +func ReadCoreDKGPrivateKey(db DatabaseReader, round uint64) *coreDKG.PrivateKey { + data := ReadCoreDKGPrivateKeyRLP(db, round) + if len(data) == 0 { + return nil + } + key := new(coreDKG.PrivateKey) + if err := rlp.Decode(bytes.NewReader(data), key); err != nil { + log.Error("Invalid core DKG private key RLP", "round", round, "err", err) + return nil + } + return key +} + +func WriteCoreDKGPrivateKey(db DatabaseWriter, round uint64, key *coreDKG.PrivateKey) error { + data, err := rlp.EncodeToBytes(key) + if err != nil { + log.Crit("Failed to RLP encode core DKG private key", "round", round, "err", err) + return err + } + return WriteCoreDKGPrivateKeyRLP(db, round, data) +} diff --git a/core/rawdb/schema.go b/core/rawdb/schema.go index 9a820a578..87a56c0ba 100644 --- a/core/rawdb/schema.go +++ b/core/rawdb/schema.go @@ -53,7 +53,9 @@ var ( txLookupPrefix = []byte("l") // txLookupPrefix + hash -> transaction/receipt lookup metadata bloomBitsPrefix = []byte("B") // bloomBitsPrefix + bit (uint16 big endian) + section (uint64 big endian) + hash -> bloom bits - coreBlockPrefix = []byte("D") + coreBlockPrefix = []byte("D") + coreDKGPrivateKeyPrefix = []byte("DPK") + coreCompactionChainTipKey = []byte("CoreChainTip") preimagePrefix = []byte("secure-key-") // preimagePrefix + hash -> preimage configPrefix = []byte("ethereum-config-") // config prefix for the db @@ -120,6 +122,14 @@ func coreBlockKey(hash common.Hash) []byte { return append(coreBlockPrefix, hash.Bytes()...) } +// coreDKGPrivateKeyKey = coreDKGPrivateKeyPrefix + round +func coreDKGPrivateKeyKey(round uint64) []byte { + ret := make([]byte, len(coreDKGPrivateKeyPrefix)+8) + copy(ret, coreDKGPrivateKeyPrefix) + binary.LittleEndian.PutUint64(ret[len(coreDKGPrivateKeyPrefix):], round) + return ret +} + // bloomBitsKey = bloomBitsPrefix + bit (uint16 big endian) + section (uint64 big endian) + hash func bloomBitsKey(bit uint, section uint64, hash common.Hash) []byte { key := append(append(bloomBitsPrefix, make([]byte, 10)...), hash.Bytes()...) diff --git a/dex/backend.go b/dex/backend.go index 5ea30b1a9..2c87425de 100644 --- a/dex/backend.go +++ b/dex/backend.go @@ -31,7 +31,7 @@ import ( "github.com/dexon-foundation/dexon/core/bloombits" "github.com/dexon-foundation/dexon/core/rawdb" "github.com/dexon-foundation/dexon/core/vm" - "github.com/dexon-foundation/dexon/dex/blockdb" + dexDB "github.com/dexon-foundation/dexon/dex/db" "github.com/dexon-foundation/dexon/dex/downloader" "github.com/dexon-foundation/dexon/eth/filters" "github.com/dexon-foundation/dexon/eth/gasprice" @@ -170,7 +170,7 @@ func New(ctx *node.ServiceContext, config *Config) (*Dexon, error) { log.Info("DEXON Consensus DMoment", "time", dMoment) dex.consensus = dexCore.NewConsensus(dMoment, - dex.app, dex.governance, blockdb.NewDatabase(chainDb), dex.network, privKey, log.Root()) + dex.app, dex.governance, dexDB.NewDatabase(chainDb), dex.network, privKey, log.Root()) return dex, nil } diff --git a/dex/blockdb/db.go b/dex/blockdb/db.go deleted file mode 100644 index 4f08a3edd..000000000 --- a/dex/blockdb/db.go +++ /dev/null @@ -1,71 +0,0 @@ -// 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 -// . - -package blockdb - -import ( - coreCommon "github.com/dexon-foundation/dexon-consensus/common" - coreDb "github.com/dexon-foundation/dexon-consensus/core/db" - coreTypes "github.com/dexon-foundation/dexon-consensus/core/types" - - "github.com/dexon-foundation/dexon/common" - "github.com/dexon-foundation/dexon/core/rawdb" - "github.com/dexon-foundation/dexon/ethdb" -) - -// BlockDB implement dexon-consensus BlockDatabase interface. -type BlockDB struct { - db ethdb.Database -} - -func NewDatabase(db ethdb.Database) *BlockDB { - return &BlockDB{db} -} - -func (d *BlockDB) HasBlock(hash coreCommon.Hash) bool { - return rawdb.HasCoreBlock(d.db, common.Hash(hash)) -} - -func (d *BlockDB) GetBlock(hash coreCommon.Hash) (coreTypes.Block, error) { - block := rawdb.ReadCoreBlock(d.db, common.Hash(hash)) - if block == nil { - return coreTypes.Block{}, coreDb.ErrBlockDoesNotExist - } - return *block, nil -} - -func (d *BlockDB) GetAllBlocks() (coreDb.BlockIterator, error) { - return nil, coreDb.ErrNotImplemented -} - -func (d *BlockDB) UpdateBlock(block coreTypes.Block) error { - if !d.HasBlock(block.Hash) { - return coreDb.ErrBlockDoesNotExist - } - rawdb.WriteCoreBlock(d.db, common.Hash(block.Hash), &block) - return nil -} - -func (d *BlockDB) PutBlock(block coreTypes.Block) error { - if d.HasBlock(block.Hash) { - return coreDb.ErrBlockExists - } - rawdb.WriteCoreBlock(d.db, common.Hash(block.Hash), &block) - return nil -} - -func (d *BlockDB) Close() error { return nil } diff --git a/dex/db/db.go b/dex/db/db.go new file mode 100644 index 000000000..d51c2df54 --- /dev/null +++ b/dex/db/db.go @@ -0,0 +1,107 @@ +// 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 +// . + +package db + +import ( + coreCommon "github.com/dexon-foundation/dexon-consensus/common" + coreDKG "github.com/dexon-foundation/dexon-consensus/core/crypto/dkg" + coreDb "github.com/dexon-foundation/dexon-consensus/core/db" + coreTypes "github.com/dexon-foundation/dexon-consensus/core/types" + + "github.com/dexon-foundation/dexon/common" + "github.com/dexon-foundation/dexon/core/rawdb" + "github.com/dexon-foundation/dexon/ethdb" +) + +// DB implement dexon-consensus BlockDatabase interface. +type DB struct { + db ethdb.Database +} + +func NewDatabase(db ethdb.Database) *DB { + return &DB{db} +} + +func (d *DB) HasBlock(hash coreCommon.Hash) bool { + return rawdb.HasCoreBlock(d.db, common.Hash(hash)) +} + +func (d *DB) GetBlock(hash coreCommon.Hash) (coreTypes.Block, error) { + block := rawdb.ReadCoreBlock(d.db, common.Hash(hash)) + if block == nil { + return coreTypes.Block{}, coreDb.ErrBlockDoesNotExist + } + return *block, nil +} + +func (d *DB) GetAllBlocks() (coreDb.BlockIterator, error) { + return nil, coreDb.ErrNotImplemented +} + +func (d *DB) UpdateBlock(block coreTypes.Block) error { + if !d.HasBlock(block.Hash) { + return coreDb.ErrBlockDoesNotExist + } + rawdb.WriteCoreBlock(d.db, common.Hash(block.Hash), &block) + return nil +} + +func (d *DB) PutBlock(block coreTypes.Block) error { + if d.HasBlock(block.Hash) { + return coreDb.ErrBlockExists + } + rawdb.WriteCoreBlock(d.db, common.Hash(block.Hash), &block) + return nil +} + +func (d *DB) HasDKGPrivateKey(round uint64) (bool, error) { + return rawdb.HasCoreDKGPrivateKey(d.db, round) +} + +func (d *DB) GetDKGPrivateKey(round uint64) (coreDKG.PrivateKey, error) { + key := rawdb.ReadCoreDKGPrivateKey(d.db, round) + if key == nil { + return coreDKG.PrivateKey{}, coreDb.ErrDKGPrivateKeyDoesNotExist + } + return *key, nil +} + +func (d *DB) PutDKGPrivateKey(round uint64, key coreDKG.PrivateKey) error { + has, err := d.HasDKGPrivateKey(round) + if err != nil { + return err + } + if has { + return coreDb.ErrDKGPrivateKeyExists + } + return rawdb.WriteCoreDKGPrivateKey(d.db, round, &key) +} + +func (d *DB) PutCompactionChainTipInfo(hash coreCommon.Hash, height uint64) error { + _, currentHeight := d.GetCompactionChainTipInfo() + if height <= currentHeight { + return coreDb.ErrInvalidCompactionChainTipHeight + } + return rawdb.WriteCoreCompactionChainTip(d.db, hash, height) +} + +func (d *DB) GetCompactionChainTipInfo() (hash coreCommon.Hash, height uint64) { + return rawdb.ReadCoreCompactionChainTip(d.db) +} + +func (d *DB) Close() error { return nil } diff --git a/dex/handler.go b/dex/handler.go index 620320f49..9174d8516 100644 --- a/dex/handler.go +++ b/dex/handler.go @@ -53,7 +53,7 @@ import ( "github.com/dexon-foundation/dexon/core" "github.com/dexon-foundation/dexon/core/types" "github.com/dexon-foundation/dexon/crypto" - "github.com/dexon-foundation/dexon/dex/blockdb" + dexDB "github.com/dexon-foundation/dexon/dex/db" "github.com/dexon-foundation/dexon/dex/downloader" "github.com/dexon-foundation/dexon/dex/fetcher" "github.com/dexon-foundation/dexon/ethdb" @@ -158,7 +158,7 @@ func NewProtocolManager( nodeTable: tab, gov: gov, blockchain: blockchain, - cache: newCache(5120, blockdb.NewDatabase(chaindb)), + cache: newCache(5120, dexDB.NewDatabase(chaindb)), chainconfig: config, newPeerCh: make(chan *peer), noMorePeers: make(chan struct{}), 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 364f2c75c..2b3a859ed 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 @@ -24,6 +24,7 @@ import ( "github.com/dexon-foundation/dexon-consensus/common" "github.com/dexon-foundation/dexon-consensus/core/crypto" + "github.com/dexon-foundation/dexon-consensus/core/db" "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" @@ -53,6 +54,7 @@ type configurationChain struct { tsigTouched map[common.Hash]struct{} tsigReady *sync.Cond cache *utils.NodeSetCache + db db.Database dkgSet map[types.NodeID]struct{} mpkReady bool pendingPrvShare map[types.NodeID]*typesDKG.PrivateShare @@ -66,6 +68,7 @@ func newConfigurationChain( recv dkgReceiver, gov Governance, cache *utils.NodeSetCache, + dbInst db.Database, logger common.Logger) *configurationChain { return &configurationChain{ ID: ID, @@ -78,6 +81,7 @@ func newConfigurationChain( tsigTouched: make(map[common.Hash]struct{}), tsigReady: sync.NewCond(&sync.Mutex{}), cache: cache, + db: dbInst, pendingPsig: make(map[common.Hash][]*typesDKG.PartialSignature), } } @@ -104,6 +108,10 @@ func (cc *configurationChain) registerDKG(round uint64, threshold int) { } func (cc *configurationChain) runDKG(round uint64) error { + // Check if corresponding DKG signer is ready. + if _, _, err := cc.getDKGInfo(round); err == nil { + return nil + } cc.dkgLock.Lock() defer cc.dkgLock.Unlock() if cc.dkg == nil || cc.dkg.round != round { @@ -113,20 +121,11 @@ func (cc *configurationChain) runDKG(round uint64) error { } return ErrDKGNotRegistered } - if func() bool { - cc.dkgResult.RLock() - defer cc.dkgResult.RUnlock() - _, exist := cc.gpk[round] - return exist - }() { - return nil - } cc.logger.Debug("Calling Governance.IsDKGFinal", "round", round) if cc.gov.IsDKGFinal(round) { cc.logger.Warn("DKG already final", "round", round) return nil } - ticker := newTicker(cc.gov, round, TickerDKG) cc.dkgLock.Unlock() <-ticker.Tick() @@ -153,7 +152,8 @@ func (cc *configurationChain) runDKG(round uint64) error { cc.dkgLock.Lock() // Phase 5(T = 2λ): Propose Anti nack complaint. cc.logger.Debug("Calling Governance.DKGComplaints", "round", round) - cc.dkg.processNackComplaints(cc.gov.DKGComplaints(round)) + complaints := cc.gov.DKGComplaints(round) + cc.dkg.processNackComplaints(complaints) cc.dkgLock.Unlock() <-ticker.Tick() cc.dkgLock.Lock() @@ -163,8 +163,7 @@ func (cc *configurationChain) runDKG(round uint64) error { <-ticker.Tick() cc.dkgLock.Lock() // Phase 7(T = 4λ): Enforce complaints and nack complaints. - cc.logger.Debug("Calling Governance.DKGComplaints", "round", round) - cc.dkg.enforceNackComplaints(cc.gov.DKGComplaints(round)) + cc.dkg.enforceNackComplaints(complaints) // Enforce complaint is done in `processPrivateShare`. // Phase 8(T = 5λ): DKG finalize. cc.dkgLock.Unlock() @@ -209,6 +208,10 @@ func (cc *configurationChain) runDKG(round uint64) error { if err != nil { return err } + // Save private shares to DB. + if err = cc.db.PutDKGPrivateKey(round, *signer.privateKey); err != nil { + return err + } cc.dkgResult.Lock() defer cc.dkgResult.Unlock() cc.dkgSigner[round] = signer @@ -220,23 +223,74 @@ func (cc *configurationChain) isDKGReady(round uint64) bool { if !cc.gov.IsDKGFinal(round) { return false } - return func() bool { + _, _, err := cc.getDKGInfo(round) + return err == nil +} + +func (cc *configurationChain) getDKGInfo( + round uint64) (*DKGGroupPublicKey, *dkgShareSecret, error) { + getFromCache := func() (*DKGGroupPublicKey, *dkgShareSecret) { cc.dkgResult.RLock() defer cc.dkgResult.RUnlock() - _, exist := cc.gpk[round] - return exist - }() + gpk := cc.gpk[round] + signer := cc.dkgSigner[round] + return gpk, signer + } + gpk, signer := getFromCache() + if gpk == nil || signer == nil { + if err := cc.recoverDKGInfo(round); err != nil { + return nil, nil, err + } + gpk, signer = getFromCache() + } + if gpk == nil || signer == nil { + return nil, nil, ErrDKGNotReady + } + return gpk, signer, nil +} + +func (cc *configurationChain) recoverDKGInfo(round uint64) error { + cc.dkgResult.Lock() + defer cc.dkgResult.Unlock() + _, signerExists := cc.dkgSigner[round] + _, gpkExists := cc.gpk[round] + if signerExists && gpkExists { + return nil + } + if !cc.gov.IsDKGFinal(round) { + return ErrDKGNotReady + } + + threshold := getDKGThreshold(cc.gov.Configuration(round)) + // Restore group public key. + gpk, err := NewDKGGroupPublicKey(round, + cc.gov.DKGMasterPublicKeys(round), + cc.gov.DKGComplaints(round), + threshold) + if err != nil { + return err + } + // Restore DKG share secret, this segment of code is copied from + // dkgProtocol.recoverShareSecret. + if len(gpk.qualifyIDs) < threshold { + return ErrNotReachThreshold + } + // Check if we have private shares in DB. + prvKey, err := cc.db.GetDKGPrivateKey(round) + if err != nil { + return err + } + cc.gpk[round] = gpk + cc.dkgSigner[round] = &dkgShareSecret{ + privateKey: &prvKey, + } + return nil } func (cc *configurationChain) preparePartialSignature( round uint64, hash common.Hash) (*typesDKG.PartialSignature, error) { - signer, exist := func() (*dkgShareSecret, bool) { - cc.dkgResult.RLock() - defer cc.dkgResult.RUnlock() - signer, exist := cc.dkgSigner[round] - return signer, exist - }() - if !exist { + _, signer, _ := cc.getDKGInfo(round) + if signer == nil { return nil, ErrDKGNotReady } return &typesDKG.PartialSignature{ @@ -264,13 +318,8 @@ func (cc *configurationChain) untouchTSigHash(hash common.Hash) { func (cc *configurationChain) runTSig( round uint64, hash common.Hash) ( crypto.Signature, error) { - gpk, exist := func() (*DKGGroupPublicKey, bool) { - cc.dkgResult.RLock() - defer cc.dkgResult.RUnlock() - gpk, exist := cc.gpk[round] - return gpk, exist - }() - if !exist { + gpk, _, _ := cc.getDKGInfo(round) + if gpk == nil { return crypto.Signature{}, ErrDKGNotReady } cc.tsigReady.L.Lock() 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 a6d80371d..5beaf546a 100644 --- a/vendor/github.com/dexon-foundation/dexon-consensus/core/consensus.go +++ b/vendor/github.com/dexon-foundation/dexon-consensus/core/consensus.go @@ -424,6 +424,7 @@ func NewConsensus( recv, gov, nodeSetCache, + db, logger) recv.cfgModule = cfgModule // Construct Consensus instance. @@ -490,6 +491,7 @@ func NewConsensusFromSyncer( recv, gov, nodeSetCache, + db, logger) recv.cfgModule = cfgModule // Setup Consensus instance. @@ -576,7 +578,7 @@ func (con *Consensus) prepare(initBlock *types.Block) error { } if _, exist := dkgSet[con.ID]; exist { con.logger.Info("Selected as DKG set", "round", initRound) - con.cfgModule.registerDKG(initRound, int(initConfig.DKGSetSize)/3+1) + con.cfgModule.registerDKG(initRound, getDKGThreshold(initConfig)) con.event.RegisterTime(con.dMoment.Add(initConfig.RoundInterval/4), func(time.Time) { con.runDKG(initRound, initConfig) @@ -742,8 +744,7 @@ func (con *Consensus) initialRound( return } con.logger.Info("Selected as DKG set", "round", nextRound) - con.cfgModule.registerDKG( - nextRound, int(config.DKGSetSize/3)+1) + con.cfgModule.registerDKG(nextRound, getDKGThreshold(config)) con.event.RegisterTime( startTime.Add(config.RoundInterval*2/3), func(time.Time) { @@ -1003,6 +1004,14 @@ func (con *Consensus) preProcessBlock(b *types.Block) (err error) { // deliverBlock deliver a block to application layer. func (con *Consensus) deliverBlock(b *types.Block) { + if err := con.db.UpdateBlock(*b); err != nil { + panic(err) + } + if err := con.db.PutCompactionChainTipInfo( + b.Hash, b.Finalization.Height); err != nil { + panic(err) + } + con.cfgModule.untouchTSigHash(b.Hash) con.logger.Debug("Calling Application.BlockDelivered", "block", b) con.app.BlockDelivered(b.Hash, b.Position, b.Finalization.Clone()) if b.Position.Round == con.roundToNotify { @@ -1032,6 +1041,9 @@ func (con *Consensus) deliverBlock(b *types.Block) { con.roundToNotify, b.Finalization.Height) con.roundToNotify++ } + if con.debugApp != nil { + con.debugApp.BlockReady(b.Hash) + } } // processBlock is the entry point to submit one block to a Consensus instance. @@ -1072,14 +1084,7 @@ func (con *Consensus) processBlock(block *types.Block) (err error) { "delivered", con.ccModule.lastDeliveredBlock(), "pending", con.ccModule.lastPendingBlock()) for _, b := range deliveredBlocks { - if err = con.db.UpdateBlock(*b); err != nil { - panic(err) - } - con.cfgModule.untouchTSigHash(b.Hash) con.deliverBlock(b) - if con.debugApp != nil { - con.debugApp.BlockReady(b.Hash) - } } if err = con.lattice.PurgeBlocks(deliveredBlocks); err != nil { return diff --git a/vendor/github.com/dexon-foundation/dexon-consensus/core/crypto/dkg/utils.go b/vendor/github.com/dexon-foundation/dexon-consensus/core/crypto/dkg/utils.go index fa4ad9f05..9e470f0cf 100644 --- a/vendor/github.com/dexon-foundation/dexon-consensus/core/crypto/dkg/utils.go +++ b/vendor/github.com/dexon-foundation/dexon-consensus/core/crypto/dkg/utils.go @@ -18,7 +18,9 @@ package dkg import ( + "encoding/binary" "fmt" + "math/rand" "github.com/dexon-foundation/bls/ffi/go/bls" @@ -69,3 +71,22 @@ func RecoverGroupPublicKey(pubShares []*PublicKeyShares) *PublicKey { } return pub } + +// NewRandomPrivateKeyShares constructs a private key shares randomly. +func NewRandomPrivateKeyShares() *PrivateKeyShares { + // Generate IDs. + rndIDs := make(IDs, 0, 10) + for i := range rndIDs { + id := make([]byte, 8) + binary.LittleEndian.PutUint64(id, rand.Uint64()) + rndIDs[i] = NewID(id) + } + prvShares := NewEmptyPrivateKeyShares() + prvShares.SetParticipants(rndIDs) + for _, id := range rndIDs { + if err := prvShares.AddShare(id, NewPrivateKey()); err != nil { + panic(err) + } + } + return prvShares +} diff --git a/vendor/github.com/dexon-foundation/dexon-consensus/core/db/interfaces.go b/vendor/github.com/dexon-foundation/dexon-consensus/core/db/interfaces.go index 5e13dc604..ebbbbd475 100644 --- a/vendor/github.com/dexon-foundation/dexon-consensus/core/db/interfaces.go +++ b/vendor/github.com/dexon-foundation/dexon-consensus/core/db/interfaces.go @@ -22,6 +22,7 @@ import ( "fmt" "github.com/dexon-foundation/dexon-consensus/common" + "github.com/dexon-foundation/dexon-consensus/core/crypto/dkg" "github.com/dexon-foundation/dexon-consensus/core/types" ) @@ -38,6 +39,17 @@ var ( ErrClosed = fmt.Errorf("db closed") // ErrNotImplemented is the error that some interface is not implemented. ErrNotImplemented = fmt.Errorf("not implemented") + // ErrInvalidCompactionChainTipHeight means the newly updated height of + // the tip of compaction chain is invalid, usually means it's smaller than + // current cached one. + ErrInvalidCompactionChainTipHeight = fmt.Errorf( + "invalid compaction chain tip height") + // ErrDKGPrivateKeyExists raised when attempting to save DKG private key + // that already saved. + ErrDKGPrivateKeyExists = errors.New("dkg private key exists") + // ErrDKGPrivateKeyDoesNotExist raised when the DKG private key of the + // requested round does not exists. + ErrDKGPrivateKeyDoesNotExist = errors.New("dkg private key does not exists") ) // Database is the interface for a Database. @@ -55,12 +67,23 @@ type Reader interface { HasBlock(hash common.Hash) bool GetBlock(hash common.Hash) (types.Block, error) GetAllBlocks() (BlockIterator, error) + + // GetCompactionChainTipInfo returns the block hash and finalization height + // of the tip block of compaction chain. Empty hash and zero height means + // the compaction chain is empty. + GetCompactionChainTipInfo() (common.Hash, uint64) + + // DKG Private Key related methods. + HasDKGPrivateKey(round uint64) (bool, error) + GetDKGPrivateKey(round uint64) (dkg.PrivateKey, error) } // Writer defines the interface for writing blocks into DB. type Writer interface { UpdateBlock(block types.Block) error PutBlock(block types.Block) error + PutCompactionChainTipInfo(common.Hash, uint64) error + PutDKGPrivateKey(uint64, dkg.PrivateKey) error } // BlockIterator defines an iterator on blocks hold 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 6983d3a5e..3b5994b26 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 @@ -18,14 +18,27 @@ package db import ( - "encoding/json" + "encoding/binary" "github.com/syndtr/goleveldb/leveldb" "github.com/dexon-foundation/dexon-consensus/common" + "github.com/dexon-foundation/dexon-consensus/core/crypto/dkg" "github.com/dexon-foundation/dexon-consensus/core/types" + "github.com/dexon-foundation/dexon/rlp" ) +var ( + blockKeyPrefix = []byte("b-") + compactionChainTipInfoKey = []byte("cc-tip") + dkgPrivateKeyKeyPrefix = []byte("dkg-prvs") +) + +type compactionChainTipInfo struct { + Height uint64 `json:"height"` + Hash common.Hash `json:"hash"` +} + // LevelDBBackedDB is a leveldb backed DB implementation. type LevelDBBackedDB struct { db *leveldb.DB @@ -50,7 +63,7 @@ func (lvl *LevelDBBackedDB) Close() error { // HasBlock implements the Reader.Has method. func (lvl *LevelDBBackedDB) HasBlock(hash common.Hash) bool { - exists, err := lvl.db.Has([]byte(hash[:]), nil) + exists, err := lvl.internalHasBlock(lvl.getBlockKey(hash)) if err != nil { // TODO(missionliao): Modify the interface to return error. panic(err) @@ -58,18 +71,25 @@ func (lvl *LevelDBBackedDB) HasBlock(hash common.Hash) bool { return exists } +func (lvl *LevelDBBackedDB) internalHasBlock(key []byte) (bool, error) { + exists, err := lvl.db.Has(key, nil) + if err != nil { + return false, err + } + return exists, nil +} + // GetBlock implements the Reader.GetBlock method. func (lvl *LevelDBBackedDB) GetBlock( hash common.Hash) (block types.Block, err error) { - - queried, err := lvl.db.Get([]byte(hash[:]), nil) + queried, err := lvl.db.Get(lvl.getBlockKey(hash), nil) if err != nil { if err == leveldb.ErrNotFound { err = ErrBlockDoesNotExist } return } - err = json.Unmarshal(queried, &block) + err = rlp.DecodeBytes(queried, &block) if err != nil { return } @@ -80,20 +100,20 @@ func (lvl *LevelDBBackedDB) GetBlock( func (lvl *LevelDBBackedDB) UpdateBlock(block types.Block) (err error) { // NOTE: we didn't handle changes of block hash (and it // should not happen). - marshaled, err := json.Marshal(&block) + marshaled, err := rlp.EncodeToBytes(&block) if err != nil { return } - - if !lvl.HasBlock(block.Hash) { + blockKey := lvl.getBlockKey(block.Hash) + exists, err := lvl.internalHasBlock(blockKey) + if err != nil { + return + } + if !exists { err = ErrBlockDoesNotExist return } - err = lvl.db.Put( - []byte(block.Hash[:]), - marshaled, - nil) - if err != nil { + if err = lvl.db.Put(blockKey, marshaled, nil); err != nil { return } return @@ -101,19 +121,20 @@ func (lvl *LevelDBBackedDB) UpdateBlock(block types.Block) (err error) { // PutBlock implements the Writer.PutBlock method. func (lvl *LevelDBBackedDB) PutBlock(block types.Block) (err error) { - marshaled, err := json.Marshal(&block) + marshaled, err := rlp.EncodeToBytes(&block) if err != nil { return } - if lvl.HasBlock(block.Hash) { + blockKey := lvl.getBlockKey(block.Hash) + exists, err := lvl.internalHasBlock(blockKey) + if err != nil { + return + } + if exists { err = ErrBlockExists return } - err = lvl.db.Put( - []byte(block.Hash[:]), - marshaled, - nil) - if err != nil { + if err = lvl.db.Put(blockKey, marshaled, nil); err != nil { return } return @@ -125,3 +146,118 @@ func (lvl *LevelDBBackedDB) GetAllBlocks() (BlockIterator, error) { // TODO (mission): Implement this part via goleveldb's iterator. return nil, ErrNotImplemented } + +// PutCompactionChainTipInfo saves tip of compaction chain into the database. +func (lvl *LevelDBBackedDB) PutCompactionChainTipInfo( + blockHash common.Hash, height uint64) error { + marshaled, err := rlp.EncodeToBytes(&compactionChainTipInfo{ + Hash: blockHash, + Height: height, + }) + if err != nil { + return err + } + // Check current cached tip info to make sure the one to be updated is + // valid. + info, err := lvl.internalGetCompactionChainTipInfo() + if err != nil { + return err + } + if info.Height >= height { + return ErrInvalidCompactionChainTipHeight + } + if err = lvl.db.Put(compactionChainTipInfoKey, marshaled, nil); err != nil { + return err + } + return nil +} + +func (lvl *LevelDBBackedDB) internalGetCompactionChainTipInfo() ( + info compactionChainTipInfo, err error) { + queried, err := lvl.db.Get(compactionChainTipInfoKey, nil) + if err != nil { + if err == leveldb.ErrNotFound { + err = nil + } + return + } + if err = rlp.DecodeBytes(queried, &info); err != nil { + return + } + return +} + +// GetCompactionChainTipInfo get the tip info of compaction chain into the +// database. +func (lvl *LevelDBBackedDB) GetCompactionChainTipInfo() ( + hash common.Hash, height uint64) { + info, err := lvl.internalGetCompactionChainTipInfo() + if err != nil { + panic(err) + } + hash, height = info.Hash, info.Height + return +} + +// HasDKGPrivateKey check existence of DKG private key of one round. +func (lvl *LevelDBBackedDB) HasDKGPrivateKey(round uint64) (bool, error) { + exists, err := lvl.db.Has(lvl.getDKGPrivateKeyKey(round), nil) + if err != nil { + return false, err + } + return exists, nil +} + +// GetDKGPrivateKey get DKG private key of one round. +func (lvl *LevelDBBackedDB) GetDKGPrivateKey(round uint64) ( + prv dkg.PrivateKey, err error) { + queried, err := lvl.db.Get(lvl.getDKGPrivateKeyKey(round), nil) + if err != nil { + if err == leveldb.ErrNotFound { + err = ErrDKGPrivateKeyDoesNotExist + } + return + } + if err = rlp.DecodeBytes(queried, &prv); err != nil { + return + } + return +} + +// PutDKGPrivateKey save DKG private key of one round. +func (lvl *LevelDBBackedDB) PutDKGPrivateKey( + round uint64, prv dkg.PrivateKey) error { + // Check existence. + exists, err := lvl.HasDKGPrivateKey(round) + if err != nil { + return err + } + if exists { + return ErrDKGPrivateKeyExists + } + marshaled, err := rlp.EncodeToBytes(&prv) + if err != nil { + return err + } + if err := lvl.db.Put( + lvl.getDKGPrivateKeyKey(round), marshaled, nil); err != nil { + return err + } + return nil +} + +func (lvl *LevelDBBackedDB) getBlockKey(hash common.Hash) (ret []byte) { + ret = make([]byte, len(blockKeyPrefix)+len(hash[:])) + copy(ret, blockKeyPrefix) + copy(ret[len(blockKeyPrefix):], hash[:]) + return +} + +func (lvl *LevelDBBackedDB) getDKGPrivateKeyKey( + round uint64) (ret []byte) { + ret = make([]byte, len(dkgPrivateKeyKeyPrefix)+8) + copy(ret, dkgPrivateKeyKeyPrefix) + binary.LittleEndian.PutUint64( + ret[len(dkgPrivateKeyKeyPrefix):], round) + return +} 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 4246e4fe1..7393de9db 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 @@ -24,6 +24,7 @@ import ( "sync" "github.com/dexon-foundation/dexon-consensus/common" + "github.com/dexon-foundation/dexon-consensus/core/crypto/dkg" "github.com/dexon-foundation/dexon-consensus/core/types" ) @@ -41,10 +42,15 @@ func (seq *blockSeqIterator) NextBlock() (types.Block, error) { // MemBackedDB is a memory backed DB implementation. type MemBackedDB struct { - blocksMutex sync.RWMutex - blockHashSequence common.Hashes - blocksByHash map[common.Hash]*types.Block - persistantFilePath string + blocksLock sync.RWMutex + blockHashSequence common.Hashes + blocksByHash map[common.Hash]*types.Block + compactionChainTipLock sync.RWMutex + compactionChainTipHash common.Hash + compactionChainTipHeight uint64 + dkgPrivateKeysLock sync.RWMutex + dkgPrivateKeys map[uint64]*dkg.PrivateKey + persistantFilePath string } // NewMemBackedDB initialize a memory-backed database. @@ -53,6 +59,7 @@ func NewMemBackedDB(persistantFilePath ...string) ( dbInst = &MemBackedDB{ blockHashSequence: common.Hashes{}, blocksByHash: make(map[common.Hash]*types.Block), + dkgPrivateKeys: make(map[uint64]*dkg.PrivateKey), } if len(persistantFilePath) == 0 || len(persistantFilePath[0]) == 0 { return @@ -87,8 +94,8 @@ func NewMemBackedDB(persistantFilePath ...string) ( // HasBlock returns wheter or not the DB has a block identified with the hash. func (m *MemBackedDB) HasBlock(hash common.Hash) bool { - m.blocksMutex.RLock() - defer m.blocksMutex.RUnlock() + m.blocksLock.RLock() + defer m.blocksLock.RUnlock() _, ok := m.blocksByHash[hash] return ok @@ -96,8 +103,8 @@ func (m *MemBackedDB) HasBlock(hash common.Hash) bool { // GetBlock returns a block given a hash. func (m *MemBackedDB) GetBlock(hash common.Hash) (types.Block, error) { - m.blocksMutex.RLock() - defer m.blocksMutex.RUnlock() + m.blocksLock.RLock() + defer m.blocksLock.RUnlock() return m.internalGetBlock(hash) } @@ -116,8 +123,8 @@ func (m *MemBackedDB) PutBlock(block types.Block) error { return ErrBlockExists } - m.blocksMutex.Lock() - defer m.blocksMutex.Unlock() + m.blocksLock.Lock() + defer m.blocksLock.Unlock() m.blockHashSequence = append(m.blockHashSequence, block.Hash) m.blocksByHash[block.Hash] = &block @@ -130,13 +137,66 @@ func (m *MemBackedDB) UpdateBlock(block types.Block) error { return ErrBlockDoesNotExist } - m.blocksMutex.Lock() - defer m.blocksMutex.Unlock() + m.blocksLock.Lock() + defer m.blocksLock.Unlock() m.blocksByHash[block.Hash] = &block return nil } +// PutCompactionChainTipInfo saves tip of compaction chain into the database. +func (m *MemBackedDB) PutCompactionChainTipInfo( + blockHash common.Hash, height uint64) error { + m.compactionChainTipLock.Lock() + defer m.compactionChainTipLock.Unlock() + if m.compactionChainTipHeight >= height { + return ErrInvalidCompactionChainTipHeight + } + m.compactionChainTipHeight = height + m.compactionChainTipHash = blockHash + return nil +} + +// GetCompactionChainTipInfo get the tip info of compaction chain into the +// database. +func (m *MemBackedDB) GetCompactionChainTipInfo() ( + hash common.Hash, height uint64) { + m.compactionChainTipLock.RLock() + defer m.compactionChainTipLock.RUnlock() + return m.compactionChainTipHash, m.compactionChainTipHeight +} + +// HasDKGPrivateKey check existence of DKG private key of one round. +func (m *MemBackedDB) HasDKGPrivateKey(round uint64) (bool, error) { + m.dkgPrivateKeysLock.RLock() + defer m.dkgPrivateKeysLock.RUnlock() + _, exists := m.dkgPrivateKeys[round] + return exists, nil +} + +// GetDKGPrivateKey get DKG private key of one round. +func (m *MemBackedDB) GetDKGPrivateKey(round uint64) ( + dkg.PrivateKey, error) { + m.dkgPrivateKeysLock.RLock() + defer m.dkgPrivateKeysLock.RUnlock() + if prv, exists := m.dkgPrivateKeys[round]; exists { + return *prv, nil + } + return dkg.PrivateKey{}, ErrDKGPrivateKeyDoesNotExist +} + +// PutDKGPrivateKey save DKG private key of one round. +func (m *MemBackedDB) PutDKGPrivateKey( + round uint64, prv dkg.PrivateKey) error { + m.dkgPrivateKeysLock.Lock() + defer m.dkgPrivateKeysLock.Unlock() + if _, exists := m.dkgPrivateKeys[round]; exists { + return ErrDKGPrivateKeyExists + } + m.dkgPrivateKeys[round] = &prv + return nil +} + // Close implement Closer interface, which would release allocated resource. func (m *MemBackedDB) Close() (err error) { // Save internal state to a pretty-print json file. It's a temporary way @@ -145,8 +205,8 @@ func (m *MemBackedDB) Close() (err error) { return } - m.blocksMutex.RLock() - defer m.blocksMutex.RUnlock() + m.blocksLock.RLock() + defer m.blocksLock.RUnlock() toDump := struct { Sequence common.Hashes @@ -167,8 +227,8 @@ func (m *MemBackedDB) Close() (err error) { } func (m *MemBackedDB) getBlockByIndex(idx int) (types.Block, error) { - m.blocksMutex.RLock() - defer m.blocksMutex.RUnlock() + m.blocksLock.RLock() + defer m.blocksLock.RUnlock() if idx >= len(m.blockHashSequence) { return types.Block{}, ErrIterationFinished 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 6645ecbae..8e03cbbda 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 @@ -378,16 +378,21 @@ func NewDKGGroupPublicKey( // Calculate qualify members. disqualifyIDs := map[types.NodeID]struct{}{} - complaintsByID := map[types.NodeID]int{} + complaintsByID := map[types.NodeID]map[types.NodeID]struct{}{} for _, complaint := range complaints { if complaint.IsNack() { - complaintsByID[complaint.PrivateShare.ProposerID]++ + if _, exist := complaintsByID[complaint.PrivateShare.ProposerID]; !exist { + complaintsByID[complaint.PrivateShare.ProposerID] = + make(map[types.NodeID]struct{}) + } + complaintsByID[complaint.PrivateShare.ProposerID][complaint.ProposerID] = + struct{}{} } else { disqualifyIDs[complaint.PrivateShare.ProposerID] = struct{}{} } } - for nID, num := range complaintsByID { - if num > threshold { + for nID, complaints := range complaintsByID { + if len(complaints) > threshold { disqualifyIDs[nID] = struct{}{} } } diff --git a/vendor/github.com/dexon-foundation/dexon-consensus/core/utils.go b/vendor/github.com/dexon-foundation/dexon-consensus/core/utils.go index 2ef243757..671d68018 100644 --- a/vendor/github.com/dexon-foundation/dexon-consensus/core/utils.go +++ b/vendor/github.com/dexon-foundation/dexon-consensus/core/utils.go @@ -231,3 +231,7 @@ func isCircleCI() bool { func isTravisCI() bool { return isCI() && os.Getenv("TRAVIS") == "true" } + +func getDKGThreshold(config *types.Config) int { + return int(config.DKGSetSize/3) + 1 +} diff --git a/vendor/vendor.json b/vendor/vendor.json index 81119dc09..add9ce181 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": "0ead4a7c012af9ddaa4a934729e216539d2caeb1", - "revisionTime": "2018-12-13T03:01:43Z" + "revision": "99d72382687196fb15ea6ab0fcf297b9ab10ac46", + "revisionTime": "2018-12-16T06:44:15Z" }, { - "checksumSHA1": "7Oa+i0v4Xtpk+mA1ANSwPzOZrZo=", + "checksumSHA1": "jZLh+ZsuMIiMuksK9c/5QpMQ2IM=", "path": "github.com/dexon-foundation/dexon-consensus/core", - "revision": "0ead4a7c012af9ddaa4a934729e216539d2caeb1", - "revisionTime": "2018-12-13T03:01:43Z" + "revision": "99d72382687196fb15ea6ab0fcf297b9ab10ac46", + "revisionTime": "2018-12-16T06:44:15Z" }, { "checksumSHA1": "v4fKR7uhoyufi6hAVO44cFEb+tY=", @@ -123,44 +123,44 @@ { "checksumSHA1": "tQSbYCu5P00lUhKsx3IbBZCuSLY=", "path": "github.com/dexon-foundation/dexon-consensus/core/crypto", - "revision": "0ead4a7c012af9ddaa4a934729e216539d2caeb1", - "revisionTime": "2018-12-13T03:01:43Z" + "revision": "99d72382687196fb15ea6ab0fcf297b9ab10ac46", + "revisionTime": "2018-12-16T06:44:15Z" }, { - "checksumSHA1": "p2jOAulavUU2xyj018pYPHlj8XA=", + "checksumSHA1": "W2P7pkuJ+26BpJg03K4Y0nB5obI=", "path": "github.com/dexon-foundation/dexon-consensus/core/crypto/dkg", - "revision": "0ead4a7c012af9ddaa4a934729e216539d2caeb1", - "revisionTime": "2018-12-13T03:01:43Z" + "revision": "99d72382687196fb15ea6ab0fcf297b9ab10ac46", + "revisionTime": "2018-12-16T06:44:15Z" }, { "checksumSHA1": "6Pf6caC8LTNCI7IflFmglKYnxYo=", "path": "github.com/dexon-foundation/dexon-consensus/core/crypto/ecdsa", - "revision": "0ead4a7c012af9ddaa4a934729e216539d2caeb1", - "revisionTime": "2018-12-13T03:01:43Z" + "revision": "99d72382687196fb15ea6ab0fcf297b9ab10ac46", + "revisionTime": "2018-12-16T06:44:15Z" }, { - "checksumSHA1": "oE4WEMp92OrJrujzd3XdQEkPiDI=", + "checksumSHA1": "trkFVPLd7UFFUzL8bn6KuvFU9gE=", "path": "github.com/dexon-foundation/dexon-consensus/core/db", - "revision": "0ead4a7c012af9ddaa4a934729e216539d2caeb1", - "revisionTime": "2018-12-13T03:01:43Z" + "revision": "99d72382687196fb15ea6ab0fcf297b9ab10ac46", + "revisionTime": "2018-12-16T06:44:15Z" }, { "checksumSHA1": "Z079qQV+aQV9A3kSJ0LbFjx5VO4=", "path": "github.com/dexon-foundation/dexon-consensus/core/types", - "revision": "0ead4a7c012af9ddaa4a934729e216539d2caeb1", - "revisionTime": "2018-12-13T03:01:43Z" + "revision": "99d72382687196fb15ea6ab0fcf297b9ab10ac46", + "revisionTime": "2018-12-16T06:44:15Z" }, { "checksumSHA1": "Sn3PAYsblIXmr7gVKDzxnoBPku4=", "path": "github.com/dexon-foundation/dexon-consensus/core/types/dkg", - "revision": "0ead4a7c012af9ddaa4a934729e216539d2caeb1", - "revisionTime": "2018-12-13T03:01:43Z" + "revision": "99d72382687196fb15ea6ab0fcf297b9ab10ac46", + "revisionTime": "2018-12-16T06:44:15Z" }, { "checksumSHA1": "A7UQ+7rv9FuElmFBEn/ZdhBqFKI=", "path": "github.com/dexon-foundation/dexon-consensus/core/utils", - "revision": "0ead4a7c012af9ddaa4a934729e216539d2caeb1", - "revisionTime": "2018-12-13T03:01:43Z" + "revision": "99d72382687196fb15ea6ab0fcf297b9ab10ac46", + "revisionTime": "2018-12-16T06:44:15Z" }, { "checksumSHA1": "TAkwduKZqLyimyTPPWIllZWYFuE=", -- cgit v1.2.3