smeb_y/ceremonyclient
1
0
Fork 0
mirror of https://source.quilibrium.com/quilibrium/ceremonyclient.git synced 2024-12-24 23:55:18 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

v1.4.13 (#146)

Browse Source 
* v1.4.13

* adjust blossomsub param
This commit is contained in:
Cassandra Heart 2024-03-27 03:50:52 -05:00 committed by GitHub
parent 0baa4ea341
commit 5a3af70dc8
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
18 changed files with 669 additions and 788 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
go-libp2p-blossomsub/blossomsub.go
View File

@ -26,7 +26,7 @@ const (
var (
BlossomSubD = 6
BlossomSubDlo = 5
BlossomSubDhi = 24
BlossomSubDhi = 10
BlossomSubDscore = 4
BlossomSubDout = 2
BlossomSubHistoryLength = 5

25
node/app/wire.go
View File

@ -27,10 +27,23 @@ func logger() *zap.Logger {
return log
}
func debugLogger() *zap.Logger {
log, err := zap.NewDevelopment()
if err != nil {
panic(err)
}
return log
}
var loggerSet = wire.NewSet(
logger,
)
var debugLoggerSet = wire.NewSet(
debugLogger,
)
var keyManagerSet = wire.NewSet(
wire.FieldsOf(new(*config.Config), "Key"),
keys.NewFileKeyManager,
@ -75,6 +88,18 @@ var consensusSet = wire.NewSet(
),
)
func NewDebugNode(*config.Config, *protobufs.SelfTestReport) (*Node, error) {
panic(wire.Build(
debugLoggerSet,
keyManagerSet,
storeSet,
pubSubSet,
engineSet,
consensusSet,
newNode,
))
}
func NewNode(*config.Config, *protobufs.SelfTestReport) (*Node, error) {
panic(wire.Build(
loggerSet,

37
node/app/wire_gen.go
View File

@ -23,6 +23,30 @@ import (
// Injectors from wire.go:
func NewDebugNode(configConfig *config.Config, selfTestReport *protobufs.SelfTestReport) (*Node, error) {
zapLogger := debugLogger()
dbConfig := configConfig.DB
pebbleDB := store.NewPebbleDB(dbConfig)
pebbleClockStore := store.NewPebbleClockStore(pebbleDB, zapLogger)
keyConfig := configConfig.Key
fileKeyManager := keys.NewFileKeyManager(keyConfig, zapLogger)
p2PConfig := configConfig.P2P
blossomSub := p2p.NewBlossomSub(p2PConfig, zapLogger)
engineConfig := configConfig.Engine
wesolowskiFrameProver := crypto.NewWesolowskiFrameProver(zapLogger)
kzgInclusionProver := crypto.NewKZGInclusionProver(zapLogger)
masterTimeReel := time.NewMasterTimeReel(zapLogger, pebbleClockStore, engineConfig, wesolowskiFrameProver)
inMemoryPeerInfoManager := p2p.NewInMemoryPeerInfoManager(zapLogger)
pebbleKeyStore := store.NewPebbleKeyStore(pebbleDB, zapLogger)
ceremonyExecutionEngine := ceremony.NewCeremonyExecutionEngine(zapLogger, engineConfig, fileKeyManager, blossomSub, wesolowskiFrameProver, kzgInclusionProver, pebbleClockStore, masterTimeReel, inMemoryPeerInfoManager, pebbleKeyStore)
masterClockConsensusEngine := master.NewMasterClockConsensusEngine(engineConfig, zapLogger, pebbleClockStore, fileKeyManager, blossomSub, wesolowskiFrameProver, masterTimeReel, inMemoryPeerInfoManager, selfTestReport)
node, err := newNode(zapLogger, pebbleClockStore, fileKeyManager, blossomSub, ceremonyExecutionEngine, masterClockConsensusEngine)
if err != nil {
return nil, err
}
return node, nil
}
func NewNode(configConfig *config.Config, selfTestReport *protobufs.SelfTestReport) (*Node, error) {
zapLogger := logger()
dbConfig := configConfig.DB
@ -74,10 +98,23 @@ func logger() *zap.Logger {
return log
}
func debugLogger() *zap.Logger {
log, err := zap.NewDevelopment()
if err != nil {
panic(err)
}
return log
}
var loggerSet = wire.NewSet(
logger,
)
var debugLoggerSet = wire.NewSet(
debugLogger,
)
var keyManagerSet = wire.NewSet(wire.FieldsOf(new(*config.Config), "Key"), keys.NewFileKeyManager, wire.Bind(new(keys.KeyManager), new(*keys.FileKeyManager)))
var storeSet = wire.NewSet(wire.FieldsOf(new(*config.Config), "DB"), store.NewPebbleDB, wire.Bind(new(store.KVDB), new(*store.PebbleDB)), store.NewPebbleClockStore, store.NewPebbleKeyStore, store.NewPebbleDataProofStore, wire.Bind(new(store.ClockStore), new(*store.PebbleClockStore)), wire.Bind(new(store.KeyStore), new(*store.PebbleKeyStore)), wire.Bind(new(store.DataProofStore), new(*store.PebbleDataProofStore)))

6
node/config/version.go
View File

@ -6,15 +6,15 @@ import (
)
func GetMinimumVersionCutoff() time.Time {
return time.Date(2024, time.March, 21, 5, 00, 0, 0, time.UTC)
return time.Date(2024, time.March, 27, 8, 30, 0, 0, time.UTC)
}
func GetMinimumVersion() []byte {
return []byte{0x01, 0x04, 0x0B}
return []byte{0x01, 0x04, 0x0D}
}
func GetVersion() []byte {
return []byte{0x01, 0x04, 0x0C}
return []byte{0x01, 0x04, 0x0D}
}
func GetVersionString() string {

24
node/consensus/ceremony/ceremony_data_clock_consensus_engine.go
View File

@ -242,7 +242,7 @@ func NewCeremonyDataClockConsensusEngine(
dataTimeReel: dataTimeReel,
peerInfoManager: peerInfoManager,
statsClient: statsClient,
messageProcessorCh: make(chan *pb.Message, 128),
messageProcessorCh: make(chan *pb.Message),
}
logger.Info("constructing consensus engine")
@ -280,9 +280,7 @@ func (e *CeremonyDataClockConsensusEngine) Start() <-chan error {
panic(err)
}
go func() {
e.runMessageHandler()
}()
go e.runMessageHandler()
e.logger.Info("subscribing to pubsub messages")
e.pubSub.Subscribe(e.filter, e.handleMessage, true)
@ -309,8 +307,6 @@ func (e *CeremonyDataClockConsensusEngine) Start() <-chan error {
thresholdBeforeConfirming := 4
for {
time.Sleep(120 * time.Second)
list := &protobufs.CeremonyPeerListAnnounce{
PeerList: []*protobufs.CeremonyPeer{},
}
@ -413,12 +409,12 @@ func (e *CeremonyDataClockConsensusEngine) Start() <-chan error {
if thresholdBeforeConfirming > 0 {
thresholdBeforeConfirming--
}
time.Sleep(120 * time.Second)
}
}()
go func() {
e.runLoop()
}()
go e.runLoop()
go func() {
errChan <- nil
@ -467,7 +463,10 @@ func (e *CeremonyDataClockConsensusEngine) runLoop() {
if e.latestFrameReceived < latestFrame.FrameNumber {
e.latestFrameReceived = latestFrame.FrameNumber
go func() {
e.frameChan <- latestFrame
select {
case e.frameChan <- latestFrame:
default:
}
}()
}
@ -512,7 +511,10 @@ func (e *CeremonyDataClockConsensusEngine) runLoop() {
if e.latestFrameReceived < latestFrame.FrameNumber {
e.latestFrameReceived = latestFrame.FrameNumber
go func() {
e.frameChan <- latestFrame
select {
case e.frameChan <- latestFrame:
default:
}
}()
}

299
node/consensus/ceremony/consensus_frames.go
View File

@ -3,8 +3,6 @@ package ceremony
import (
"bytes"
"context"
"encoding/binary"
"io"
"time"
"source.quilibrium.com/quilibrium/monorepo/node/config"
@ -161,6 +159,13 @@ func (e *CeremonyDataClockConsensusEngine) GetMostAheadPeer(
var peer []byte = nil
e.peerMapMx.RLock()
for _, v := range e.peerMap {
e.logger.Debug(
"checking peer info",
zap.Binary("peer_id", v.peerId),
zap.Uint64("max_frame_number", v.maxFrame),
zap.Int64("timestamp", v.timestamp),
zap.Binary("version", v.version),
)
_, ok := e.uncooperativePeersMap[string(v.peerId)]
if v.maxFrame > max &&
v.timestamp > config.GetMinimumVersionCutoff().UnixMilli() &&
@ -203,52 +208,16 @@ func (e *CeremonyDataClockConsensusEngine) sync(
client := protobufs.NewCeremonyServiceClient(cc)
from := latest.FrameNumber
if from == 0 {
from = 1
}
rangeParentSelectors := []*protobufs.ClockFrameParentSelectors{}
if from > 128 {
rangeSubtract := uint64(16)
for {
if from <= rangeSubtract {
break
}
parentNumber := from - uint64(rangeSubtract)
rangeSubtract *= 2
parent, _, err := e.clockStore.GetDataClockFrame(
e.filter,
parentNumber,
true,
)
if err != nil {
break
}
parentSelector, err := parent.GetSelector()
if err != nil {
panic(err)
}
rangeParentSelectors = append(
rangeParentSelectors,
&protobufs.ClockFrameParentSelectors{
FrameNumber: parentNumber,
ParentSelector: parentSelector.FillBytes(make([]byte, 32)),
},
)
}
}
s, err := client.NegotiateCompressedSyncFrames(
context.Background(),
response, err := client.GetDataFrame(
context.TODO(),
&protobufs.GetDataFrameRequest{
FrameNumber: 0,
},
grpc.MaxCallRecvMsgSize(600*1024*1024),
)
if err != nil {
e.logger.Debug(
"received error from peer",
e.logger.Error(
"could not get frame",
zap.Error(err),
)
e.peerMapMx.Lock()
@ -258,249 +227,31 @@ func (e *CeremonyDataClockConsensusEngine) sync(
delete(e.peerMap, string(peerId))
}
e.peerMapMx.Unlock()
return latest, errors.Wrap(err, "sync")
}
challenge := binary.BigEndian.AppendUint64(
append([]byte{}, peerId...),
uint64(time.Now().UnixMilli()),
)
signature, err := e.pubSub.SignMessage(challenge)
if err != nil {
panic(err)
}
err = s.Send(&protobufs.CeremonyCompressedSyncRequestMessage{
SyncMessage: &protobufs.CeremonyCompressedSyncRequestMessage_Authentication{
Authentication: &protobufs.SyncRequestAuthentication{
PeerId: e.pubSub.GetPeerID(),
Challenge: challenge,
Response: &protobufs.Ed448Signature{
Signature: signature,
PublicKey: &protobufs.Ed448PublicKey{
KeyValue: e.pubSub.GetPublicKey(),
},
},
},
},
})
if err != nil {
e.peerMapMx.Lock()
if _, ok := e.peerMap[string(peerId)]; ok {
e.uncooperativePeersMap[string(peerId)] = e.peerMap[string(peerId)]
e.uncooperativePeersMap[string(peerId)].timestamp = time.Now().UnixMilli()
delete(e.peerMap, string(peerId))
}
e.peerMapMx.Unlock()
return latest, errors.Wrap(err, "sync")
}
err = s.Send(&protobufs.CeremonyCompressedSyncRequestMessage{
SyncMessage: &protobufs.CeremonyCompressedSyncRequestMessage_Preflight{
Preflight: &protobufs.ClockFramesPreflight{
RangeParentSelectors: rangeParentSelectors,
},
},
})
if err != nil {
e.peerMapMx.Lock()
if _, ok := e.peerMap[string(peerId)]; ok {
e.uncooperativePeersMap[string(peerId)] = e.peerMap[string(peerId)]
e.uncooperativePeersMap[string(peerId)].timestamp = time.Now().UnixMilli()
delete(e.peerMap, string(peerId))
}
e.peerMapMx.Unlock()
return latest, errors.Wrap(err, "sync")
}
syncMsg, err := s.Recv()
if err != nil {
e.peerMapMx.Lock()
if _, ok := e.peerMap[string(peerId)]; ok {
e.uncooperativePeersMap[string(peerId)] = e.peerMap[string(peerId)]
e.uncooperativePeersMap[string(peerId)].timestamp = time.Now().UnixMilli()
delete(e.peerMap, string(peerId))
}
e.peerMapMx.Unlock()
return latest, errors.Wrap(err, "sync")
}
preflight, ok := syncMsg.
SyncMessage.(*protobufs.CeremonyCompressedSyncResponseMessage_Preflight)
if !ok {
e.peerMapMx.Lock()
if _, ok := e.peerMap[string(peerId)]; ok {
e.uncooperativePeersMap[string(peerId)] = e.peerMap[string(peerId)]
e.uncooperativePeersMap[string(peerId)].timestamp = time.Now().UnixMilli()
delete(e.peerMap, string(peerId))
}
e.peerMapMx.Unlock()
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.GetStagedDataClockFrame(
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
break
}
}
if found != 0 && !bytes.Equal(parentSelector, make([]byte, 32)) {
check, err := e.clockStore.GetStagedDataClockFrame(
e.filter,
found,
parentSelector,
true,
)
if err != nil {
from = 1
} else {
e.logger.Info("checking interstitial continuity")
for check.FrameNumber > 1 {
check, err = e.clockStore.GetStagedDataClockFrame(
e.filter,
check.FrameNumber-1,
check.ParentSelector,
true,
)
if err != nil {
from = 1
e.logger.Info(
"could not confirm interstitial continuity, setting search to 1",
)
break
}
}
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", response.FromFrameNumber),
zap.Uint64("to", response.ToFrameNumber),
zap.Int("frames", len(response.TruncatedClockFrames)),
zap.Int("proofs", len(response.Proofs)),
)
// This can only happen if we get a peer with state that was initially
// farther ahead, but something happened. However, this has a sticking
// 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 response.FromFrameNumber == 0 && response.ToFrameNumber == 0 {
if err := cc.Close(); err != nil {
e.logger.Error("error while closing connection", zap.Error(err))
}
return currentLatest, errors.Wrap(ErrNoNewFrames, "sync")
}
var next *protobufs.ClockFrame
if next, err = e.decompressAndStoreCandidates(
peerId,
response,
); err != nil && !errors.Is(err, ErrNoNewFrames) {
e.logger.Error(
"could not decompress and store candidate",
zap.Error(err),
)
e.peerMapMx.Lock()
if _, ok := e.peerMap[string(peerId)]; ok {
e.uncooperativePeersMap[string(peerId)] = e.peerMap[string(peerId)]
e.uncooperativePeersMap[string(peerId)].timestamp = time.Now().
UnixMilli()
delete(e.peerMap, string(peerId))
}
e.peerMapMx.Unlock()
if err := cc.Close(); err != nil {
e.logger.Error("error while closing connection", zap.Error(err))
}
return currentLatest, errors.Wrap(err, "sync")
}
if next != nil {
latest = next
}
}
if err != nil && err != io.EOF && !errors.Is(err, ErrNoNewFrames) {
e.logger.Debug("error while receiving sync", zap.Error(err))
if err := cc.Close(); err != nil {
e.logger.Error("error while closing connection", zap.Error(err))
}
e.peerMapMx.Lock()
if _, ok := e.peerMap[string(peerId)]; ok {
e.uncooperativePeersMap[string(peerId)] = e.peerMap[string(peerId)]
e.uncooperativePeersMap[string(peerId)].timestamp = time.Now().UnixMilli()
delete(e.peerMap, string(peerId))
}
e.peerMapMx.Unlock()
return latest, errors.Wrap(err, "sync")
}
if response == nil {
e.logger.Error("received no response from peer")
if err := cc.Close(); err != nil {
e.logger.Error("error while closing connection", zap.Error(err))
}
return latest, nil
}
e.logger.Info(
"received new leading frame",
zap.Uint64("frame_number", latest.FrameNumber),
zap.Uint64("frame_number", response.ClockFrame.FrameNumber),
)
if err := cc.Close(); err != nil {
e.logger.Error("error while closing connection", zap.Error(err))
}
e.dataTimeReel.Insert(latest, false)
e.dataTimeReel.Insert(response.ClockFrame, false)
return latest, nil
return response.ClockFrame, nil
}
func (e *CeremonyDataClockConsensusEngine) collect(

8
node/consensus/ceremony/message_handler.go
View File

@ -20,6 +20,7 @@ func (e *CeremonyDataClockConsensusEngine) runMessageHandler() {
for {
select {
case message := <-e.messageProcessorCh:
e.logger.Debug("handling message")
msg := &protobufs.Message{}
if err := proto.Unmarshal(message.Data, msg); err != nil {
@ -84,6 +85,7 @@ func (e *CeremonyDataClockConsensusEngine) runMessageHandler() {
any := &anypb.Any{}
if err := proto.Unmarshal(msg.Payload, any); err != nil {
e.logger.Error("error while unmarshaling", zap.Error(err))
continue
}
@ -94,6 +96,7 @@ func (e *CeremonyDataClockConsensusEngine) runMessageHandler() {
peer.version,
config.GetMinimumVersion(),
) < 0 {
e.logger.Debug("received frame from unknown or outdated peer")
return
}
if err := e.handleClockFrameData(
@ -334,7 +337,10 @@ func (e *CeremonyDataClockConsensusEngine) handleClockFrameData(
if e.latestFrameReceived < frame.FrameNumber {
e.latestFrameReceived = frame.FrameNumber
go func() {
e.frameChan <- frame
select {
case e.frameChan <- frame:
default:
}
}()
}
e.dataTimeReel.Insert(frame, isSync)

397
node/consensus/ceremony/peer_messaging.go
View File

@ -3,14 +3,9 @@ package ceremony
import (
"bytes"
"context"
"encoding/binary"
"io"
"time"
pcrypto "github.com/libp2p/go-libp2p/core/crypto"
"github.com/libp2p/go-libp2p/core/peer"
"github.com/mr-tron/base58"
"github.com/pbnjay/memory"
"github.com/pkg/errors"
"go.uber.org/zap"
"google.golang.org/grpc"
@ -24,347 +19,63 @@ 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) GetDataFrame(
ctx context.Context,
request *protobufs.GetDataFrameRequest,
) (*protobufs.DataFrameResponse, error) {
e.logger.Debug(
"received frame request",
zap.Uint64("frame_number", request.FrameNumber),
)
var frame *protobufs.ClockFrame
var err error
if request.FrameNumber == 0 {
frame, err = e.dataTimeReel.Head()
} else {
frame, _, err = e.clockStore.GetDataClockFrame(
e.filter,
request.FrameNumber,
false,
)
}
if err != nil {
e.logger.Error(
"received error while fetching time reel head",
zap.Error(err),
)
return nil, errors.Wrap(err, "get data frame")
}
idx, err := e.frameProver.GenerateWeakRecursiveProofIndex(frame)
if err != nil {
return nil, errors.Wrap(err, "get data frame")
}
indexFrame, _, err := e.clockStore.GetDataClockFrame(e.filter, idx, false)
if err != nil {
return &protobufs.DataFrameResponse{
ClockFrame: frame,
}, nil
}
proof := e.frameProver.FetchRecursiveProof(indexFrame)
e.logger.Debug(
"sending frame response",
zap.Uint64("frame_number", frame.FrameNumber),
)
return &protobufs.DataFrameResponse{
ClockFrame: frame,
Proof: proof,
}, nil
}
func (e *CeremonyDataClockConsensusEngine) NegotiateCompressedSyncFrames(
server protobufs.CeremonyService_NegotiateCompressedSyncFramesServer,
) error {
e.currentReceivingSyncPeersMx.Lock()
if e.currentReceivingSyncPeers > int(
memory.TotalMemory()/uint64(4294967296)-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
}
request, err := server.Recv()
if err == io.EOF {
return nil
}
if err != nil {
return errors.Wrap(err, "negotiate compressed sync frames")
}
authentication, ok := request.
SyncMessage.(*protobufs.CeremonyCompressedSyncRequestMessage_Authentication)
if !ok {
return nil
}
if authentication.Authentication == nil ||
authentication.Authentication.Challenge == nil ||
authentication.Authentication.PeerId == nil ||
authentication.Authentication.Response == nil ||
authentication.Authentication.Response.PublicKey == nil ||
authentication.Authentication.Response.PublicKey.KeyValue == nil ||
authentication.Authentication.Response.Signature == nil ||
len(authentication.Authentication.Challenge) < 8 {
return nil
}
if !bytes.Equal(
authentication.Authentication.Challenge[:len(
authentication.Authentication.Challenge,
)-8],
e.pubSub.GetPeerID(),
) {
e.logger.Warn(
"peer provided invalid challenge",
)
return nil
}
// probably some remark to make about chronometers here, whether one or three
challenge := int64(
binary.BigEndian.Uint64(
authentication.Authentication.Challenge[len(
authentication.Authentication.Challenge,
)-8:],
),
)
dist := time.Now().UnixMilli() - challenge
if dist < 0 {
dist *= -1
}
// account for skew
if dist > 30000 {
e.logger.Debug(
"peer provided challenge with too great of a distance",
zap.Int64("distance", dist),
)
return nil
}
key, err := pcrypto.UnmarshalEd448PublicKey(
authentication.Authentication.Response.PublicKey.KeyValue,
)
if err != nil {
e.logger.Debug(
"peer provided invalid pubkey",
zap.Binary(
"public_key",
authentication.Authentication.Response.PublicKey.KeyValue,
),
)
return errors.Wrap(err, "negotiate compressed sync frames")
}
if !(peer.ID(authentication.Authentication.PeerId)).MatchesPublicKey(key) {
e.logger.Debug(
"peer id does not match pubkey",
zap.Binary("peer_id", authentication.Authentication.PeerId),
zap.Binary(
"public_key",
authentication.Authentication.Response.PublicKey.KeyValue,
),
)
return nil
}
b, err := key.Verify(
authentication.Authentication.Challenge,
authentication.Authentication.Response.Signature,
)
if err != nil || !b {
e.logger.Debug(
"peer provided invalid signature",
zap.Binary("peer_id", authentication.Authentication.PeerId),
zap.Binary(
"public_key",
authentication.Authentication.Response.PublicKey.KeyValue,
),
zap.Binary(
"signature",
authentication.Authentication.Response.Signature,
),
)
return nil
}
manifest := e.peerInfoManager.GetPeerInfo(
authentication.Authentication.PeerId,
)
if manifest == nil || manifest.Bandwidth <= 1048576 {
e.logger.Debug(
"peer manifest was null or bandwidth was low",
zap.Binary("peer_id", authentication.Authentication.PeerId),
)
return nil
}
// TODO: should give this more tlc, but should remap into blossomsub
// heuristics
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(4)
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 > 4 {
if max > from+3 {
to = from + 4
} 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
}
}
return nil
}
// Deprecated: Use NegotiateCompressedSyncFrames.

2
node/consensus/master/master_clock_consensus_engine.go
View File

@ -123,7 +123,7 @@ func NewMasterClockConsensusEngine(
masterTimeReel: masterTimeReel,
peerInfoManager: peerInfoManager,
report: report,
frameValidationCh: make(chan *protobufs.ClockFrame, 10),
frameValidationCh: make(chan *protobufs.ClockFrame),
bandwidthTestCh: make(chan []byte),
}

75
node/consensus/time/data_time_reel.go
View File

@ -135,9 +135,9 @@ func (d *DataTimeReel) Start() error {
if err != nil {
panic(err)
}
d.totalDistance = big.NewInt(0)
d.proverTrie = trie
d.headDistance, err = d.GetDistance(frame)
d.totalDistance = d.getTotalDistance(frame)
}
go d.runLoop()
@ -287,7 +287,11 @@ func (d *DataTimeReel) runLoop() {
case frame := <-d.frames:
// Most common scenario: in order – new frame is higher number
if d.head.FrameNumber < frame.frameNumber {
d.logger.Debug("frame is higher")
d.logger.Debug(
"frame is higher",
zap.Uint64("head_frame_number", d.head.FrameNumber),
zap.Uint64("frame_number", frame.frameNumber),
)
// tag: equinox – master filter changes
_, err := d.clockStore.GetMasterClockFrame(
@ -302,17 +306,9 @@ func (d *DataTimeReel) runLoop() {
if !errors.Is(err, store.ErrNotFound) {
panic(err)
}
d.addPending(frame.selector, frame.parentSelector, frame.frameNumber)
d.processPending(d.head, frame)
continue
}
headSelector, err := d.head.GetSelector()
if err != nil {
panic(err)
}
rawFrame, err := d.clockStore.GetStagedDataClockFrame(
d.filter,
frame.frameNumber,
@ -328,25 +324,8 @@ func (d *DataTimeReel) runLoop() {
panic(err)
}
// If the frame has a gap from the head or is not descendent, mark it as
// pending:
if frame.frameNumber-d.head.FrameNumber != 1 ||
frame.parentSelector.Cmp(headSelector) != 0 {
d.logger.Debug(
"frame has has gap or is non-descendent, fork choice",
zap.Bool("has_gap", frame.frameNumber-d.head.FrameNumber != 1),
zap.String("parent_selector", frame.parentSelector.Text(16)),
zap.String("head_selector", headSelector.Text(16)),
)
d.forkChoice(rawFrame, distance)
d.processPending(d.head, frame)
continue
}
// Otherwise set it as the next and process all pending
d.setHead(rawFrame, distance)
d.processPending(d.head, frame)
} else if d.head.FrameNumber == frame.frameNumber {
// frames are equivalent, no need to act
headSelector, err := d.head.GetSelector()
@ -356,7 +335,6 @@ func (d *DataTimeReel) runLoop() {
if headSelector.Cmp(frame.selector) == 0 {
d.logger.Debug("equivalent frame")
d.processPending(d.head, frame)
continue
}
@ -383,44 +361,11 @@ func (d *DataTimeReel) runLoop() {
d.logger.Debug(
"frame shares parent, has shorter distance, short circuit",
)
d.totalDistance.Sub(d.totalDistance, d.headDistance)
d.setHead(rawFrame, distance)
d.processPending(d.head, frame)
continue
}
// Choose fork
d.forkChoice(rawFrame, distance)
d.processPending(d.head, frame)
} else {
d.logger.Debug("frame is lower height")
// tag: dusk – we should have some kind of check here to avoid brutal
// thrashing
existing, _, err := d.clockStore.GetDataClockFrame(
d.filter,
frame.frameNumber,
true,
)
if err != nil {
// if this returns an error it's either not found (which shouldn't
// happen without corruption) or pebble is borked, either way, panic
panic(err)
}
existingSelector, err := existing.GetSelector()
if err != nil {
panic(err)
}
// It's a fork, but it's behind. We need to stash it until it catches
// up (or dies off)
if existingSelector.Cmp(frame.selector) != 0 {
d.logger.Debug("is fork, add pending")
d.addPending(frame.selector, frame.parentSelector, frame.frameNumber)
d.processPending(d.head, frame)
}
}
case <-d.done:
return
@ -616,14 +561,6 @@ func (d *DataTimeReel) setHead(frame *protobufs.ClockFrame, distance *big.Int) {
}
d.head = frame
d.totalDistance.Add(d.totalDistance, distance)
d.clockStore.SetTotalDistance(
d.filter,
frame.FrameNumber,
selector.FillBytes(make([]byte, 32)),
d.totalDistance,
)
d.headDistance = distance
go func() {

11
node/crypto/frame_prover.go
View File

@ -40,4 +40,15 @@ type FrameProver interface {
VerifyDataClockFrame(
frame *protobufs.ClockFrame,
) error
GenerateWeakRecursiveProofIndex(
frame *protobufs.ClockFrame,
) (uint64, error)
FetchRecursiveProof(
frame *protobufs.ClockFrame,
) []byte
VerifyWeakRecursiveProof(
frame *protobufs.ClockFrame,
proof []byte,
deepVerifier *protobufs.ClockFrame,
) bool
}

112
node/crypto/wesolowski_frame_prover.go
View File

@ -481,3 +481,115 @@ func (w *WesolowskiFrameProver) VerifyDataClockFrame(
return nil
}
func (w *WesolowskiFrameProver) GenerateWeakRecursiveProofIndex(
frame *protobufs.ClockFrame,
) (uint64, error) {
hash, err := poseidon.HashBytes(frame.Output)
if err != nil {
return 0, errors.Wrap(err, "generate weak recursive proof")
}
return hash.Mod(
hash,
new(big.Int).SetUint64(frame.FrameNumber),
).Uint64(), nil
}
func (w *WesolowskiFrameProver) FetchRecursiveProof(
frame *protobufs.ClockFrame,
) []byte {
var pubkey []byte
ed448PublicKey := frame.GetPublicKeySignatureEd448()
if ed448PublicKey != nil {
pubkey = ed448PublicKey.PublicKey.KeyValue
} else {
return nil
}
h, err := poseidon.HashBytes(pubkey)
if err != nil {
return nil
}
address := h.Bytes()
input := []byte{}
input = append(input, frame.Filter...)
input = binary.BigEndian.AppendUint64(input, frame.FrameNumber)
input = binary.BigEndian.AppendUint64(input, uint64(frame.Timestamp))
input = binary.BigEndian.AppendUint32(input, frame.Difficulty)
input = append(input, address...)
input = append(input, frame.Input...)
input = append(input, frame.Output...)
return input
}
func (w *WesolowskiFrameProver) VerifyWeakRecursiveProof(
frame *protobufs.ClockFrame,
proof []byte,
deepVerifier *protobufs.ClockFrame,
) bool {
hash, err := poseidon.HashBytes(frame.Output)
if err != nil {
w.logger.Debug("could not hash output")
return false
}
frameNumber := hash.Mod(
hash,
new(big.Int).SetUint64(frame.FrameNumber),
).Uint64()
if len(proof) < 1084 {
w.logger.Debug("invalid proof size")
return false
}
filter := proof[:len(frame.Filter)]
check := binary.BigEndian.Uint64(proof[len(frame.Filter) : len(frame.Filter)+8])
timestamp := binary.BigEndian.Uint64(
proof[len(frame.Filter)+8 : len(frame.Filter)+16],
)
difficulty := binary.BigEndian.Uint32(
proof[len(frame.Filter)+16 : len(frame.Filter)+20],
)
input := proof[len(frame.Filter)+52:]
if check != frameNumber ||
!bytes.Equal(filter, frame.Filter) ||
int64(timestamp) >= frame.Timestamp ||
difficulty > frame.Difficulty ||
len(input) < 1032 {
w.logger.Debug(
"check failed",
zap.Bool("failed_frame_number", check != frameNumber),
zap.Bool("failed_filter", !bytes.Equal(filter, frame.Filter)),
zap.Bool("failed_timestamp", int64(timestamp) >= frame.Timestamp),
zap.Bool("failed_difficulty", difficulty > frame.Difficulty),
zap.Bool("failed_input_size", len(input) < 1032),
)
return false
}
if deepVerifier != nil && (check != deepVerifier.FrameNumber ||
!bytes.Equal(filter, deepVerifier.Filter) ||
int64(timestamp) != deepVerifier.Timestamp ||
difficulty != deepVerifier.Difficulty ||
!bytes.Equal(input[:len(input)-516], deepVerifier.Input)) {
return false
}
b := sha3.Sum256(input[:len(input)-516])
v := vdf.New(difficulty, b)
output := [516]byte{}
copy(output[:], input[len(input)-516:])
if v.Verify(output) {
w.logger.Debug("verification succeeded")
return true
} else {
w.logger.Debug("verification failed")
return false
}
}

4
node/execution/intrinsics/ceremony/ceremony_execution_engine.go
View File

@ -447,9 +447,7 @@ func (e *CeremonyExecutionEngine) Start() <-chan error {
panic(err)
}
go func() {
e.RunWorker()
}()
go e.RunWorker()
errChan <- nil
}()

12
node/main.go
View File

@ -79,6 +79,11 @@ var (
false,
"print node related information",
)
debug = flag.Bool(
"debug",
false,
"sets log output to debug (verbose)",
)
)
func main() {
@ -180,7 +185,12 @@ func main() {
report := RunSelfTestIfNeeded(*configDirectory, nodeConfig)
node, err := app.NewNode(nodeConfig, report)
var node *app.Node
if *debug {
node, err = app.NewDebugNode(nodeConfig, report)
} else {
node, err = app.NewNode(nodeConfig, report)
}
if err != nil {
panic(err)
}

308
node/protobufs/ceremony.pb.go
View File

@ -1634,6 +1634,108 @@ func (x *InclusionCommitmentsMap) GetSegmentHashes() [][]byte {
return nil
}
type GetDataFrameRequest struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
FrameNumber uint64 `protobuf:"varint,1,opt,name=frame_number,json=frameNumber,proto3" json:"frame_number,omitempty"`
}
func (x *GetDataFrameRequest) Reset() {
*x = GetDataFrameRequest{}
if protoimpl.UnsafeEnabled {
mi := &file_ceremony_proto_msgTypes[22]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *GetDataFrameRequest) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*GetDataFrameRequest) ProtoMessage() {}
func (x *GetDataFrameRequest) ProtoReflect() protoreflect.Message {
mi := &file_ceremony_proto_msgTypes[22]
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 GetDataFrameRequest.ProtoReflect.Descriptor instead.
func (*GetDataFrameRequest) Descriptor() ([]byte, []int) {
return file_ceremony_proto_rawDescGZIP(), []int{22}
}
func (x *GetDataFrameRequest) GetFrameNumber() uint64 {
if x != nil {
return x.FrameNumber
}
return 0
}
type DataFrameResponse struct {
state protoimpl.MessageState
sizeCache protoimpl.SizeCache
unknownFields protoimpl.UnknownFields
ClockFrame *ClockFrame `protobuf:"bytes,1,opt,name=clock_frame,json=clockFrame,proto3" json:"clock_frame,omitempty"`
Proof []byte `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"`
}
func (x *DataFrameResponse) Reset() {
*x = DataFrameResponse{}
if protoimpl.UnsafeEnabled {
mi := &file_ceremony_proto_msgTypes[23]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
}
func (x *DataFrameResponse) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*DataFrameResponse) ProtoMessage() {}
func (x *DataFrameResponse) ProtoReflect() protoreflect.Message {
mi := &file_ceremony_proto_msgTypes[23]
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 DataFrameResponse.ProtoReflect.Descriptor instead.
func (*DataFrameResponse) Descriptor() ([]byte, []int) {
return file_ceremony_proto_rawDescGZIP(), []int{23}
}
func (x *DataFrameResponse) GetClockFrame() *ClockFrame {
if x != nil {
return x.ClockFrame
}
return nil
}
func (x *DataFrameResponse) GetProof() []byte {
if x != nil {
return x.Proof
}
return nil
}
var File_ceremony_proto protoreflect.FileDescriptor
var file_ceremony_proto_rawDesc = []byte{
@ -2036,39 +2138,56 @@ var file_ceremony_proto_rawDesc = []byte{
0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x74, 0x79, 0x70, 0x65, 0x55, 0x72, 0x6c, 0x12, 0x25, 0x0a,
0x0e, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x18,
0x03, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0d, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x48, 0x61,
0x73, 0x68, 0x65, 0x73, 0x32, 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, 0x2e, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x70, 0x62, 0x2e, 0x43,
0x6c, 0x6f, 0x63, 0x6b, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
0x74, 0x1a, 0x33, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e,
0x6f, 0x64, 0x65, 0x2e, 0x63, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x79, 0x2e, 0x70, 0x62, 0x2e,
0x43, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x79, 0x43, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73,
0x65, 0x64, 0x53, 0x79, 0x6e, 0x63, 0x30, 0x01, 0x12, 0xaa, 0x01, 0x0a, 0x1d, 0x4e, 0x65, 0x67,
0x6f, 0x74, 0x69, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64,
0x53, 0x79, 0x6e, 0x63, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x41, 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, 0x52,
0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x42, 0x2e,
0x73, 0x68, 0x65, 0x73, 0x22, 0x38, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x46,
0x72, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x21, 0x0a, 0x0c, 0x66,
0x72, 0x61, 0x6d, 0x65, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28,
0x04, 0x52, 0x0b, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x70,
0x0a, 0x11, 0x44, 0x61, 0x74, 0x61, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f,
0x6e, 0x73, 0x65, 0x12, 0x45, 0x0a, 0x0b, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x66, 0x72, 0x61,
0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69,
0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63, 0x6c, 0x6f, 0x63, 0x6b,
0x2e, 0x70, 0x62, 0x2e, 0x43, 0x6c, 0x6f, 0x63, 0x6b, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x52, 0x0a,
0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x70, 0x72,
0x6f, 0x6f, 0x66, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x70, 0x72, 0x6f, 0x6f, 0x66,
0x32, 0xa8, 0x04, 0x0a, 0x0f, 0x43, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x79, 0x53, 0x65, 0x72,
0x76, 0x69, 0x63, 0x65, 0x12, 0x7e, 0x0a, 0x17, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x70, 0x72,
0x65, 0x73, 0x73, 0x65, 0x64, 0x53, 0x79, 0x6e, 0x63, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x73, 0x12,
0x2c, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64,
0x65, 0x2e, 0x63, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x70, 0x62, 0x2e, 0x43, 0x6c, 0x6f, 0x63, 0x6b,
0x46, 0x72, 0x61, 0x6d, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x33, 0x2e,
0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e,
0x63, 0x65, 0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x79, 0x2e, 0x70, 0x62, 0x2e, 0x43, 0x65, 0x72, 0x65,
0x6d, 0x6f, 0x6e, 0x79, 0x43, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x53, 0x79,
0x6e, 0x63, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67,
0x65, 0x28, 0x01, 0x30, 0x01, 0x12, 0x76, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6c,
0x69, 0x63, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x2e, 0x2e, 0x71, 0x75, 0x69, 0x6c,
0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63, 0x68, 0x61, 0x6e,
0x6e, 0x65, 0x6c, 0x2e, 0x70, 0x62, 0x2e, 0x50, 0x32, 0x50, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65,
0x6c, 0x45, 0x6e, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x1a, 0x2e, 0x2e, 0x71, 0x75, 0x69, 0x6c,
0x69, 0x62, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63, 0x68, 0x61, 0x6e,
0x6e, 0x65, 0x6c, 0x2e, 0x70, 0x62, 0x2e, 0x50, 0x32, 0x50, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65,
0x6c, 0x45, 0x6e, 0x76, 0x65, 0x6c, 0x6f, 0x70, 0x65, 0x28, 0x01, 0x30, 0x01, 0x42, 0x3a, 0x5a,
0x38, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69,
0x75, 0x6d, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69, 0x75,
0x6d, 0x2f, 0x6d, 0x6f, 0x6e, 0x6f, 0x72, 0x65, 0x70, 0x6f, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2f,
0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f,
0x33,
0x6e, 0x63, 0x30, 0x01, 0x12, 0xaa, 0x01, 0x0a, 0x1d, 0x4e, 0x65, 0x67, 0x6f, 0x74, 0x69, 0x61,
0x74, 0x65, 0x43, 0x6f, 0x6d, 0x70, 0x72, 0x65, 0x73, 0x73, 0x65, 0x64, 0x53, 0x79, 0x6e, 0x63,
0x46, 0x72, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x41, 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, 0x52, 0x65, 0x71, 0x75, 0x65,
0x73, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x42, 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, 0x52, 0x65,
0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x28, 0x01, 0x30,
0x01, 0x12, 0x76, 0x0a, 0x10, 0x47, 0x65, 0x74, 0x50, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x43, 0x68,
0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x2e, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69,
0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x2e,
0x70, 0x62, 0x2e, 0x50, 0x32, 0x50, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x45, 0x6e, 0x76,
0x65, 0x6c, 0x6f, 0x70, 0x65, 0x1a, 0x2e, 0x2e, 0x71, 0x75, 0x69, 0x6c, 0x69, 0x62, 0x72, 0x69,
0x75, 0x6d, 0x2e, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x2e,
0x70, 0x62, 0x2e, 0x50, 0x32, 0x50, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x45, 0x6e, 0x76,
0x65, 0x6c, 0x6f, 0x70, 0x65, 0x28, 0x01, 0x30, 0x01, 0x12, 0x70, 0x0a, 0x0c, 0x47, 0x65, 0x74,
0x44, 0x61, 0x74, 0x61, 0x46, 0x72, 0x61, 0x6d, 0x65, 0x12, 0x30, 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, 0x47, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x46,
0x72, 0x61, 0x6d, 0x65, 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, 0x63, 0x65,
0x72, 0x65, 0x6d, 0x6f, 0x6e, 0x79, 0x2e, 0x70, 0x62, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x46, 0x72,
0x61, 0x6d, 0x65, 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 (
@ -2083,7 +2202,7 @@ func file_ceremony_proto_rawDescGZIP() []byte {
return file_ceremony_proto_rawDescData
}
var file_ceremony_proto_msgTypes = make([]protoimpl.MessageInfo, 22)
var file_ceremony_proto_msgTypes = make([]protoimpl.MessageInfo, 24)
var file_ceremony_proto_goTypes = []interface{}{
(*CeremonyTranscript)(nil), // 0: quilibrium.node.ceremony.pb.CeremonyTranscript
(*CeremonyLobbyState)(nil), // 1: quilibrium.node.ceremony.pb.CeremonyLobbyState
@ -2107,80 +2226,85 @@ var file_ceremony_proto_goTypes = []interface{}{
(*InclusionProofsMap)(nil), // 19: quilibrium.node.ceremony.pb.InclusionProofsMap
(*InclusionSegmentsMap)(nil), // 20: quilibrium.node.ceremony.pb.InclusionSegmentsMap
(*InclusionCommitmentsMap)(nil), // 21: quilibrium.node.ceremony.pb.InclusionCommitmentsMap
(*BLS48581G1PublicKey)(nil), // 22: quilibrium.node.keys.pb.BLS48581G1PublicKey
(*BLS48581G2PublicKey)(nil), // 23: quilibrium.node.keys.pb.BLS48581G2PublicKey
(*Ed448PublicKey)(nil), // 24: quilibrium.node.keys.pb.Ed448PublicKey
(*Ed448Signature)(nil), // 25: quilibrium.node.keys.pb.Ed448Signature
(*BLS48581Signature)(nil), // 26: quilibrium.node.keys.pb.BLS48581Signature
(*X448PublicKey)(nil), // 27: quilibrium.node.keys.pb.X448PublicKey
(*ClockFrame)(nil), // 28: quilibrium.node.clock.pb.ClockFrame
(*ClockFramesPreflight)(nil), // 29: quilibrium.node.clock.pb.ClockFramesPreflight
(*ClockFramesRequest)(nil), // 30: quilibrium.node.clock.pb.ClockFramesRequest
(*P2PChannelEnvelope)(nil), // 31: quilibrium.node.channel.pb.P2PChannelEnvelope
(*GetDataFrameRequest)(nil), // 22: quilibrium.node.ceremony.pb.GetDataFrameRequest
(*DataFrameResponse)(nil), // 23: quilibrium.node.ceremony.pb.DataFrameResponse
(*BLS48581G1PublicKey)(nil), // 24: quilibrium.node.keys.pb.BLS48581G1PublicKey
(*BLS48581G2PublicKey)(nil), // 25: quilibrium.node.keys.pb.BLS48581G2PublicKey
(*Ed448PublicKey)(nil), // 26: quilibrium.node.keys.pb.Ed448PublicKey
(*Ed448Signature)(nil), // 27: quilibrium.node.keys.pb.Ed448Signature
(*BLS48581Signature)(nil), // 28: quilibrium.node.keys.pb.BLS48581Signature
(*X448PublicKey)(nil), // 29: quilibrium.node.keys.pb.X448PublicKey
(*ClockFrame)(nil), // 30: quilibrium.node.clock.pb.ClockFrame
(*ClockFramesPreflight)(nil), // 31: quilibrium.node.clock.pb.ClockFramesPreflight
(*ClockFramesRequest)(nil), // 32: quilibrium.node.clock.pb.ClockFramesRequest
(*P2PChannelEnvelope)(nil), // 33: quilibrium.node.channel.pb.P2PChannelEnvelope
}
var file_ceremony_proto_depIdxs = []int32{
22, // 0: quilibrium.node.ceremony.pb.CeremonyTranscript.g1_powers:type_name -> quilibrium.node.keys.pb.BLS48581G1PublicKey
23, // 1: quilibrium.node.ceremony.pb.CeremonyTranscript.g2_powers:type_name -> quilibrium.node.keys.pb.BLS48581G2PublicKey
22, // 2: quilibrium.node.ceremony.pb.CeremonyTranscript.running_g1_256_witnesses:type_name -> quilibrium.node.keys.pb.BLS48581G1PublicKey
23, // 3: quilibrium.node.ceremony.pb.CeremonyTranscript.running_g2_256_powers:type_name -> quilibrium.node.keys.pb.BLS48581G2PublicKey
24, // 0: quilibrium.node.ceremony.pb.CeremonyTranscript.g1_powers:type_name -> quilibrium.node.keys.pb.BLS48581G1PublicKey
25, // 1: quilibrium.node.ceremony.pb.CeremonyTranscript.g2_powers:type_name -> quilibrium.node.keys.pb.BLS48581G2PublicKey
24, // 2: quilibrium.node.ceremony.pb.CeremonyTranscript.running_g1_256_witnesses:type_name -> quilibrium.node.keys.pb.BLS48581G1PublicKey
25, // 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
24, // 9: quilibrium.node.ceremony.pb.CeremonySeenProverAttestation.seen_prover_key:type_name -> quilibrium.node.keys.pb.Ed448PublicKey
25, // 10: quilibrium.node.ceremony.pb.CeremonySeenProverAttestation.prover_signature:type_name -> quilibrium.node.keys.pb.Ed448Signature
24, // 11: quilibrium.node.ceremony.pb.CeremonyDroppedProverAttestation.dropped_prover_key:type_name -> quilibrium.node.keys.pb.Ed448PublicKey
25, // 12: quilibrium.node.ceremony.pb.CeremonyDroppedProverAttestation.prover_signature:type_name -> quilibrium.node.keys.pb.Ed448Signature
22, // 13: quilibrium.node.ceremony.pb.CeremonyTranscriptShare.additive_g1_powers:type_name -> quilibrium.node.keys.pb.BLS48581G1PublicKey
23, // 14: quilibrium.node.ceremony.pb.CeremonyTranscriptShare.additive_g2_powers:type_name -> quilibrium.node.keys.pb.BLS48581G2PublicKey
22, // 15: quilibrium.node.ceremony.pb.CeremonyTranscriptShare.additive_g1_256_witness:type_name -> quilibrium.node.keys.pb.BLS48581G1PublicKey
23, // 16: quilibrium.node.ceremony.pb.CeremonyTranscriptShare.additive_g2_256_witness:type_name -> quilibrium.node.keys.pb.BLS48581G2PublicKey
25, // 17: quilibrium.node.ceremony.pb.CeremonyTranscriptShare.prover_signature:type_name -> quilibrium.node.keys.pb.Ed448Signature
25, // 18: quilibrium.node.ceremony.pb.CeremonyTranscriptCommit.prover_signature:type_name -> quilibrium.node.keys.pb.Ed448Signature
26, // 19: quilibrium.node.ceremony.pb.CeremonyTranscriptCommit.contribution_signature:type_name -> quilibrium.node.keys.pb.BLS48581Signature
26, // 9: quilibrium.node.ceremony.pb.CeremonySeenProverAttestation.seen_prover_key:type_name -> quilibrium.node.keys.pb.Ed448PublicKey
27, // 10: quilibrium.node.ceremony.pb.CeremonySeenProverAttestation.prover_signature:type_name -> quilibrium.node.keys.pb.Ed448Signature
26, // 11: quilibrium.node.ceremony.pb.CeremonyDroppedProverAttestation.dropped_prover_key:type_name -> quilibrium.node.keys.pb.Ed448PublicKey
27, // 12: quilibrium.node.ceremony.pb.CeremonyDroppedProverAttestation.prover_signature:type_name -> quilibrium.node.keys.pb.Ed448Signature
24, // 13: quilibrium.node.ceremony.pb.CeremonyTranscriptShare.additive_g1_powers:type_name -> quilibrium.node.keys.pb.BLS48581G1PublicKey
25, // 14: quilibrium.node.ceremony.pb.CeremonyTranscriptShare.additive_g2_powers:type_name -> quilibrium.node.keys.pb.BLS48581G2PublicKey
24, // 15: quilibrium.node.ceremony.pb.CeremonyTranscriptShare.additive_g1_256_witness:type_name -> quilibrium.node.keys.pb.BLS48581G1PublicKey
25, // 16: quilibrium.node.ceremony.pb.CeremonyTranscriptShare.additive_g2_256_witness:type_name -> quilibrium.node.keys.pb.BLS48581G2PublicKey
27, // 17: quilibrium.node.ceremony.pb.CeremonyTranscriptShare.prover_signature:type_name -> quilibrium.node.keys.pb.Ed448Signature
27, // 18: quilibrium.node.ceremony.pb.CeremonyTranscriptCommit.prover_signature:type_name -> quilibrium.node.keys.pb.Ed448Signature
28, // 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
27, // 21: quilibrium.node.ceremony.pb.CeremonyLobbyJoin.identity_key:type_name -> quilibrium.node.keys.pb.X448PublicKey
27, // 22: quilibrium.node.ceremony.pb.CeremonyLobbyJoin.signed_pre_key:type_name -> quilibrium.node.keys.pb.X448PublicKey
25, // 23: quilibrium.node.ceremony.pb.CeremonyLobbyJoin.public_key_signature_ed448:type_name -> quilibrium.node.keys.pb.Ed448Signature
29, // 21: quilibrium.node.ceremony.pb.CeremonyLobbyJoin.identity_key:type_name -> quilibrium.node.keys.pb.X448PublicKey
29, // 22: quilibrium.node.ceremony.pb.CeremonyLobbyJoin.signed_pre_key:type_name -> quilibrium.node.keys.pb.X448PublicKey
27, // 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
24, // 25: quilibrium.node.ceremony.pb.CeremonyOpenState.preferred_participants:type_name -> quilibrium.node.keys.pb.Ed448PublicKey
26, // 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
24, // 30: quilibrium.node.ceremony.pb.CeremonyInProgressState.next_round_participants:type_name -> quilibrium.node.keys.pb.Ed448PublicKey
26, // 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
24, // 36: quilibrium.node.ceremony.pb.CeremonyFinalizingState.next_round_participants:type_name -> quilibrium.node.keys.pb.Ed448PublicKey
26, // 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
24, // 39: quilibrium.node.ceremony.pb.CeremonyValidatingState.next_round_participants:type_name -> quilibrium.node.keys.pb.Ed448PublicKey
26, // 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
28, // 41: quilibrium.node.ceremony.pb.CeremonyCompressedSync.truncated_clock_frames:type_name -> quilibrium.node.clock.pb.ClockFrame
30, // 41: quilibrium.node.ceremony.pb.CeremonyCompressedSync.truncated_clock_frames:type_name -> quilibrium.node.clock.pb.ClockFrame
19, // 42: quilibrium.node.ceremony.pb.CeremonyCompressedSync.proofs:type_name -> quilibrium.node.ceremony.pb.InclusionProofsMap
20, // 43: quilibrium.node.ceremony.pb.CeremonyCompressedSync.segments:type_name -> quilibrium.node.ceremony.pb.InclusionSegmentsMap
25, // 44: quilibrium.node.ceremony.pb.SyncRequestAuthentication.response:type_name -> quilibrium.node.keys.pb.Ed448Signature
29, // 45: quilibrium.node.ceremony.pb.CeremonyCompressedSyncRequestMessage.preflight:type_name -> quilibrium.node.clock.pb.ClockFramesPreflight
30, // 46: quilibrium.node.ceremony.pb.CeremonyCompressedSyncRequestMessage.request:type_name -> quilibrium.node.clock.pb.ClockFramesRequest
27, // 44: quilibrium.node.ceremony.pb.SyncRequestAuthentication.response:type_name -> quilibrium.node.keys.pb.Ed448Signature
31, // 45: quilibrium.node.ceremony.pb.CeremonyCompressedSyncRequestMessage.preflight:type_name -> quilibrium.node.clock.pb.ClockFramesPreflight
32, // 46: quilibrium.node.ceremony.pb.CeremonyCompressedSyncRequestMessage.request:type_name -> quilibrium.node.clock.pb.ClockFramesRequest
16, // 47: quilibrium.node.ceremony.pb.CeremonyCompressedSyncRequestMessage.authentication:type_name -> quilibrium.node.ceremony.pb.SyncRequestAuthentication
29, // 48: quilibrium.node.ceremony.pb.CeremonyCompressedSyncResponseMessage.preflight:type_name -> quilibrium.node.clock.pb.ClockFramesPreflight
31, // 48: quilibrium.node.ceremony.pb.CeremonyCompressedSyncResponseMessage.preflight:type_name -> quilibrium.node.clock.pb.ClockFramesPreflight
15, // 49: quilibrium.node.ceremony.pb.CeremonyCompressedSyncResponseMessage.response:type_name -> quilibrium.node.ceremony.pb.CeremonyCompressedSync
21, // 50: quilibrium.node.ceremony.pb.InclusionProofsMap.commitments:type_name -> quilibrium.node.ceremony.pb.InclusionCommitmentsMap
30, // 51: quilibrium.node.ceremony.pb.CeremonyService.GetCompressedSyncFrames:input_type -> quilibrium.node.clock.pb.ClockFramesRequest
17, // 52: quilibrium.node.ceremony.pb.CeremonyService.NegotiateCompressedSyncFrames:input_type -> quilibrium.node.ceremony.pb.CeremonyCompressedSyncRequestMessage
31, // 53: quilibrium.node.ceremony.pb.CeremonyService.GetPublicChannel:input_type -> quilibrium.node.channel.pb.P2PChannelEnvelope
15, // 54: quilibrium.node.ceremony.pb.CeremonyService.GetCompressedSyncFrames:output_type -> quilibrium.node.ceremony.pb.CeremonyCompressedSync
18, // 55: quilibrium.node.ceremony.pb.CeremonyService.NegotiateCompressedSyncFrames:output_type -> quilibrium.node.ceremony.pb.CeremonyCompressedSyncResponseMessage
31, // 56: quilibrium.node.ceremony.pb.CeremonyService.GetPublicChannel:output_type -> quilibrium.node.channel.pb.P2PChannelEnvelope
54, // [54:57] is the sub-list for method output_type
51, // [51:54] is the sub-list for method input_type
51, // [51:51] is the sub-list for extension type_name
51, // [51:51] is the sub-list for extension extendee
0, // [0:51] is the sub-list for field type_name
30, // 51: quilibrium.node.ceremony.pb.DataFrameResponse.clock_frame:type_name -> quilibrium.node.clock.pb.ClockFrame
32, // 52: quilibrium.node.ceremony.pb.CeremonyService.GetCompressedSyncFrames:input_type -> quilibrium.node.clock.pb.ClockFramesRequest
17, // 53: quilibrium.node.ceremony.pb.CeremonyService.NegotiateCompressedSyncFrames:input_type -> quilibrium.node.ceremony.pb.CeremonyCompressedSyncRequestMessage
33, // 54: quilibrium.node.ceremony.pb.CeremonyService.GetPublicChannel:input_type -> quilibrium.node.channel.pb.P2PChannelEnvelope
22, // 55: quilibrium.node.ceremony.pb.CeremonyService.GetDataFrame:input_type -> quilibrium.node.ceremony.pb.GetDataFrameRequest
15, // 56: quilibrium.node.ceremony.pb.CeremonyService.GetCompressedSyncFrames:output_type -> quilibrium.node.ceremony.pb.CeremonyCompressedSync
18, // 57: quilibrium.node.ceremony.pb.CeremonyService.NegotiateCompressedSyncFrames:output_type -> quilibrium.node.ceremony.pb.CeremonyCompressedSyncResponseMessage
33, // 58: quilibrium.node.ceremony.pb.CeremonyService.GetPublicChannel:output_type -> quilibrium.node.channel.pb.P2PChannelEnvelope
23, // 59: quilibrium.node.ceremony.pb.CeremonyService.GetDataFrame:output_type -> quilibrium.node.ceremony.pb.DataFrameResponse
56, // [56:60] is the sub-list for method output_type
52, // [52:56] is the sub-list for method input_type
52, // [52:52] is the sub-list for extension type_name
52, // [52:52] is the sub-list for extension extendee
0, // [0:52] is the sub-list for field type_name
}
func init() { file_ceremony_proto_init() }
@ -2456,6 +2580,30 @@ func file_ceremony_proto_init() {
return nil
}
}
file_ceremony_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*GetDataFrameRequest); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
file_ceremony_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} {
switch v := v.(*DataFrameResponse); i {
case 0:
return &v.state
case 1:
return &v.sizeCache
case 2:
return &v.unknownFields
default:
return nil
}
}
}
file_ceremony_proto_msgTypes[1].OneofWrappers = []interface{}{
(*CeremonyLobbyState_CeremonyOpenState)(nil),
@ -2478,7 +2626,7 @@ func file_ceremony_proto_init() {
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: file_ceremony_proto_rawDesc,
NumEnums: 0,
NumMessages: 22,
NumMessages: 24,
NumExtensions: 0,
NumServices: 1,
},

85
node/protobufs/ceremony.pb.gw.go
View File

@ -142,6 +142,40 @@ func request_CeremonyService_GetPublicChannel_0(ctx context.Context, marshaler r
return stream, metadata, nil
}
func request_CeremonyService_GetDataFrame_0(ctx context.Context, marshaler runtime.Marshaler, client CeremonyServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GetDataFrameRequest
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)
}
msg, err := client.GetDataFrame(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_CeremonyService_GetDataFrame_0(ctx context.Context, marshaler runtime.Marshaler, server CeremonyServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq GetDataFrameRequest
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)
}
msg, err := server.GetDataFrame(ctx, &protoReq)
return msg, metadata, err
}
// RegisterCeremonyServiceHandlerServer registers the http handlers for service CeremonyService to "mux".
// UnaryRPC :call CeremonyServiceServer directly.
// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
@ -169,6 +203,31 @@ func RegisterCeremonyServiceHandlerServer(ctx context.Context, mux *runtime.Serv
return
})
mux.Handle("POST", pattern_CeremonyService_GetDataFrame_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
var stream runtime.ServerTransportStream
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
var err error
var annotatedContext context.Context
annotatedContext, err = runtime.AnnotateIncomingContext(ctx, mux, req, "/quilibrium.node.ceremony.pb.CeremonyService/GetDataFrame", runtime.WithHTTPPathPattern("/quilibrium.node.ceremony.pb.CeremonyService/GetDataFrame"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_CeremonyService_GetDataFrame_0(annotatedContext, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
if err != nil {
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
return
}
forward_CeremonyService_GetDataFrame_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
return nil
}
@ -276,6 +335,28 @@ func RegisterCeremonyServiceHandlerClient(ctx context.Context, mux *runtime.Serv
})
mux.Handle("POST", pattern_CeremonyService_GetDataFrame_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/GetDataFrame", runtime.WithHTTPPathPattern("/quilibrium.node.ceremony.pb.CeremonyService/GetDataFrame"))
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_CeremonyService_GetDataFrame_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_GetDataFrame_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
return nil
}
@ -285,6 +366,8 @@ var (
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"}, ""))
pattern_CeremonyService_GetDataFrame_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"quilibrium.node.ceremony.pb.CeremonyService", "GetDataFrame"}, ""))
)
var (
@ -293,4 +376,6 @@ var (
forward_CeremonyService_NegotiateCompressedSyncFrames_0 = runtime.ForwardResponseStream
forward_CeremonyService_GetPublicChannel_0 = runtime.ForwardResponseStream
forward_CeremonyService_GetDataFrame_0 = runtime.ForwardResponseMessage
)

10
node/protobufs/ceremony.proto
View File

@ -189,8 +189,18 @@ message InclusionCommitmentsMap {
repeated bytes segment_hashes = 3;
}
message GetDataFrameRequest {
uint64 frame_number = 1;
}
message DataFrameResponse {
quilibrium.node.clock.pb.ClockFrame clock_frame = 1;
bytes proof = 2;
}
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);
rpc GetDataFrame (GetDataFrameRequest) returns (DataFrameResponse);
}

40
node/protobufs/ceremony_grpc.pb.go
View File

@ -22,6 +22,7 @@ const (
CeremonyService_GetCompressedSyncFrames_FullMethodName = "/quilibrium.node.ceremony.pb.CeremonyService/GetCompressedSyncFrames"
CeremonyService_NegotiateCompressedSyncFrames_FullMethodName = "/quilibrium.node.ceremony.pb.CeremonyService/NegotiateCompressedSyncFrames"
CeremonyService_GetPublicChannel_FullMethodName = "/quilibrium.node.ceremony.pb.CeremonyService/GetPublicChannel"
CeremonyService_GetDataFrame_FullMethodName = "/quilibrium.node.ceremony.pb.CeremonyService/GetDataFrame"
)
// CeremonyServiceClient is the client API for CeremonyService service.
@ -31,6 +32,7 @@ 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)
GetDataFrame(ctx context.Context, in *GetDataFrameRequest, opts ...grpc.CallOption) (*DataFrameResponse, error)
}
type ceremonyServiceClient struct {
@ -135,6 +137,15 @@ func (x *ceremonyServiceGetPublicChannelClient) Recv() (*P2PChannelEnvelope, err
return m, nil
}
func (c *ceremonyServiceClient) GetDataFrame(ctx context.Context, in *GetDataFrameRequest, opts ...grpc.CallOption) (*DataFrameResponse, error) {
out := new(DataFrameResponse)
err := c.cc.Invoke(ctx, CeremonyService_GetDataFrame_FullMethodName, in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// CeremonyServiceServer is the server API for CeremonyService service.
// All implementations must embed UnimplementedCeremonyServiceServer
// for forward compatibility
@ -142,6 +153,7 @@ type CeremonyServiceServer interface {
GetCompressedSyncFrames(*ClockFramesRequest, CeremonyService_GetCompressedSyncFramesServer) error
NegotiateCompressedSyncFrames(CeremonyService_NegotiateCompressedSyncFramesServer) error
GetPublicChannel(CeremonyService_GetPublicChannelServer) error
GetDataFrame(context.Context, *GetDataFrameRequest) (*DataFrameResponse, error)
mustEmbedUnimplementedCeremonyServiceServer()
}
@ -158,6 +170,9 @@ func (UnimplementedCeremonyServiceServer) NegotiateCompressedSyncFrames(Ceremony
func (UnimplementedCeremonyServiceServer) GetPublicChannel(CeremonyService_GetPublicChannelServer) error {
return status.Errorf(codes.Unimplemented, "method GetPublicChannel not implemented")
}
func (UnimplementedCeremonyServiceServer) GetDataFrame(context.Context, *GetDataFrameRequest) (*DataFrameResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method GetDataFrame not implemented")
}
func (UnimplementedCeremonyServiceServer) mustEmbedUnimplementedCeremonyServiceServer() {}
// UnsafeCeremonyServiceServer may be embedded to opt out of forward compatibility for this service.
@ -244,13 +259,36 @@ func (x *ceremonyServiceGetPublicChannelServer) Recv() (*P2PChannelEnvelope, err
return m, nil
}
func _CeremonyService_GetDataFrame_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(GetDataFrameRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(CeremonyServiceServer).GetDataFrame(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: CeremonyService_GetDataFrame_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(CeremonyServiceServer).GetDataFrame(ctx, req.(*GetDataFrameRequest))
}
return interceptor(ctx, in, info, handler)
}
// CeremonyService_ServiceDesc is the grpc.ServiceDesc for CeremonyService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var CeremonyService_ServiceDesc = grpc.ServiceDesc{
ServiceName: "quilibrium.node.ceremony.pb.CeremonyService",
HandlerType: (*CeremonyServiceServer)(nil),
Methods: []grpc.MethodDesc{},
Methods: []grpc.MethodDesc{
{
MethodName: "GetDataFrame",
Handler: _CeremonyService_GetDataFrame_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "GetCompressedSyncFrames",