v1.3.0 (#81)

node/app/db_console.go

@@ -886,11 +886,11 @@ func logoVersion(width int) string {
 		out += "                     #######################################        ########\n"
 		out += "                          #############################                ##\n"
 		out += " \n"
-		out += "                        Quilibrium Node - v1.2.15 – Dawn\n"
+		out += "                         Quilibrium Node - v1.3.0 – Dawn\n"
 		out += " \n"
 		out += "                                   DB Console\n"
 	} else {
-		out = "Quilibrium Node - v1.2.15 – Dawn - DB Console\n"
+		out = "Quilibrium Node - v1.3.0 – Dawn - DB Console\n"
 	}
 	return out
 }

node/consensus/ceremony/consensus_frames.go

@@ -242,15 +242,8 @@ func (e *CeremonyDataClockConsensusEngine) sync(
 		}
 	}
 
-	s, err := client.GetCompressedSyncFrames(
+	s, err := client.NegotiateCompressedSyncFrames(
 		context.Background(),
-		&protobufs.ClockFramesRequest{
-			Filter:               e.filter,
-			FromFrameNumber:      from,
-			ToFrameNumber:        maxFrame,
-			ParentSelector:       latest.ParentSelector,
-			RangeParentSelectors: rangeParentSelectors,
-		},
 		grpc.MaxCallRecvMsgSize(600*1024*1024),
 	)
 	if err != nil {
@@ -268,14 +261,92 @@ func (e *CeremonyDataClockConsensusEngine) sync(
 		return latest, errors.Wrap(err, "sync")
 	}
 
-	var syncMsg *protobufs.CeremonyCompressedSync
+	err = s.Send(&protobufs.CeremonyCompressedSyncRequestMessage{
+		SyncMessage: &protobufs.CeremonyCompressedSyncRequestMessage_Preflight{
+			Preflight: &protobufs.ClockFramesPreflight{
+				RangeParentSelectors: rangeParentSelectors,
+			},
+		},
+	})
+	if err != nil {
+		return latest, errors.Wrap(err, "sync")
+	}
+
+	syncMsg, err := s.Recv()
+	if err != nil {
+		return latest, errors.Wrap(err, "sync")
+	}
+	preflight, ok := syncMsg.
+		SyncMessage.(*protobufs.CeremonyCompressedSyncResponseMessage_Preflight)
+	if !ok {
+		s.CloseSend()
+		return latest, errors.Wrap(
+			errors.New("preflight message invalid"),
+			"sync",
+		)
+	}
+
+	// loop through parent selectors, set found to first match, and if subsequent
+	// matches fail to be found, cancel the search, start from 1.
+	found := uint64(0)
+	parentSelector := make([]byte, 32)
+
+	for _, selector := range preflight.Preflight.RangeParentSelectors {
+		match, err := e.clockStore.GetParentDataClockFrame(
+			e.filter,
+			selector.FrameNumber,
+			selector.ParentSelector,
+			true,
+		)
+		if err != nil && found == 0 {
+			continue
+		}
+		if err != nil && found != 0 {
+			found = 1
+			e.logger.Info("could not find interstitial frame, setting search to 1")
+			break
+		}
+		if match != nil && found == 0 {
+			found = match.FrameNumber
+			parentSelector = match.ParentSelector
+		}
+	}
+	if found != 0 {
+		from = found
+	}
+
+	err = s.Send(&protobufs.CeremonyCompressedSyncRequestMessage{
+		SyncMessage: &protobufs.CeremonyCompressedSyncRequestMessage_Request{
+			Request: &protobufs.ClockFramesRequest{
+				Filter:          e.filter,
+				FromFrameNumber: from,
+				ToFrameNumber:   0,
+				ParentSelector:  parentSelector,
+			},
+		},
+	})
+	if err != nil {
+		return latest, errors.Wrap(err, "sync")
+	}
+
 	for syncMsg, err = s.Recv(); err == nil; syncMsg, err = s.Recv() {
+		sync, ok := syncMsg.
+			SyncMessage.(*protobufs.CeremonyCompressedSyncResponseMessage_Response)
+		if !ok {
+			return latest, errors.Wrap(
+				errors.New("response message invalid"),
+				"sync",
+			)
+		}
+
+		response := sync.Response
+
 		e.logger.Info(
 			"received compressed sync frame",
-			zap.Uint64("from", syncMsg.FromFrameNumber),
+			zap.Uint64("from", response.FromFrameNumber),
-			zap.Uint64("to", syncMsg.ToFrameNumber),
+			zap.Uint64("to", response.ToFrameNumber),
-			zap.Int("frames", len(syncMsg.TruncatedClockFrames)),
+			zap.Int("frames", len(response.TruncatedClockFrames)),
-			zap.Int("proofs", len(syncMsg.Proofs)),
+			zap.Int("proofs", len(response.Proofs)),
 		)
 
 		// This can only happen if we get a peer with state that was initially
@@ -283,8 +354,7 @@ func (e *CeremonyDataClockConsensusEngine) sync(
 		// effect that doesn't go away for them until they're caught up again,
 		// so let's not penalize their score and make everyone else suffer,
 		// let's just move on:
-		if syncMsg.FromFrameNumber == 0 &&
+		if response.FromFrameNumber == 0 && response.ToFrameNumber == 0 {
-			syncMsg.ToFrameNumber == 0 {
 			if err := cc.Close(); err != nil {
 				e.logger.Error("error while closing connection", zap.Error(err))
 			}
@@ -295,7 +365,7 @@ func (e *CeremonyDataClockConsensusEngine) sync(
 		var next *protobufs.ClockFrame
 		if next, err = e.decompressAndStoreCandidates(
 			peerId,
-			syncMsg,
+			response,
 		); err != nil && !errors.Is(err, ErrNoNewFrames) {
 			e.logger.Error(
 				"could not decompress and store candidate",

node/consensus/ceremony/peer_messaging.go

@@ -3,6 +3,7 @@ package ceremony
 import (
 	"bytes"
 	"context"
+	"io"
 	"time"
 
 	"github.com/pkg/errors"
@@ -18,6 +19,227 @@ import (
 
 var ErrNoNewFrames = errors.New("peer reported no frames")
 
+// Compressed sync negotiation:
+// Recipients of the sync                                 Servers providing sync
+// |                                                                           |
+// |---------[Preflight{HEAD, HEAD-16, HEAD-32, HEAD-64, ..., 1}]------------->|
+// |<--------[Preflight{HEAD, HEAD-16, HEAD-32, HEAD-64, ..., M}]--------------|
+// |                    M = matching selector or 1                             |
+// |------------------------------[Request{N}]-------------------------------->|
+// |                    N = matching higher selector or M                      |
+// |<-------------------------[Response{N...N+16}]-----------------------------|
+// |<--------------------------[Response{N+17...}]-----------------------------|
+// |<--------------------------[Response{...HEAD}]-----------------------------|
+func (e *CeremonyDataClockConsensusEngine) NegotiateCompressedSyncFrames(
+	server protobufs.CeremonyService_NegotiateCompressedSyncFramesServer,
+) error {
+	e.currentReceivingSyncPeersMx.Lock()
+	if e.currentReceivingSyncPeers > 4 {
+		e.currentReceivingSyncPeersMx.Unlock()
+
+		e.logger.Debug(
+			"currently processing maximum sync requests, returning",
+		)
+
+		if err := server.SendMsg(
+			&protobufs.CeremonyCompressedSyncResponseMessage{
+				SyncMessage: &protobufs.CeremonyCompressedSyncResponseMessage_Response{
+					Response: &protobufs.CeremonyCompressedSync{
+						FromFrameNumber: 0,
+						ToFrameNumber:   0,
+					},
+				},
+			},
+		); err != nil {
+			return errors.Wrap(err, "negotiate compressed sync frames")
+		}
+
+		return nil
+	}
+	e.currentReceivingSyncPeers++
+	e.currentReceivingSyncPeersMx.Unlock()
+
+	defer func() {
+		e.currentReceivingSyncPeersMx.Lock()
+		e.currentReceivingSyncPeers--
+		e.currentReceivingSyncPeersMx.Unlock()
+	}()
+
+	for {
+		request, err := server.Recv()
+		if err == io.EOF {
+			return nil
+		}
+
+		if err != nil {
+			return errors.Wrap(err, "negotiate compressed sync frames")
+		}
+
+		switch msg := request.SyncMessage.(type) {
+		case *protobufs.CeremonyCompressedSyncRequestMessage_Preflight:
+			e.logger.Debug(
+				"received clock frame preflight",
+				zap.Int("selector_count", len(msg.Preflight.RangeParentSelectors)),
+			)
+
+			from := uint64(1)
+
+			preflightResponse := []*protobufs.ClockFrameParentSelectors{}
+			for _, selector := range msg.Preflight.RangeParentSelectors {
+				frame, _, err := e.clockStore.GetDataClockFrame(
+					e.filter,
+					selector.FrameNumber,
+					true,
+				)
+				if err == nil && frame != nil {
+					from = selector.FrameNumber
+					break
+				}
+			}
+
+			head, err := e.dataTimeReel.Head()
+			if err != nil {
+				return errors.Wrap(err, "negotiate compressed sync frames")
+			}
+
+			to := head.FrameNumber
+			selector, err := head.GetSelector()
+			if err != nil {
+				return errors.Wrap(err, "negotiate compressed sync frames")
+			}
+
+			preflightResponse = append(
+				preflightResponse,
+				&protobufs.ClockFrameParentSelectors{
+					FrameNumber:    to,
+					ParentSelector: selector.FillBytes(make([]byte, 32)),
+				},
+			)
+			rangeSubtract := uint64(16)
+			for {
+				parentNumber := to - uint64(rangeSubtract)
+
+				if parentNumber < from {
+					break
+				}
+				rangeSubtract *= 2
+				parent, _, err := e.clockStore.GetDataClockFrame(
+					e.filter,
+					parentNumber,
+					true,
+				)
+				if err != nil {
+					break
+				}
+
+				parentSelector, err := parent.GetSelector()
+				if err != nil {
+					return errors.Wrap(err, "negotiate compressed sync frames")
+				}
+
+				preflightResponse = append(
+					preflightResponse,
+					&protobufs.ClockFrameParentSelectors{
+						FrameNumber:    parent.FrameNumber,
+						ParentSelector: parentSelector.FillBytes(make([]byte, 32)),
+					},
+				)
+			}
+			err = server.Send(&protobufs.CeremonyCompressedSyncResponseMessage{
+				SyncMessage: &protobufs.CeremonyCompressedSyncResponseMessage_Preflight{
+					Preflight: &protobufs.ClockFramesPreflight{
+						RangeParentSelectors: preflightResponse,
+					},
+				},
+			})
+			if err != nil {
+				return errors.Wrap(err, "negotiate compressed sync frames")
+			}
+		case *protobufs.CeremonyCompressedSyncRequestMessage_Request:
+			e.logger.Info(
+				"received clock frame request",
+				zap.Uint64("from_frame_number", msg.Request.FromFrameNumber),
+				zap.Uint64("to_frame_number", msg.Request.ToFrameNumber),
+			)
+			from := msg.Request.FromFrameNumber
+			_, _, err := e.clockStore.GetDataClockFrame(
+				e.filter,
+				from,
+				true,
+			)
+			if err != nil {
+				if !errors.Is(err, store.ErrNotFound) {
+					e.logger.Error(
+						"peer asked for frame that returned error",
+						zap.Uint64("frame_number", msg.Request.FromFrameNumber),
+					)
+
+					return errors.Wrap(err, "negotiate compressed sync frames")
+				} else {
+					from = 1
+				}
+			}
+
+			head, err := e.dataTimeReel.Head()
+			if err != nil {
+				panic(err)
+			}
+
+			max := head.FrameNumber
+			to := msg.Request.ToFrameNumber
+
+			// We need to slightly rewind, to compensate for unconfirmed frame heads
+			// on a given branch
+			if from >= 2 {
+				from--
+			}
+
+			for {
+				if to == 0 || to-from > 16 {
+					if max > from+15 {
+						to = from + 16
+					} else {
+						to = max + 1
+					}
+				}
+
+				syncMsg, err := e.clockStore.GetCompressedDataClockFrames(
+					e.filter,
+					from,
+					to,
+				)
+				if err != nil {
+					return errors.Wrap(err, "negotiate compressed sync frames")
+				}
+
+				if err := server.Send(&protobufs.CeremonyCompressedSyncResponseMessage{
+					SyncMessage: &protobufs.
+						CeremonyCompressedSyncResponseMessage_Response{
+						Response: syncMsg,
+					},
+				}); err != nil {
+					return errors.Wrap(err, "negotiate compressed sync frames")
+				}
+
+				if (msg.Request.ToFrameNumber == 0 || msg.Request.ToFrameNumber > to) &&
+					max > to {
+					from = to + 1
+					if msg.Request.ToFrameNumber > to {
+						to = msg.Request.ToFrameNumber
+					} else {
+						to = 0
+					}
+				} else {
+					break
+				}
+			}
+
+			return nil
+		}
+	}
+}
+
+// Deprecated: Use NegotiateCompressedSyncFrames.
 // GetCompressedSyncFrames implements protobufs.CeremonyServiceServer.
 func (e *CeremonyDataClockConsensusEngine) GetCompressedSyncFrames(
 	request *protobufs.ClockFramesRequest,
@@ -237,7 +459,7 @@ func (e *CeremonyDataClockConsensusEngine) decompressAndStoreCandidates(
 			zap.Int("aggregate_commits", commits),
 		)
 		for j := 0; j < commits; j++ {
-			e.logger.Info(
+			e.logger.Debug(
 				"processing commit",
 				zap.Uint64("frame_number", frame.FrameNumber),
 				zap.Int("commit_index", j),
@@ -278,7 +500,7 @@ func (e *CeremonyDataClockConsensusEngine) decompressAndStoreCandidates(
 			for k, c := range aggregateProof.Commitments {
 				k := k
 				c := c
-				e.logger.Info(
+				e.logger.Debug(
 					"adding inclusion commitment",
 					zap.Uint64("frame_number", frame.FrameNumber),
 					zap.Int("commit_index", j),
@@ -307,7 +529,7 @@ func (e *CeremonyDataClockConsensusEngine) decompressAndStoreCandidates(
 						if bytes.Equal(s.Hash, h) {
 							if output != nil {
 								if l == 0 {
-									e.logger.Info(
+									e.logger.Debug(
 										"found first half of matching segment data",
 										zap.Uint64("frame_number", frame.FrameNumber),
 										zap.Int("commit_index", j),
@@ -317,7 +539,7 @@ func (e *CeremonyDataClockConsensusEngine) decompressAndStoreCandidates(
 									output.Address = s.Data[:32]
 									output.Output = s.Data[32:]
 								} else {
-									e.logger.Info(
+									e.logger.Debug(
 										"found second half of matching segment data",
 										zap.Uint64("frame_number", frame.FrameNumber),
 										zap.Int("commit_index", j),
@@ -336,7 +558,7 @@ func (e *CeremonyDataClockConsensusEngine) decompressAndStoreCandidates(
 									break
 								}
 							} else {
-								e.logger.Info(
+								e.logger.Debug(
 									"found matching segment data",
 									zap.Uint64("frame_number", frame.FrameNumber),
 									zap.Int("commit_index", j),
@@ -405,6 +627,12 @@ func (e *svr) GetCompressedSyncFrames(
 	return errors.New("not supported")
 }
 
+func (e *svr) NegotiateCompressedSyncFrames(
+	server protobufs.CeremonyService_NegotiateCompressedSyncFramesServer,
+) error {
+	return errors.New("not supported")
+}
+
 func (e *svr) GetPublicChannel(
 	server protobufs.CeremonyService_GetPublicChannelServer,
 ) error {

node/consensus/consensus_engine.go

@@ -51,13 +51,13 @@ type DataConsensusEngine interface {
 }
 
 func GetMinimumVersionCutoff() time.Time {
-	return time.Date(2024, time.February, 20, 7, 0, 0, 0, time.UTC)
+	return time.Date(2024, time.February, 28, 7, 0, 0, 0, time.UTC)
 }
 
 func GetMinimumVersion() []byte {
-	return []byte{0x01, 0x02, 0x0D}
+	return []byte{0x01, 0x03, 0x00}
 }
 
 func GetVersion() []byte {
-	return []byte{0x01, 0x02, 0x0F}
+	return []byte{0x01, 0x03, 0x00}
 }

node/main.go

@@ -307,5 +307,5 @@ func printLogo() {
 
 func printVersion() {
 	fmt.Println(" ")
-	fmt.Println("                        Quilibrium Node - v1.2.15 – Dawn")
+	fmt.Println("                         Quilibrium Node - v1.3.0 – Dawn")
 }

node/protobufs/ceremony.pb.go

@@ -1201,6 +1201,172 @@ func (x *CeremonyCompressedSync) GetSegments() []*InclusionSegmentsMap {
 	return nil
 }
 
+type CeremonyCompressedSyncRequestMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Types that are assignable to SyncMessage:
+	//
+	//	*CeremonyCompressedSyncRequestMessage_Preflight
+	//	*CeremonyCompressedSyncRequestMessage_Request
+	SyncMessage isCeremonyCompressedSyncRequestMessage_SyncMessage `protobuf_oneof:"sync_message"`
+}
+
+func (x *CeremonyCompressedSyncRequestMessage) Reset() {
+	*x = CeremonyCompressedSyncRequestMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_ceremony_proto_msgTypes[16]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *CeremonyCompressedSyncRequestMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*CeremonyCompressedSyncRequestMessage) ProtoMessage() {}
+
+func (x *CeremonyCompressedSyncRequestMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_ceremony_proto_msgTypes[16]
+	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 CeremonyCompressedSyncRequestMessage.ProtoReflect.Descriptor instead.
+func (*CeremonyCompressedSyncRequestMessage) Descriptor() ([]byte, []int) {
+	return file_ceremony_proto_rawDescGZIP(), []int{16}
+}
+
+func (m *CeremonyCompressedSyncRequestMessage) GetSyncMessage() isCeremonyCompressedSyncRequestMessage_SyncMessage {
+	if m != nil {
+		return m.SyncMessage
+	}
+	return nil
+}
+
+func (x *CeremonyCompressedSyncRequestMessage) GetPreflight() *ClockFramesPreflight {
+	if x, ok := x.GetSyncMessage().(*CeremonyCompressedSyncRequestMessage_Preflight); ok {
+		return x.Preflight
+	}
+	return nil
+}
+
+func (x *CeremonyCompressedSyncRequestMessage) GetRequest() *ClockFramesRequest {
+	if x, ok := x.GetSyncMessage().(*CeremonyCompressedSyncRequestMessage_Request); ok {
+		return x.Request
+	}
+	return nil
+}
+
+type isCeremonyCompressedSyncRequestMessage_SyncMessage interface {
+	isCeremonyCompressedSyncRequestMessage_SyncMessage()
+}
+
+type CeremonyCompressedSyncRequestMessage_Preflight struct {
+	Preflight *ClockFramesPreflight `protobuf:"bytes,1,opt,name=preflight,proto3,oneof"`
+}
+
+type CeremonyCompressedSyncRequestMessage_Request struct {
+	Request *ClockFramesRequest `protobuf:"bytes,2,opt,name=request,proto3,oneof"`
+}
+
+func (*CeremonyCompressedSyncRequestMessage_Preflight) isCeremonyCompressedSyncRequestMessage_SyncMessage() {
+}
+
+func (*CeremonyCompressedSyncRequestMessage_Request) isCeremonyCompressedSyncRequestMessage_SyncMessage() {
+}
+
+type CeremonyCompressedSyncResponseMessage struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	// Types that are assignable to SyncMessage:
+	//
+	//	*CeremonyCompressedSyncResponseMessage_Preflight
+	//	*CeremonyCompressedSyncResponseMessage_Response
+	SyncMessage isCeremonyCompressedSyncResponseMessage_SyncMessage `protobuf_oneof:"sync_message"`
+}
+
+func (x *CeremonyCompressedSyncResponseMessage) Reset() {
+	*x = CeremonyCompressedSyncResponseMessage{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_ceremony_proto_msgTypes[17]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *CeremonyCompressedSyncResponseMessage) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*CeremonyCompressedSyncResponseMessage) ProtoMessage() {}
+
+func (x *CeremonyCompressedSyncResponseMessage) ProtoReflect() protoreflect.Message {
+	mi := &file_ceremony_proto_msgTypes[17]
+	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 CeremonyCompressedSyncResponseMessage.ProtoReflect.Descriptor instead.
+func (*CeremonyCompressedSyncResponseMessage) Descriptor() ([]byte, []int) {
+	return file_ceremony_proto_rawDescGZIP(), []int{17}
+}
+
+func (m *CeremonyCompressedSyncResponseMessage) GetSyncMessage() isCeremonyCompressedSyncResponseMessage_SyncMessage {
+	if m != nil {
+		return m.SyncMessage
+	}
+	return nil
+}
+
+func (x *CeremonyCompressedSyncResponseMessage) GetPreflight() *ClockFramesPreflight {
+	if x, ok := x.GetSyncMessage().(*CeremonyCompressedSyncResponseMessage_Preflight); ok {
+		return x.Preflight
+	}
+	return nil
+}
+
+func (x *CeremonyCompressedSyncResponseMessage) GetResponse() *CeremonyCompressedSync {
+	if x, ok := x.GetSyncMessage().(*CeremonyCompressedSyncResponseMessage_Response); ok {
+		return x.Response
+	}
+	return nil
+}
+
+type isCeremonyCompressedSyncResponseMessage_SyncMessage interface {
+	isCeremonyCompressedSyncResponseMessage_SyncMessage()
+}
+
+type CeremonyCompressedSyncResponseMessage_Preflight struct {
+	Preflight *ClockFramesPreflight `protobuf:"bytes,1,opt,name=preflight,proto3,oneof"`
+}
+
+type CeremonyCompressedSyncResponseMessage_Response struct {
+	Response *CeremonyCompressedSync `protobuf:"bytes,2,opt,name=response,proto3,oneof"`
+}
+
+func (*CeremonyCompressedSyncResponseMessage_Preflight) isCeremonyCompressedSyncResponseMessage_SyncMessage() {
+}
+
+func (*CeremonyCompressedSyncResponseMessage_Response) isCeremonyCompressedSyncResponseMessage_SyncMessage() {
+}
+
 type InclusionProofsMap struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -1214,7 +1380,7 @@ type InclusionProofsMap struct {
 func (x *InclusionProofsMap) Reset() {
 	*x = InclusionProofsMap{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ceremony_proto_msgTypes[16]
+		mi := &file_ceremony_proto_msgTypes[18]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1227,7 +1393,7 @@ func (x *InclusionProofsMap) String() string {
 func (*InclusionProofsMap) ProtoMessage() {}
 
 func (x *InclusionProofsMap) ProtoReflect() protoreflect.Message {
-	mi := &file_ceremony_proto_msgTypes[16]
+	mi := &file_ceremony_proto_msgTypes[18]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1240,7 +1406,7 @@ func (x *InclusionProofsMap) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use InclusionProofsMap.ProtoReflect.Descriptor instead.
 func (*InclusionProofsMap) Descriptor() ([]byte, []int) {
-	return file_ceremony_proto_rawDescGZIP(), []int{16}
+	return file_ceremony_proto_rawDescGZIP(), []int{18}
 }
 
 func (x *InclusionProofsMap) GetFrameCommit() []byte {
@@ -1276,7 +1442,7 @@ type InclusionSegmentsMap struct {
 func (x *InclusionSegmentsMap) Reset() {
 	*x = InclusionSegmentsMap{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ceremony_proto_msgTypes[17]
+		mi := &file_ceremony_proto_msgTypes[19]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1289,7 +1455,7 @@ func (x *InclusionSegmentsMap) String() string {
 func (*InclusionSegmentsMap) ProtoMessage() {}
 
 func (x *InclusionSegmentsMap) ProtoReflect() protoreflect.Message {
-	mi := &file_ceremony_proto_msgTypes[17]
+	mi := &file_ceremony_proto_msgTypes[19]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1302,7 +1468,7 @@ func (x *InclusionSegmentsMap) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use InclusionSegmentsMap.ProtoReflect.Descriptor instead.
 func (*InclusionSegmentsMap) Descriptor() ([]byte, []int) {
-	return file_ceremony_proto_rawDescGZIP(), []int{17}
+	return file_ceremony_proto_rawDescGZIP(), []int{19}
 }
 
 func (x *InclusionSegmentsMap) GetHash() []byte {
@@ -1332,7 +1498,7 @@ type InclusionCommitmentsMap struct {
 func (x *InclusionCommitmentsMap) Reset() {
 	*x = InclusionCommitmentsMap{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_ceremony_proto_msgTypes[18]
+		mi := &file_ceremony_proto_msgTypes[20]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -1345,7 +1511,7 @@ func (x *InclusionCommitmentsMap) String() string {
 func (*InclusionCommitmentsMap) ProtoMessage() {}
 
 func (x *InclusionCommitmentsMap) ProtoReflect() protoreflect.Message {
-	mi := &file_ceremony_proto_msgTypes[18]
+	mi := &file_ceremony_proto_msgTypes[20]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -1358,7 +1524,7 @@ func (x *InclusionCommitmentsMap) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use InclusionCommitmentsMap.ProtoReflect.Descriptor instead.
 func (*InclusionCommitmentsMap) Descriptor() ([]byte, []int) {
-	return file_ceremony_proto_rawDescGZIP(), []int{18}
+	return file_ceremony_proto_rawDescGZIP(), []int{20}
 }
 
 func (x *InclusionCommitmentsMap) GetCommitment() []byte {
@@ -1717,7 +1883,34 @@ var file_ceremony_proto_rawDesc = []byte{
 	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,
+	0x52, 0x08, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0xd0, 0x01, 0x0a, 0x24, 0x43,
+	0x65, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x79, 0x43, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65,
+	0x64, 0x53, 0x79, 0x6e, 0x63, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73,
+	0x61, 0x67, 0x65, 0x12, 0x4e, 0x0a, 0x09, 0x70, 0x72, 0x65, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 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, 0x50, 0x72, 0x65,
+	0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x48, 0x00, 0x52, 0x09, 0x70, 0x72, 0x65, 0x66, 0x6c, 0x69,
+	0x67, 0x68, 0x74, 0x12, 0x48, 0x0a, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x02,
+	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, 0x48, 0x00, 0x52, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x42, 0x0e, 0x0a,
+	0x0c, 0x73, 0x79, 0x6e, 0x63, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0xda, 0x01,
+	0x0a, 0x25, 0x43, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x79, 0x43, 0x6f, 0x6d, 0x70, 0x72, 0x65,
+	0x73, 0x73, 0x65, 0x64, 0x53, 0x79, 0x6e, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x4e, 0x0a, 0x09, 0x70, 0x72, 0x65, 0x66, 0x6c,
+	0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2e, 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, 0x50, 0x72, 0x65, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x48, 0x00, 0x52, 0x09, 0x70, 0x72,
+	0x65, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x12, 0x51, 0x0a, 0x08, 0x72, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 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, 0x48, 0x00,
+	0x52, 0x08, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x42, 0x0e, 0x0a, 0x0c, 0x73, 0x79,
+	0x6e, 0x63, 0x5f, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 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,
@@ -1740,7 +1933,7 @@ var file_ceremony_proto_rawDesc = []byte{
 	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,
+	0xb6, 0x03, 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,
@@ -1749,18 +1942,29 @@ var file_ceremony_proto_rawDesc = []byte{
 	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,
+	0x63, 0x30, 0x01, 0x12, 0xaa, 0x01, 0x0a, 0x1d, 0x4e, 0x65, 0x67, 0x6f, 0x74, 0x69, 0x61, 0x74,
-	0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x2e, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62,
+	0x65, 0x43, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x53, 0x79, 0x6e, 0x63, 0x46,
-	0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65,
+	0x72, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x41, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69,
-	0x6c, 0x2e, 0x70, 0x62, 0x2e, 0x50, 0x32, 0x50, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x45,
+	0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x79,
-	0x6e, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x1a, 0x2e, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62,
+	0x2e, 0x70, 0x62, 0x2e, 0x43, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x79, 0x43, 0x6f, 0x6d, 0x70,
-	0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65,
+	0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x53, 0x79, 0x6e, 0x63, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x6c, 0x2e, 0x70, 0x62, 0x2e, 0x50, 0x32, 0x50, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x45,
+	0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x42, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69,
-	0x6e, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x28, 0x01, 0x30, 0x01, 0x42, 0x3a, 0x5a, 0x38, 0x73,
+	0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63, 0x65, 0x72, 0x65, 0x6d,
-	0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d,
+	0x6f, 0x6e, 0x79, 0x2e, 0x70, 0x62, 0x2e, 0x43, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x79, 0x43,
-	0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2f,
+	0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x53, 0x79, 0x6e, 0x63, 0x52, 0x65, 0x73,
-	0x6d, 0x6f, 0x6e, 0x6f, 0x72, 0x65, 0x70, 0x6f, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2f, 0x70, 0x72,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x28, 0x01, 0x30, 0x01,
-	0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	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 (
@@ -1775,92 +1979,101 @@ func file_ceremony_proto_rawDescGZIP() []byte {
 	return file_ceremony_proto_rawDescData
 }
 
-var file_ceremony_proto_msgTypes = make([]protoimpl.MessageInfo, 19)
+var file_ceremony_proto_msgTypes = make([]protoimpl.MessageInfo, 21)
 var file_ceremony_proto_goTypes = []interface{}{
-	(*CeremonyTranscript)(nil),               // 0: quilibrium.node.ceremony.pb.CeremonyTranscript
+	(*CeremonyTranscript)(nil),                    // 0: quilibrium.node.ceremony.pb.CeremonyTranscript
-	(*CeremonyLobbyState)(nil),               // 1: quilibrium.node.ceremony.pb.CeremonyLobbyState
+	(*CeremonyLobbyState)(nil),                    // 1: quilibrium.node.ceremony.pb.CeremonyLobbyState
-	(*CeremonySeenProverAttestation)(nil),    // 2: quilibrium.node.ceremony.pb.CeremonySeenProverAttestation
+	(*CeremonySeenProverAttestation)(nil),         // 2: quilibrium.node.ceremony.pb.CeremonySeenProverAttestation
-	(*CeremonyDroppedProverAttestation)(nil), // 3: quilibrium.node.ceremony.pb.CeremonyDroppedProverAttestation
+	(*CeremonyDroppedProverAttestation)(nil),      // 3: quilibrium.node.ceremony.pb.CeremonyDroppedProverAttestation
-	(*CeremonyTranscriptShare)(nil),          // 4: quilibrium.node.ceremony.pb.CeremonyTranscriptShare
+	(*CeremonyTranscriptShare)(nil),               // 4: quilibrium.node.ceremony.pb.CeremonyTranscriptShare
-	(*CeremonyTranscriptCommit)(nil),         // 5: quilibrium.node.ceremony.pb.CeremonyTranscriptCommit
+	(*CeremonyTranscriptCommit)(nil),              // 5: quilibrium.node.ceremony.pb.CeremonyTranscriptCommit
-	(*CeremonyAdvanceRound)(nil),             // 6: quilibrium.node.ceremony.pb.CeremonyAdvanceRound
+	(*CeremonyAdvanceRound)(nil),                  // 6: quilibrium.node.ceremony.pb.CeremonyAdvanceRound
-	(*CeremonyLobbyJoin)(nil),                // 7: quilibrium.node.ceremony.pb.CeremonyLobbyJoin
+	(*CeremonyLobbyJoin)(nil),                     // 7: quilibrium.node.ceremony.pb.CeremonyLobbyJoin
-	(*CeremonyLobbyStateTransition)(nil),     // 8: quilibrium.node.ceremony.pb.CeremonyLobbyStateTransition
+	(*CeremonyLobbyStateTransition)(nil),          // 8: quilibrium.node.ceremony.pb.CeremonyLobbyStateTransition
-	(*CeremonyOpenState)(nil),                // 9: quilibrium.node.ceremony.pb.CeremonyOpenState
+	(*CeremonyOpenState)(nil),                     // 9: quilibrium.node.ceremony.pb.CeremonyOpenState
-	(*CeremonyInProgressState)(nil),          // 10: quilibrium.node.ceremony.pb.CeremonyInProgressState
+	(*CeremonyInProgressState)(nil),               // 10: quilibrium.node.ceremony.pb.CeremonyInProgressState
-	(*CeremonyFinalizingState)(nil),          // 11: quilibrium.node.ceremony.pb.CeremonyFinalizingState
+	(*CeremonyFinalizingState)(nil),               // 11: quilibrium.node.ceremony.pb.CeremonyFinalizingState
-	(*CeremonyValidatingState)(nil),          // 12: quilibrium.node.ceremony.pb.CeremonyValidatingState
+	(*CeremonyValidatingState)(nil),               // 12: quilibrium.node.ceremony.pb.CeremonyValidatingState
-	(*CeremonyPeerListAnnounce)(nil),         // 13: quilibrium.node.ceremony.pb.CeremonyPeerListAnnounce
+	(*CeremonyPeerListAnnounce)(nil),              // 13: quilibrium.node.ceremony.pb.CeremonyPeerListAnnounce
-	(*CeremonyPeer)(nil),                     // 14: quilibrium.node.ceremony.pb.CeremonyPeer
+	(*CeremonyPeer)(nil),                          // 14: quilibrium.node.ceremony.pb.CeremonyPeer
-	(*CeremonyCompressedSync)(nil),           // 15: quilibrium.node.ceremony.pb.CeremonyCompressedSync
+	(*CeremonyCompressedSync)(nil),                // 15: quilibrium.node.ceremony.pb.CeremonyCompressedSync
-	(*InclusionProofsMap)(nil),               // 16: quilibrium.node.ceremony.pb.InclusionProofsMap
+	(*CeremonyCompressedSyncRequestMessage)(nil),  // 16: quilibrium.node.ceremony.pb.CeremonyCompressedSyncRequestMessage
-	(*InclusionSegmentsMap)(nil),             // 17: quilibrium.node.ceremony.pb.InclusionSegmentsMap
+	(*CeremonyCompressedSyncResponseMessage)(nil), // 17: quilibrium.node.ceremony.pb.CeremonyCompressedSyncResponseMessage
-	(*InclusionCommitmentsMap)(nil),          // 18: quilibrium.node.ceremony.pb.InclusionCommitmentsMap
+	(*InclusionProofsMap)(nil),                    // 18: quilibrium.node.ceremony.pb.InclusionProofsMap
-	(*BLS48581G1PublicKey)(nil),              // 19: quilibrium.node.keys.pb.BLS48581G1PublicKey
+	(*InclusionSegmentsMap)(nil),                  // 19: quilibrium.node.ceremony.pb.InclusionSegmentsMap
-	(*BLS48581G2PublicKey)(nil),              // 20: quilibrium.node.keys.pb.BLS48581G2PublicKey
+	(*InclusionCommitmentsMap)(nil),               // 20: quilibrium.node.ceremony.pb.InclusionCommitmentsMap
-	(*Ed448PublicKey)(nil),                   // 21: quilibrium.node.keys.pb.Ed448PublicKey
+	(*BLS48581G1PublicKey)(nil),                   // 21: quilibrium.node.keys.pb.BLS48581G1PublicKey
-	(*Ed448Signature)(nil),                   // 22: quilibrium.node.keys.pb.Ed448Signature
+	(*BLS48581G2PublicKey)(nil),                   // 22: quilibrium.node.keys.pb.BLS48581G2PublicKey
-	(*BLS48581Signature)(nil),                // 23: quilibrium.node.keys.pb.BLS48581Signature
+	(*Ed448PublicKey)(nil),                        // 23: quilibrium.node.keys.pb.Ed448PublicKey
-	(*X448PublicKey)(nil),                    // 24: quilibrium.node.keys.pb.X448PublicKey
+	(*Ed448Signature)(nil),                        // 24: quilibrium.node.keys.pb.Ed448Signature
-	(*ClockFrame)(nil),                       // 25: quilibrium.node.clock.pb.ClockFrame
+	(*BLS48581Signature)(nil),                     // 25: quilibrium.node.keys.pb.BLS48581Signature
-	(*ClockFramesRequest)(nil),               // 26: quilibrium.node.clock.pb.ClockFramesRequest
+	(*X448PublicKey)(nil),                         // 26: quilibrium.node.keys.pb.X448PublicKey
-	(*P2PChannelEnvelope)(nil),               // 27: quilibrium.node.channel.pb.P2PChannelEnvelope
+	(*ClockFrame)(nil),                            // 27: quilibrium.node.clock.pb.ClockFrame
+	(*ClockFramesPreflight)(nil),                  // 28: quilibrium.node.clock.pb.ClockFramesPreflight
+	(*ClockFramesRequest)(nil),                    // 29: quilibrium.node.clock.pb.ClockFramesRequest
+	(*P2PChannelEnvelope)(nil),                    // 30: quilibrium.node.channel.pb.P2PChannelEnvelope
 }
 var file_ceremony_proto_depIdxs = []int32{
-	19, // 0: quilibrium.node.ceremony.pb.CeremonyTranscript.g1_powers:type_name -> quilibrium.node.keys.pb.BLS48581G1PublicKey
+	21, // 0: quilibrium.node.ceremony.pb.CeremonyTranscript.g1_powers:type_name -> quilibrium.node.keys.pb.BLS48581G1PublicKey
-	20, // 1: quilibrium.node.ceremony.pb.CeremonyTranscript.g2_powers:type_name -> quilibrium.node.keys.pb.BLS48581G2PublicKey
+	22, // 1: quilibrium.node.ceremony.pb.CeremonyTranscript.g2_powers:type_name -> quilibrium.node.keys.pb.BLS48581G2PublicKey
-	19, // 2: quilibrium.node.ceremony.pb.CeremonyTranscript.running_g1_256_witnesses:type_name -> quilibrium.node.keys.pb.BLS48581G1PublicKey
+	21, // 2: quilibrium.node.ceremony.pb.CeremonyTranscript.running_g1_256_witnesses:type_name -> quilibrium.node.keys.pb.BLS48581G1PublicKey
-	20, // 3: quilibrium.node.ceremony.pb.CeremonyTranscript.running_g2_256_powers:type_name -> quilibrium.node.keys.pb.BLS48581G2PublicKey
+	22, // 3: quilibrium.node.ceremony.pb.CeremonyTranscript.running_g2_256_powers:type_name -> quilibrium.node.keys.pb.BLS48581G2PublicKey
 	9,  // 4: quilibrium.node.ceremony.pb.CeremonyLobbyState.ceremony_open_state:type_name -> quilibrium.node.ceremony.pb.CeremonyOpenState
 	10, // 5: quilibrium.node.ceremony.pb.CeremonyLobbyState.ceremony_in_progress_state:type_name -> quilibrium.node.ceremony.pb.CeremonyInProgressState
 	11, // 6: quilibrium.node.ceremony.pb.CeremonyLobbyState.ceremony_finalizing_state:type_name -> quilibrium.node.ceremony.pb.CeremonyFinalizingState
 	12, // 7: quilibrium.node.ceremony.pb.CeremonyLobbyState.ceremony_validating_state:type_name -> quilibrium.node.ceremony.pb.CeremonyValidatingState
 	0,  // 8: quilibrium.node.ceremony.pb.CeremonyLobbyState.latest_transcript:type_name -> quilibrium.node.ceremony.pb.CeremonyTranscript
-	21, // 9: quilibrium.node.ceremony.pb.CeremonySeenProverAttestation.seen_prover_key:type_name -> quilibrium.node.keys.pb.Ed448PublicKey
+	23, // 9: quilibrium.node.ceremony.pb.CeremonySeenProverAttestation.seen_prover_key:type_name -> quilibrium.node.keys.pb.Ed448PublicKey
-	22, // 10: quilibrium.node.ceremony.pb.CeremonySeenProverAttestation.prover_signature:type_name -> quilibrium.node.keys.pb.Ed448Signature
+	24, // 10: quilibrium.node.ceremony.pb.CeremonySeenProverAttestation.prover_signature:type_name -> quilibrium.node.keys.pb.Ed448Signature
-	21, // 11: quilibrium.node.ceremony.pb.CeremonyDroppedProverAttestation.dropped_prover_key:type_name -> quilibrium.node.keys.pb.Ed448PublicKey
+	23, // 11: quilibrium.node.ceremony.pb.CeremonyDroppedProverAttestation.dropped_prover_key:type_name -> quilibrium.node.keys.pb.Ed448PublicKey
-	22, // 12: quilibrium.node.ceremony.pb.CeremonyDroppedProverAttestation.prover_signature:type_name -> quilibrium.node.keys.pb.Ed448Signature
+	24, // 12: quilibrium.node.ceremony.pb.CeremonyDroppedProverAttestation.prover_signature:type_name -> quilibrium.node.keys.pb.Ed448Signature
-	19, // 13: quilibrium.node.ceremony.pb.CeremonyTranscriptShare.additive_g1_powers:type_name -> quilibrium.node.keys.pb.BLS48581G1PublicKey
+	21, // 13: quilibrium.node.ceremony.pb.CeremonyTranscriptShare.additive_g1_powers:type_name -> quilibrium.node.keys.pb.BLS48581G1PublicKey
-	20, // 14: quilibrium.node.ceremony.pb.CeremonyTranscriptShare.additive_g2_powers:type_name -> quilibrium.node.keys.pb.BLS48581G2PublicKey
+	22, // 14: quilibrium.node.ceremony.pb.CeremonyTranscriptShare.additive_g2_powers:type_name -> quilibrium.node.keys.pb.BLS48581G2PublicKey
-	19, // 15: quilibrium.node.ceremony.pb.CeremonyTranscriptShare.additive_g1_256_witness:type_name -> quilibrium.node.keys.pb.BLS48581G1PublicKey
+	21, // 15: quilibrium.node.ceremony.pb.CeremonyTranscriptShare.additive_g1_256_witness:type_name -> quilibrium.node.keys.pb.BLS48581G1PublicKey
-	20, // 16: quilibrium.node.ceremony.pb.CeremonyTranscriptShare.additive_g2_256_witness:type_name -> quilibrium.node.keys.pb.BLS48581G2PublicKey
+	22, // 16: quilibrium.node.ceremony.pb.CeremonyTranscriptShare.additive_g2_256_witness:type_name -> quilibrium.node.keys.pb.BLS48581G2PublicKey
-	22, // 17: quilibrium.node.ceremony.pb.CeremonyTranscriptShare.prover_signature:type_name -> quilibrium.node.keys.pb.Ed448Signature
+	24, // 17: quilibrium.node.ceremony.pb.CeremonyTranscriptShare.prover_signature:type_name -> quilibrium.node.keys.pb.Ed448Signature
-	22, // 18: quilibrium.node.ceremony.pb.CeremonyTranscriptCommit.prover_signature:type_name -> quilibrium.node.keys.pb.Ed448Signature
+	24, // 18: quilibrium.node.ceremony.pb.CeremonyTranscriptCommit.prover_signature:type_name -> quilibrium.node.keys.pb.Ed448Signature
-	23, // 19: quilibrium.node.ceremony.pb.CeremonyTranscriptCommit.contribution_signature:type_name -> quilibrium.node.keys.pb.BLS48581Signature
+	25, // 19: quilibrium.node.ceremony.pb.CeremonyTranscriptCommit.contribution_signature:type_name -> quilibrium.node.keys.pb.BLS48581Signature
 	5,  // 20: quilibrium.node.ceremony.pb.CeremonyAdvanceRound.commits:type_name -> quilibrium.node.ceremony.pb.CeremonyTranscriptCommit
-	24, // 21: quilibrium.node.ceremony.pb.CeremonyLobbyJoin.identity_key:type_name -> quilibrium.node.keys.pb.X448PublicKey
+	26, // 21: quilibrium.node.ceremony.pb.CeremonyLobbyJoin.identity_key:type_name -> quilibrium.node.keys.pb.X448PublicKey
-	24, // 22: quilibrium.node.ceremony.pb.CeremonyLobbyJoin.signed_pre_key:type_name -> quilibrium.node.keys.pb.X448PublicKey
+	26, // 22: quilibrium.node.ceremony.pb.CeremonyLobbyJoin.signed_pre_key:type_name -> quilibrium.node.keys.pb.X448PublicKey
-	22, // 23: quilibrium.node.ceremony.pb.CeremonyLobbyJoin.public_key_signature_ed448:type_name -> quilibrium.node.keys.pb.Ed448Signature
+	24, // 23: quilibrium.node.ceremony.pb.CeremonyLobbyJoin.public_key_signature_ed448:type_name -> quilibrium.node.keys.pb.Ed448Signature
 	7,  // 24: quilibrium.node.ceremony.pb.CeremonyOpenState.joined_participants:type_name -> quilibrium.node.ceremony.pb.CeremonyLobbyJoin
-	21, // 25: quilibrium.node.ceremony.pb.CeremonyOpenState.preferred_participants:type_name -> quilibrium.node.keys.pb.Ed448PublicKey
+	23, // 25: quilibrium.node.ceremony.pb.CeremonyOpenState.preferred_participants:type_name -> quilibrium.node.keys.pb.Ed448PublicKey
 	7,  // 26: quilibrium.node.ceremony.pb.CeremonyInProgressState.active_participants:type_name -> quilibrium.node.ceremony.pb.CeremonyLobbyJoin
 	2,  // 27: quilibrium.node.ceremony.pb.CeremonyInProgressState.latest_seen_prover_attestations:type_name -> quilibrium.node.ceremony.pb.CeremonySeenProverAttestation
 	3,  // 28: quilibrium.node.ceremony.pb.CeremonyInProgressState.dropped_participant_attestations:type_name -> quilibrium.node.ceremony.pb.CeremonyDroppedProverAttestation
 	6,  // 29: quilibrium.node.ceremony.pb.CeremonyInProgressState.transcript_round_advance_commits:type_name -> quilibrium.node.ceremony.pb.CeremonyAdvanceRound
-	21, // 30: quilibrium.node.ceremony.pb.CeremonyInProgressState.next_round_participants:type_name -> quilibrium.node.keys.pb.Ed448PublicKey
+	23, // 30: quilibrium.node.ceremony.pb.CeremonyInProgressState.next_round_participants:type_name -> quilibrium.node.keys.pb.Ed448PublicKey
 	7,  // 31: quilibrium.node.ceremony.pb.CeremonyFinalizingState.active_participants:type_name -> quilibrium.node.ceremony.pb.CeremonyLobbyJoin
 	2,  // 32: quilibrium.node.ceremony.pb.CeremonyFinalizingState.latest_seen_prover_attestations:type_name -> quilibrium.node.ceremony.pb.CeremonySeenProverAttestation
 	3,  // 33: quilibrium.node.ceremony.pb.CeremonyFinalizingState.dropped_participant_attestations:type_name -> quilibrium.node.ceremony.pb.CeremonyDroppedProverAttestation
 	5,  // 34: quilibrium.node.ceremony.pb.CeremonyFinalizingState.commits:type_name -> quilibrium.node.ceremony.pb.CeremonyTranscriptCommit
 	4,  // 35: quilibrium.node.ceremony.pb.CeremonyFinalizingState.shares:type_name -> quilibrium.node.ceremony.pb.CeremonyTranscriptShare
-	21, // 36: quilibrium.node.ceremony.pb.CeremonyFinalizingState.next_round_participants:type_name -> quilibrium.node.keys.pb.Ed448PublicKey
+	23, // 36: quilibrium.node.ceremony.pb.CeremonyFinalizingState.next_round_participants:type_name -> quilibrium.node.keys.pb.Ed448PublicKey
 	5,  // 37: quilibrium.node.ceremony.pb.CeremonyValidatingState.commits:type_name -> quilibrium.node.ceremony.pb.CeremonyTranscriptCommit
 	0,  // 38: quilibrium.node.ceremony.pb.CeremonyValidatingState.updated_transcript:type_name -> quilibrium.node.ceremony.pb.CeremonyTranscript
-	21, // 39: quilibrium.node.ceremony.pb.CeremonyValidatingState.next_round_participants:type_name -> quilibrium.node.keys.pb.Ed448PublicKey
+	23, // 39: quilibrium.node.ceremony.pb.CeremonyValidatingState.next_round_participants:type_name -> quilibrium.node.keys.pb.Ed448PublicKey
 	14, // 40: quilibrium.node.ceremony.pb.CeremonyPeerListAnnounce.peer_list:type_name -> quilibrium.node.ceremony.pb.CeremonyPeer
-	25, // 41: quilibrium.node.ceremony.pb.CeremonyCompressedSync.truncated_clock_frames:type_name -> quilibrium.node.clock.pb.ClockFrame
+	27, // 41: quilibrium.node.ceremony.pb.CeremonyCompressedSync.truncated_clock_frames:type_name -> quilibrium.node.clock.pb.ClockFrame
-	16, // 42: quilibrium.node.ceremony.pb.CeremonyCompressedSync.proofs:type_name -> quilibrium.node.ceremony.pb.InclusionProofsMap
+	18, // 42: quilibrium.node.ceremony.pb.CeremonyCompressedSync.proofs:type_name -> quilibrium.node.ceremony.pb.InclusionProofsMap
-	17, // 43: quilibrium.node.ceremony.pb.CeremonyCompressedSync.segments:type_name -> quilibrium.node.ceremony.pb.InclusionSegmentsMap
+	19, // 43: quilibrium.node.ceremony.pb.CeremonyCompressedSync.segments:type_name -> quilibrium.node.ceremony.pb.InclusionSegmentsMap
-	18, // 44: quilibrium.node.ceremony.pb.InclusionProofsMap.commitments:type_name -> quilibrium.node.ceremony.pb.InclusionCommitmentsMap
+	28, // 44: quilibrium.node.ceremony.pb.CeremonyCompressedSyncRequestMessage.preflight:type_name -> quilibrium.node.clock.pb.ClockFramesPreflight
-	26, // 45: quilibrium.node.ceremony.pb.CeremonyService.GetCompressedSyncFrames:input_type -> quilibrium.node.clock.pb.ClockFramesRequest
+	29, // 45: quilibrium.node.ceremony.pb.CeremonyCompressedSyncRequestMessage.request:type_name -> quilibrium.node.clock.pb.ClockFramesRequest
-	27, // 46: quilibrium.node.ceremony.pb.CeremonyService.GetPublicChannel:input_type -> quilibrium.node.channel.pb.P2PChannelEnvelope
+	28, // 46: quilibrium.node.ceremony.pb.CeremonyCompressedSyncResponseMessage.preflight:type_name -> quilibrium.node.clock.pb.ClockFramesPreflight
-	15, // 47: quilibrium.node.ceremony.pb.CeremonyService.GetCompressedSyncFrames:output_type -> quilibrium.node.ceremony.pb.CeremonyCompressedSync
+	15, // 47: quilibrium.node.ceremony.pb.CeremonyCompressedSyncResponseMessage.response:type_name -> quilibrium.node.ceremony.pb.CeremonyCompressedSync
-	27, // 48: quilibrium.node.ceremony.pb.CeremonyService.GetPublicChannel:output_type -> quilibrium.node.channel.pb.P2PChannelEnvelope
+	20, // 48: quilibrium.node.ceremony.pb.InclusionProofsMap.commitments:type_name -> quilibrium.node.ceremony.pb.InclusionCommitmentsMap
-	47, // [47:49] is the sub-list for method output_type
+	29, // 49: quilibrium.node.ceremony.pb.CeremonyService.GetCompressedSyncFrames:input_type -> quilibrium.node.clock.pb.ClockFramesRequest
-	45, // [45:47] is the sub-list for method input_type
+	16, // 50: quilibrium.node.ceremony.pb.CeremonyService.NegotiateCompressedSyncFrames:input_type -> quilibrium.node.ceremony.pb.CeremonyCompressedSyncRequestMessage
-	45, // [45:45] is the sub-list for extension type_name
+	30, // 51: quilibrium.node.ceremony.pb.CeremonyService.GetPublicChannel:input_type -> quilibrium.node.channel.pb.P2PChannelEnvelope
-	45, // [45:45] is the sub-list for extension extendee
+	15, // 52: quilibrium.node.ceremony.pb.CeremonyService.GetCompressedSyncFrames:output_type -> quilibrium.node.ceremony.pb.CeremonyCompressedSync
-	0,  // [0:45] is the sub-list for field type_name
+	17, // 53: quilibrium.node.ceremony.pb.CeremonyService.NegotiateCompressedSyncFrames:output_type -> quilibrium.node.ceremony.pb.CeremonyCompressedSyncResponseMessage
+	30, // 54: quilibrium.node.ceremony.pb.CeremonyService.GetPublicChannel:output_type -> quilibrium.node.channel.pb.P2PChannelEnvelope
+	52, // [52:55] is the sub-list for method output_type
+	49, // [49:52] is the sub-list for method input_type
+	49, // [49:49] is the sub-list for extension type_name
+	49, // [49:49] is the sub-list for extension extendee
+	0,  // [0:49] is the sub-list for field type_name
 }
 
 func init() { file_ceremony_proto_init() }
@@ -2065,7 +2278,7 @@ func file_ceremony_proto_init() {
 			}
 		}
 		file_ceremony_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*InclusionProofsMap); i {
+			switch v := v.(*CeremonyCompressedSyncRequestMessage); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2077,7 +2290,7 @@ func file_ceremony_proto_init() {
 			}
 		}
 		file_ceremony_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*InclusionSegmentsMap); i {
+			switch v := v.(*CeremonyCompressedSyncResponseMessage); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -2089,6 +2302,30 @@ func file_ceremony_proto_init() {
 			}
 		}
 		file_ceremony_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*InclusionProofsMap); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_ceremony_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*InclusionSegmentsMap); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_ceremony_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*InclusionCommitmentsMap); i {
 			case 0:
 				return &v.state
@@ -2107,13 +2344,21 @@ func file_ceremony_proto_init() {
 		(*CeremonyLobbyState_CeremonyFinalizingState)(nil),
 		(*CeremonyLobbyState_CeremonyValidatingState)(nil),
 	}
+	file_ceremony_proto_msgTypes[16].OneofWrappers = []interface{}{
+		(*CeremonyCompressedSyncRequestMessage_Preflight)(nil),
+		(*CeremonyCompressedSyncRequestMessage_Request)(nil),
+	}
+	file_ceremony_proto_msgTypes[17].OneofWrappers = []interface{}{
+		(*CeremonyCompressedSyncResponseMessage_Preflight)(nil),
+		(*CeremonyCompressedSyncResponseMessage_Response)(nil),
+	}
 	type x struct{}
 	out := protoimpl.TypeBuilder{
 		File: protoimpl.DescBuilder{
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_ceremony_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   19,
+			NumMessages:   21,
 			NumExtensions: 0,
 			NumServices:   1,
 		},

node/protobufs/ceremony.pb.gw.go

@@ -56,6 +56,49 @@ func request_CeremonyService_GetCompressedSyncFrames_0(ctx context.Context, mars
 
 }
 
+func request_CeremonyService_NegotiateCompressedSyncFrames_0(ctx context.Context, marshaler runtime.Marshaler, client CeremonyServiceClient, req *http.Request, pathParams map[string]string) (CeremonyService_NegotiateCompressedSyncFramesClient, runtime.ServerMetadata, error) {
+	var metadata runtime.ServerMetadata
+	stream, err := client.NegotiateCompressedSyncFrames(ctx)
+	if err != nil {
+		grpclog.Infof("Failed to start streaming: %v", err)
+		return nil, metadata, err
+	}
+	dec := marshaler.NewDecoder(req.Body)
+	handleSend := func() error {
+		var protoReq CeremonyCompressedSyncRequestMessage
+		err := dec.Decode(&protoReq)
+		if err == io.EOF {
+			return err
+		}
+		if err != nil {
+			grpclog.Infof("Failed to decode request: %v", err)
+			return err
+		}
+		if err := stream.Send(&protoReq); err != nil {
+			grpclog.Infof("Failed to send request: %v", err)
+			return err
+		}
+		return nil
+	}
+	go func() {
+		for {
+			if err := handleSend(); err != nil {
+				break
+			}
+		}
+		if err := stream.CloseSend(); err != nil {
+			grpclog.Infof("Failed to terminate client stream: %v", err)
+		}
+	}()
+	header, err := stream.Header()
+	if err != nil {
+		grpclog.Infof("Failed to get header from client: %v", err)
+		return nil, metadata, err
+	}
+	metadata.HeaderMD = header
+	return stream, metadata, nil
+}
+
 func request_CeremonyService_GetPublicChannel_0(ctx context.Context, marshaler runtime.Marshaler, client CeremonyServiceClient, req *http.Request, pathParams map[string]string) (CeremonyService_GetPublicChannelClient, runtime.ServerMetadata, error) {
 	var metadata runtime.ServerMetadata
 	stream, err := client.GetPublicChannel(ctx)
@@ -112,6 +155,13 @@ func RegisterCeremonyServiceHandlerServer(ctx context.Context, mux *runtime.Serv
 		return
 	})
 
+	mux.Handle("POST", pattern_CeremonyService_NegotiateCompressedSyncFrames_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
+	})
+
 	mux.Handle("POST", pattern_CeremonyService_GetPublicChannel_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)
@@ -182,6 +232,28 @@ func RegisterCeremonyServiceHandlerClient(ctx context.Context, mux *runtime.Serv
 
 	})
 
+	mux.Handle("POST", pattern_CeremonyService_NegotiateCompressedSyncFrames_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.ceremony.pb.CeremonyService/NegotiateCompressedSyncFrames", runtime.WithHTTPPathPattern("/quilibrium.node.ceremony.pb.CeremonyService/NegotiateCompressedSyncFrames"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_CeremonyService_NegotiateCompressedSyncFrames_0(annotatedContext, inboundMarshaler, client, req, pathParams)
+		annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
+		if err != nil {
+			runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_CeremonyService_NegotiateCompressedSyncFrames_0(annotatedContext, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...)
+
+	})
+
 	mux.Handle("POST", pattern_CeremonyService_GetPublicChannel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -210,11 +282,15 @@ func RegisterCeremonyServiceHandlerClient(ctx context.Context, mux *runtime.Serv
 var (
 	pattern_CeremonyService_GetCompressedSyncFrames_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"quilibrium.node.ceremony.pb.CeremonyService", "GetCompressedSyncFrames"}, ""))
 
+	pattern_CeremonyService_NegotiateCompressedSyncFrames_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"quilibrium.node.ceremony.pb.CeremonyService", "NegotiateCompressedSyncFrames"}, ""))
+
 	pattern_CeremonyService_GetPublicChannel_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"quilibrium.node.ceremony.pb.CeremonyService", "GetPublicChannel"}, ""))
 )
 
 var (
 	forward_CeremonyService_GetCompressedSyncFrames_0 = runtime.ForwardResponseStream
 
+	forward_CeremonyService_NegotiateCompressedSyncFrames_0 = runtime.ForwardResponseStream
+
 	forward_CeremonyService_GetPublicChannel_0 = runtime.ForwardResponseStream
 )

node/protobufs/ceremony.proto

@@ -150,6 +150,20 @@ message CeremonyCompressedSync {
   repeated InclusionSegmentsMap segments = 5;
 }
 
+message CeremonyCompressedSyncRequestMessage {
+  oneof sync_message {
+    quilibrium.node.clock.pb.ClockFramesPreflight preflight = 1;
+    quilibrium.node.clock.pb.ClockFramesRequest request = 2;
+  }
+}
+
+message CeremonyCompressedSyncResponseMessage {
+  oneof sync_message {
+    quilibrium.node.clock.pb.ClockFramesPreflight preflight = 1;
+    CeremonyCompressedSync response = 2;
+  }
+}
+
 message InclusionProofsMap {
   bytes frame_commit = 1;
   bytes proof = 2;
@@ -169,5 +183,6 @@ message InclusionCommitmentsMap {
 
 service CeremonyService {
   rpc GetCompressedSyncFrames (quilibrium.node.clock.pb.ClockFramesRequest) returns (stream CeremonyCompressedSync);
+  rpc NegotiateCompressedSyncFrames (stream CeremonyCompressedSyncRequestMessage) returns (stream CeremonyCompressedSyncResponseMessage);
   rpc GetPublicChannel (stream quilibrium.node.channel.pb.P2PChannelEnvelope) returns (stream quilibrium.node.channel.pb.P2PChannelEnvelope);
 }

node/protobufs/ceremony_grpc.pb.go

@@ -19,8 +19,9 @@ import (
 const _ = grpc.SupportPackageIsVersion7
 
 const (
-	CeremonyService_GetCompressedSyncFrames_FullMethodName = "/quilibrium.node.ceremony.pb.CeremonyService/GetCompressedSyncFrames"
+	CeremonyService_GetCompressedSyncFrames_FullMethodName       = "/quilibrium.node.ceremony.pb.CeremonyService/GetCompressedSyncFrames"
-	CeremonyService_GetPublicChannel_FullMethodName        = "/quilibrium.node.ceremony.pb.CeremonyService/GetPublicChannel"
+	CeremonyService_NegotiateCompressedSyncFrames_FullMethodName = "/quilibrium.node.ceremony.pb.CeremonyService/NegotiateCompressedSyncFrames"
+	CeremonyService_GetPublicChannel_FullMethodName              = "/quilibrium.node.ceremony.pb.CeremonyService/GetPublicChannel"
 )
 
 // CeremonyServiceClient is the client API for CeremonyService service.
@@ -28,6 +29,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 CeremonyServiceClient interface {
 	GetCompressedSyncFrames(ctx context.Context, in *ClockFramesRequest, opts ...grpc.CallOption) (CeremonyService_GetCompressedSyncFramesClient, error)
+	NegotiateCompressedSyncFrames(ctx context.Context, opts ...grpc.CallOption) (CeremonyService_NegotiateCompressedSyncFramesClient, error)
 	GetPublicChannel(ctx context.Context, opts ...grpc.CallOption) (CeremonyService_GetPublicChannelClient, error)
 }
 
@@ -71,8 +73,39 @@ func (x *ceremonyServiceGetCompressedSyncFramesClient) Recv() (*CeremonyCompress
 	return m, nil
 }
 
+func (c *ceremonyServiceClient) NegotiateCompressedSyncFrames(ctx context.Context, opts ...grpc.CallOption) (CeremonyService_NegotiateCompressedSyncFramesClient, error) {
+	stream, err := c.cc.NewStream(ctx, &CeremonyService_ServiceDesc.Streams[1], CeremonyService_NegotiateCompressedSyncFrames_FullMethodName, opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &ceremonyServiceNegotiateCompressedSyncFramesClient{stream}
+	return x, nil
+}
+
+type CeremonyService_NegotiateCompressedSyncFramesClient interface {
+	Send(*CeremonyCompressedSyncRequestMessage) error
+	Recv() (*CeremonyCompressedSyncResponseMessage, error)
+	grpc.ClientStream
+}
+
+type ceremonyServiceNegotiateCompressedSyncFramesClient struct {
+	grpc.ClientStream
+}
+
+func (x *ceremonyServiceNegotiateCompressedSyncFramesClient) Send(m *CeremonyCompressedSyncRequestMessage) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *ceremonyServiceNegotiateCompressedSyncFramesClient) Recv() (*CeremonyCompressedSyncResponseMessage, error) {
+	m := new(CeremonyCompressedSyncResponseMessage)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 func (c *ceremonyServiceClient) GetPublicChannel(ctx context.Context, opts ...grpc.CallOption) (CeremonyService_GetPublicChannelClient, error) {
-	stream, err := c.cc.NewStream(ctx, &CeremonyService_ServiceDesc.Streams[1], CeremonyService_GetPublicChannel_FullMethodName, opts...)
+	stream, err := c.cc.NewStream(ctx, &CeremonyService_ServiceDesc.Streams[2], CeremonyService_GetPublicChannel_FullMethodName, opts...)
 	if err != nil {
 		return nil, err
 	}
@@ -107,6 +140,7 @@ func (x *ceremonyServiceGetPublicChannelClient) Recv() (*P2PChannelEnvelope, err
 // for forward compatibility
 type CeremonyServiceServer interface {
 	GetCompressedSyncFrames(*ClockFramesRequest, CeremonyService_GetCompressedSyncFramesServer) error
+	NegotiateCompressedSyncFrames(CeremonyService_NegotiateCompressedSyncFramesServer) error
 	GetPublicChannel(CeremonyService_GetPublicChannelServer) error
 	mustEmbedUnimplementedCeremonyServiceServer()
 }
@@ -118,6 +152,9 @@ type UnimplementedCeremonyServiceServer struct {
 func (UnimplementedCeremonyServiceServer) GetCompressedSyncFrames(*ClockFramesRequest, CeremonyService_GetCompressedSyncFramesServer) error {
 	return status.Errorf(codes.Unimplemented, "method GetCompressedSyncFrames not implemented")
 }
+func (UnimplementedCeremonyServiceServer) NegotiateCompressedSyncFrames(CeremonyService_NegotiateCompressedSyncFramesServer) error {
+	return status.Errorf(codes.Unimplemented, "method NegotiateCompressedSyncFrames not implemented")
+}
 func (UnimplementedCeremonyServiceServer) GetPublicChannel(CeremonyService_GetPublicChannelServer) error {
 	return status.Errorf(codes.Unimplemented, "method GetPublicChannel not implemented")
 }
@@ -155,6 +192,32 @@ func (x *ceremonyServiceGetCompressedSyncFramesServer) Send(m *CeremonyCompresse
 	return x.ServerStream.SendMsg(m)
 }
 
+func _CeremonyService_NegotiateCompressedSyncFrames_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(CeremonyServiceServer).NegotiateCompressedSyncFrames(&ceremonyServiceNegotiateCompressedSyncFramesServer{stream})
+}
+
+type CeremonyService_NegotiateCompressedSyncFramesServer interface {
+	Send(*CeremonyCompressedSyncResponseMessage) error
+	Recv() (*CeremonyCompressedSyncRequestMessage, error)
+	grpc.ServerStream
+}
+
+type ceremonyServiceNegotiateCompressedSyncFramesServer struct {
+	grpc.ServerStream
+}
+
+func (x *ceremonyServiceNegotiateCompressedSyncFramesServer) Send(m *CeremonyCompressedSyncResponseMessage) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *ceremonyServiceNegotiateCompressedSyncFramesServer) Recv() (*CeremonyCompressedSyncRequestMessage, error) {
+	m := new(CeremonyCompressedSyncRequestMessage)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
 func _CeremonyService_GetPublicChannel_Handler(srv interface{}, stream grpc.ServerStream) error {
 	return srv.(CeremonyServiceServer).GetPublicChannel(&ceremonyServiceGetPublicChannelServer{stream})
 }
@@ -194,6 +257,12 @@ var CeremonyService_ServiceDesc = grpc.ServiceDesc{
 			Handler:       _CeremonyService_GetCompressedSyncFrames_Handler,
 			ServerStreams: true,
 		},
+		{
+			StreamName:    "NegotiateCompressedSyncFrames",
+			Handler:       _CeremonyService_NegotiateCompressedSyncFrames_Handler,
+			ServerStreams: true,
+			ClientStreams: true,
+		},
 		{
 			StreamName:    "GetPublicChannel",
 			Handler:       _CeremonyService_GetPublicChannel_Handler,

node/protobufs/clock.pb.go

@@ -336,6 +336,53 @@ func (x *ClockFramesRequest) GetRangeParentSelectors() []*ClockFrameParentSelect
 	return nil
 }
 
+type ClockFramesPreflight struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	RangeParentSelectors []*ClockFrameParentSelectors `protobuf:"bytes,1,rep,name=range_parent_selectors,json=rangeParentSelectors,proto3" json:"range_parent_selectors,omitempty"`
+}
+
+func (x *ClockFramesPreflight) Reset() {
+	*x = ClockFramesPreflight{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_clock_proto_msgTypes[3]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *ClockFramesPreflight) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*ClockFramesPreflight) ProtoMessage() {}
+
+func (x *ClockFramesPreflight) ProtoReflect() protoreflect.Message {
+	mi := &file_clock_proto_msgTypes[3]
+	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 ClockFramesPreflight.ProtoReflect.Descriptor instead.
+func (*ClockFramesPreflight) Descriptor() ([]byte, []int) {
+	return file_clock_proto_rawDescGZIP(), []int{3}
+}
+
+func (x *ClockFramesPreflight) GetRangeParentSelectors() []*ClockFrameParentSelectors {
+	if x != nil {
+		return x.RangeParentSelectors
+	}
+	return nil
+}
+
 // Represents a response for a range of clock frames. Used to stay synchronized
 // to the latest state.
 type ClockFramesResponse struct {
@@ -357,7 +404,7 @@ type ClockFramesResponse struct {
 func (x *ClockFramesResponse) Reset() {
 	*x = ClockFramesResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_clock_proto_msgTypes[3]
+		mi := &file_clock_proto_msgTypes[4]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -370,7 +417,7 @@ func (x *ClockFramesResponse) String() string {
 func (*ClockFramesResponse) ProtoMessage() {}
 
 func (x *ClockFramesResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_clock_proto_msgTypes[3]
+	mi := &file_clock_proto_msgTypes[4]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -383,7 +430,7 @@ func (x *ClockFramesResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use ClockFramesResponse.ProtoReflect.Descriptor instead.
 func (*ClockFramesResponse) Descriptor() ([]byte, []int) {
-	return file_clock_proto_rawDescGZIP(), []int{3}
+	return file_clock_proto_rawDescGZIP(), []int{4}
 }
 
 func (x *ClockFramesResponse) GetFilter() []byte {
@@ -473,24 +520,32 @@ var file_clock_proto_rawDesc = []byte{
 	0x62, 0x2e, 0x43, 0x6c, 0x6f, 0x63, 0x6b, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x50, 0x61, 0x72, 0x65,
 	0x6e, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x52, 0x14, 0x72, 0x61, 0x6e,
 	0x67, 0x65, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72,
-	0x73, 0x22, 0xca, 0x01, 0x0a, 0x13, 0x43, 0x6c, 0x6f, 0x63, 0x6b, 0x46, 0x72, 0x61, 0x6d, 0x65,
+	0x73, 0x22, 0x81, 0x01, 0x0a, 0x14, 0x43, 0x6c, 0x6f, 0x63, 0x6b, 0x46, 0x72, 0x61, 0x6d, 0x65,
-	0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x66, 0x69, 0x6c,
+	0x73, 0x50, 0x72, 0x65, 0x66, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x12, 0x69, 0x0a, 0x16, 0x72, 0x61,
-	0x74, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x66, 0x69, 0x6c, 0x74, 0x65,
+	0x6e, 0x67, 0x65, 0x5f, 0x70, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x65, 0x6c, 0x65, 0x63,
-	0x72, 0x12, 0x2a, 0x0a, 0x11, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x5f,
+	0x74, 0x6f, 0x72, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x71, 0x75, 0x69,
-	0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0f, 0x66, 0x72,
+	0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63, 0x6c, 0x6f,
-	0x6f, 0x6d, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x26, 0x0a,
+	0x63, 0x6b, 0x2e, 0x70, 0x62, 0x2e, 0x43, 0x6c, 0x6f, 0x63, 0x6b, 0x46, 0x72, 0x61, 0x6d, 0x65,
-	0x0f, 0x74, 0x6f, 0x5f, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72,
+	0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x73, 0x52,
-	0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x74, 0x6f, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x4e,
+	0x14, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x50, 0x61, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x65, 0x6c, 0x65,
-	0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x47, 0x0a, 0x0c, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x66,
+	0x63, 0x74, 0x6f, 0x72, 0x73, 0x22, 0xca, 0x01, 0x0a, 0x13, 0x43, 0x6c, 0x6f, 0x63, 0x6b, 0x46,
-	0x72, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x71, 0x75,
+	0x72, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, 0x0a,
-	0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63, 0x6c,
+	0x06, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x66,
-	0x6f, 0x63, 0x6b, 0x2e, 0x70, 0x62, 0x2e, 0x43, 0x6c, 0x6f, 0x63, 0x6b, 0x46, 0x72, 0x61, 0x6d,
+	0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x2a, 0x0a, 0x11, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x66, 0x72,
-	0x65, 0x52, 0x0b, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x73, 0x42, 0x3a,
+	0x61, 0x6d, 0x65, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04,
-	0x5a, 0x38, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72,
+	0x52, 0x0f, 0x66, 0x72, 0x6f, 0x6d, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x4e, 0x75, 0x6d, 0x62, 0x65,
-	0x69, 0x75, 0x6d, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69,
+	0x72, 0x12, 0x26, 0x0a, 0x0f, 0x74, 0x6f, 0x5f, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x5f, 0x6e, 0x75,
-	0x75, 0x6d, 0x2f, 0x6d, 0x6f, 0x6e, 0x6f, 0x72, 0x65, 0x70, 0x6f, 0x2f, 0x6e, 0x6f, 0x64, 0x65,
+	0x6d, 0x62, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x74, 0x6f, 0x46, 0x72,
-	0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74,
+	0x61, 0x6d, 0x65, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x47, 0x0a, 0x0c, 0x63, 0x6c, 0x6f,
-	0x6f, 0x33,
+	0x63, 0x6b, 0x5f, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x04, 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, 0x0b, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x46, 0x72, 0x61, 0x6d,
+	0x65, 0x73, 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 (
@@ -505,25 +560,27 @@ func file_clock_proto_rawDescGZIP() []byte {
 	return file_clock_proto_rawDescData
 }
 
-var file_clock_proto_msgTypes = make([]protoimpl.MessageInfo, 4)
+var file_clock_proto_msgTypes = make([]protoimpl.MessageInfo, 5)
 var file_clock_proto_goTypes = []interface{}{
 	(*ClockFrame)(nil),                // 0: quilibrium.node.clock.pb.ClockFrame
 	(*ClockFrameParentSelectors)(nil), // 1: quilibrium.node.clock.pb.ClockFrameParentSelectors
 	(*ClockFramesRequest)(nil),        // 2: quilibrium.node.clock.pb.ClockFramesRequest
-	(*ClockFramesResponse)(nil),       // 3: quilibrium.node.clock.pb.ClockFramesResponse
+	(*ClockFramesPreflight)(nil),      // 3: quilibrium.node.clock.pb.ClockFramesPreflight
-	(*InclusionAggregateProof)(nil),   // 4: quilibrium.node.channel.pb.InclusionAggregateProof
+	(*ClockFramesResponse)(nil),       // 4: quilibrium.node.clock.pb.ClockFramesResponse
-	(*Ed448Signature)(nil),            // 5: quilibrium.node.keys.pb.Ed448Signature
+	(*InclusionAggregateProof)(nil),   // 5: quilibrium.node.channel.pb.InclusionAggregateProof
+	(*Ed448Signature)(nil),            // 6: quilibrium.node.keys.pb.Ed448Signature
 }
 var file_clock_proto_depIdxs = []int32{
-	4, // 0: quilibrium.node.clock.pb.ClockFrame.aggregate_proofs:type_name -> quilibrium.node.channel.pb.InclusionAggregateProof
+	5, // 0: quilibrium.node.clock.pb.ClockFrame.aggregate_proofs:type_name -> quilibrium.node.channel.pb.InclusionAggregateProof
-	5, // 1: quilibrium.node.clock.pb.ClockFrame.public_key_signature_ed448:type_name -> quilibrium.node.keys.pb.Ed448Signature
+	6, // 1: quilibrium.node.clock.pb.ClockFrame.public_key_signature_ed448:type_name -> quilibrium.node.keys.pb.Ed448Signature
 	1, // 2: quilibrium.node.clock.pb.ClockFramesRequest.range_parent_selectors:type_name -> quilibrium.node.clock.pb.ClockFrameParentSelectors
-	0, // 3: quilibrium.node.clock.pb.ClockFramesResponse.clock_frames:type_name -> quilibrium.node.clock.pb.ClockFrame
+	1, // 3: quilibrium.node.clock.pb.ClockFramesPreflight.range_parent_selectors:type_name -> quilibrium.node.clock.pb.ClockFrameParentSelectors
-	4, // [4:4] is the sub-list for method output_type
+	0, // 4: quilibrium.node.clock.pb.ClockFramesResponse.clock_frames:type_name -> quilibrium.node.clock.pb.ClockFrame
-	4, // [4:4] is the sub-list for method input_type
+	5, // [5:5] is the sub-list for method output_type
-	4, // [4:4] is the sub-list for extension type_name
+	5, // [5:5] is the sub-list for method input_type
-	4, // [4:4] is the sub-list for extension extendee
+	5, // [5:5] is the sub-list for extension type_name
-	0, // [0:4] is the sub-list for field type_name
+	5, // [5:5] is the sub-list for extension extendee
+	0, // [0:5] is the sub-list for field type_name
 }
 
 func init() { file_clock_proto_init() }
@@ -571,6 +628,18 @@ func file_clock_proto_init() {
 			}
 		}
 		file_clock_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*ClockFramesPreflight); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_clock_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*ClockFramesResponse); i {
 			case 0:
 				return &v.state
@@ -592,7 +661,7 @@ func file_clock_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_clock_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   4,
+			NumMessages:   5,
 			NumExtensions: 0,
 			NumServices:   0,
 		},

node/protobufs/clock.proto

@@ -84,6 +84,10 @@ message ClockFramesRequest {
   repeated ClockFrameParentSelectors range_parent_selectors = 5;
 }
 
+message ClockFramesPreflight {
+  repeated ClockFrameParentSelectors range_parent_selectors = 1;
+}
+
 // Represents a response for a range of clock frames. Used to stay synchronized
 // to the latest state.
 message ClockFramesResponse {