diff --git a/node/app/db_console.go b/node/app/db_console.go
index 9bf7dc0..65efc19 100644
--- a/node/app/db_console.go
+++ b/node/app/db_console.go
@@ -887,11 +887,11 @@ func logoVersion(width int) string {
 		out += "                          ''---..              ...---''               ##\n"
 		out += "                                 ''----------''\n"
 		out += " \n"
-		out += "                        Quilibrium Node - v1.4.2 – Sunset\n"
+		out += "                        Quilibrium Node - v1.4.3 – Sunset\n"
 		out += " \n"
 		out += "                                   DB Console\n"
 	} else {
-		out = "Quilibrium Node - v1.4.2 – Sunset - DB Console\n"
+		out = "Quilibrium Node - v1.4.3 – Sunset - DB Console\n"
 	}
 	return out
 }
diff --git a/node/app/node.go b/node/app/node.go
index 0a88b13..c3be256 100644
--- a/node/app/node.go
+++ b/node/app/node.go
@@ -1,6 +1,7 @@
 package app
 
 import (
+	"bytes"
 	"errors"
 
 	"go.uber.org/zap"
@@ -8,9 +9,11 @@ import (
 	"source.quilibrium.com/quilibrium/monorepo/node/consensus/master"
 	"source.quilibrium.com/quilibrium/monorepo/node/execution"
 	"source.quilibrium.com/quilibrium/monorepo/node/execution/intrinsics/ceremony"
+	"source.quilibrium.com/quilibrium/monorepo/node/execution/intrinsics/ceremony/application"
 	"source.quilibrium.com/quilibrium/monorepo/node/keys"
 	"source.quilibrium.com/quilibrium/monorepo/node/p2p"
 	"source.quilibrium.com/quilibrium/monorepo/node/store"
+	"source.quilibrium.com/quilibrium/monorepo/node/tries"
 )
 
 type Node struct {
@@ -39,6 +42,20 @@ func newNode(
 		execEngines[ceremonyExecutionEngine.GetName()] = ceremonyExecutionEngine
 	}
 
+	intrinsicFilter := append(
+		p2p.GetBloomFilter(application.CEREMONY_ADDRESS, 256, 3),
+		p2p.GetBloomFilterIndices(application.CEREMONY_ADDRESS, 65536, 24)...,
+	)
+	logger.Info("running compaction")
+
+	if err := clockStore.Compact(
+		bytes.Repeat([]byte{0xff}, 32),
+		intrinsicFilter,
+	); err != nil {
+		panic(err)
+	}
+	logger.Info("compaction complete")
+
 	return &Node{
 		logger,
 		clockStore,
@@ -49,6 +66,68 @@ func newNode(
 	}, nil
 }
 
+func (n *Node) RunRepair() {
+	intrinsicFilter := append(
+		p2p.GetBloomFilter(application.CEREMONY_ADDRESS, 256, 3),
+		p2p.GetBloomFilterIndices(application.CEREMONY_ADDRESS, 65536, 24)...,
+	)
+	n.logger.Info("check store and repair if needed, this may take a few minutes")
+	proverTrie := &tries.RollingFrecencyCritbitTrie{}
+	head, err := n.clockStore.GetLatestDataClockFrame(intrinsicFilter, proverTrie)
+	if err == nil && head != nil {
+		for head != nil && head.FrameNumber != 0 {
+			prev := head
+			head, err = n.clockStore.GetParentDataClockFrame(
+				intrinsicFilter,
+				head.FrameNumber-1,
+				head.ParentSelector,
+				true,
+			)
+			if err != nil {
+				panic(err)
+			}
+			compare, _, err := n.clockStore.GetDataClockFrame(
+				intrinsicFilter,
+				prev.FrameNumber-1,
+				true,
+			)
+			if err != nil {
+				panic(err)
+			}
+			if !bytes.Equal(head.Output, compare.Output) {
+				n.logger.Warn(
+					"repairing frame",
+					zap.Uint64("frame_number", head.FrameNumber),
+				)
+				head, err = n.clockStore.GetParentDataClockFrame(
+					intrinsicFilter,
+					prev.FrameNumber-1,
+					prev.ParentSelector,
+					false,
+				)
+				if err != nil {
+					panic(err)
+				}
+
+				txn, err := n.clockStore.NewTransaction()
+				if err != nil {
+					panic(err)
+				}
+
+				err = n.clockStore.PutDataClockFrame(head, proverTrie, txn, true)
+				if err != nil {
+					panic(err)
+				}
+
+				if err = txn.Commit(); err != nil {
+					panic(err)
+				}
+			}
+		}
+	}
+	n.logger.Info("check complete")
+}
+
 func (n *Node) Start() {
 	err := <-n.engine.Start()
 	if err != nil {
diff --git a/node/consensus/consensus_engine.go b/node/consensus/consensus_engine.go
index 2f1c10c..0ffd94d 100644
--- a/node/consensus/consensus_engine.go
+++ b/node/consensus/consensus_engine.go
@@ -51,13 +51,13 @@ type DataConsensusEngine interface {
 }
 
 func GetMinimumVersionCutoff() time.Time {
-	return time.Date(2024, time.March, 1, 7, 0, 0, 0, time.UTC)
+	return time.Date(2024, time.March, 7, 5, 0, 0, 0, time.UTC)
 }
 
 func GetMinimumVersion() []byte {
-	return []byte{0x01, 0x04, 0x00}
+	return []byte{0x01, 0x04, 0x03}
 }
 
 func GetVersion() []byte {
-	return []byte{0x01, 0x04, 0x02}
+	return []byte{0x01, 0x04, 0x03}
 }
diff --git a/node/consensus/master/broadcast_messaging.go b/node/consensus/master/broadcast_messaging.go
index 5325c65..3c93631 100644
--- a/node/consensus/master/broadcast_messaging.go
+++ b/node/consensus/master/broadcast_messaging.go
@@ -156,6 +156,7 @@ func (e *MasterClockConsensusEngine) handleSelfTestReport(
 
 	e.peerMapMx.Lock()
 	if _, ok := e.peerMap[string(peerID)]; ok {
+		e.peerMap[string(peerID)].MasterHeadFrame = report.MasterHeadFrame
 		e.peerMapMx.Unlock()
 		return nil
 	}
@@ -163,7 +164,7 @@ func (e *MasterClockConsensusEngine) handleSelfTestReport(
 	e.peerMapMx.Unlock()
 
 	memory := binary.BigEndian.Uint64(report.Memory)
-	e.logger.Info(
+	e.logger.Debug(
 		"received self test report",
 		zap.String("peer_id", base58.Encode(peerID)),
 		zap.Uint32("difficulty", report.Difficulty),
diff --git a/node/consensus/master/consensus_frames.go b/node/consensus/master/consensus_frames.go
index 278047e..3389f0a 100644
--- a/node/consensus/master/consensus_frames.go
+++ b/node/consensus/master/consensus_frames.go
@@ -1,11 +1,12 @@
 package master
 
 import (
+	"context"
 	"time"
 
+	"github.com/mr-tron/base58"
 	"github.com/pkg/errors"
 	"go.uber.org/zap"
-	"source.quilibrium.com/quilibrium/monorepo/go-libp2p-blossomsub/pb"
 	"source.quilibrium.com/quilibrium/monorepo/node/consensus"
 	"source.quilibrium.com/quilibrium/monorepo/node/p2p"
 	"source.quilibrium.com/quilibrium/monorepo/node/protobufs"
@@ -30,6 +31,38 @@ func (e *MasterClockConsensusEngine) prove(
 	return frame, nil
 }
 
+func (e *MasterClockConsensusEngine) GetMostAheadPeers() (
+	[][]byte,
+	error,
+) {
+	frame, err := e.masterTimeReel.Head()
+	if err != nil {
+		panic(err)
+	}
+
+	// Needs to be enough to make the sync worthwhile:
+	max := frame.FrameNumber + 10
+
+	var peers [][]byte = [][]byte{}
+	e.peerMapMx.Lock()
+	for peerId, v := range e.peerMap {
+		if v.MasterHeadFrame > max {
+			peers = append(peers, []byte(peerId))
+		}
+
+		if len(peers) >= 30 {
+			break
+		}
+	}
+	e.peerMapMx.Unlock()
+
+	if len(peers) == 0 {
+		return nil, p2p.ErrNoPeersAvailable
+	}
+
+	return peers, nil
+}
+
 func (e *MasterClockConsensusEngine) collect(
 	currentFramePublished *protobufs.ClockFrame,
 ) (*protobufs.ClockFrame, error) {
@@ -40,65 +73,75 @@ func (e *MasterClockConsensusEngine) collect(
 		panic(err)
 	}
 
-	if e.syncingStatus == SyncStatusNotSyncing {
-		peer, err := e.pubSub.GetRandomPeer(e.filter)
-		if err != nil {
-			if errors.Is(err, p2p.ErrNoPeersAvailable) {
-				e.logger.Debug("no peers available, skipping sync")
-			} else {
-				e.logger.Error("error while fetching random peer", zap.Error(err))
-			}
-		} else {
-			e.syncingStatus = SyncStatusAwaitingResponse
-			e.logger.Debug("setting syncing target", zap.Binary("peer_id", peer))
-			e.syncingTarget = peer
-
-			channel := e.createPeerReceiveChannel(peer)
-			e.logger.Debug(
-				"listening on peer receive channel",
-				zap.Binary("channel", channel),
-			)
-			e.pubSub.Subscribe(channel, e.handleSync, true)
-			e.pubSub.Subscribe(
-				peer,
-				func(message *pb.Message) error { return nil },
-				true,
-			)
-
-			go func() {
-				time.Sleep(2 * time.Second)
-				if err := e.publishMessage(peer, &protobufs.ClockFramesRequest{
-					Filter:          e.filter,
-					FromFrameNumber: latest.FrameNumber + 1,
-				}); err != nil {
-					e.logger.Error(
-						"could not publish clock frame request",
-						zap.Error(err),
-					)
-				}
-			}()
-		}
+	// With the increase of network size, constrain down to top thirty
+	peers, err := e.GetMostAheadPeers()
+	if err != nil {
+		return latest, nil
 	}
 
-	waitDecay := time.Duration(2000)
-	for e.syncingStatus != SyncStatusNotSyncing {
-		e.logger.Debug(
-			"waiting for sync to complete...",
-			zap.Duration("wait_decay", waitDecay),
+	for i := 0; i < len(peers); i++ {
+		peer := peers[i]
+		e.logger.Debug("setting syncing target", zap.Binary("peer_id", peer))
+
+		cc, err := e.pubSub.GetDirectChannel(peer, "validation")
+		if err != nil {
+			e.logger.Error(
+				"could not connect for sync",
+				zap.String("peer_id", base58.Encode(peer)),
+			)
+			continue
+		}
+		client := protobufs.NewValidationServiceClient(cc)
+		syncClient, err := client.Sync(
+			context.Background(),
+			&protobufs.SyncRequest{
+				FramesRequest: &protobufs.ClockFramesRequest{
+					Filter:          e.filter,
+					FromFrameNumber: latest.FrameNumber,
+					ToFrameNumber:   0,
+				},
+			},
 		)
 
-		time.Sleep(waitDecay * time.Millisecond)
-
-		waitDecay = waitDecay * 2
-		if waitDecay >= (100 * (2 << 6)) {
-			if e.syncingStatus == SyncStatusAwaitingResponse {
-				e.logger.Debug("maximum wait for sync response, skipping sync")
-				e.syncingStatus = SyncStatusNotSyncing
+		for msg, err := syncClient.Recv(); msg != nil &&
+			err == nil; msg, err = syncClient.Recv() {
+			if msg.FramesResponse == nil {
 				break
-			} else {
-				waitDecay = 100 * (2 << 6)
+			}
+
+			for _, frame := range msg.FramesResponse.ClockFrames {
+				frame := frame
+
+				if frame.FrameNumber < latest.FrameNumber {
+					continue
+				}
+
+				if e.difficulty != frame.Difficulty {
+					e.logger.Debug(
+						"frame difficulty mismatched",
+						zap.Uint32("difficulty", frame.Difficulty),
+					)
+					break
+				}
+
+				if err := e.frameProver.VerifyMasterClockFrame(frame); err != nil {
+					e.logger.Error(
+						"peer returned invalid frame",
+						zap.String("peer_id", base58.Encode(peer)))
+					e.pubSub.SetPeerScore(peer, -1000)
+					break
+				}
+
+				e.masterTimeReel.Insert(frame)
+				latest = frame
 			}
 		}
+		if err != nil {
+			cc.Close()
+			break
+		}
+		cc.Close()
+		break
 	}
 
 	return latest, nil
diff --git a/node/consensus/master/master_clock_consensus_engine.go b/node/consensus/master/master_clock_consensus_engine.go
index af86e15..a0c7eb7 100644
--- a/node/consensus/master/master_clock_consensus_engine.go
+++ b/node/consensus/master/master_clock_consensus_engine.go
@@ -150,7 +150,6 @@ func (e *MasterClockConsensusEngine) Start() <-chan error {
 
 	e.logger.Info("subscribing to pubsub messages")
 	e.pubSub.Subscribe(e.filter, e.handleMessage, true)
-	e.pubSub.Subscribe(e.pubSub.GetPeerID(), e.handleSync, true)
 
 	e.state = consensus.EngineStateCollecting
 
@@ -186,6 +185,12 @@ func (e *MasterClockConsensusEngine) Start() <-chan error {
 			time.Sleep(30 * time.Second)
 
 			e.logger.Info("broadcasting self-test info")
+			head, err := e.masterTimeReel.Head()
+			if err != nil {
+				panic(err)
+			}
+
+			e.report.MasterHeadFrame = head.FrameNumber
 
 			if err := e.publishMessage(e.filter, e.report); err != nil {
 				e.logger.Debug("error publishing message", zap.Error(err))
@@ -306,6 +311,7 @@ func (
 			Cores:              peerManifest.Cores,
 			Memory:             new(big.Int).SetBytes(peerManifest.Memory).Bytes(),
 			Storage:            new(big.Int).SetBytes(peerManifest.Storage).Bytes(),
+			MasterHeadFrame:    peerManifest.MasterHeadFrame,
 		}
 
 		for _, capability := range peerManifest.Capabilities {
diff --git a/node/consensus/master/peer_messaging.go b/node/consensus/master/peer_messaging.go
index 65e79d5..e3f277d 100644
--- a/node/consensus/master/peer_messaging.go
+++ b/node/consensus/master/peer_messaging.go
@@ -1,143 +1,18 @@
 package master
 
 import (
-	"bytes"
+	"time"
 
 	"github.com/pkg/errors"
 	"go.uber.org/zap"
-	"google.golang.org/protobuf/proto"
-	"google.golang.org/protobuf/types/known/anypb"
-	"source.quilibrium.com/quilibrium/monorepo/go-libp2p-blossomsub/pb"
 	"source.quilibrium.com/quilibrium/monorepo/node/protobufs"
 )
 
-func (e *MasterClockConsensusEngine) handleSync(message *pb.Message) error {
-	e.logger.Debug(
-		"received peer message",
-		zap.Binary("data", message.Data),
-		zap.Binary("from", message.From),
-		zap.Binary("signature", message.Signature),
-	)
-	msg := &protobufs.Message{}
-
-	if err := proto.Unmarshal(message.Data, msg); err != nil {
-		return errors.Wrap(err, "handle sync")
-	}
-
-	any := &anypb.Any{}
-	if err := proto.Unmarshal(msg.Payload, any); err != nil {
-		return errors.Wrap(err, "handle sync")
-	}
-
-	switch any.TypeUrl {
-	case protobufs.ClockFramesResponseType:
-		if err := e.handleClockFramesResponse(
-			message.From,
-			any,
-		); err != nil {
-			return errors.Wrap(err, "handle sync")
-		}
-	case protobufs.ClockFramesRequestType:
-		if err := e.handleClockFramesRequest(
-			message.From,
-			any,
-		); err != nil {
-			return errors.Wrap(err, "handle sync")
-		}
-	}
-
-	return nil
-}
-
-func (e *MasterClockConsensusEngine) createPeerReceiveChannel(
-	peerID []byte,
-) []byte {
-	return append(append([]byte{}, peerID...), e.pubSub.GetPeerID()...)
-}
-
-func (e *MasterClockConsensusEngine) createPeerSendChannel(
-	peerID []byte,
-) []byte {
-	return append(append([]byte{}, e.pubSub.GetPeerID()...), peerID...)
-}
-
-func (e *MasterClockConsensusEngine) handleClockFramesResponse(
-	peerID []byte,
-	any *anypb.Any,
+func (e *MasterClockConsensusEngine) Sync(
+	request *protobufs.SyncRequest,
+	server protobufs.ValidationService_SyncServer,
 ) error {
-	if bytes.Equal(peerID, e.pubSub.GetPeerID()) {
-		return nil
-	}
-
-	if !bytes.Equal(peerID, e.syncingTarget) {
-		e.logger.Warn(
-			"received clock frames response from unexpected target",
-			zap.Binary("peer_id", peerID),
-			zap.Binary("expected_peer_id", e.syncingTarget),
-		)
-	}
-
-	e.syncingStatus = SyncStatusSynchronizing
-
-	defer func() { e.syncingStatus = SyncStatusNotSyncing }()
-
-	response := &protobufs.ClockFramesResponse{}
-	if err := any.UnmarshalTo(response); err != nil {
-		return errors.Wrap(err, "handle clock frames response")
-	}
-
-	for _, frame := range response.ClockFrames {
-		frame := frame
-		e.logger.Debug(
-			"processing clock frame",
-			zap.Binary("sender", peerID),
-			zap.Binary("filter", frame.Filter),
-			zap.Uint64("frame_number", frame.FrameNumber),
-		)
-
-		if err := e.frameProver.VerifyMasterClockFrame(frame); err != nil {
-			e.logger.Error("could not verify clock frame", zap.Error(err))
-			return errors.Wrap(err, "handle clock frame response")
-		}
-
-		e.logger.Debug(
-			"clock frame was valid",
-			zap.Binary("sender", peerID),
-			zap.Binary("filter", frame.Filter),
-			zap.Uint64("frame_number", frame.FrameNumber),
-		)
-
-		e.masterTimeReel.Insert(frame)
-	}
-
-	return nil
-}
-
-func (e *MasterClockConsensusEngine) handleClockFramesRequest(
-	peerID []byte,
-	any *anypb.Any,
-) error {
-	if bytes.Equal(peerID, e.pubSub.GetPeerID()) {
-		return nil
-	}
-
-	request := &protobufs.ClockFramesRequest{}
-	if err := any.UnmarshalTo(request); err != nil {
-		return errors.Wrap(err, "handle clock frame request")
-	}
-
-	channel := e.createPeerSendChannel(peerID)
-
-	e.pubSub.Subscribe(channel, e.handleSync, true)
-
-	e.logger.Debug(
-		"received clock frame request",
-		zap.Binary("peer_id", peerID),
-		zap.Uint64("from_frame_number", request.FromFrameNumber),
-		zap.Uint64("to_frame_number", request.ToFrameNumber),
-	)
-
-	from := request.FromFrameNumber
+	from := request.FramesRequest.FromFrameNumber
 
 	masterFrame, err := e.masterTimeReel.Head()
 	if err != nil {
@@ -147,71 +22,71 @@ func (e *MasterClockConsensusEngine) handleClockFramesRequest(
 	if masterFrame.FrameNumber < from || len(e.historicFrames) == 0 {
 		e.logger.Debug(
 			"peer asked for undiscovered frame",
-			zap.Binary("peer_id", peerID),
-			zap.Uint64("frame_number", request.FromFrameNumber),
+			zap.Uint64("frame_number", request.FramesRequest.FromFrameNumber),
 		)
 
-		if err := e.publishMessage(channel, &protobufs.ClockFramesResponse{
-			Filter:          request.Filter,
-			FromFrameNumber: 0,
-			ToFrameNumber:   0,
-			ClockFrames:     []*protobufs.ClockFrame{},
-		}); err != nil {
-			return errors.Wrap(err, "handle clock frame request")
-		}
-
 		return nil
 	}
 
-	to := request.ToFrameNumber
-	if to == 0 || to-request.FromFrameNumber > 128 {
-		to = request.FromFrameNumber + 127
+	to := request.FramesRequest.ToFrameNumber
+	if to == 0 || to-request.FramesRequest.FromFrameNumber > 16 {
+		to = request.FramesRequest.FromFrameNumber + 15
 	}
 
-	if int(to) > int(masterFrame.FrameNumber) {
-		to = masterFrame.FrameNumber
-	}
-
-	e.logger.Debug(
-		"sending response",
-		zap.Binary("peer_id", peerID),
-		zap.Uint64("from", from),
-		zap.Uint64("to", to),
-		zap.Uint64("total_frames", uint64(to-from+1)),
-	)
-
-	iter, err := e.clockStore.RangeMasterClockFrames(
-		request.Filter,
-		from,
-		to,
-	)
-	if err != nil {
-		return errors.Wrap(err, "handle clock frame request")
-	}
-
-	response := []*protobufs.ClockFrame{}
-
-	for iter.First(); iter.Valid(); iter.Next() {
-		frame, err := iter.Value()
-		if err != nil {
-			return errors.Wrap(err, "handle clock frame request")
+	for {
+		if int(to) > int(masterFrame.FrameNumber) {
+			to = masterFrame.FrameNumber
 		}
 
-		response = append(response, frame)
-	}
+		e.logger.Debug(
+			"sending response",
+			zap.Uint64("from", from),
+			zap.Uint64("to", to),
+			zap.Uint64("total_frames", uint64(to-from+1)),
+		)
 
-	if err = iter.Close(); err != nil {
-		return errors.Wrap(err, "handle clock frame request")
-	}
+		iter, err := e.clockStore.RangeMasterClockFrames(
+			e.filter,
+			from,
+			to,
+		)
+		if err != nil {
+			return errors.Wrap(err, "sync")
+		}
 
-	if err := e.publishMessage(channel, &protobufs.ClockFramesResponse{
-		Filter:          request.Filter,
-		FromFrameNumber: request.FromFrameNumber,
-		ToFrameNumber:   to,
-		ClockFrames:     response,
-	}); err != nil {
-		return errors.Wrap(err, "handle clock frame request")
-	}
+		response := []*protobufs.ClockFrame{}
 
-	return nil
+		for iter.First(); iter.Valid(); iter.Next() {
+			frame, err := iter.Value()
+			if err != nil {
+				return errors.Wrap(err, "sync")
+			}
+
+			response = append(response, frame)
+		}
+
+		if err = iter.Close(); err != nil {
+			return errors.Wrap(err, "sync")
+		}
+
+		if len(response) == 0 {
+			return nil
+		}
+
+		if err := server.Send(&protobufs.SyncResponse{
+			FramesResponse: &protobufs.ClockFramesResponse{
+				Filter:          e.filter,
+				FromFrameNumber: from,
+				ToFrameNumber:   to,
+				ClockFrames:     response,
+			},
+		}); err != nil {
+			return errors.Wrap(err, "sync")
+		}
+
+		from = response[len(response)-1].FrameNumber + 1
+		to = from + 15
+
+		time.Sleep(1 * time.Second)
+	}
 }
diff --git a/node/consensus/time/data_time_reel.go b/node/consensus/time/data_time_reel.go
index 2c74e0a..4c87af1 100644
--- a/node/consensus/time/data_time_reel.go
+++ b/node/consensus/time/data_time_reel.go
@@ -829,7 +829,7 @@ func (d *DataTimeReel) forkChoice(
 			rightIndex,
 			d.proverTrie,
 			txn,
-			false,
+			rightIndex.FrameNumber < d.head.FrameNumber,
 		); err != nil {
 			panic(err)
 		}
diff --git a/node/consensus/time/master_time_reel.go b/node/consensus/time/master_time_reel.go
index 7797b8d..28bbc75 100644
--- a/node/consensus/time/master_time_reel.go
+++ b/node/consensus/time/master_time_reel.go
@@ -23,7 +23,7 @@ type MasterTimeReel struct {
 	frameProver  crypto.FrameProver
 
 	head       *protobufs.ClockFrame
-	pending    map[uint64][]*big.Int
+	pending    map[uint64][]*protobufs.ClockFrame
 	frames     chan *protobufs.ClockFrame
 	newFrameCh chan *protobufs.ClockFrame
 	badFrameCh chan *protobufs.ClockFrame
@@ -63,7 +63,7 @@ func NewMasterTimeReel(
 		engineConfig: engineConfig,
 		clockStore:   clockStore,
 		frameProver:  frameProver,
-		pending:      make(map[uint64][]*big.Int),
+		pending:      make(map[uint64][]*protobufs.ClockFrame),
 		frames:       make(chan *protobufs.ClockFrame),
 		newFrameCh:   make(chan *protobufs.ClockFrame),
 		badFrameCh:   make(chan *protobufs.ClockFrame),
@@ -222,10 +222,15 @@ func (m *MasterTimeReel) runLoop() {
 						m.newFrameCh <- frame
 					}()
 				} else {
-					go func() {
-						m.frames <- frame
-					}()
+					if _, ok := m.pending[frame.FrameNumber]; !ok {
+						m.pending[frame.FrameNumber] = []*protobufs.ClockFrame{}
+					}
+					m.pending[frame.FrameNumber] = append(
+						m.pending[frame.FrameNumber],
+						frame,
+					)
 				}
+				m.processPending()
 			} else {
 				m.logger.Debug(
 					"new frame has same or lower frame number",
@@ -240,4 +245,64 @@ func (m *MasterTimeReel) runLoop() {
 	}
 }
 
+func (m *MasterTimeReel) processPending() {
+	for pending, ok := m.pending[m.head.FrameNumber+1]; ok; pending,
+		ok = m.pending[m.head.FrameNumber+1] {
+
+		for _, frame := range pending {
+			frame := frame
+			parent := new(big.Int).SetBytes(frame.ParentSelector)
+			selector, err := m.head.GetSelector()
+			if err != nil {
+				panic(err)
+			}
+
+			// master frames cannot fork, this is invalid
+			if parent.Cmp(selector) != 0 {
+				m.logger.Debug(
+					"invalid parent selector for frame",
+					zap.Binary("frame_parent_selector", frame.ParentSelector),
+					zap.Binary("actual_parent_selector", selector.FillBytes(
+						make([]byte, 32),
+					)),
+				)
+				go func() {
+					m.badFrameCh <- frame
+				}()
+				continue
+			}
+
+			txn, err := m.clockStore.NewTransaction()
+			if err != nil {
+				panic(err)
+			}
+
+			if err := m.clockStore.PutMasterClockFrame(frame, txn); err != nil {
+				panic(err)
+			}
+
+			if err = txn.Commit(); err != nil {
+				panic(err)
+			}
+
+			m.head = frame
+			go func() {
+				m.newFrameCh <- frame
+			}()
+			break
+		}
+
+		delete(m.pending, m.head.FrameNumber+1)
+	}
+	deletes := []uint64{}
+	for number := range m.pending {
+		if number < m.head.FrameNumber {
+			deletes = append(deletes, number)
+		}
+	}
+	for _, number := range deletes {
+		delete(m.pending, number)
+	}
+}
+
 var _ TimeReel = (*MasterTimeReel)(nil)
diff --git a/node/main.go b/node/main.go
index 4a6ae3a..7e97c3f 100644
--- a/node/main.go
+++ b/node/main.go
@@ -172,6 +172,8 @@ func main() {
 		panic(err)
 	}
 
+	repair(*configDirectory, node)
+
 	if nodeConfig.ListenGRPCMultiaddr != "" {
 		srv, err := rpc.NewRPCServer(
 			nodeConfig.ListenGRPCMultiaddr,
@@ -407,6 +409,32 @@ func clearIfTestData(configDir string, nodeConfig *config.Config) {
 	}
 }
 
+func repair(configDir string, node *app.Node) {
+	_, err := os.Stat(filepath.Join(configDir, "REPAIR"))
+	if os.IsNotExist(err) {
+		node.RunRepair()
+
+		repairFile, err := os.OpenFile(
+			filepath.Join(configDir, "REPAIR"),
+			os.O_CREATE|os.O_RDWR,
+			fs.FileMode(0600),
+		)
+		if err != nil {
+			panic(err)
+		}
+
+		_, err = repairFile.Write([]byte{0x00, 0x00, 0x01})
+		if err != nil {
+			panic(err)
+		}
+
+		err = repairFile.Close()
+		if err != nil {
+			panic(err)
+		}
+	}
+}
+
 func migrate(configDir string, nodeConfig *config.Config) {
 	_, err := os.Stat(filepath.Join(configDir, "MIGRATIONS"))
 	if os.IsNotExist(err) {
@@ -495,5 +523,5 @@ func printLogo() {
 
 func printVersion() {
 	fmt.Println(" ")
-	fmt.Println("                       Quilibrium Node - v1.4.2 – Sunset")
+	fmt.Println("                       Quilibrium Node - v1.4.3 – Sunset")
 }
diff --git a/node/protobufs/node.pb.go b/node/protobufs/node.pb.go
index 8f0e14f..0f0f65d 100644
--- a/node/protobufs/node.pb.go
+++ b/node/protobufs/node.pb.go
@@ -1084,6 +1084,8 @@ type SelfTestReport struct {
 	Storage []byte `protobuf:"bytes,13,opt,name=storage,proto3" json:"storage,omitempty"`
 	// The list of supported capabilities
 	Capabilities []*Capability `protobuf:"bytes,14,rep,name=capabilities,proto3" json:"capabilities,omitempty"`
+	// The highest master frame the node has
+	MasterHeadFrame uint64 `protobuf:"varint,15,opt,name=master_head_frame,json=masterHeadFrame,proto3" json:"master_head_frame,omitempty"`
 }
 
 func (x *SelfTestReport) Reset() {
@@ -1216,6 +1218,13 @@ func (x *SelfTestReport) GetCapabilities() []*Capability {
 	return nil
 }
 
+func (x *SelfTestReport) GetMasterHeadFrame() uint64 {
+	if x != nil {
+		return x.MasterHeadFrame
+	}
+	return 0
+}
+
 type ValidationMessage struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -1263,6 +1272,100 @@ func (x *ValidationMessage) GetValidation() []byte {
 	return nil
 }
 
+type SyncRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	FramesRequest *ClockFramesRequest `protobuf:"bytes,1,opt,name=frames_request,json=framesRequest,proto3" json:"frames_request,omitempty"`
+}
+
+func (x *SyncRequest) Reset() {
+	*x = SyncRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_node_proto_msgTypes[20]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *SyncRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SyncRequest) ProtoMessage() {}
+
+func (x *SyncRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_node_proto_msgTypes[20]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use SyncRequest.ProtoReflect.Descriptor instead.
+func (*SyncRequest) Descriptor() ([]byte, []int) {
+	return file_node_proto_rawDescGZIP(), []int{20}
+}
+
+func (x *SyncRequest) GetFramesRequest() *ClockFramesRequest {
+	if x != nil {
+		return x.FramesRequest
+	}
+	return nil
+}
+
+type SyncResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	FramesResponse *ClockFramesResponse `protobuf:"bytes,1,opt,name=frames_response,json=framesResponse,proto3" json:"frames_response,omitempty"`
+}
+
+func (x *SyncResponse) Reset() {
+	*x = SyncResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_node_proto_msgTypes[21]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *SyncResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*SyncResponse) ProtoMessage() {}
+
+func (x *SyncResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_node_proto_msgTypes[21]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use SyncResponse.ProtoReflect.Descriptor instead.
+func (*SyncResponse) Descriptor() ([]byte, []int) {
+	return file_node_proto_rawDescGZIP(), []int{21}
+}
+
+func (x *SyncResponse) GetFramesResponse() *ClockFramesResponse {
+	if x != nil {
+		return x.FramesResponse
+	}
+	return nil
+}
+
 type GetPeerManifestsRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -1272,7 +1375,7 @@ type GetPeerManifestsRequest struct {
 func (x *GetPeerManifestsRequest) Reset() {
 	*x = GetPeerManifestsRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_node_proto_msgTypes[20]
+		mi := &file_node_proto_msgTypes[22]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1285,7 +1388,7 @@ func (x *GetPeerManifestsRequest) String() string {
 func (*GetPeerManifestsRequest) ProtoMessage() {}
 
 func (x *GetPeerManifestsRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_node_proto_msgTypes[20]
+	mi := &file_node_proto_msgTypes[22]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1298,7 +1401,7 @@ func (x *GetPeerManifestsRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use GetPeerManifestsRequest.ProtoReflect.Descriptor instead.
 func (*GetPeerManifestsRequest) Descriptor() ([]byte, []int) {
-	return file_node_proto_rawDescGZIP(), []int{20}
+	return file_node_proto_rawDescGZIP(), []int{22}
 }
 
 type PeerManifest struct {
@@ -1343,12 +1446,14 @@ type PeerManifest struct {
 	Storage []byte `protobuf:"bytes,14,opt,name=storage,proto3" json:"storage,omitempty"`
 	// The list of supported capabilities
 	Capabilities []*Capability `protobuf:"bytes,15,rep,name=capabilities,proto3" json:"capabilities,omitempty"`
+	// The highest master frame the node has
+	MasterHeadFrame uint64 `protobuf:"varint,16,opt,name=master_head_frame,json=masterHeadFrame,proto3" json:"master_head_frame,omitempty"`
 }
 
 func (x *PeerManifest) Reset() {
 	*x = PeerManifest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_node_proto_msgTypes[21]
+		mi := &file_node_proto_msgTypes[23]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1361,7 +1466,7 @@ func (x *PeerManifest) String() string {
 func (*PeerManifest) ProtoMessage() {}
 
 func (x *PeerManifest) ProtoReflect() protoreflect.Message {
-	mi := &file_node_proto_msgTypes[21]
+	mi := &file_node_proto_msgTypes[23]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1374,7 +1479,7 @@ func (x *PeerManifest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use PeerManifest.ProtoReflect.Descriptor instead.
 func (*PeerManifest) Descriptor() ([]byte, []int) {
-	return file_node_proto_rawDescGZIP(), []int{21}
+	return file_node_proto_rawDescGZIP(), []int{23}
 }
 
 func (x *PeerManifest) GetPeerId() []byte {
@@ -1482,6 +1587,13 @@ func (x *PeerManifest) GetCapabilities() []*Capability {
 	return nil
 }
 
+func (x *PeerManifest) GetMasterHeadFrame() uint64 {
+	if x != nil {
+		return x.MasterHeadFrame
+	}
+	return 0
+}
+
 type PeerManifestsResponse struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -1493,7 +1605,7 @@ type PeerManifestsResponse struct {
 func (x *PeerManifestsResponse) Reset() {
 	*x = PeerManifestsResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_node_proto_msgTypes[22]
+		mi := &file_node_proto_msgTypes[24]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1506,7 +1618,7 @@ func (x *PeerManifestsResponse) String() string {
 func (*PeerManifestsResponse) ProtoMessage() {}
 
 func (x *PeerManifestsResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_node_proto_msgTypes[22]
+	mi := &file_node_proto_msgTypes[24]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1519,7 +1631,7 @@ func (x *PeerManifestsResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use PeerManifestsResponse.ProtoReflect.Descriptor instead.
 func (*PeerManifestsResponse) Descriptor() ([]byte, []int) {
-	return file_node_proto_rawDescGZIP(), []int{22}
+	return file_node_proto_rawDescGZIP(), []int{24}
 }
 
 func (x *PeerManifestsResponse) GetPeerManifests() []*PeerManifest {
@@ -1659,7 +1771,7 @@ var file_node_proto_rawDesc = []byte{
 	0x65, 0x72, 0x12, 0x2f, 0x0a, 0x13, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c,
 	0x5f, 0x6d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52,
 	0x12, 0x61, 0x64, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x4d, 0x65, 0x74, 0x61, 0x64,
-	0x61, 0x74, 0x61, 0x22, 0xce, 0x04, 0x0a, 0x0e, 0x53, 0x65, 0x6c, 0x66, 0x54, 0x65, 0x73, 0x74,
+	0x61, 0x74, 0x61, 0x22, 0xfa, 0x04, 0x0a, 0x0e, 0x53, 0x65, 0x6c, 0x66, 0x54, 0x65, 0x73, 0x74,
 	0x52, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x12, 0x1e, 0x0a, 0x0a, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63,
 	0x75, 0x6c, 0x74, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x64, 0x69, 0x66, 0x66,
 	0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x12, 0x2b, 0x0a, 0x11, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63,
@@ -1696,130 +1808,153 @@ var file_node_proto_rawDesc = []byte{
 	0x0b, 0x32, 0x23, 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, 0x43, 0x61, 0x70, 0x61,
 	0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69,
-	0x74, 0x69, 0x65, 0x73, 0x22, 0x33, 0x0a, 0x11, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x76, 0x61, 0x6c,
-	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x76,
-	0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x19, 0x0a, 0x17, 0x47, 0x65, 0x74,
-	0x50, 0x65, 0x65, 0x72, 0x4d, 0x61, 0x6e, 0x69, 0x66, 0x65, 0x73, 0x74, 0x73, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x22, 0xe5, 0x04, 0x0a, 0x0c, 0x50, 0x65, 0x65, 0x72, 0x4d, 0x61, 0x6e,
-	0x69, 0x66, 0x65, 0x73, 0x74, 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, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01,
-	0x28, 0x0d, 0x52, 0x0a, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x12, 0x2b,
-	0x0a, 0x11, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x5f, 0x6d, 0x65, 0x74,
-	0x72, 0x69, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x64, 0x69, 0x66, 0x66, 0x69,
-	0x63, 0x75, 0x6c, 0x74, 0x79, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x28, 0x0a, 0x10, 0x63,
-	0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f, 0x31, 0x36, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18,
-	0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x31, 0x36, 0x4d,
-	0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x2a, 0x0a, 0x11, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f,
-	0x31, 0x32, 0x38, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03,
-	0x52, 0x0f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x31, 0x32, 0x38, 0x4d, 0x65, 0x74, 0x72, 0x69,
-	0x63, 0x12, 0x2c, 0x0a, 0x12, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f, 0x31, 0x30, 0x32, 0x34,
-	0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x63,
-	0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x31, 0x30, 0x32, 0x34, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12,
-	0x2e, 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f, 0x36, 0x35, 0x35, 0x33, 0x36, 0x5f,
-	0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, 0x63, 0x6f,
-	0x6d, 0x6d, 0x69, 0x74, 0x36, 0x35, 0x35, 0x33, 0x36, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12,
-	0x26, 0x0a, 0x0f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x31, 0x36, 0x5f, 0x6d, 0x65, 0x74, 0x72,
-	0x69, 0x63, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x31,
-	0x36, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x28, 0x0a, 0x10, 0x70, 0x72, 0x6f, 0x6f, 0x66,
-	0x5f, 0x31, 0x32, 0x38, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18, 0x09, 0x20, 0x01, 0x28,
-	0x03, 0x52, 0x0e, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x31, 0x32, 0x38, 0x4d, 0x65, 0x74, 0x72, 0x69,
-	0x63, 0x12, 0x2a, 0x0a, 0x11, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x31, 0x30, 0x32, 0x34, 0x5f,
-	0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x70, 0x72,
-	0x6f, 0x6f, 0x66, 0x31, 0x30, 0x32, 0x34, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x2c, 0x0a,
-	0x12, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x36, 0x35, 0x35, 0x33, 0x36, 0x5f, 0x6d, 0x65, 0x74,
-	0x72, 0x69, 0x63, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x70, 0x72, 0x6f, 0x6f, 0x66,
-	0x36, 0x35, 0x35, 0x33, 0x36, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x14, 0x0a, 0x05, 0x63,
-	0x6f, 0x72, 0x65, 0x73, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x05, 0x63, 0x6f, 0x72, 0x65,
-	0x73, 0x12, 0x16, 0x0a, 0x06, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x18, 0x0d, 0x20, 0x01, 0x28,
-	0x0c, 0x52, 0x06, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x74, 0x6f,
-	0x72, 0x61, 0x67, 0x65, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x73, 0x74, 0x6f, 0x72,
-	0x61, 0x67, 0x65, 0x12, 0x47, 0x0a, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74,
-	0x69, 0x65, 0x73, 0x18, 0x0f, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 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, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x0c,
-	0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x22, 0x65, 0x0a, 0x15,
-	0x50, 0x65, 0x65, 0x72, 0x4d, 0x61, 0x6e, 0x69, 0x66, 0x65, 0x73, 0x74, 0x73, 0x52, 0x65, 0x73,
-	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4c, 0x0a, 0x0e, 0x70, 0x65, 0x65, 0x72, 0x5f, 0x6d, 0x61,
-	0x6e, 0x69, 0x66, 0x65, 0x73, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 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, 0x4d, 0x61, 0x6e, 0x69,
-	0x66, 0x65, 0x73, 0x74, 0x52, 0x0d, 0x70, 0x65, 0x65, 0x72, 0x4d, 0x61, 0x6e, 0x69, 0x66, 0x65,
-	0x73, 0x74, 0x73, 0x32, 0x80, 0x01, 0x0a, 0x11, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x6b, 0x0a, 0x11, 0x50, 0x65, 0x72,
-	0x66, 0x6f, 0x72, 0x6d, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2a,
+	0x74, 0x69, 0x65, 0x73, 0x12, 0x2a, 0x0a, 0x11, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x68,
+	0x65, 0x61, 0x64, 0x5f, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x04, 0x52,
+	0x0f, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x48, 0x65, 0x61, 0x64, 0x46, 0x72, 0x61, 0x6d, 0x65,
+	0x22, 0x33, 0x0a, 0x11, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65,
+	0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x76, 0x61, 0x6c, 0x69, 0x64,
+	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x62, 0x0a, 0x0b, 0x53, 0x79, 0x6e, 0x63, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x12, 0x53, 0x0a, 0x0e, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x73, 0x5f, 0x72,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 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, 0x52, 0x0d, 0x66, 0x72, 0x61, 0x6d,
+	0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x66, 0x0a, 0x0c, 0x53, 0x79, 0x6e,
+	0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x56, 0x0a, 0x0f, 0x66, 0x72, 0x61,
+	0x6d, 0x65, 0x73, 0x5f, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x0b, 0x32, 0x2d, 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, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x52, 0x0e, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x22, 0x19, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x50, 0x65, 0x65, 0x72, 0x4d, 0x61, 0x6e, 0x69,
+	0x66, 0x65, 0x73, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x91, 0x05, 0x0a,
+	0x0c, 0x50, 0x65, 0x65, 0x72, 0x4d, 0x61, 0x6e, 0x69, 0x66, 0x65, 0x73, 0x74, 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, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63,
+	0x75, 0x6c, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0a, 0x64, 0x69, 0x66, 0x66,
+	0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x12, 0x2b, 0x0a, 0x11, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63,
+	0x75, 0x6c, 0x74, 0x79, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x03, 0x52, 0x10, 0x64, 0x69, 0x66, 0x66, 0x69, 0x63, 0x75, 0x6c, 0x74, 0x79, 0x4d, 0x65, 0x74,
+	0x72, 0x69, 0x63, 0x12, 0x28, 0x0a, 0x10, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f, 0x31, 0x36,
+	0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x63,
+	0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x31, 0x36, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x2a, 0x0a,
+	0x11, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x5f, 0x31, 0x32, 0x38, 0x5f, 0x6d, 0x65, 0x74, 0x72,
+	0x69, 0x63, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74,
+	0x31, 0x32, 0x38, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x2c, 0x0a, 0x12, 0x63, 0x6f, 0x6d,
+	0x6d, 0x69, 0x74, 0x5f, 0x31, 0x30, 0x32, 0x34, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18,
+	0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x31, 0x30, 0x32,
+	0x34, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x2e, 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x6d, 0x69,
+	0x74, 0x5f, 0x36, 0x35, 0x35, 0x33, 0x36, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18, 0x07,
+	0x20, 0x01, 0x28, 0x03, 0x52, 0x11, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x36, 0x35, 0x35, 0x33,
+	0x36, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x26, 0x0a, 0x0f, 0x70, 0x72, 0x6f, 0x6f, 0x66,
+	0x5f, 0x31, 0x36, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03,
+	0x52, 0x0d, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x31, 0x36, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12,
+	0x28, 0x0a, 0x10, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x31, 0x32, 0x38, 0x5f, 0x6d, 0x65, 0x74,
+	0x72, 0x69, 0x63, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x70, 0x72, 0x6f, 0x6f, 0x66,
+	0x31, 0x32, 0x38, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x2a, 0x0a, 0x11, 0x70, 0x72, 0x6f,
+	0x6f, 0x66, 0x5f, 0x31, 0x30, 0x32, 0x34, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18, 0x0a,
+	0x20, 0x01, 0x28, 0x03, 0x52, 0x0f, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x31, 0x30, 0x32, 0x34, 0x4d,
+	0x65, 0x74, 0x72, 0x69, 0x63, 0x12, 0x2c, 0x0a, 0x12, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x5f, 0x36,
+	0x35, 0x35, 0x33, 0x36, 0x5f, 0x6d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x18, 0x0b, 0x20, 0x01, 0x28,
+	0x03, 0x52, 0x10, 0x70, 0x72, 0x6f, 0x6f, 0x66, 0x36, 0x35, 0x35, 0x33, 0x36, 0x4d, 0x65, 0x74,
+	0x72, 0x69, 0x63, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x18, 0x0c, 0x20, 0x01,
+	0x28, 0x0d, 0x52, 0x05, 0x63, 0x6f, 0x72, 0x65, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x6d, 0x65, 0x6d,
+	0x6f, 0x72, 0x79, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x6d, 0x65, 0x6d, 0x6f, 0x72,
+	0x79, 0x12, 0x18, 0x0a, 0x07, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x18, 0x0e, 0x20, 0x01,
+	0x28, 0x0c, 0x52, 0x07, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x12, 0x47, 0x0a, 0x0c, 0x63,
+	0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73, 0x18, 0x0f, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x23, 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, 0x43, 0x61, 0x70, 0x61,
+	0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x52, 0x0c, 0x63, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69,
+	0x74, 0x69, 0x65, 0x73, 0x12, 0x2a, 0x0a, 0x11, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x5f, 0x68,
+	0x65, 0x61, 0x64, 0x5f, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x18, 0x10, 0x20, 0x01, 0x28, 0x04, 0x52,
+	0x0f, 0x6d, 0x61, 0x73, 0x74, 0x65, 0x72, 0x48, 0x65, 0x61, 0x64, 0x46, 0x72, 0x61, 0x6d, 0x65,
+	0x22, 0x65, 0x0a, 0x15, 0x50, 0x65, 0x65, 0x72, 0x4d, 0x61, 0x6e, 0x69, 0x66, 0x65, 0x73, 0x74,
+	0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x4c, 0x0a, 0x0e, 0x70, 0x65, 0x65,
+	0x72, 0x5f, 0x6d, 0x61, 0x6e, 0x69, 0x66, 0x65, 0x73, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28,
+	0x0b, 0x32, 0x25, 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,
+	0x4d, 0x61, 0x6e, 0x69, 0x66, 0x65, 0x73, 0x74, 0x52, 0x0d, 0x70, 0x65, 0x65, 0x72, 0x4d, 0x61,
+	0x6e, 0x69, 0x66, 0x65, 0x73, 0x74, 0x73, 0x32, 0xd7, 0x01, 0x0a, 0x11, 0x56, 0x61, 0x6c, 0x69,
+	0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x6b, 0x0a,
+	0x11, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x12, 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, 0x56, 0x61, 0x6c,
+	0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 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, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74,
-	0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 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, 0x56, 0x61, 0x6c, 0x69, 0x64, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4d,
-	0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x32, 0xf6, 0x05, 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,
+	0x69, 0x6f, 0x6e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x55, 0x0a, 0x04, 0x53, 0x79,
+	0x6e, 0x63, 0x12, 0x24, 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, 0x53, 0x79, 0x6e,
+	0x63, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 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, 0x53, 0x79, 0x6e, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30,
+	0x01, 0x32, 0xf6, 0x05, 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, 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, 0x47, 0x65, 0x74, 0x50, 0x65,
-	0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 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, 0x50, 0x65, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x65, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x4e,
+	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, 0x47, 0x65, 0x74, 0x50, 0x65, 0x65, 0x72, 0x49, 0x6e, 0x66,
+	0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 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, 0x50, 0x65, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x12, 0x65, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 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, 0x47, 0x65, 0x74,
+	0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+	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, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e,
+	0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x6e, 0x0a, 0x0e, 0x47, 0x65,
+	0x74, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x2e, 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, 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, 0x12, 0x68, 0x0a, 0x0c, 0x47, 0x65,
+	0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 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, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 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, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x74, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x50, 0x65, 0x65, 0x72, 0x4d,
+	0x61, 0x6e, 0x69, 0x66, 0x65, 0x73, 0x74, 0x73, 0x12, 0x30, 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, 0x50, 0x65, 0x65, 0x72, 0x4d, 0x61, 0x6e, 0x69, 0x66, 0x65,
+	0x73, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 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, 0x4d, 0x61, 0x6e, 0x69, 0x66, 0x65, 0x73,
+	0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0xcf, 0x01, 0x0a, 0x09, 0x4e,
+	0x6f, 0x64, 0x65, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x60, 0x0a, 0x0b, 0x50, 0x75, 0x74, 0x4e,
 	0x6f, 0x64, 0x65, 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, 0x47, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x1a, 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, 0x4e,
-	0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
-	0x6e, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x4e, 0x65, 0x74, 0x77, 0x6f, 0x72, 0x6b, 0x49, 0x6e, 0x66,
-	0x6f, 0x12, 0x2e, 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, 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, 0x12,
-	0x68, 0x0a, 0x0c, 0x47, 0x65, 0x74, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 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, 0x54, 0x6f, 0x6b,
-	0x65, 0x6e, 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, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x49, 0x6e, 0x66,
-	0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x74, 0x0a, 0x10, 0x47, 0x65, 0x74,
-	0x50, 0x65, 0x65, 0x72, 0x4d, 0x61, 0x6e, 0x69, 0x66, 0x65, 0x73, 0x74, 0x73, 0x12, 0x30, 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, 0x50, 0x65, 0x65, 0x72, 0x4d,
-	0x61, 0x6e, 0x69, 0x66, 0x65, 0x73, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
-	0x2e, 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, 0x4d, 0x61,
-	0x6e, 0x69, 0x66, 0x65, 0x73, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32,
-	0xcf, 0x01, 0x0a, 0x09, 0x4e, 0x6f, 0x64, 0x65, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x60, 0x0a,
-	0x0b, 0x50, 0x75, 0x74, 0x4e, 0x6f, 0x64, 0x65, 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, 0x50, 0x75, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e,
-	0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x71, 0x75, 0x69, 0x6c,
+	0x62, 0x2e, 0x50, 0x75, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 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,
+	0x75, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x60, 0x0a, 0x0b, 0x50, 0x75,
+	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, 0x50, 0x75, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12,
-	0x60, 0x0a, 0x0b, 0x50, 0x75, 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, 0x50, 0x75, 0x74, 0x50, 0x65, 0x65, 0x72,
-	0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 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, 0x75, 0x74, 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,
+	0x2e, 0x70, 0x62, 0x2e, 0x50, 0x75, 0x74, 0x50, 0x65, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 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, 0x75, 0x74, 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 (
@@ -1834,7 +1969,7 @@ func file_node_proto_rawDescGZIP() []byte {
 	return file_node_proto_rawDescData
 }
 
-var file_node_proto_msgTypes = make([]protoimpl.MessageInfo, 23)
+var file_node_proto_msgTypes = make([]protoimpl.MessageInfo, 25)
 var file_node_proto_goTypes = []interface{}{
 	(*GetFramesRequest)(nil),        // 0: quilibrium.node.node.pb.GetFramesRequest
 	(*GetFrameInfoRequest)(nil),     // 1: quilibrium.node.node.pb.GetFrameInfoRequest
@@ -1856,47 +1991,55 @@ var file_node_proto_goTypes = []interface{}{
 	(*Capability)(nil),              // 17: quilibrium.node.node.pb.Capability
 	(*SelfTestReport)(nil),          // 18: quilibrium.node.node.pb.SelfTestReport
 	(*ValidationMessage)(nil),       // 19: quilibrium.node.node.pb.ValidationMessage
-	(*GetPeerManifestsRequest)(nil), // 20: quilibrium.node.node.pb.GetPeerManifestsRequest
-	(*PeerManifest)(nil),            // 21: quilibrium.node.node.pb.PeerManifest
-	(*PeerManifestsResponse)(nil),   // 22: quilibrium.node.node.pb.PeerManifestsResponse
-	(*ClockFrame)(nil),              // 23: quilibrium.node.clock.pb.ClockFrame
+	(*SyncRequest)(nil),             // 20: quilibrium.node.node.pb.SyncRequest
+	(*SyncResponse)(nil),            // 21: quilibrium.node.node.pb.SyncResponse
+	(*GetPeerManifestsRequest)(nil), // 22: quilibrium.node.node.pb.GetPeerManifestsRequest
+	(*PeerManifest)(nil),            // 23: quilibrium.node.node.pb.PeerManifest
+	(*PeerManifestsResponse)(nil),   // 24: quilibrium.node.node.pb.PeerManifestsResponse
+	(*ClockFrame)(nil),              // 25: quilibrium.node.clock.pb.ClockFrame
+	(*ClockFramesRequest)(nil),      // 26: quilibrium.node.clock.pb.ClockFramesRequest
+	(*ClockFramesResponse)(nil),     // 27: quilibrium.node.clock.pb.ClockFramesResponse
 }
 var file_node_proto_depIdxs = []int32{
-	23, // 0: quilibrium.node.node.pb.FramesResponse.truncated_clock_frames:type_name -> quilibrium.node.clock.pb.ClockFrame
-	23, // 1: quilibrium.node.node.pb.FrameInfoResponse.clock_frame:type_name -> quilibrium.node.clock.pb.ClockFrame
+	25, // 0: quilibrium.node.node.pb.FramesResponse.truncated_clock_frames:type_name -> quilibrium.node.clock.pb.ClockFrame
+	25, // 1: quilibrium.node.node.pb.FrameInfoResponse.clock_frame:type_name -> quilibrium.node.clock.pb.ClockFrame
 	7,  // 2: quilibrium.node.node.pb.PeerInfoResponse.peer_info:type_name -> quilibrium.node.node.pb.PeerInfo
 	7,  // 3: quilibrium.node.node.pb.PeerInfoResponse.uncooperative_peer_info:type_name -> quilibrium.node.node.pb.PeerInfo
 	7,  // 4: quilibrium.node.node.pb.PutPeerInfoRequest.peer_info:type_name -> quilibrium.node.node.pb.PeerInfo
 	7,  // 5: quilibrium.node.node.pb.PutPeerInfoRequest.uncooperative_peer_info:type_name -> quilibrium.node.node.pb.PeerInfo
 	9,  // 6: quilibrium.node.node.pb.NetworkInfoResponse.network_info:type_name -> quilibrium.node.node.pb.NetworkInfo
 	17, // 7: quilibrium.node.node.pb.SelfTestReport.capabilities:type_name -> quilibrium.node.node.pb.Capability
-	17, // 8: quilibrium.node.node.pb.PeerManifest.capabilities:type_name -> quilibrium.node.node.pb.Capability
-	21, // 9: quilibrium.node.node.pb.PeerManifestsResponse.peer_manifests:type_name -> quilibrium.node.node.pb.PeerManifest
-	19, // 10: quilibrium.node.node.pb.ValidationService.PerformValidation:input_type -> quilibrium.node.node.pb.ValidationMessage
-	0,  // 11: quilibrium.node.node.pb.NodeService.GetFrames:input_type -> quilibrium.node.node.pb.GetFramesRequest
-	1,  // 12: quilibrium.node.node.pb.NodeService.GetFrameInfo:input_type -> quilibrium.node.node.pb.GetFrameInfoRequest
-	2,  // 13: quilibrium.node.node.pb.NodeService.GetPeerInfo:input_type -> quilibrium.node.node.pb.GetPeerInfoRequest
-	3,  // 14: quilibrium.node.node.pb.NodeService.GetNodeInfo:input_type -> quilibrium.node.node.pb.GetNodeInfoRequest
-	4,  // 15: quilibrium.node.node.pb.NodeService.GetNetworkInfo:input_type -> quilibrium.node.node.pb.GetNetworkInfoRequest
-	15, // 16: quilibrium.node.node.pb.NodeService.GetTokenInfo:input_type -> quilibrium.node.node.pb.GetTokenInfoRequest
-	20, // 17: quilibrium.node.node.pb.NodeService.GetPeerManifests:input_type -> quilibrium.node.node.pb.GetPeerManifestsRequest
-	12, // 18: quilibrium.node.node.pb.NodeStats.PutNodeInfo:input_type -> quilibrium.node.node.pb.PutNodeInfoRequest
-	11, // 19: quilibrium.node.node.pb.NodeStats.PutPeerInfo:input_type -> quilibrium.node.node.pb.PutPeerInfoRequest
-	19, // 20: quilibrium.node.node.pb.ValidationService.PerformValidation:output_type -> quilibrium.node.node.pb.ValidationMessage
-	5,  // 21: quilibrium.node.node.pb.NodeService.GetFrames:output_type -> quilibrium.node.node.pb.FramesResponse
-	6,  // 22: quilibrium.node.node.pb.NodeService.GetFrameInfo:output_type -> quilibrium.node.node.pb.FrameInfoResponse
-	8,  // 23: quilibrium.node.node.pb.NodeService.GetPeerInfo:output_type -> quilibrium.node.node.pb.PeerInfoResponse
-	10, // 24: quilibrium.node.node.pb.NodeService.GetNodeInfo:output_type -> quilibrium.node.node.pb.NodeInfoResponse
-	14, // 25: quilibrium.node.node.pb.NodeService.GetNetworkInfo:output_type -> quilibrium.node.node.pb.NetworkInfoResponse
-	16, // 26: quilibrium.node.node.pb.NodeService.GetTokenInfo:output_type -> quilibrium.node.node.pb.TokenInfoResponse
-	22, // 27: quilibrium.node.node.pb.NodeService.GetPeerManifests:output_type -> quilibrium.node.node.pb.PeerManifestsResponse
-	13, // 28: quilibrium.node.node.pb.NodeStats.PutNodeInfo:output_type -> quilibrium.node.node.pb.PutResponse
-	13, // 29: quilibrium.node.node.pb.NodeStats.PutPeerInfo:output_type -> quilibrium.node.node.pb.PutResponse
-	20, // [20:30] is the sub-list for method output_type
-	10, // [10:20] is the sub-list for method input_type
-	10, // [10:10] is the sub-list for extension type_name
-	10, // [10:10] is the sub-list for extension extendee
-	0,  // [0:10] is the sub-list for field type_name
+	26, // 8: quilibrium.node.node.pb.SyncRequest.frames_request:type_name -> quilibrium.node.clock.pb.ClockFramesRequest
+	27, // 9: quilibrium.node.node.pb.SyncResponse.frames_response:type_name -> quilibrium.node.clock.pb.ClockFramesResponse
+	17, // 10: quilibrium.node.node.pb.PeerManifest.capabilities:type_name -> quilibrium.node.node.pb.Capability
+	23, // 11: quilibrium.node.node.pb.PeerManifestsResponse.peer_manifests:type_name -> quilibrium.node.node.pb.PeerManifest
+	19, // 12: quilibrium.node.node.pb.ValidationService.PerformValidation:input_type -> quilibrium.node.node.pb.ValidationMessage
+	20, // 13: quilibrium.node.node.pb.ValidationService.Sync:input_type -> quilibrium.node.node.pb.SyncRequest
+	0,  // 14: quilibrium.node.node.pb.NodeService.GetFrames:input_type -> quilibrium.node.node.pb.GetFramesRequest
+	1,  // 15: quilibrium.node.node.pb.NodeService.GetFrameInfo:input_type -> quilibrium.node.node.pb.GetFrameInfoRequest
+	2,  // 16: quilibrium.node.node.pb.NodeService.GetPeerInfo:input_type -> quilibrium.node.node.pb.GetPeerInfoRequest
+	3,  // 17: quilibrium.node.node.pb.NodeService.GetNodeInfo:input_type -> quilibrium.node.node.pb.GetNodeInfoRequest
+	4,  // 18: quilibrium.node.node.pb.NodeService.GetNetworkInfo:input_type -> quilibrium.node.node.pb.GetNetworkInfoRequest
+	15, // 19: quilibrium.node.node.pb.NodeService.GetTokenInfo:input_type -> quilibrium.node.node.pb.GetTokenInfoRequest
+	22, // 20: quilibrium.node.node.pb.NodeService.GetPeerManifests:input_type -> quilibrium.node.node.pb.GetPeerManifestsRequest
+	12, // 21: quilibrium.node.node.pb.NodeStats.PutNodeInfo:input_type -> quilibrium.node.node.pb.PutNodeInfoRequest
+	11, // 22: quilibrium.node.node.pb.NodeStats.PutPeerInfo:input_type -> quilibrium.node.node.pb.PutPeerInfoRequest
+	19, // 23: quilibrium.node.node.pb.ValidationService.PerformValidation:output_type -> quilibrium.node.node.pb.ValidationMessage
+	21, // 24: quilibrium.node.node.pb.ValidationService.Sync:output_type -> quilibrium.node.node.pb.SyncResponse
+	5,  // 25: quilibrium.node.node.pb.NodeService.GetFrames:output_type -> quilibrium.node.node.pb.FramesResponse
+	6,  // 26: quilibrium.node.node.pb.NodeService.GetFrameInfo:output_type -> quilibrium.node.node.pb.FrameInfoResponse
+	8,  // 27: quilibrium.node.node.pb.NodeService.GetPeerInfo:output_type -> quilibrium.node.node.pb.PeerInfoResponse
+	10, // 28: quilibrium.node.node.pb.NodeService.GetNodeInfo:output_type -> quilibrium.node.node.pb.NodeInfoResponse
+	14, // 29: quilibrium.node.node.pb.NodeService.GetNetworkInfo:output_type -> quilibrium.node.node.pb.NetworkInfoResponse
+	16, // 30: quilibrium.node.node.pb.NodeService.GetTokenInfo:output_type -> quilibrium.node.node.pb.TokenInfoResponse
+	24, // 31: quilibrium.node.node.pb.NodeService.GetPeerManifests:output_type -> quilibrium.node.node.pb.PeerManifestsResponse
+	13, // 32: quilibrium.node.node.pb.NodeStats.PutNodeInfo:output_type -> quilibrium.node.node.pb.PutResponse
+	13, // 33: quilibrium.node.node.pb.NodeStats.PutPeerInfo:output_type -> quilibrium.node.node.pb.PutResponse
+	23, // [23:34] is the sub-list for method output_type
+	12, // [12:23] is the sub-list for method input_type
+	12, // [12:12] is the sub-list for extension type_name
+	12, // [12:12] is the sub-list for extension extendee
+	0,  // [0:12] is the sub-list for field type_name
 }
 
 func init() { file_node_proto_init() }
@@ -2147,7 +2290,7 @@ func file_node_proto_init() {
 			}
 		}
 		file_node_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*GetPeerManifestsRequest); i {
+			switch v := v.(*SyncRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2159,7 +2302,7 @@ func file_node_proto_init() {
 			}
 		}
 		file_node_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*PeerManifest); i {
+			switch v := v.(*SyncResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2171,6 +2314,30 @@ func file_node_proto_init() {
 			}
 		}
 		file_node_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*GetPeerManifestsRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_node_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*PeerManifest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_node_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*PeerManifestsResponse); i {
 			case 0:
 				return &v.state
@@ -2189,7 +2356,7 @@ func file_node_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_node_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   23,
+			NumMessages:   25,
 			NumExtensions: 0,
 			NumServices:   3,
 		},
diff --git a/node/protobufs/node.pb.gw.go b/node/protobufs/node.pb.gw.go
index b75fb58..e393378 100644
--- a/node/protobufs/node.pb.gw.go
+++ b/node/protobufs/node.pb.gw.go
@@ -65,6 +65,31 @@ func local_request_ValidationService_PerformValidation_0(ctx context.Context, ma
 
 }
 
+func request_ValidationService_Sync_0(ctx context.Context, marshaler runtime.Marshaler, client ValidationServiceClient, req *http.Request, pathParams map[string]string) (ValidationService_SyncClient, runtime.ServerMetadata, error) {
+	var protoReq SyncRequest
+	var metadata runtime.ServerMetadata
+
+	newReader, berr := utilities.IOReaderFactory(req.Body)
+	if berr != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
+	}
+	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
+	}
+
+	stream, err := client.Sync(ctx, &protoReq)
+	if err != nil {
+		return nil, metadata, err
+	}
+	header, err := stream.Header()
+	if err != nil {
+		return nil, metadata, err
+	}
+	metadata.HeaderMD = header
+	return stream, metadata, nil
+
+}
+
 func request_NodeService_GetFrames_0(ctx context.Context, marshaler runtime.Marshaler, client NodeServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
 	var protoReq GetFramesRequest
 	var metadata runtime.ServerMetadata
@@ -402,6 +427,13 @@ func RegisterValidationServiceHandlerServer(ctx context.Context, mux *runtime.Se
 
 	})
 
+	mux.Handle("POST", pattern_ValidationService_Sync_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport")
+		_, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+		return
+	})
+
 	return nil
 }
 
@@ -708,15 +740,41 @@ func RegisterValidationServiceHandlerClient(ctx context.Context, mux *runtime.Se
 
 	})
 
+	mux.Handle("POST", pattern_ValidationService_Sync_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		var err error
+		var annotatedContext context.Context
+		annotatedContext, err = runtime.AnnotateContext(ctx, mux, req, "/quilibrium.node.node.pb.ValidationService/Sync", runtime.WithHTTPPathPattern("/quilibrium.node.node.pb.ValidationService/Sync"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_ValidationService_Sync_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_ValidationService_Sync_0(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
+
+	})
+
 	return nil
 }
 
 var (
 	pattern_ValidationService_PerformValidation_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"quilibrium.node.node.pb.ValidationService", "PerformValidation"}, ""))
+
+	pattern_ValidationService_Sync_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"quilibrium.node.node.pb.ValidationService", "Sync"}, ""))
 )
 
 var (
 	forward_ValidationService_PerformValidation_0 = runtime.ForwardResponseMessage
+
+	forward_ValidationService_Sync_0 = runtime.ForwardResponseStream
 )
 
 // RegisterNodeServiceHandlerFromEndpoint is same as RegisterNodeServiceHandler but
diff --git a/node/protobufs/node.proto b/node/protobufs/node.proto
index 4a2602b..1847a2e 100644
--- a/node/protobufs/node.proto
+++ b/node/protobufs/node.proto
@@ -152,14 +152,25 @@ message SelfTestReport {
   bytes storage = 13;
   // The list of supported capabilities
   repeated Capability capabilities = 14;
+  // The highest master frame the node has
+  uint64 master_head_frame = 15;
 }
 
 message ValidationMessage {
   bytes validation = 1;
 }
 
+message SyncRequest {
+  quilibrium.node.clock.pb.ClockFramesRequest frames_request = 1;
+}
+
+message SyncResponse {
+  quilibrium.node.clock.pb.ClockFramesResponse frames_response = 1;
+}
+
 service ValidationService {
   rpc PerformValidation(ValidationMessage) returns (ValidationMessage);
+  rpc Sync(SyncRequest) returns (stream SyncResponse);
 }
 
 message GetPeerManifestsRequest {}
@@ -202,6 +213,8 @@ message PeerManifest {
   bytes storage = 14;
   // The list of supported capabilities
   repeated Capability capabilities = 15;
+  // The highest master frame the node has
+  uint64 master_head_frame = 16;
 }
 
 message PeerManifestsResponse {
diff --git a/node/protobufs/node_grpc.pb.go b/node/protobufs/node_grpc.pb.go
index 9ffa13f..10f8663 100644
--- a/node/protobufs/node_grpc.pb.go
+++ b/node/protobufs/node_grpc.pb.go
@@ -20,6 +20,7 @@ const _ = grpc.SupportPackageIsVersion7
 
 const (
 	ValidationService_PerformValidation_FullMethodName = "/quilibrium.node.node.pb.ValidationService/PerformValidation"
+	ValidationService_Sync_FullMethodName              = "/quilibrium.node.node.pb.ValidationService/Sync"
 )
 
 // ValidationServiceClient is the client API for ValidationService service.
@@ -27,6 +28,7 @@ const (
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
 type ValidationServiceClient interface {
 	PerformValidation(ctx context.Context, in *ValidationMessage, opts ...grpc.CallOption) (*ValidationMessage, error)
+	Sync(ctx context.Context, in *SyncRequest, opts ...grpc.CallOption) (ValidationService_SyncClient, error)
 }
 
 type validationServiceClient struct {
@@ -46,11 +48,44 @@ func (c *validationServiceClient) PerformValidation(ctx context.Context, in *Val
 	return out, nil
 }
 
+func (c *validationServiceClient) Sync(ctx context.Context, in *SyncRequest, opts ...grpc.CallOption) (ValidationService_SyncClient, error) {
+	stream, err := c.cc.NewStream(ctx, &ValidationService_ServiceDesc.Streams[0], ValidationService_Sync_FullMethodName, opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &validationServiceSyncClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+type ValidationService_SyncClient interface {
+	Recv() (*SyncResponse, error)
+	grpc.ClientStream
+}
+
+type validationServiceSyncClient struct {
+	grpc.ClientStream
+}
+
+func (x *validationServiceSyncClient) Recv() (*SyncResponse, error) {
+	m := new(SyncResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 // ValidationServiceServer is the server API for ValidationService service.
 // All implementations must embed UnimplementedValidationServiceServer
 // for forward compatibility
 type ValidationServiceServer interface {
 	PerformValidation(context.Context, *ValidationMessage) (*ValidationMessage, error)
+	Sync(*SyncRequest, ValidationService_SyncServer) error
 	mustEmbedUnimplementedValidationServiceServer()
 }
 
@@ -61,6 +96,9 @@ type UnimplementedValidationServiceServer struct {
 func (UnimplementedValidationServiceServer) PerformValidation(context.Context, *ValidationMessage) (*ValidationMessage, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method PerformValidation not implemented")
 }
+func (UnimplementedValidationServiceServer) Sync(*SyncRequest, ValidationService_SyncServer) error {
+	return status.Errorf(codes.Unimplemented, "method Sync not implemented")
+}
 func (UnimplementedValidationServiceServer) mustEmbedUnimplementedValidationServiceServer() {}
 
 // UnsafeValidationServiceServer may be embedded to opt out of forward compatibility for this service.
@@ -92,6 +130,27 @@ func _ValidationService_PerformValidation_Handler(srv interface{}, ctx context.C
 	return interceptor(ctx, in, info, handler)
 }
 
+func _ValidationService_Sync_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(SyncRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(ValidationServiceServer).Sync(m, &validationServiceSyncServer{stream})
+}
+
+type ValidationService_SyncServer interface {
+	Send(*SyncResponse) error
+	grpc.ServerStream
+}
+
+type validationServiceSyncServer struct {
+	grpc.ServerStream
+}
+
+func (x *validationServiceSyncServer) Send(m *SyncResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
 // ValidationService_ServiceDesc is the grpc.ServiceDesc for ValidationService service.
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
@@ -104,7 +163,13 @@ var ValidationService_ServiceDesc = grpc.ServiceDesc{
 			Handler:    _ValidationService_PerformValidation_Handler,
 		},
 	},
-	Streams:  []grpc.StreamDesc{},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "Sync",
+			Handler:       _ValidationService_Sync_Handler,
+			ServerStreams: true,
+		},
+	},
 	Metadata: "node.proto",
 }
 
diff --git a/node/rpc/rpc_server.go b/node/rpc/rpc_server.go
index 87c554b..9319656 100644
--- a/node/rpc/rpc_server.go
+++ b/node/rpc/rpc_server.go
@@ -452,7 +452,7 @@ func (r *RPCServer) GetTokenInfo(
 	}, nil
 }
 
-func (r *RPCServer) GetPeerManifest(
+func (r *RPCServer) GetPeerManifests(
 	ctx context.Context,
 	req *protobufs.GetPeerManifestsRequest,
 ) (*protobufs.PeerManifestsResponse, error) {
diff --git a/node/store/clock.go b/node/store/clock.go
index 201ba5b..f23f57b 100644
--- a/node/store/clock.go
+++ b/node/store/clock.go
@@ -105,6 +105,10 @@ type ClockStore interface {
 	) (*protobufs.ClockFrame, error)
 	ResetMasterClockFrames(filter []byte) error
 	ResetDataClockFrames(filter []byte) error
+	Compact(
+		masterFilter []byte,
+		dataFilter []byte,
+	) error
 }
 
 type PebbleClockStore struct {
@@ -1722,3 +1726,48 @@ func (p *PebbleClockStore) ResetDataClockFrames(filter []byte) error {
 
 	return nil
 }
+
+func (p *PebbleClockStore) Compact(
+	masterFilter []byte,
+	dataFilter []byte,
+) error {
+	if masterFilter != nil {
+		if err := p.db.Compact(
+			clockMasterFrameKey(masterFilter, 0),
+			clockMasterFrameKey(masterFilter, 1000000),
+			true,
+		); err != nil {
+			return errors.Wrap(err, "compact")
+		}
+	}
+
+	if dataFilter != nil {
+		if err := p.db.Compact(
+			clockDataFrameKey(dataFilter, 0),
+			clockDataFrameKey(dataFilter, 1000000),
+			true,
+		); err != nil {
+			return errors.Wrap(err, "compact")
+		}
+
+		if err := p.db.Compact(
+			clockDataCandidateFrameKey(
+				dataFilter,
+				0,
+				make([]byte, 32),
+				make([]byte, 32),
+			),
+			clockDataCandidateFrameKey(
+				dataFilter,
+				1000000,
+				bytes.Repeat([]byte{0xff}, 32),
+				bytes.Repeat([]byte{0xff}, 32),
+			),
+			true,
+		); err != nil {
+			return errors.Wrap(err, "compact")
+		}
+	}
+
+	return nil
+}