package master import ( "bytes" "encoding/binary" "sort" "time" "github.com/pkg/errors" "go.uber.org/zap" "golang.org/x/crypto/sha3" "source.quilibrium.com/quilibrium/monorepo/go-libp2p-blossomsub/pb" "source.quilibrium.com/quilibrium/monorepo/nekryptology/pkg/vdf" "source.quilibrium.com/quilibrium/monorepo/node/consensus" "source.quilibrium.com/quilibrium/monorepo/node/p2p" "source.quilibrium.com/quilibrium/monorepo/node/protobufs" ) func (e *MasterClockConsensusEngine) prove( previousFrame *protobufs.ClockFrame, ) (*protobufs.ClockFrame, error) { if e.state == consensus.EngineStateProving { e.logger.Debug("proving new frame") frame, err := protobufs.ProveMasterClockFrame( previousFrame, e.difficulty, ) if err != nil { return nil, errors.Wrap(err, "prove") } e.state = consensus.EngineStatePublishing e.logger.Debug("returning new proven frame") return frame, nil } return nil, nil } func (e *MasterClockConsensusEngine) setFrame(frame *protobufs.ClockFrame) { previousSelectorBytes := [516]byte{} copy(previousSelectorBytes[:], frame.Output[:516]) e.logger.Debug("set frame", zap.Uint64("frame_number", frame.FrameNumber)) e.frame = frame.FrameNumber e.latestFrame = frame go func() { e.frameChan <- e.frame }() } func ( e *MasterClockConsensusEngine, ) createGenesisFrame() *protobufs.ClockFrame { e.logger.Debug("creating genesis frame") b := sha3.Sum256(e.input) v := vdf.New(e.difficulty, b) v.Execute() o := v.GetOutput() inputMessage := o[:] e.logger.Debug("proving genesis frame") input := []byte{} input = append(input, e.filter...) input = binary.BigEndian.AppendUint64(input, e.frame) input = binary.BigEndian.AppendUint32(input, e.difficulty) if bytes.Equal(e.input, []byte{0x00}) { value := [516]byte{} input = append(input, value[:]...) } else { input = append(input, e.input...) } b = sha3.Sum256(input) v = vdf.New(e.difficulty, b) v.Execute() o = v.GetOutput() frame := &protobufs.ClockFrame{ Filter: e.filter, FrameNumber: e.frame, Timestamp: 0, Difficulty: e.difficulty, Input: inputMessage, Output: o[:], ParentSelector: []byte{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }, AggregateProofs: []*protobufs.InclusionAggregateProof{}, PublicKeySignature: nil, } e.setFrame(frame) return frame } func (e *MasterClockConsensusEngine) collect( currentFramePublished *protobufs.ClockFrame, ) (*protobufs.ClockFrame, error) { if e.state == consensus.EngineStateCollecting { e.logger.Debug("collecting vdf proofs") latest := e.latestFrame if e.syncingStatus == SyncStatusNotSyncing { peer, err := e.pubSub.GetRandomPeer(e.filter) if err != nil { if errors.Is(err, p2p.ErrNoPeersAvailable) { e.logger.Warn("no peers available, skipping sync") } else { e.logger.Error("error while fetching random peer", zap.Error(err)) } } else { e.syncingStatus = SyncStatusAwaitingResponse e.logger.Debug("setting syncing target", zap.Binary("peer_id", peer)) e.syncingTarget = peer channel := e.createPeerReceiveChannel(peer) e.logger.Debug( "listening on peer receive channel", zap.Binary("channel", channel), ) e.pubSub.Subscribe(channel, e.handleSync, true) e.pubSub.Subscribe( peer, func(message *pb.Message) error { return nil }, true, ) go func() { time.Sleep(2 * time.Second) if err := e.publishMessage(peer, &protobufs.ClockFramesRequest{ Filter: e.filter, FromFrameNumber: latest.FrameNumber + 1, }); err != nil { e.logger.Error( "could not publish clock frame request", zap.Error(err), ) } }() } } waitDecay := time.Duration(2000) for e.syncingStatus != SyncStatusNotSyncing { e.logger.Debug( "waiting for sync to complete...", zap.Duration("wait_decay", waitDecay), ) time.Sleep(waitDecay * time.Millisecond) waitDecay = waitDecay * 2 if waitDecay >= (100 * (2 << 6)) { if e.syncingStatus == SyncStatusAwaitingResponse { e.logger.Debug("maximum wait for sync response, skipping sync") e.syncingStatus = SyncStatusNotSyncing break } else { waitDecay = 100 * (2 << 6) } } } e.logger.Debug("selecting leader") latestFrame, err := e.confirmLatestFrame() if err != nil { e.logger.Error("could not confirm latest frame", zap.Error(err)) return nil, errors.Wrap(err, "collect") } e.logger.Debug( "returning leader frame", zap.Uint64("frame_number", latestFrame.FrameNumber), ) e.state = consensus.EngineStateProving return latestFrame, nil } return nil, nil } func ( e *MasterClockConsensusEngine, ) confirmLatestFrame() (*protobufs.ClockFrame, error) { e.seenFramesMx.Lock() defer e.seenFramesMx.Unlock() sort.Slice(e.seenFrames, func(i, j int) bool { return e.seenFrames[i].FrameNumber < e.seenFrames[j].FrameNumber }) if len(e.seenFrames) == 0 { return e.latestFrame, nil } prev := e.latestFrame committedSet := []*protobufs.ClockFrame{} for len(e.seenFrames) > 0 { curr := e.seenFrames[0] e.seenFrames = e.seenFrames[1:] e.logger.Debug( "checking continuity for frame", zap.Uint64("frame_number", curr.FrameNumber), ) if prev.FrameNumber+1 < curr.FrameNumber || prev.FrameNumber > curr.FrameNumber { e.logger.Debug( "continuity break found", zap.Uint64("prev_frame_number", prev.FrameNumber), zap.Uint64("curr_frame_number", curr.FrameNumber), ) break } if bytes.Equal(prev.Output, curr.Input[:516]) { prev = curr committedSet = append(committedSet, prev) } else { e.logger.Debug("frame mismatch on input/output") } } txn, err := e.clockStore.NewTransaction() if err != nil { e.logger.Error("error while creating transaction", zap.Error(err)) return nil, errors.Wrap(err, "confirm latest frame") } for _, frame := range committedSet { frame := frame if err = e.clockStore.PutMasterClockFrame(frame, txn); err != nil { e.logger.Error("error while committing frame", zap.Error(err)) return nil, errors.Wrap(err, "confirm latest frame") } } if err = txn.Commit(); err != nil { e.logger.Error("error while committing transaction", zap.Error(err)) return nil, errors.Wrap(err, "confirm latest frame") } e.logger.Debug("stored frames", zap.Int("frame_count", len(committedSet))) e.historicFramesMx.Lock() e.historicFrames = append(e.historicFrames, committedSet...) if len(e.historicFrames) > 256 { e.historicFrames = e.historicFrames[len(e.historicFrames)-256:] } e.historicFramesMx.Unlock() e.setFrame(prev) return prev, nil }