Update TSC to compare tangle time with time of confirmed message.

packages/jsonmodels/info.go

@@ -40,9 +40,12 @@ type InfoResponse struct {
 
 // TangleTime contains the TangleTime sync detailed status.
 type TangleTime struct {
-	MessageID string `json:"messageID"`
-	Time      int64  `json:"time"`
-	Synced    bool   `json:"synced"`
+	AcceptedMessageID string `json:"messageID"`
+	ATT               int64  `json:"ATT"`
+	RATT              int64  `json:"RATT"`
+	CTT               int64  `json:"CTT"`
+	RCTT              int64  `json:"RCTT"`
+	Synced            bool   `json:"synced"`
 }
 
 // Mana contains the different mana values of the node.

packages/remotemetrics/events.go

@@ -13,7 +13,7 @@ type CollectionLogEvents struct {
 	SchedulerQuery        *event.Event[*SchedulerQueryEvent]
 }
 
-func newCollectionLogEvents() (newEvents *CollectionLogEvents) {
+func newCollectionLogEvents() *CollectionLogEvents {
 	return &CollectionLogEvents{
 		TangleTimeSyncChanged: event.New[*TangleTimeSyncChangedEvent](),
 		SchedulerQuery:        event.New[*SchedulerQueryEvent](),
@@ -34,8 +34,14 @@ type TangleTimeSyncChangedEvent struct {
 	CurrentStatus bool `json:"currentStatus" bson:"currentStatus"`
 	// PreviousStatus contains previous sync status
 	PreviousStatus bool `json:"previousStatus" bson:"previousStatus"`
-	// LastConfirmedMessageTime contains time of the last confirmed message
-	LastConfirmedMessageTime time.Time `json:"lastConfirmedMessageTime" bson:"lastConfirmedMessageTime"`
+	// ATT contains time of the last accepted message
+	ATT time.Time `json:"acceptanceTangleTime" bson:"acceptanceTangleTime"`
+	// RATT contains relative time of the last accepted message
+	RATT time.Time `json:"relativeAcceptanceTangleTime" bson:"relativeAcceptanceTangleTime"`
+	// CTT contains time of the last confirmed message
+	CTT time.Time `json:"confirmedTangleTime" bson:"confirmedTangleTime"`
+	// RCTT contains relative time of the last confirmed message
+	RCTT time.Time `json:"relativeConfirmedTangleTime" bson:"relativeConfirmedTangleTime"`
 }
 
 // SchedulerQueryEvent is used to trigger scheduler metric collection for remote metric monitoring.

packages/spammer/spammer.go

@@ -96,7 +96,7 @@ func (s *Spammer) run(rate int, timeUnit time.Duration, imif string) {
 				defer s.goroutinesCount.Add(-1)
 				// we don't care about errors or the actual issued message
 				_, err := s.issuePayloadFunc(payload.NewGenericDataPayload([]byte("SPAM")))
-				if errors.Is(err, tangle.ErrNotSynced) {
+				if errors.Is(err, tangle.ErrNotBootstrapped) {
 					s.log.Info("Stopped spamming messages because node lost sync")
 					s.signalShutdown()
 					return

packages/tangle/cmanaweightprovider.go

@@ -24,7 +24,7 @@ func init() {
 }
 
 const (
-	activeTimeThreshold  = 30 * time.Minute
+	activeTimeThreshold  = 5 * time.Minute
 	minimumManaThreshold = 0
 	activeNodesKey       = "WeightProviderActiveNodes"
 )

packages/tangle/cmanaweightprovider_test.go

@@ -66,16 +66,16 @@ func TestCManaWeightProvider(t *testing.T) {
 
 	// Add node2 and node3 activity at tangleTime+20 -> only node1 is active.
 	{
-		weightProvider.Update(tangleTime.Add(20*time.Minute), nodes["2"])
-		weightProvider.Update(tangleTime.Add(20*time.Minute), nodes["3"])
+		weightProvider.Update(tangleTime.Add(3*time.Minute), nodes["2"])
+		weightProvider.Update(tangleTime.Add(3*time.Minute), nodes["3"])
 		assertWeightsOfRelevantVoters(t, weightProvider, nodes, map[string]float64{
 			"1": 20,
 		})
 	}
 
-	// Advance TangleTime by 25min -> all nodes are active.
+	// Advance TangleTime by 4min -> all nodes are active.
 	{
-		tangleTime = tangleTime.Add(25 * time.Minute)
+		tangleTime = tangleTime.Add(4 * time.Minute)
 		assertWeightsOfRelevantVoters(t, weightProvider, nodes, map[string]float64{
 			"1": 20,
 			"2": 50,
@@ -85,7 +85,7 @@ func TestCManaWeightProvider(t *testing.T) {
 
 	// Advance TangleTime by 10min -> node1 and node2 are active.
 	{
-		tangleTime = tangleTime.Add(25 * time.Minute)
+		tangleTime = tangleTime.Add(2 * time.Minute)
 		assertWeightsOfRelevantVoters(t, weightProvider, nodes, map[string]float64{
 			"2": 50,
 			"3": 30,
@@ -94,7 +94,7 @@ func TestCManaWeightProvider(t *testing.T) {
 
 	// Advance tangleTime by 25min -> no node is active anymore.
 	{
-		tangleTime = tangleTime.Add(25 * time.Minute)
+		tangleTime = tangleTime.Add(4 * time.Minute)
 		assertWeightsOfRelevantVoters(t, weightProvider, nodes, map[string]float64{})
 	}
 }

packages/tangle/errors.go

@@ -3,8 +3,8 @@ package tangle
 import "github.com/cockroachdb/errors"
 
 var (
-	// ErrNotSynced is triggered when somebody tries to issue a Payload before the Tangle is fully synced.
-	ErrNotSynced = errors.New("tangle not synced")
+	// ErrNotBootstrapped is triggered when somebody tries to issue a Payload before the Tangle is fully bootstrapped.
+	ErrNotBootstrapped = errors.New("tangle not bootstrapped")
 	// ErrParentsInvalid is returned when one or more parents of a message is invalid.
 	ErrParentsInvalid = errors.New("one or more parents is invalid")
 )

packages/tangle/events.go

@@ -1,6 +1,8 @@
 package tangle
 
 import (
+	"time"
+
 	"github.com/iotaledger/hive.go/autopeering/peer"
 	"github.com/iotaledger/hive.go/generics/event"
 	"github.com/iotaledger/hive.go/identity"
@@ -382,12 +384,16 @@ type RequestFailedEvent struct {
 // TimeManagerEvents represents events happening in the TimeManager.
 type TimeManagerEvents struct {
 	// Fired when the nodes sync status changes.
-	SyncChanged *event.Event[*SyncChangedEvent]
+	SyncChanged           *event.Event[*SyncChangedEvent]
+	AcceptanceTimeUpdated *event.Event[*TimeUpdate]
+	ConfirmedTimeUpdated  *event.Event[*TimeUpdate]
 }
 
 func newTimeManagerEvents() (new *TimeManagerEvents) {
 	return &TimeManagerEvents{
-		SyncChanged: event.New[*SyncChangedEvent](),
+		SyncChanged:           event.New[*SyncChangedEvent](),
+		AcceptanceTimeUpdated: event.New[*TimeUpdate](),
+		ConfirmedTimeUpdated:  event.New[*TimeUpdate](),
 	}
 }
 
@@ -396,6 +402,11 @@ type SyncChangedEvent struct {
 	Synced bool
 }
 
+// TimeUpdate represents an update in Tangle Time.
+type TimeUpdate struct {
+	NewTime time.Time
+}
+
 // endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 // region TipManagerEvents /////////////////////////////////////////////////////////////////////////////////////////////

packages/tangle/tangle.go

@@ -149,17 +149,21 @@ func (t *Tangle) ProcessGossipMessage(messageBytes []byte, peer *peer.Peer) {
 
 // IssuePayload allows to attach a payload (i.e. a Transaction) to the Tangle.
 func (t *Tangle) IssuePayload(p payload.Payload, parentsCount ...int) (message *Message, err error) {
-	if !t.Synced() {
-		err = errors.Errorf("can't issue payload: %w", ErrNotSynced)
+	if !t.Bootstrapped() {
+		err = errors.Errorf("can't issue payload: %w", ErrNotBootstrapped)
 		return
 	}
-
 	return t.MessageFactory.IssuePayload(p, parentsCount...)
 }
 
-// Synced returns a boolean value that indicates if the node is fully synced and the Tangle has solidified all messages
+// Bootstrapped returns a boolean value that indicates if the node has bootstrapped and the Tangle has solidified all messages
 // until the genesis.
-func (t *Tangle) Synced() (synced bool) {
+func (t *Tangle) Bootstrapped() bool {
+	return t.TimeManager.Bootstrapped()
+}
+
+// Synced returns a boolean value that indicates if the node is in sync at this moment.
+func (t *Tangle) Synced() bool {
 	return t.TimeManager.Synced()
 }