Merge pull request #23 from QuilibriumNetwork/v1.1.4

1.1.4 – Reversed sync, detached consensus loop

node/config/engine.go

@@ -6,4 +6,5 @@ type EngineConfig struct {
 	GenesisSeed          string `yaml:"genesisSeed"`
 	MaxFrames            int64  `yaml:"maxFrames"`
 	PendingCommitWorkers int64  `yaml:"pendingCommitWorkers"`
+	MinimumPeersRequired int    `yaml:"minimumPeersRequired"`
 }

node/consensus/ceremony/broadcast_messaging.go

@@ -8,7 +8,6 @@ import (
 	"time"
 
 	"github.com/iden3/go-iden3-crypto/poseidon"
-	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/pkg/errors"
 	"go.uber.org/zap"
 	"golang.org/x/crypto/sha3"
@@ -158,6 +157,10 @@ func (e *CeremonyDataClockConsensusEngine) handleCeremonyPeerListAnnounce(
 
 	e.peerMapMx.Lock()
 	for _, p := range announce.PeerList {
+		if p.Timestamp < time.Now().UnixMilli()-PEER_INFO_TTL {
+			continue
+		}
+
 		if _, ok := e.uncooperativePeersMap[string(p.PeerId)]; ok {
 			continue
 		}
@@ -166,83 +169,40 @@ func (e *CeremonyDataClockConsensusEngine) handleCeremonyPeerListAnnounce(
 			continue
 		}
 
+		multiaddr := p.Multiaddr
+		if bytes.Equal(p.PeerId, peerID) {
+			// we have to fetch self-reported peer info
+			multiaddr = e.pubSub.GetMultiaddrOfPeer(peerID)
+		}
+
 		pr, ok := e.peerMap[string(p.PeerId)]
 		if !ok {
-			if bytes.Equal(p.PeerId, peerID) {
 			e.peerMap[string(p.PeerId)] = &peerInfo{
 				peerId:    p.PeerId,
-					multiaddr: e.pubSub.GetMultiaddrOfPeer(peerID),
+				multiaddr: multiaddr,
 				maxFrame:  p.MaxFrame,
 				direct:    bytes.Equal(p.PeerId, peerID),
 				lastSeen:  time.Now().Unix(),
-				}
+				timestamp: p.Timestamp,
-			} else {
-				e.peerMap[string(p.PeerId)] = &peerInfo{
-					peerId:    p.PeerId,
-					multiaddr: p.Multiaddr,
-					maxFrame:  p.MaxFrame,
-					direct:    bytes.Equal(p.PeerId, peerID),
-					lastSeen:  time.Now().Unix(),
-				}
 			}
 		} else {
 			if bytes.Equal(p.PeerId, peerID) {
 				e.peerMap[string(p.PeerId)] = &peerInfo{
 					peerId:    p.PeerId,
-					multiaddr: e.pubSub.GetMultiaddrOfPeer(peerID),
+					multiaddr: multiaddr,
 					maxFrame:  p.MaxFrame,
-					direct:    bytes.Equal(p.PeerId, peerID),
+					direct:    true,
 					lastSeen:  time.Now().Unix(),
+					timestamp: p.Timestamp,
 				}
-			} else {
+			} else if !pr.direct || time.Now().Unix()-pr.lastSeen > 30 {
-				if pr.direct {
-					dst := int64(p.MaxFrame) - int64(pr.maxFrame)
-					if time.Now().Unix()-pr.lastSeen > 30 {
 				e.peerMap[string(p.PeerId)] = &peerInfo{
 					peerId:    p.PeerId,
 					multiaddr: p.Multiaddr,
 					maxFrame:  p.MaxFrame,
 					direct:    false,
 					lastSeen:  time.Now().Unix(),
-						}
+					timestamp: p.Timestamp,
-					} else if dst > 4 {
-						e.logger.Warn(
-							"peer sent announcement with higher frame index for peer",
-							zap.String("sender_peer", peer.ID(peerID).String()),
-							zap.String("announced_peer", peer.ID(pr.peerId).String()),
-							zap.Int64("frame_distance", dst),
-						)
-						e.peerMap[string(p.PeerId)] = &peerInfo{
-							peerId:    p.PeerId,
-							multiaddr: p.Multiaddr,
-							maxFrame:  p.MaxFrame,
-							direct:    false,
-							lastSeen:  time.Now().Unix(),
-						}
-					} else if dst < -4 {
-						e.logger.Debug(
-							"peer sent announcement with lower frame index for peer",
-							zap.String("sender_peer", peer.ID(peerID).String()),
-							zap.String("announced_peer", peer.ID(pr.peerId).String()),
-							zap.Int64("frame_distance", dst),
-						)
-					} else {
-						e.peerMap[string(p.PeerId)] = &peerInfo{
-							peerId:    p.PeerId,
-							multiaddr: p.Multiaddr,
-							maxFrame:  p.MaxFrame,
-							direct:    false,
-							lastSeen:  time.Now().Unix(),
-						}
-					}
-				} else {
-					e.peerMap[string(p.PeerId)] = &peerInfo{
-						peerId:    p.PeerId,
-						multiaddr: p.Multiaddr,
-						maxFrame:  p.MaxFrame,
-						direct:    false,
-						lastSeen:  time.Now().Unix(),
-					}
 				}
 			}
 		}

node/consensus/ceremony/ceremony_data_clock_consensus_engine.go

@@ -22,6 +22,9 @@ import (
 	"source.quilibrium.com/quilibrium/monorepo/node/tries"
 )
 
+const PEER_INFO_TTL = 5 * 60 * 1000
+const UNCOOPERATIVE_PEER_INFO_TTL = 60 * 60 * 1000
+
 type InclusionMap = map[curves.PairingPoint]*protobufs.InclusionCommitment
 type PolynomialMap = map[curves.PairingPoint][]curves.PairingScalar
 type SyncStatusType int
@@ -36,6 +39,7 @@ type peerInfo struct {
 	peerId    []byte
 	multiaddr string
 	maxFrame  uint64
+	timestamp int64
 	lastSeen  int64
 	direct    bool
 }
@@ -68,6 +72,7 @@ type CeremonyDataClockConsensusEngine struct {
 	stagedKeyCommits            InclusionMap
 	stagedKeyPolynomials        PolynomialMap
 	stagedLobbyStateTransitions *protobufs.CeremonyLobbyStateTransition
+	minimumPeersRequired        int
 
 	frameChan                      chan *protobufs.ClockFrame
 	executionEngines               map[string]execution.ExecutionEngine
@@ -127,6 +132,11 @@ func NewCeremonyDataClockConsensusEngine(
 		panic(errors.New("pubsub is nil"))
 	}
 
+	minimumPeersRequired := engineConfig.MinimumPeersRequired
+	if minimumPeersRequired == 0 {
+		minimumPeersRequired = 6
+	}
+
 	e := &CeremonyDataClockConsensusEngine{
 		frame:            0,
 		difficulty:       10000,
@@ -157,6 +167,7 @@ func NewCeremonyDataClockConsensusEngine(
 		peerAnnounceMap:       map[string]*protobufs.CeremonyPeerListAnnounce{},
 		peerMap:               map[string]*peerInfo{},
 		uncooperativePeersMap: map[string]*peerInfo{},
+		minimumPeersRequired:  minimumPeersRequired,
 	}
 
 	logger.Info("constructing consensus engine")
@@ -243,12 +254,27 @@ func (e *CeremonyDataClockConsensusEngine) Start(
 				multiaddr: "",
 				maxFrame:  e.frame,
 			}
+			deletes := []*peerInfo{}
 			for _, v := range e.peerMap {
+				if v.timestamp > time.Now().UnixMilli()-PEER_INFO_TTL {
 					list.PeerList = append(list.PeerList, &protobufs.CeremonyPeer{
 						PeerId:    v.peerId,
 						Multiaddr: v.multiaddr,
 						MaxFrame:  v.maxFrame,
+						Timestamp: v.timestamp,
 					})
+				} else {
+					deletes = append(deletes, v)
+				}
+			}
+			for _, v := range e.uncooperativePeersMap {
+				if v.timestamp <= time.Now().UnixMilli()-UNCOOPERATIVE_PEER_INFO_TTL {
+					deletes = append(deletes, v)
+				}
+			}
+			for _, v := range deletes {
+				delete(e.peerMap, string(v.peerId))
+				delete(e.uncooperativePeersMap, string(v.peerId))
 			}
 			e.peerMapMx.Unlock()
 
@@ -258,8 +284,35 @@ func (e *CeremonyDataClockConsensusEngine) Start(
 		}
 	}()
 
+	go func() {
+		latest := latestFrame
+		for {
+			time.Sleep(30 * time.Second)
+			peerCount := e.pubSub.GetNetworkPeersCount()
+			if peerCount >= e.minimumPeersRequired {
+				e.logger.Info("selecting leader")
+				latest, err = e.commitLongestPath(latest)
+				if err != nil {
+					e.logger.Error("could not collect longest path", zap.Error(err))
+					latest, _, err = e.clockStore.GetDataClockFrame(e.filter, 0)
+					if err != nil {
+						panic(err)
+					}
+				}
+			}
+		}
+	}()
+
 	go func() {
 		for e.state < consensus.EngineStateStopping {
+			peerCount := e.pubSub.GetNetworkPeersCount()
+			if peerCount < e.minimumPeersRequired {
+				e.logger.Info(
+					"waiting for minimum peers",
+					zap.Int("peer_count", peerCount),
+				)
+				time.Sleep(1 * time.Second)
+			} else {
 				switch e.state {
 				case consensus.EngineStateCollecting:
 					if latestFrame, err = e.collect(latestFrame); err != nil {
@@ -281,6 +334,7 @@ func (e *CeremonyDataClockConsensusEngine) Start(
 					}
 				}
 			}
+		}
 	}()
 
 	go func() {
@@ -356,6 +410,7 @@ func (
 			PeerId:     v.peerId,
 			Multiaddrs: []string{v.multiaddr},
 			MaxFrame:   v.maxFrame,
+			Timestamp:  v.timestamp,
 		})
 	}
 	for _, v := range e.uncooperativePeersMap {
@@ -365,6 +420,7 @@ func (
 				PeerId:     v.peerId,
 				Multiaddrs: []string{v.multiaddr},
 				MaxFrame:   v.maxFrame,
+				Timestamp:  v.timestamp,
 			},
 		)
 	}

node/consensus/ceremony/consensus_frames.go

@@ -861,33 +861,12 @@ func (e *CeremonyDataClockConsensusEngine) GetMostAheadPeer() (
 	return peer, max, nil
 }
 
-func (e *CeremonyDataClockConsensusEngine) collect(
+func (e *CeremonyDataClockConsensusEngine) reverseOptimisticSync(
-	currentFramePublished *protobufs.ClockFrame,
+	currentLatest *protobufs.ClockFrame,
+	maxFrame uint64,
+	peerId []byte,
 ) (*protobufs.ClockFrame, error) {
-	if e.state == consensus.EngineStateCollecting {
+	latest := currentLatest
-		e.logger.Info("collecting vdf proofs")
-
-		latest, err := e.clockStore.GetLatestDataClockFrame(e.filter, nil)
-		if err != nil {
-			e.logger.Error("could not obtain latest clock frame", zap.Error(err))
-
-			return nil, errors.Wrap(err, "collect")
-		}
-
-		maxFrame := uint64(0)
-		var peerId []byte
-		peerId, maxFrame, err = e.GetMostAheadPeer()
-		if err != nil {
-			e.logger.Warn("no peers available, skipping sync")
-		} else if peerId == nil {
-			e.logger.Info("currently up to date, skipping sync")
-		} else {
-			e.syncingStatus = SyncStatusAwaitingResponse
-			e.logger.Info(
-				"setting syncing target",
-				zap.String("peer_id", peer.ID(peerId).String()),
-			)
-
 	cc, err := e.pubSub.GetDirectChannel(peerId)
 	if err != nil {
 		e.logger.Error(
@@ -898,34 +877,96 @@ func (e *CeremonyDataClockConsensusEngine) collect(
 		e.uncooperativePeersMap[string(peerId)] = e.peerMap[string(peerId)]
 		delete(e.peerMap, string(peerId))
 		e.peerMapMx.Unlock()
-			} else {
+		e.syncingTarget = nil
-				from := latest.FrameNumber
+		return latest, errors.Wrap(err, "reverse optimistic sync")
-				originalFrom := from
-				originalLatest := latest
-				if from == 0 {
-					from = 1
-				} else if maxFrame-from > 32 {
-					// divergence is high, we need to confirm we're not in a fork
-					from = 1
-					latest, _, err = e.clockStore.GetDataClockFrame(e.filter, 0)
-					if err != nil {
-						// This should never happen for healthy systems, if it does we're
-						// in a severely corrupted state.
-						e.logger.Error(
-							"could not find genesis frame, please reset your store",
-						)
-						panic(err)
-					}
 	}
 
 	client := protobufs.NewCeremonyServiceClient(cc)
+
+	from := latest.FrameNumber
+	if from == 0 {
+		from = 1
+	}
+
+	if maxFrame-from > 32 {
+		// divergence is high, ask them for the latest frame and if they
+		// respond with a valid answer, optimistically continue from this
+		// frame, if we hit a fault we'll mark them as uncooperative and move
+		// on
+		from = 1
+		s, err := client.GetCompressedSyncFrames(
+			context.Background(),
+			&protobufs.ClockFramesRequest{
+				Filter:          e.filter,
+				FromFrameNumber: maxFrame - 32,
+			},
+			grpc.MaxCallRecvMsgSize(400*1024*1024),
+		)
+		if err != nil {
+			e.logger.Error(
+				"received error from peer",
+				zap.Error(err),
+			)
+			e.peerMapMx.Lock()
+			e.uncooperativePeersMap[string(peerId)] = e.peerMap[string(peerId)]
+			delete(e.peerMap, string(peerId))
+			e.peerMapMx.Unlock()
+			e.syncingTarget = nil
+			return latest, errors.Wrap(err, "reverse optimistic sync")
+		}
+		var syncMsg *protobufs.CeremonyCompressedSync
+		for syncMsg, err = s.Recv(); err == nil; syncMsg, err = s.Recv() {
+			e.logger.Info(
+				"received compressed sync frame",
+				zap.Uint64("from", syncMsg.FromFrameNumber),
+				zap.Uint64("to", syncMsg.ToFrameNumber),
+				zap.Int("frames", len(syncMsg.TruncatedClockFrames)),
+				zap.Int("proofs", len(syncMsg.Proofs)),
+			)
+			var next *protobufs.ClockFrame
+			if next, err = e.decompressAndStoreCandidates(
+				syncMsg,
+				e.logger.Info,
+			); err != nil && !errors.Is(err, ErrNoNewFrames) {
+				e.logger.Error(
+					"could not decompress and store candidate",
+					zap.Error(err),
+				)
+				e.peerMapMx.Lock()
+				e.uncooperativePeersMap[string(peerId)] = e.peerMap[string(peerId)]
+				delete(e.peerMap, string(peerId))
+				e.peerMapMx.Unlock()
+
+				if err := cc.Close(); err != nil {
+					e.logger.Error("error while closing connection", zap.Error(err))
+				}
+
+				e.syncingTarget = nil
+				return currentLatest, errors.Wrap(err, "reverse optimistic sync")
+			}
+			if next != nil {
+				latest = next
+			}
+		}
+		if err != nil && err != io.EOF && !errors.Is(err, ErrNoNewFrames) {
+			if err := cc.Close(); err != nil {
+				e.logger.Error("error while closing connection", zap.Error(err))
+			}
+			e.logger.Error("error while receiving sync", zap.Error(err))
+			e.syncingTarget = nil
+			return latest, errors.Wrap(err, "reverse optimistic sync")
+		}
+	}
+
+	go func() {
+		defer func() { e.syncingTarget = nil }()
+		e.logger.Info("continuing sync in background")
 		s, err := client.GetCompressedSyncFrames(
 			context.Background(),
 			&protobufs.ClockFramesRequest{
 				Filter:          e.filter,
 				FromFrameNumber: from,
 				ToFrameNumber:   maxFrame,
-						ParentSelector:  latest.ParentSelector,
 			},
 			grpc.MaxCallRecvMsgSize(400*1024*1024),
 		)
@@ -934,92 +975,101 @@ func (e *CeremonyDataClockConsensusEngine) collect(
 				"error while retrieving sync",
 				zap.Error(err),
 			)
-					latest = originalLatest
 			e.peerMapMx.Lock()
 			e.uncooperativePeersMap[string(peerId)] = e.peerMap[string(peerId)]
 			delete(e.peerMap, string(peerId))
 			e.peerMapMx.Unlock()
+
+			if err := cc.Close(); err != nil {
+				e.logger.Error("error while closing connection", zap.Error(err))
+			}
+			return
 		} else {
 			var syncMsg *protobufs.CeremonyCompressedSync
-					askedFrom := from
 			for syncMsg, err = s.Recv(); err == nil; syncMsg, err = s.Recv() {
-						if syncMsg.FromFrameNumber < askedFrom {
+				e.logger.Debug(
-							askedFrom = syncMsg.FromFrameNumber
-						}
-
-						e.logger.Info(
 					"received compressed sync frame",
 					zap.Uint64("from", syncMsg.FromFrameNumber),
 					zap.Uint64("to", syncMsg.ToFrameNumber),
 					zap.Int("frames", len(syncMsg.TruncatedClockFrames)),
 					zap.Int("proofs", len(syncMsg.Proofs)),
 				)
-						if err = e.decompressAndStoreCandidates(syncMsg); err != nil {
+				if _, err = e.decompressAndStoreCandidates(
+					syncMsg,
+					e.logger.Debug,
+				); err != nil && !errors.Is(err, ErrNoNewFrames) {
 					e.logger.Error(
 						"could not decompress and store candidate",
 						zap.Error(err),
 					)
-							from = originalFrom
-							latest = originalLatest
-							break
-						}
-					}
-					if err != nil && err != io.EOF {
-						e.logger.Error("error while receiving sync", zap.Error(err))
-						from = originalFrom
-						latest = originalLatest
-						askedFrom = from
-					}
 
-					if askedFrom < from {
+					if err := cc.Close(); err != nil {
-						e.logger.Info(
+						e.logger.Error("error while closing connection", zap.Error(err))
-							"peer provided deeper history due to fork, rewinding consensus " +
-								"head",
-						)
-						askedLatest, _, err := e.clockStore.GetDataClockFrame(
-							e.filter,
-							askedFrom-1,
-						)
-						if err != nil {
-							e.logger.Error("error while receiving sync", zap.Error(err))
-						} else {
-							latest = askedLatest
 					}
+					return
+				}
+			}
+			if err != nil && err != io.EOF && !errors.Is(err, ErrNoNewFrames) {
+				e.logger.Error("error while receiving sync", zap.Error(err))
+				if err := cc.Close(); err != nil {
+					e.logger.Error("error while closing connection", zap.Error(err))
+				}
+				return
 			}
 		}
 
 		if err := cc.Close(); err != nil {
 			e.logger.Error("error while closing connection", zap.Error(err))
 		}
-			}
+	}()
+
+	return latest, nil
 }
 
-		e.logger.Info("selecting leader")
+func (e *CeremonyDataClockConsensusEngine) collect(
-		latestFrame, err := e.commitLongestPath(latest)
+	currentFramePublished *protobufs.ClockFrame,
+) (*protobufs.ClockFrame, error) {
+	if e.state == consensus.EngineStateCollecting {
+		e.logger.Info("collecting vdf proofs")
+
+		latest := currentFramePublished
+		maxFrame := uint64(0)
+		var peerId []byte
+		peerId, maxFrame, err := e.GetMostAheadPeer()
 		if err != nil {
-			e.logger.Error("could not collect longest path", zap.Error(err))
+			e.logger.Warn("no peers available, skipping sync")
-			return nil, errors.Wrap(err, "collect")
+		} else if peerId == nil {
+			e.logger.Info("currently up to date, skipping sync")
+		} else if e.syncingTarget == nil {
+			e.syncingStatus = SyncStatusAwaitingResponse
+			e.logger.Info(
+				"setting syncing target",
+				zap.String("peer_id", peer.ID(peerId).String()),
+			)
+
+			e.syncingTarget = peerId
+			latest, err = e.reverseOptimisticSync(latest, maxFrame, peerId)
 		}
 
 		go func() {
 			_, err = e.keyStore.GetProvingKey(e.provingKeyBytes)
 			if errors.Is(err, store.ErrNotFound) &&
-				latestFrame.FrameNumber-e.lastKeyBundleAnnouncementFrame > 6 {
+				latest.FrameNumber-e.lastKeyBundleAnnouncementFrame > 6 {
 				if err = e.announceKeyBundle(); err != nil {
 					panic(err)
 				}
-				e.lastKeyBundleAnnouncementFrame = latestFrame.FrameNumber
+				e.lastKeyBundleAnnouncementFrame = latest.FrameNumber
 			}
 		}()
 
 		e.logger.Info(
 			"returning leader frame",
-			zap.Uint64("frame_number", latestFrame.FrameNumber),
+			zap.Uint64("frame_number", latest.FrameNumber),
 		)
 
-		e.setFrame(latestFrame)
+		e.setFrame(latest)
 		e.state = consensus.EngineStateProving
-		return latestFrame, nil
+		return latest, nil
 	}
 
 	return nil, nil

node/consensus/ceremony/peer_messaging.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/pkg/errors"
 	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
 	"google.golang.org/grpc"
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/types/known/anypb"
@@ -17,6 +18,8 @@ import (
 	"source.quilibrium.com/quilibrium/monorepo/node/store"
 )
 
+var ErrNoNewFrames = errors.New("peer reported no frames")
+
 func (e *CeremonyDataClockConsensusEngine) handleSync(
 	message *pb.Message,
 ) error {
@@ -151,9 +154,9 @@ func (e *CeremonyDataClockConsensusEngine) GetCompressedSyncFrames(
 	for {
 		if to == 0 || to-from > 32 {
 			if max > from+31 {
-				to = from + 31
+				to = from + 32
 			} else {
-				to = max
+				to = max + 1
 			}
 		}
 
@@ -187,23 +190,29 @@ func (e *CeremonyDataClockConsensusEngine) GetCompressedSyncFrames(
 
 func (e *CeremonyDataClockConsensusEngine) decompressAndStoreCandidates(
 	syncMsg *protobufs.CeremonyCompressedSync,
-) error {
+	loggerFunc func(msg string, fields ...zapcore.Field),
+) (*protobufs.ClockFrame, error) {
+	if len(syncMsg.TruncatedClockFrames) == 0 {
+		return nil, ErrNoNewFrames
+	}
+
 	if len(syncMsg.TruncatedClockFrames) != int(
 		syncMsg.ToFrameNumber-syncMsg.FromFrameNumber+1,
 	) {
-		return errors.New("invalid continuity for compressed sync response")
+		return nil, errors.New("invalid continuity for compressed sync response")
 	}
 
+	var final *protobufs.ClockFrame
 	for _, frame := range syncMsg.TruncatedClockFrames {
 		frame := frame
 		commits := (len(frame.Input) - 516) / 74
-		e.logger.Info(
+		loggerFunc(
 			"processing frame",
 			zap.Uint64("frame_number", frame.FrameNumber),
 			zap.Int("aggregate_commits", commits),
 		)
 		for j := 0; j < commits; j++ {
-			e.logger.Info(
+			loggerFunc(
 				"processing commit",
 				zap.Uint64("frame_number", frame.FrameNumber),
 				zap.Int("commit_index", j),
@@ -213,7 +222,7 @@ func (e *CeremonyDataClockConsensusEngine) decompressAndStoreCandidates(
 			for _, a := range syncMsg.Proofs {
 				a := a
 				if bytes.Equal(a.FrameCommit, commit) {
-					e.logger.Info(
+					loggerFunc(
 						"found matching proof",
 						zap.Uint64("frame_number", frame.FrameNumber),
 						zap.Int("commit_index", j),
@@ -229,7 +238,7 @@ func (e *CeremonyDataClockConsensusEngine) decompressAndStoreCandidates(
 					zap.Int("commit_index", j),
 					zap.Binary("proof", aggregateProof.Proof),
 				)
-				return errors.Wrap(
+				return nil, errors.Wrap(
 					store.ErrInvalidData,
 					"decompress and store candidates",
 				)
@@ -244,7 +253,7 @@ func (e *CeremonyDataClockConsensusEngine) decompressAndStoreCandidates(
 			for k, c := range aggregateProof.Commitments {
 				k := k
 				c := c
-				e.logger.Info(
+				loggerFunc(
 					"adding inclusion commitment",
 					zap.Uint64("frame_number", frame.FrameNumber),
 					zap.Int("commit_index", j),
@@ -273,7 +282,7 @@ func (e *CeremonyDataClockConsensusEngine) decompressAndStoreCandidates(
 						if bytes.Equal(s.Hash, h) {
 							if output != nil {
 								if l == 0 {
-									e.logger.Info(
+									loggerFunc(
 										"found first half of matching segment data",
 										zap.Uint64("frame_number", frame.FrameNumber),
 										zap.Int("commit_index", j),
@@ -283,7 +292,7 @@ func (e *CeremonyDataClockConsensusEngine) decompressAndStoreCandidates(
 									output.Address = s.Data[:32]
 									output.Output = s.Data[32:]
 								} else {
-									e.logger.Info(
+									loggerFunc(
 										"found second half of matching segment data",
 										zap.Uint64("frame_number", frame.FrameNumber),
 										zap.Int("commit_index", j),
@@ -293,13 +302,16 @@ func (e *CeremonyDataClockConsensusEngine) decompressAndStoreCandidates(
 									output.Proof = s.Data
 									b, err := proto.Marshal(output)
 									if err != nil {
-										return errors.Wrap(err, "decompress and store candidates")
+										return nil, errors.Wrap(
+											err,
+											"decompress and store candidates",
+										)
 									}
 									incCommit.Data = b
 									break
 								}
 							} else {
-								e.logger.Info(
+								loggerFunc(
 									"found matching segment data",
 									zap.Uint64("frame_number", frame.FrameNumber),
 									zap.Int("commit_index", j),
@@ -326,7 +338,7 @@ func (e *CeremonyDataClockConsensusEngine) decompressAndStoreCandidates(
 
 		f, err := proto.Marshal(frame)
 		if err != nil {
-			return errors.Wrap(err, "decompress and store candidates")
+			return nil, errors.Wrap(err, "decompress and store candidates")
 		}
 
 		any := &anypb.Any{
@@ -339,16 +351,17 @@ func (e *CeremonyDataClockConsensusEngine) decompressAndStoreCandidates(
 			any,
 			true,
 		); err != nil {
-			return errors.Wrap(err, "decompress and store candidates")
+			return nil, errors.Wrap(err, "decompress and store candidates")
 		}
+		final = frame
 	}
 
-	e.logger.Info(
+	loggerFunc(
 		"decompressed and stored sync for range",
 		zap.Uint64("from", syncMsg.FromFrameNumber),
 		zap.Uint64("to", syncMsg.ToFrameNumber),
 	)
-	return nil
+	return final, nil
 }
 
 type svr struct {

node/main.go

@@ -230,5 +230,5 @@ func printLogo() {
 
 func printVersion() {
 	fmt.Println(" ")
-	fmt.Println("                         Quilibrium Node - v1.1.3 – Dawn")
+	fmt.Println("                         Quilibrium Node - v1.1.4 – Dawn")
 }

node/protobufs/ceremony.pb.go

@@ -1027,6 +1027,7 @@ type CeremonyPeer struct {
 	PeerId    []byte `protobuf:"bytes,1,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
 	Multiaddr string `protobuf:"bytes,2,opt,name=multiaddr,proto3" json:"multiaddr,omitempty"`
 	MaxFrame  uint64 `protobuf:"varint,3,opt,name=max_frame,json=maxFrame,proto3" json:"max_frame,omitempty"`
+	Timestamp int64  `protobuf:"varint,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
 }
 
 func (x *CeremonyPeer) Reset() {
@@ -1082,6 +1083,13 @@ func (x *CeremonyPeer) GetMaxFrame() uint64 {
 	return 0
 }
 
+func (x *CeremonyPeer) GetTimestamp() int64 {
+	if x != nil {
+		return x.Timestamp
+	}
+	return 0
+}
+
 type CeremonyCompressedSync struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -1638,79 +1646,81 @@ var file_ceremony_proto_rawDesc = []byte{
 	0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d,
 	0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x79, 0x2e, 0x70,
 	0x62, 0x2e, 0x43, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x79, 0x50, 0x65, 0x65, 0x72, 0x52, 0x08,
-	0x70, 0x65, 0x65, 0x72, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x62, 0x0a, 0x0c, 0x43, 0x65, 0x72, 0x65,
+	0x70, 0x65, 0x65, 0x72, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x80, 0x01, 0x0a, 0x0c, 0x43, 0x65, 0x72,
-	0x6d, 0x6f, 0x6e, 0x79, 0x50, 0x65, 0x65, 0x72, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x65, 0x65, 0x72,
+	0x65, 0x6d, 0x6f, 0x6e, 0x79, 0x50, 0x65, 0x65, 0x72, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x65, 0x65,
-	0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x70, 0x65, 0x65, 0x72, 0x49,
+	0x72, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x70, 0x65, 0x65, 0x72,
-	0x64, 0x12, 0x1c, 0x0a, 0x09, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x61, 0x64, 0x64, 0x72, 0x18, 0x02,
+	0x49, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x61, 0x64, 0x64, 0x72, 0x18,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x61, 0x64, 0x64, 0x72, 0x12,
+	0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x61, 0x64, 0x64, 0x72,
-	0x1b, 0x0a, 0x09, 0x6d, 0x61, 0x78, 0x5f, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01,
+	0x12, 0x1b, 0x0a, 0x09, 0x6d, 0x61, 0x78, 0x5f, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20,
-	0x28, 0x04, 0x52, 0x08, 0x6d, 0x61, 0x78, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x22, 0xe0, 0x02, 0x0a,
+	0x01, 0x28, 0x04, 0x52, 0x08, 0x6d, 0x61, 0x78, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a,
-	0x16, 0x43, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x79, 0x43, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73,
+	0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03,
-	0x73, 0x65, 0x64, 0x53, 0x79, 0x6e, 0x63, 0x12, 0x2a, 0x0a, 0x11, 0x66, 0x72, 0x6f, 0x6d, 0x5f,
+	0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0xe0, 0x02, 0x0a, 0x16,
-	0x66, 0x72, 0x61, 0x6d, 0x65, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x04, 0x52, 0x0f, 0x66, 0x72, 0x6f, 0x6d, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x4e, 0x75, 0x6d,
-	0x62, 0x65, 0x72, 0x12, 0x26, 0x0a, 0x0f, 0x74, 0x6f, 0x5f, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x5f,
-	0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x74, 0x6f,
-	0x46, 0x72, 0x61, 0x6d, 0x65, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x5a, 0x0a, 0x16, 0x74,
-	0x72, 0x75, 0x6e, 0x63, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x66,
-	0x72, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x71, 0x75,
-	0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63, 0x6c,
-	0x6f, 0x63, 0x6b, 0x2e, 0x70, 0x62, 0x2e, 0x43, 0x6c, 0x6f, 0x63, 0x6b, 0x46, 0x72, 0x61, 0x6d,
-	0x65, 0x52, 0x14, 0x74, 0x72, 0x75, 0x6e, 0x63, 0x61, 0x74, 0x65, 0x64, 0x43, 0x6c, 0x6f, 0x63,
-	0x6b, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x47, 0x0a, 0x06, 0x70, 0x72, 0x6f, 0x6f, 0x66,
-	0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62,
-	0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63, 0x65, 0x72, 0x65, 0x6d, 0x6f,
-	0x6e, 0x79, 0x2e, 0x70, 0x62, 0x2e, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x50,
-	0x72, 0x6f, 0x6f, 0x66, 0x73, 0x4d, 0x61, 0x70, 0x52, 0x06, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x73,
-	0x12, 0x4d, 0x0a, 0x08, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x05, 0x20, 0x03,
-	0x28, 0x0b, 0x32, 0x31, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e,
-	0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x79, 0x2e, 0x70, 0x62,
-	0x2e, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e,
-	0x74, 0x73, 0x4d, 0x61, 0x70, 0x52, 0x08, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22,
-	0xa5, 0x01, 0x0a, 0x12, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f,
-	0x6f, 0x66, 0x73, 0x4d, 0x61, 0x70, 0x12, 0x21, 0x0a, 0x0c, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x5f,
-	0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x66, 0x72,
-	0x61, 0x6d, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x72, 0x6f,
-	0x6f, 0x66, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x12,
-	0x56, 0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x03,
-	0x20, 0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75,
-	0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x79, 0x2e,
-	0x70, 0x62, 0x2e, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6d, 0x6d,
-	0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x4d, 0x61, 0x70, 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x6d,
-	0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x3e, 0x0a, 0x14, 0x49, 0x6e, 0x63, 0x6c, 0x75,
-	0x73, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x4d, 0x61, 0x70, 0x12,
-	0x12, 0x0a, 0x04, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x68,
-	0x61, 0x73, 0x68, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28,
-	0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x22, 0x7b, 0x0a, 0x17, 0x49, 0x6e, 0x63, 0x6c, 0x75,
-	0x73, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x4d,
-	0x61, 0x70, 0x12, 0x1e, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74,
-	0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65,
-	0x6e, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x74, 0x79, 0x70, 0x65, 0x55, 0x72, 0x6c, 0x12, 0x25, 0x0a,
-	0x0e, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x18,
-	0x03, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0d, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x48, 0x61,
-	0x73, 0x68, 0x65, 0x73, 0x32, 0x89, 0x02, 0x0a, 0x0f, 0x43, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x6e,
-	0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x7e, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x43,
-	0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x53, 0x79, 0x6e, 0x63, 0x46, 0x72, 0x61,
-	0x6d, 0x65, 0x73, 0x12, 0x2c, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d,
-	0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x70, 0x62, 0x2e, 0x43,
-	0x6c, 0x6f, 0x63, 0x6b, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x1a, 0x33, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e,
-	0x6f, 0x64, 0x65, 0x2e, 0x63, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x79, 0x2e, 0x70, 0x62, 0x2e,
 	0x43, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x79, 0x43, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73,
-	0x65, 0x64, 0x53, 0x79, 0x6e, 0x63, 0x30, 0x01, 0x12, 0x76, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x50,
+	0x65, 0x64, 0x53, 0x79, 0x6e, 0x63, 0x12, 0x2a, 0x0a, 0x11, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x66,
-	0x75, 0x62, 0x6c, 0x69, 0x63, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x2e, 0x2e, 0x71,
+	0x72, 0x61, 0x6d, 0x65, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63,
+	0x04, 0x52, 0x0f, 0x66, 0x72, 0x6f, 0x6d, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x4e, 0x75, 0x6d, 0x62,
-	0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x2e, 0x70, 0x62, 0x2e, 0x50, 0x32, 0x50, 0x43, 0x68, 0x61,
+	0x65, 0x72, 0x12, 0x26, 0x0a, 0x0f, 0x74, 0x6f, 0x5f, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x5f, 0x6e,
-	0x6e, 0x6e, 0x65, 0x6c, 0x45, 0x6e, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x1a, 0x2e, 0x2e, 0x71,
+	0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x74, 0x6f, 0x46,
-	0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63,
+	0x72, 0x61, 0x6d, 0x65, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x5a, 0x0a, 0x16, 0x74, 0x72,
-	0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x2e, 0x70, 0x62, 0x2e, 0x50, 0x32, 0x50, 0x43, 0x68, 0x61,
+	0x75, 0x6e, 0x63, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x66, 0x72,
-	0x6e, 0x6e, 0x65, 0x6c, 0x45, 0x6e, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x28, 0x01, 0x30, 0x01,
+	0x61, 0x6d, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x71, 0x75, 0x69,
-	0x42, 0x3a, 0x5a, 0x38, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69,
+	0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63, 0x6c, 0x6f,
-	0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62,
+	0x63, 0x6b, 0x2e, 0x70, 0x62, 0x2e, 0x43, 0x6c, 0x6f, 0x63, 0x6b, 0x46, 0x72, 0x61, 0x6d, 0x65,
-	0x72, 0x69, 0x75, 0x6d, 0x2f, 0x6d, 0x6f, 0x6e, 0x6f, 0x72, 0x65, 0x70, 0x6f, 0x2f, 0x6e, 0x6f,
+	0x52, 0x14, 0x74, 0x72, 0x75, 0x6e, 0x63, 0x61, 0x74, 0x65, 0x64, 0x43, 0x6c, 0x6f, 0x63, 0x6b,
-	0x64, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x73, 0x62, 0x06, 0x70, 0x72,
+	0x46, 0x72, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x47, 0x0a, 0x06, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x73,
-	0x6f, 0x74, 0x6f, 0x33,
+	0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72,
+	0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x6e,
+	0x79, 0x2e, 0x70, 0x62, 0x2e, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x50, 0x72,
+	0x6f, 0x6f, 0x66, 0x73, 0x4d, 0x61, 0x70, 0x52, 0x06, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x73, 0x12,
+	0x4d, 0x0a, 0x08, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x31, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e,
+	0x6f, 0x64, 0x65, 0x2e, 0x63, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x79, 0x2e, 0x70, 0x62, 0x2e,
+	0x49, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74,
+	0x73, 0x4d, 0x61, 0x70, 0x52, 0x08, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0xa5,
+	0x01, 0x0a, 0x12, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x50, 0x72, 0x6f, 0x6f,
+	0x66, 0x73, 0x4d, 0x61, 0x70, 0x12, 0x21, 0x0a, 0x0c, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x5f, 0x63,
+	0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x66, 0x72, 0x61,
+	0x6d, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x72, 0x6f, 0x6f,
+	0x66, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x12, 0x56,
+	0x0a, 0x0b, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20,
+	0x03, 0x28, 0x0b, 0x32, 0x34, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d,
+	0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x79, 0x2e, 0x70,
+	0x62, 0x2e, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x73, 0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6d, 0x6d, 0x69,
+	0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x4d, 0x61, 0x70, 0x52, 0x0b, 0x63, 0x6f, 0x6d, 0x6d, 0x69,
+	0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x3e, 0x0a, 0x14, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x73,
+	0x69, 0x6f, 0x6e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x4d, 0x61, 0x70, 0x12, 0x12,
+	0x0a, 0x04, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x68, 0x61,
+	0x73, 0x68, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c,
+	0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x22, 0x7b, 0x0a, 0x17, 0x49, 0x6e, 0x63, 0x6c, 0x75, 0x73,
+	0x69, 0x6f, 0x6e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x4d, 0x61,
+	0x70, 0x12, 0x1e, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x18,
+	0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e,
+	0x74, 0x12, 0x19, 0x0a, 0x08, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x75, 0x72, 0x6c, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x07, 0x74, 0x79, 0x70, 0x65, 0x55, 0x72, 0x6c, 0x12, 0x25, 0x0a, 0x0e,
+	0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x18, 0x03,
+	0x20, 0x03, 0x28, 0x0c, 0x52, 0x0d, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x48, 0x61, 0x73,
+	0x68, 0x65, 0x73, 0x32, 0x89, 0x02, 0x0a, 0x0f, 0x43, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x79,
+	0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x7e, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x43, 0x6f,
+	0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x53, 0x79, 0x6e, 0x63, 0x46, 0x72, 0x61, 0x6d,
+	0x65, 0x73, 0x12, 0x2c, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e,
+	0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x70, 0x62, 0x2e, 0x43, 0x6c,
+	0x6f, 0x63, 0x6b, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x1a, 0x33, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f,
+	0x64, 0x65, 0x2e, 0x63, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x79, 0x2e, 0x70, 0x62, 0x2e, 0x43,
+	0x65, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x79, 0x43, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65,
+	0x64, 0x53, 0x79, 0x6e, 0x63, 0x30, 0x01, 0x12, 0x76, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x50, 0x75,
+	0x62, 0x6c, 0x69, 0x63, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x2e, 0x2e, 0x71, 0x75,
+	0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63, 0x68,
+	0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x2e, 0x70, 0x62, 0x2e, 0x50, 0x32, 0x50, 0x43, 0x68, 0x61, 0x6e,
+	0x6e, 0x65, 0x6c, 0x45, 0x6e, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x1a, 0x2e, 0x2e, 0x71, 0x75,
+	0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63, 0x68,
+	0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x2e, 0x70, 0x62, 0x2e, 0x50, 0x32, 0x50, 0x43, 0x68, 0x61, 0x6e,
+	0x6e, 0x65, 0x6c, 0x45, 0x6e, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x28, 0x01, 0x30, 0x01, 0x42,
+	0x3a, 0x5a, 0x38, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62,
+	0x72, 0x69, 0x75, 0x6d, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72,
+	0x69, 0x75, 0x6d, 0x2f, 0x6d, 0x6f, 0x6e, 0x6f, 0x72, 0x65, 0x70, 0x6f, 0x2f, 0x6e, 0x6f, 0x64,
+	0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x33,
 }
 
 var (

node/protobufs/ceremony.proto

@@ -135,6 +135,7 @@ message CeremonyPeer {
   bytes peer_id = 1;
   string multiaddr = 2;
   uint64 max_frame = 3;
+  int64 timestamp = 4;
 }
 
 message CeremonyCompressedSync {

node/protobufs/node.pb.go

@@ -332,6 +332,7 @@ type PeerInfo struct {
 	PeerId     []byte   `protobuf:"bytes,1,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
 	Multiaddrs []string `protobuf:"bytes,2,rep,name=multiaddrs,proto3" json:"multiaddrs,omitempty"`
 	MaxFrame   uint64   `protobuf:"varint,3,opt,name=max_frame,json=maxFrame,proto3" json:"max_frame,omitempty"`
+	Timestamp  int64    `protobuf:"varint,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
 }
 
 func (x *PeerInfo) Reset() {
@@ -387,6 +388,13 @@ func (x *PeerInfo) GetMaxFrame() uint64 {
 	return 0
 }
 
+func (x *PeerInfo) GetTimestamp() int64 {
+	if x != nil {
+		return x.Timestamp
+	}
+	return 0
+}
+
 type PeerInfoResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -591,68 +599,70 @@ var file_node_proto_rawDesc = []byte{
 	0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62,
 	0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x2e,
 	0x70, 0x62, 0x2e, 0x43, 0x6c, 0x6f, 0x63, 0x6b, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x52, 0x0a, 0x63,
-	0x6c, 0x6f, 0x63, 0x6b, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x22, 0x60, 0x0a, 0x08, 0x50, 0x65, 0x65,
+	0x6c, 0x6f, 0x63, 0x6b, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x22, 0x7e, 0x0a, 0x08, 0x50, 0x65, 0x65,
 	0x72, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x69, 0x64,
 	0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x70, 0x65, 0x65, 0x72, 0x49, 0x64, 0x12, 0x1e,
 	0x0a, 0x0a, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x61, 0x64, 0x64, 0x72, 0x73, 0x18, 0x02, 0x20, 0x03,
 	0x28, 0x09, 0x52, 0x0a, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x61, 0x64, 0x64, 0x72, 0x73, 0x12, 0x1b,
 	0x0a, 0x09, 0x6d, 0x61, 0x78, 0x5f, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28,
-	0x04, 0x52, 0x08, 0x6d, 0x61, 0x78, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x22, 0xad, 0x01, 0x0a, 0x10,
+	0x04, 0x52, 0x08, 0x6d, 0x61, 0x78, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x74,
-	0x50, 0x65, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09,
-	0x12, 0x3e, 0x0a, 0x09, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x01, 0x20,
+	0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0xad, 0x01, 0x0a, 0x10, 0x50, 0x65,
-	0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d,
+	0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3e,
-	0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x70, 0x62, 0x2e, 0x50, 0x65,
+	0x0a, 0x09, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x01, 0x20, 0x03, 0x28,
-	0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x70, 0x65, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f,
-	0x12, 0x59, 0x0a, 0x17, 0x75, 0x6e, 0x63, 0x6f, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x76,
-	0x65, 0x5f, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x02, 0x20, 0x03, 0x28,
 	0x0b, 0x32, 0x21, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e,
 	0x6f, 0x64, 0x65, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x70, 0x62, 0x2e, 0x50, 0x65, 0x65, 0x72,
-	0x49, 0x6e, 0x66, 0x6f, 0x52, 0x15, 0x75, 0x6e, 0x63, 0x6f, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74,
+	0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x70, 0x65, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x59,
-	0x69, 0x76, 0x65, 0x50, 0x65, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x65, 0x0a, 0x0b, 0x4e,
+	0x0a, 0x17, 0x75, 0x6e, 0x63, 0x6f, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f,
-	0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x65,
+	0x70, 0x65, 0x65, 0x72, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32,
-	0x65, 0x72, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x70, 0x65, 0x65,
+	0x21, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64,
-	0x72, 0x49, 0x64, 0x12, 0x1e, 0x0a, 0x0a, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x61, 0x64, 0x64, 0x72,
+	0x65, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x70, 0x62, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x49, 0x6e,
-	0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x61, 0x64,
+	0x66, 0x6f, 0x52, 0x15, 0x75, 0x6e, 0x63, 0x6f, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x69, 0x76,
-	0x64, 0x72, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x73, 0x63, 0x6f, 0x72,
+	0x65, 0x50, 0x65, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x22, 0x65, 0x0a, 0x0b, 0x4e, 0x65, 0x74,
-	0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x70, 0x65, 0x65, 0x72, 0x53, 0x63, 0x6f,
+	0x77, 0x6f, 0x72, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x17, 0x0a, 0x07, 0x70, 0x65, 0x65, 0x72,
-	0x72, 0x65, 0x22, 0x5e, 0x0a, 0x13, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x49, 0x6e, 0x66,
+	0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x70, 0x65, 0x65, 0x72, 0x49,
-	0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, 0x0a, 0x0c, 0x6e, 0x65, 0x74,
+	0x64, 0x12, 0x1e, 0x0a, 0x0a, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x61, 0x64, 0x64, 0x72, 0x73, 0x18,
-	0x77, 0x6f, 0x72, 0x6b, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32,
+	0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0a, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x61, 0x64, 0x64, 0x72,
-	0x24, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64,
+	0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x18,
-	0x65, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x70, 0x62, 0x2e, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72,
+	0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x70, 0x65, 0x65, 0x72, 0x53, 0x63, 0x6f, 0x72, 0x65,
-	0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0b, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x49, 0x6e,
+	0x22, 0x5e, 0x0a, 0x13, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x52,
-	0x66, 0x6f, 0x32, 0xaf, 0x03, 0x0a, 0x0b, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, 0x0a, 0x0c, 0x6e, 0x65, 0x74, 0x77, 0x6f,
-	0x63, 0x65, 0x12, 0x5f, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x73, 0x12,
+	0x72, 0x6b, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e,
-	0x29, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64,
+	0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e,
-	0x65, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x70, 0x62, 0x2e, 0x47, 0x65, 0x74, 0x46, 0x72, 0x61,
+	0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x70, 0x62, 0x2e, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x49,
-	0x6d, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x71, 0x75, 0x69,
+	0x6e, 0x66, 0x6f, 0x52, 0x0b, 0x6e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x49, 0x6e, 0x66, 0x6f,
+	0x32, 0xaf, 0x03, 0x0a, 0x0b, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65,
+	0x12, 0x5f, 0x0a, 0x09, 0x47, 0x65, 0x74, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x29, 0x2e,
+	0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e,
+	0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x70, 0x62, 0x2e, 0x47, 0x65, 0x74, 0x46, 0x72, 0x61, 0x6d, 0x65,
+	0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69,
+	0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e,
+	0x70, 0x62, 0x2e, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x12, 0x68, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x49, 0x6e, 0x66,
+	0x6f, 0x12, 0x2c, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e,
+	0x6f, 0x64, 0x65, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x70, 0x62, 0x2e, 0x47, 0x65, 0x74, 0x46,
+	0x72, 0x61, 0x6d, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+	0x2a, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64,
+	0x65, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x70, 0x62, 0x2e, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x49,
+	0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x65, 0x0a, 0x0b, 0x47,
+	0x65, 0x74, 0x50, 0x65, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2b, 0x2e, 0x71, 0x75, 0x69,
 	0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x6e, 0x6f, 0x64,
-	0x65, 0x2e, 0x70, 0x62, 0x2e, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x65, 0x2e, 0x70, 0x62, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x65, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f,
-	0x6e, 0x73, 0x65, 0x12, 0x68, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x49,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62,
-	0x6e, 0x66, 0x6f, 0x12, 0x2c, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d,
+	0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x70,
-	0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x70, 0x62, 0x2e, 0x47, 0x65,
+	0x62, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x74, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x73, 0x65, 0x12, 0x6e, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b,
-	0x74, 0x1a, 0x2a, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e,
+	0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2e, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75,
-	0x6f, 0x64, 0x65, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x70, 0x62, 0x2e, 0x46, 0x72, 0x61, 0x6d,
+	0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x70, 0x62, 0x2e, 0x47,
-	0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x65, 0x0a,
+	0x65, 0x74, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71,
-	0x0b, 0x47, 0x65, 0x74, 0x50, 0x65, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2b, 0x2e, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75,
-	0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x6e,
+	0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x70, 0x62, 0x2e, 0x4e,
-	0x6f, 0x64, 0x65, 0x2e, 0x70, 0x62, 0x2e, 0x47, 0x65, 0x74, 0x50, 0x65, 0x65, 0x72, 0x49, 0x6e,
+	0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x71, 0x75, 0x69, 0x6c,
+	0x73, 0x65, 0x42, 0x3a, 0x5a, 0x38, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x71, 0x75, 0x69,
-	0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x6e, 0x6f, 0x64, 0x65,
+	0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x71, 0x75, 0x69, 0x6c,
-	0x2e, 0x70, 0x62, 0x2e, 0x50, 0x65, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70,
+	0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2f, 0x6d, 0x6f, 0x6e, 0x6f, 0x72, 0x65, 0x70, 0x6f, 0x2f,
-	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6e, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x4e, 0x65, 0x74, 0x77, 0x6f,
+	0x6e, 0x6f, 0x64, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x73, 0x62, 0x06,
-	0x72, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2e, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
-	0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x70, 0x62,
-	0x2e, 0x47, 0x65, 0x74, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72,
-	0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x70, 0x62,
-	0x2e, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x6e, 0x73, 0x65, 0x42, 0x3a, 0x5a, 0x38, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x71,
-	0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x71, 0x75,
-	0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2f, 0x6d, 0x6f, 0x6e, 0x6f, 0x72, 0x65, 0x70,
-	0x6f, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x73,
-	0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (

node/protobufs/node.proto

@@ -35,6 +35,7 @@ message PeerInfo {
   bytes peer_id = 1;
   repeated string multiaddrs = 2;
   uint64 max_frame = 3;
+  int64 timestamp = 4;
 }
 
 message PeerInfoResponse {