[Merged by Bors] - hare3 implementation

cmd/base.go

@@ -132,6 +132,10 @@ func EnsureCLIFlags(cmd *cobra.Command, appCFG *config.Config) error {
 			elem = reflect.ValueOf(&appCFG.HareEligibility).Elem()
 			assignFields(ff, elem, name)
 
+			ff = reflect.TypeOf(appCFG.HARE3)
+			elem = reflect.ValueOf(&appCFG.HARE3).Elem()
+			assignFields(ff, elem, name)
+
 			ff = reflect.TypeOf(appCFG.Beacon)
 			elem = reflect.ValueOf(&appCFG.Beacon).Elem()
 			assignFields(ff, elem, name)

codec/codec.go

@@ -49,6 +49,13 @@
 	encoderPool.Put(b)
 }
 
+func MustEncodeTo(w io.Writer, value Encodable) {
+	_, err := EncodeTo(w, value)
+	if err != nil {
+		panic(err)
+	}
+}
+
 func MustEncode(value Encodable) []byte {
 	buf, err := Encode(value)
 	if err != nil {

common/types/hashes.go

@@ -51,7 +51,7 @@ func (h Hash20) String() string {
 // ShortString returns a the first 5 characters of the hash, for logging purposes.
 func (h Hash20) ShortString() string {
 	l := len(h.Hex())
-	return h.Hex()[util.Min(2, l):util.Min(7, l)]
+	return Shorten(h.Hex()[util.Min(2, l):], 10)
 }
 
 // Format implements fmt.Formatter, forcing the byte slice to be formatted as is,

common/types/malfeasance.go

@@ -182,6 +182,16 @@
 	return nil
 }
 
+func (hp *HareProof) ToMalfeasenceProof() *MalfeasanceProof {
+	return &MalfeasanceProof{
+		Layer: hp.Messages[0].InnerMsg.Layer,
+		Proof: Proof{
+			Type: HareEquivocation,
+			Data: hp,
+		},
+	}
+}
+
 type AtxProofMsg struct {
 	InnerMsg ATXMetadata
 
@@ -235,6 +245,14 @@
 	return hm.Layer == other.Layer && hm.Round == other.Round && hm.MsgHash != other.MsgHash
 }
 
+func (hm HareMetadata) ToBytes() []byte {
+	buf, err := codec.Encode(&hm)
+	if err != nil {
+		panic(err.Error())
+	}
+	return buf
+}
+
 type HareProofMsg struct {
 	InnerMsg HareMetadata
 
@@ -244,11 +262,7 @@
 
 // SignedBytes returns the actual data being signed in a HareProofMsg.
 func (m *HareProofMsg) SignedBytes() []byte {
-	data, err := codec.Encode(&m.InnerMsg)
-	if err != nil {
-		log.With().Fatal("failed to serialize MultiBlockProposalsMsg", log.Err(err))
-	}
-	return data
+	return m.InnerMsg.ToBytes()
 }
 
 func MalfeasanceInfo(smesher NodeID, mp *MalfeasanceProof) string {

config/config.go

@@ -20,6 +20,7 @@ import (
 	vm "github.com/spacemeshos/go-spacemesh/genvm"
 	hareConfig "github.com/spacemeshos/go-spacemesh/hare/config"
 	eligConfig "github.com/spacemeshos/go-spacemesh/hare/eligibility/config"
+	"github.com/spacemeshos/go-spacemesh/hare3"
 	"github.com/spacemeshos/go-spacemesh/p2p"
 	"github.com/spacemeshos/go-spacemesh/syncer"
 	timeConfig "github.com/spacemeshos/go-spacemesh/timesync/config"
@@ -50,6 +51,7 @@ type Config struct {
 	P2P             p2p.Config            `mapstructure:"p2p"`
 	API             grpcserver.Config     `mapstructure:"api"`
 	HARE            hareConfig.Config     `mapstructure:"hare"`
+	HARE3           hare3.Config          `mapstructure:"hare3"`
 	HareEligibility eligConfig.Config     `mapstructure:"hare-eligibility"`
 	Beacon          beacon.Config         `mapstructure:"beacon"`
 	TIME            timeConfig.TimeConfig `mapstructure:"time"`
@@ -140,6 +142,7 @@ func DefaultConfig() Config {
 		P2P:             p2p.DefaultConfig(),
 		API:             grpcserver.DefaultConfig(),
 		HARE:            hareConfig.DefaultConfig(),
+		HARE3:           hare3.DefaultConfig(),
 		HareEligibility: eligConfig.DefaultConfig(),
 		Beacon:          beacon.DefaultConfig(),
 		TIME:            timeConfig.DefaultConfig(),

config/presets/fastnet.go

@@ -24,13 +24,21 @@ func fastnet() config.Config {
 
 	conf.BaseConfig.TestConfig.MinerGoodAtxPct = 50
 
+	conf.HARE.Disable = 1 // non-zero low layer will prevent hare1 from running
 	conf.HARE.N = 800
 	conf.HARE.ExpectedLeaders = 10
 	conf.HARE.LimitConcurrent = 5
 	conf.HARE.LimitIterations = 3
 	conf.HARE.RoundDuration = 2 * time.Second
 	conf.HARE.WakeupDelta = 3 * time.Second
 
+	conf.HARE3.Enable = true
+	conf.HARE3.Committee = 800
+	conf.HARE3.Leaders = 10
+	conf.HARE3.PreroundDelay = 3 * time.Second
+	conf.HARE3.RoundDuration = 500 * time.Millisecond
+	conf.HARE3.IterationsLimit = 2
+
 	conf.P2P.MinPeers = 10
 
 	conf.Genesis = &config.GenesisConfig{

hare/config/config.go

@@ -1,6 +1,10 @@
 package config
 
-import "time"
+import (
+	"time"
+
+	"github.com/spacemeshos/go-spacemesh/common/types"
+)
 
 // Config is the configuration of the Hare.
 type Config struct {
@@ -13,6 +17,9 @@ type Config struct {
 	StopAtxGrading  uint32        `mapstructure:"stop-atx-grading"`
 
 	Hdist uint32
+
+	// If set to non-zero value will disable hare starting at that layer.
+	Disable types.LayerID `mapstructure:"disable"`
 }
 
 // DefaultConfig returns the default configuration for the hare.

hare/hare.go

@@ -321,6 +321,10 @@
 		h.With().Debug("hare exiting", log.Context(ctx), lid)
 		return false, nil
 	}
+	if h.config.Disable != 0 && lid >= h.config.Disable {
+		h.With().Debug("hare is disabled at this layer", log.Context(ctx), lid)
+		return false, nil
+	}
 
 	h.setLastLayer(lid)
 

hare3/compat/result.go

@@ -0,0 +1,29 @@
+package compat
+
+import (
+	"context"
+
+	"go.uber.org/zap"
+
+	"github.com/spacemeshos/go-spacemesh/hare"
+	"github.com/spacemeshos/go-spacemesh/hare3"
+)
+
+func ReportResult(ctx context.Context, logger *zap.Logger, from <-chan hare3.ConsensusOutput, to chan<- hare.LayerOutput) {
+	for {
+		select {
+		case <-ctx.Done():
+			logger.Info("hare3 results reporter exited")
+			return
+		case out := <-from:
+			select {
+			case to <- hare.LayerOutput{
+				Ctx:       ctx,
+				Layer:     out.Layer,
+				Proposals: out.Proposals,
+			}:
+			case <-ctx.Done():
+			}
+		}
+	}
+}

hare3/compat/weakcoin.go

@@ -0,0 +1,31 @@
+package compat
+
+import (
+	"context"
+
+	"go.uber.org/zap"
+
+	"github.com/spacemeshos/go-spacemesh/common/types"
+	"github.com/spacemeshos/go-spacemesh/hare3"
+)
+
+type weakCoin interface {
+	Set(types.LayerID, bool) error
+}
+
+func ReportWeakcoin(ctx context.Context, logger *zap.Logger, from <-chan hare3.WeakCoinOutput, to weakCoin) {
+	for {
+		select {
+		case <-ctx.Done():
+			logger.Info("weak coin reporter exited")
+			return
+		case out := <-from:
+			if err := to.Set(out.Layer, out.Coin); err != nil {
+				logger.Error("failed to update weakcoin",
+					zap.Uint32("lid", out.Layer.Uint32()),
+					zap.Error(err),
+				)
+			}
+		}
+	}
+}