v2.0.6-p2

node/config/version.go

@@ -6,7 +6,7 @@ import (
 )
 
 func GetMinimumVersionCutoff() time.Time {
-	return time.Date(2024, time.November, 24, 0, 0, 0, 0, time.UTC)
+	return time.Date(2025, time.January, 13, 0, 0, 0, 0, time.UTC)
 }
 
 // Gets the minimum patch version – This should only be set in a release series
@@ -17,7 +17,7 @@ func GetMinimumPatchVersion() byte {
 }
 
 func GetMinimumVersion() []byte {
-	return []byte{0x02, 0x00, 0x05}
+	return []byte{0x02, 0x00, 0x06}
 }
 
 func GetVersion() []byte {
@@ -43,7 +43,7 @@ func FormatVersion(version []byte) string {
 }
 
 func GetPatchNumber() byte {
-	return 0x01
+	return 0x02
 }
 
 func GetRCNumber() byte {

node/consensus/data/consensus_frames.go

@@ -10,9 +10,12 @@ import (
 	"source.quilibrium.com/quilibrium/monorepo/node/config"
 	"source.quilibrium.com/quilibrium/monorepo/node/consensus/data/internal"
 	"source.quilibrium.com/quilibrium/monorepo/node/internal/frametime"
+	"source.quilibrium.com/quilibrium/monorepo/node/tries"
 
+	"github.com/iden3/go-iden3-crypto/poseidon"
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/pkg/errors"
+	mt "github.com/txaty/go-merkletree"
 	"go.uber.org/zap"
 	"google.golang.org/grpc"
 	"google.golang.org/protobuf/proto"
@@ -428,3 +431,146 @@ func (e *DataClockConsensusEngine) syncWithPeer(
 		}
 	}
 }
+
+func (e *DataClockConsensusEngine) initiateProvers(
+	latestFrame *protobufs.ClockFrame,
+) {
+	if latestFrame.Timestamp > time.Now().UnixMilli()-60000 {
+		if !e.IsInProverTrie(e.pubSub.GetPeerID()) {
+			e.logger.Info("announcing prover join")
+			for _, eng := range e.executionEngines {
+				eng.AnnounceProverJoin()
+				break
+			}
+		} else {
+			if e.previousFrameProven != nil &&
+				e.previousFrameProven.FrameNumber == latestFrame.FrameNumber {
+				return
+			}
+
+			h, err := poseidon.HashBytes(e.pubSub.GetPeerID())
+			if err != nil {
+				panic(err)
+			}
+			peerProvingKeyAddress := h.FillBytes(make([]byte, 32))
+
+			ring := -1
+			if tries := e.GetFrameProverTries(); len(tries) > 1 {
+				for i, tries := range tries[1:] {
+					i := i
+					if tries.Contains(peerProvingKeyAddress) {
+						ring = i
+					}
+				}
+			}
+
+			e.clientReconnectTest++
+			if e.clientReconnectTest >= 10 {
+				e.tryReconnectDataWorkerClients()
+				e.clientReconnectTest = 0
+			}
+
+			previousTreeRoot := []byte{}
+			if e.previousTree != nil {
+				previousTreeRoot = e.previousTree.Root
+			}
+			outputs := e.PerformTimeProof(latestFrame, previousTreeRoot, latestFrame.Difficulty, ring)
+			if outputs == nil || len(outputs) < 3 {
+				e.logger.Info("workers not yet available for proving")
+				return
+			}
+			modulo := len(outputs)
+			var proofTree *mt.MerkleTree
+			var output [][]byte
+			if latestFrame.FrameNumber >= application.PROOF_FRAME_COMBINE_CUTOFF {
+				proofTree, output, err = tries.PackOutputIntoMultiPayloadAndProof(
+					outputs,
+					modulo,
+					latestFrame,
+					e.previousTree,
+				)
+			} else {
+				proofTree, output, err = tries.PackOutputIntoPayloadAndProof(
+					outputs,
+					modulo,
+					latestFrame,
+					e.previousTree,
+				)
+			}
+			if err != nil {
+				e.logger.Error(
+					"could not successfully pack proof, reattempting",
+					zap.Error(err),
+				)
+				return
+			}
+			e.previousFrameProven = latestFrame
+			e.previousTree = proofTree
+
+			mint := &protobufs.MintCoinRequest{
+				Proofs: output,
+			}
+			if err := mint.SignED448(e.pubSub.GetPublicKey(), e.pubSub.SignMessage); err != nil {
+				e.logger.Error("could not sign mint", zap.Error(err))
+				return
+			}
+			if err := mint.Validate(); err != nil {
+				e.logger.Error("mint validation failed", zap.Error(err))
+				return
+			}
+
+			e.logger.Info(
+				"submitting data proof",
+				zap.Int("ring", ring),
+				zap.Int("active_workers", len(outputs)),
+				zap.Uint64("frame_number", latestFrame.FrameNumber),
+				zap.Duration("frame_age", frametime.Since(latestFrame)),
+			)
+
+			if err := e.publishMessage(e.txFilter, mint.TokenRequest()); err != nil {
+				e.logger.Error("could not publish mint", zap.Error(err))
+			}
+
+			if e.config.Engine.AutoMergeCoins {
+				_, addrs, _, err := e.coinStore.GetCoinsForOwner(
+					peerProvingKeyAddress,
+				)
+				if err != nil {
+					e.logger.Error(
+						"received error while iterating coins",
+						zap.Error(err),
+					)
+					return
+				}
+
+				if len(addrs) > 25 {
+					refs := []*protobufs.CoinRef{}
+					for _, addr := range addrs {
+						refs = append(refs, &protobufs.CoinRef{
+							Address: addr,
+						})
+					}
+
+					merge := &protobufs.MergeCoinRequest{
+						Coins: refs,
+					}
+					if err := merge.SignED448(
+						e.pubSub.GetPublicKey(),
+						e.pubSub.SignMessage,
+					); err != nil {
+						e.logger.Error("could not sign merge", zap.Error(err))
+						return
+					}
+					if err := merge.Validate(); err != nil {
+						e.logger.Error("merge validation failed", zap.Error(err))
+						return
+					}
+
+					if err := e.publishMessage(e.txFilter, merge.TokenRequest()); err != nil {
+						e.logger.Warn("could not publish merge", zap.Error(err))
+					}
+				}
+			}
+		}
+	}
+}

node/consensus/data/main_data_loop.go

@@ -4,8 +4,6 @@ import (
 	"bytes"
 	"time"
 
-	"github.com/iden3/go-iden3-crypto/poseidon"
-	mt "github.com/txaty/go-merkletree"
 	"go.uber.org/zap"
 	"source.quilibrium.com/quilibrium/monorepo/node/consensus"
 	"source.quilibrium.com/quilibrium/monorepo/node/execution/intrinsics/token/application"
@@ -282,144 +280,6 @@ func (e *DataClockConsensusEngine) processFrame(
 
 		return nextFrame
 	} else {
-		if latestFrame.Timestamp > time.Now().UnixMilli()-120000 {
-			if !e.IsInProverTrie(e.pubSub.GetPeerID()) {
-				e.logger.Info("announcing prover join")
-				for _, eng := range e.executionEngines {
-					eng.AnnounceProverJoin()
-					break
-				}
-			} else {
-				if e.previousFrameProven != nil &&
-					e.previousFrameProven.FrameNumber == latestFrame.FrameNumber {
-					return latestFrame
-				}
-
-				h, err := poseidon.HashBytes(e.pubSub.GetPeerID())
-				if err != nil {
-					panic(err)
-				}
-				peerProvingKeyAddress := h.FillBytes(make([]byte, 32))
-
-				ring := -1
-				if tries := e.GetFrameProverTries(); len(tries) > 1 {
-					for i, tries := range tries[1:] {
-						i := i
-						if tries.Contains(peerProvingKeyAddress) {
-							ring = i
-						}
-					}
-				}
-
-				e.clientReconnectTest++
-				if e.clientReconnectTest >= 10 {
-					e.tryReconnectDataWorkerClients()
-					e.clientReconnectTest = 0
-				}
-
-				previousTreeRoot := []byte{}
-				if e.previousTree != nil {
-					previousTreeRoot = e.previousTree.Root
-				}
-				outputs := e.PerformTimeProof(latestFrame, previousTreeRoot, latestFrame.Difficulty, ring)
-				if outputs == nil || len(outputs) < 3 {
-					e.logger.Info("workers not yet available for proving")
-					return latestFrame
-				}
-				modulo := len(outputs)
-				var proofTree *mt.MerkleTree
-				var output [][]byte
-				if latestFrame.FrameNumber >= application.PROOF_FRAME_COMBINE_CUTOFF {
-					proofTree, output, err = tries.PackOutputIntoMultiPayloadAndProof(
-						outputs,
-						modulo,
-						latestFrame,
-						e.previousTree,
-					)
-				} else {
-					proofTree, output, err = tries.PackOutputIntoPayloadAndProof(
-						outputs,
-						modulo,
-						latestFrame,
-						e.previousTree,
-					)
-				}
-				if err != nil {
-					e.logger.Error(
-						"could not successfully pack proof, reattempting",
-						zap.Error(err),
-					)
-					return latestFrame
-				}
-				e.previousFrameProven = latestFrame
-				e.previousTree = proofTree
-
-				mint := &protobufs.MintCoinRequest{
-					Proofs: output,
-				}
-				if err := mint.SignED448(e.pubSub.GetPublicKey(), e.pubSub.SignMessage); err != nil {
-					e.logger.Error("could not sign mint", zap.Error(err))
-					return latestFrame
-				}
-				if err := mint.Validate(); err != nil {
-					e.logger.Error("mint validation failed", zap.Error(err))
-					return latestFrame
-				}
-
-				e.logger.Info(
-					"submitting data proof",
-					zap.Int("ring", ring),
-					zap.Int("active_workers", len(outputs)),
-					zap.Uint64("frame_number", latestFrame.FrameNumber),
-					zap.Duration("frame_age", frametime.Since(latestFrame)),
-				)
-
-				if err := e.publishMessage(e.txFilter, mint.TokenRequest()); err != nil {
-					e.logger.Error("could not publish mint", zap.Error(err))
-				}
-
-				if e.config.Engine.AutoMergeCoins {
-					_, addrs, _, err := e.coinStore.GetCoinsForOwner(
-						peerProvingKeyAddress,
-					)
-					if err != nil {
-						e.logger.Error(
-							"received error while iterating coins",
-							zap.Error(err),
-						)
-						return latestFrame
-					}
-
-					if len(addrs) > 25 {
-						refs := []*protobufs.CoinRef{}
-						for _, addr := range addrs {
-							refs = append(refs, &protobufs.CoinRef{
-								Address: addr,
-							})
-						}
-
-						merge := &protobufs.MergeCoinRequest{
-							Coins: refs,
-						}
-						if err := merge.SignED448(
-							e.pubSub.GetPublicKey(),
-							e.pubSub.SignMessage,
-						); err != nil {
-							e.logger.Error("could not sign merge", zap.Error(err))
-							return latestFrame
-						}
-						if err := merge.Validate(); err != nil {
-							e.logger.Error("merge validation failed", zap.Error(err))
-							return latestFrame
-						}
-
-						if err := e.publishMessage(e.txFilter, merge.TokenRequest()); err != nil {
-							e.logger.Warn("could not publish merge", zap.Error(err))
-						}
-					}
-				}
-			}
-		}
 		return latestFrame
 	}
 }

node/consensus/data/message_handler.go

@@ -253,6 +253,8 @@ func (e *DataClockConsensusEngine) handleClockFrame(
 	}
 
 	if frame.FrameNumber > head.FrameNumber {
+		go e.initiateProvers(frame)
+
 		if _, err := e.dataTimeReel.Insert(e.ctx, frame); err != nil {
 			e.logger.Debug("could not insert frame", zap.Error(err))
 		}