Epoch commitment metrics

packages/jsonmodels/epochs.go

@@ -0,0 +1,48 @@
+package jsonmodels
+
+import (
+	"github.com/iotaledger/goshimmer/packages/epoch"
+)
+
+type EpochInfo struct {
+	EI     uint64 `json:"EI"`
+	ECR    string `json:"ECR"`
+	PrevEC string `json:"prevEC"`
+}
+
+func EpochInfoFromRecord(record *epoch.ECRecord) *EpochInfo {
+	return &EpochInfo{
+		EI:     uint64(record.EI()),
+		ECR:    record.ECR().Base58(),
+		PrevEC: record.PrevEC().Base58(),
+	}
+}
+
+type EpochsResponse struct {
+	Epochs []*EpochInfo `json:"epochs"`
+}
+
+type EpochVotersWeightResponse struct {
+	VotersWeight map[string]*NodeWeight `json:"ecrVoters"`
+}
+
+type NodeWeight struct {
+	Weights map[string]float64 `json:"weights"`
+}
+
+type EpochUTXOsResponse struct {
+	SpentOutputs   []string `json:"spentOutputs"`
+	CreatedOutputs []string `json:"createdOutputs"`
+}
+
+type EpochMessagesResponse struct {
+	Messages []string `json:"messages"`
+}
+
+type EpochTransactionsResponse struct {
+	Transactions []string `json:"transactions"`
+}
+
+type EpochPendingBranchCountResponse struct {
+	PendingBranchCount uint64 `json:"pendingBranchCount"`
+}

packages/jsonmodels/info.go

@@ -32,6 +32,10 @@ type InfoResponse struct {
 	Mana Mana `json:"mana,omitempty"`
 	// Scheduler is the scheduler.
 	Scheduler Scheduler `json:"scheduler"`
+
+	// LastCommittedEpoch contains information about the last committed epoch.
+	LastCommittedEpoch EpochInfo
+
 	// RateSetter is the rate setter.
 	RateSetter RateSetter `json:"rateSetter"`
 	// error of the response

packages/notarization/commitments.go

@@ -446,4 +446,4 @@ func EC(ecRecord *epoch.ECRecord) (ec epoch.EC) {
 	return epoch.NewMerkleRoot(ecHash[:])
 }
 
-// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////

packages/notarization/manager.go

@@ -52,8 +52,14 @@ func NewManager(epochCommitmentFactory *EpochCommitmentFactory, t *tangle.Tangle
 		log:                      options.Log,
 		options:                  options,
 		Events: &Events{
-			EpochCommittable: event.New[*EpochCommittableEvent](),
-			ManaVectorUpdate: event.New[*ManaVectorUpdateEvent](),
+			TangleTreeInserted:    event.New[*TangleTreeUpdatedEvent](),
+			TangleTreeRemoved:     event.New[*TangleTreeUpdatedEvent](),
+			StateMutationInserted: event.New[*StateMutationTreeUpdatedEvent](),
+			StateMutationRemoved:  event.New[*StateMutationTreeUpdatedEvent](),
+			UTXOInserted:          event.New[*UTXOUpdatedEvent](),
+			UTXORemoved:           event.New[*UTXOUpdatedEvent](),
+			EpochCommittable:      event.New[*EpochCommittableEvent](),
+			ManaVectorUpdate:      event.New[*ManaVectorUpdateEvent](),
 		},
 	}
 
@@ -193,7 +199,9 @@ func (m *Manager) OnMessageConfirmed(message *tangle.Message) {
 	err := m.epochCommitmentFactory.insertTangleLeaf(ei, message.ID())
 	if err != nil && m.log != nil {
 		m.log.Error(err)
+		return
 	}
+	m.Events.TangleTreeInserted.Trigger(&TangleTreeUpdatedEvent{EI: ei, MessageID: message.ID()})
 }
 
 // OnMessageOrphaned is the handler for message orphaned event.
@@ -210,10 +218,13 @@ func (m *Manager) OnMessageOrphaned(message *tangle.Message) {
 	if err != nil && m.log != nil {
 		m.log.Error(err)
 	}
+	m.Events.TangleTreeRemoved.Trigger(&TangleTreeUpdatedEvent{EI: ei, MessageID: message.ID()})
+
 	transaction, isTransaction := message.Payload().(utxo.Transaction)
 	if isTransaction {
 		spent, created := m.resolveOutputs(transaction)
 		m.epochCommitmentFactory.deleteDiffUTXOs(ei, created, spent)
+		m.Events.UTXORemoved.Trigger(&UTXOUpdatedEvent{EI: ei, Spent: spent, Created: created})
 	}
 }
 
@@ -280,7 +291,6 @@ func (m *Manager) OnTransactionInclusionUpdated(event *ledger.TransactionInclusi
 func (m *Manager) OnBranchConfirmed(branchID utxo.TransactionID) {
 	m.epochCommitmentFactoryMutex.Lock()
 	defer m.epochCommitmentFactoryMutex.Unlock()
-
 	ei := m.getBranchEI(branchID, true)
 
 	if m.isEpochAlreadyCommitted(ei) {
@@ -339,6 +349,20 @@ func (m *Manager) OnAcceptanceTimeUpdated(newTime time.Time) {
 	}
 }
 
+// PendingConflictsCount returns the current value of pendingConflictsCount.
+func (m *Manager) PendingConflictsCount(ei epoch.Index) uint64 {
+	return m.pendingConflictsCounters[ei]
+}
+
+// PendingConflictsCountAll returns the current value of pendingConflictsCount per epoch.
+func (m *Manager) PendingConflictsCountAll() map[epoch.Index]uint64 {
+	duplicate := make(map[epoch.Index]uint64, len(m.pendingConflictsCounters))
+	for k, v := range m.pendingConflictsCounters {
+		duplicate[k] = v
+	}
+	return duplicate
+}
+
 // Shutdown shuts down the manager's permanent storagee.
 func (m *Manager) Shutdown() {
 	m.epochCommitmentFactoryMutex.Lock()
@@ -362,8 +386,10 @@ func (m *Manager) includeTransactionInEpoch(txID utxo.TransactionID, ei epoch.In
 	if err := m.epochCommitmentFactory.insertStateMutationLeaf(ei, txID); err != nil {
 		return err
 	}
+	m.Events.StateMutationInserted.Trigger(&StateMutationTreeUpdatedEvent{TransactionID: txID})
 
 	m.epochCommitmentFactory.storeDiffUTXOs(ei, spent, created)
+	m.Events.UTXOInserted.Trigger(&UTXOUpdatedEvent{EI: ei, Spent: spent, Created: created})
 
 	return nil
 }
@@ -372,8 +398,10 @@ func (m *Manager) removeTransactionFromEpoch(txID utxo.TransactionID, ei epoch.I
 	if err := m.epochCommitmentFactory.removeStateMutationLeaf(ei, txID); err != nil {
 		return err
 	}
+	m.Events.StateMutationRemoved.Trigger(&StateMutationTreeUpdatedEvent{TransactionID: txID})
 
 	m.epochCommitmentFactory.deleteDiffUTXOs(ei, spent, created)
+	m.Events.UTXORemoved.Trigger(&UTXOUpdatedEvent{EI: ei, Spent: spent, Created: created})
 
 	return nil
 }
@@ -480,7 +508,9 @@ func (m *Manager) moveLatestCommittableEpoch(currentEpoch epoch.Index) {
 
 		// reads the roots and store the ec
 		// rolls the state trees
-		if _, ecRecordErr := m.epochCommitmentFactory.ecRecord(ei); ecRecordErr != nil {
+		ecRecord := epoch.NewECRecord(epoch.Index(0))
+		ecRecord, ecRecordErr := m.epochCommitmentFactory.ecRecord(ei)
+		if ecRecordErr != nil {
 			m.log.Errorf("could not update commitments for epoch %d: %v", ei, ecRecordErr)
 			return
 		}
@@ -490,7 +520,7 @@ func (m *Manager) moveLatestCommittableEpoch(currentEpoch epoch.Index) {
 			return
 		}
 
-		m.Events.EpochCommittable.Trigger(&EpochCommittableEvent{EI: ei})
+		m.Events.EpochCommittable.Trigger(&EpochCommittableEvent{EI: ei, ECRecord: ecRecord})
 		m.triggerManaVectorUpdate(ei)
 	}
 }
@@ -539,12 +569,52 @@ type Events struct {
 	// EpochCommittable is an event that gets triggered whenever an epoch commitment is committable.
 	EpochCommittable *event.Event[*EpochCommittableEvent]
 	ManaVectorUpdate *event.Event[*ManaVectorUpdateEvent]
+	// TangleTreeInserted is an event that gets triggered when a Message is inserted to Tangle smt.
+	TangleTreeInserted *event.Event[*TangleTreeUpdatedEvent]
+	// TangleTreeRemoved is an event that gets triggered when a Message is removed to Tangle smt.
+	TangleTreeRemoved *event.Event[*TangleTreeUpdatedEvent]
+	// StateMutationInserted is an event that gets triggered when a transaction is inserted to state mutation smt.
+	StateMutationInserted *event.Event[*StateMutationTreeUpdatedEvent]
+	// StateMutationRemoved is an event that gets triggered when a transaction is removed to state mutation smt.
+	StateMutationRemoved *event.Event[*StateMutationTreeUpdatedEvent]
+	// UTXOInserted is an event that gets triggered when UTXOs are stored.
+	UTXOInserted *event.Event[*UTXOUpdatedEvent]
+	// UTXORemoved is an event that gets triggered when UTXOs are removed.
+	UTXORemoved *event.Event[*UTXOUpdatedEvent]
+}
+
+// TangleTreeUpdatedEvent is a container that acts as a dictionary for the TangleTree inserted/removed event related parameters.
+type TangleTreeUpdatedEvent struct {
+	// EI is the index of the message.
+	EI epoch.Index
+	// MessageID is the messageID that inserted/removed to/from the tangle smt.
+	MessageID tangle.MessageID
+}
+
+// StateMutationTreeUpdatedEvent is a container that acts as a dictionary for the State mutation tree inserted/removed event related parameters.
+type StateMutationTreeUpdatedEvent struct {
+	// EI is the index of the transaction.
+	EI epoch.Index
+	// TransactionID is the transaction ID that inserted/removed to/from the state mutation smt.
+	TransactionID utxo.TransactionID
+}
+
+// UTXOUpdatedEvent is a container that acts as a dictionary for the UTXO update event related parameters.
+type UTXOUpdatedEvent struct {
+	// EI is the index of updated UTXO.
+	EI epoch.Index
+	// Created are the outputs created in a transaction.
+	Created []*ledger.OutputWithMetadata
+	// Spent are outputs that is spent in a transaction.
+	Spent []*ledger.OutputWithMetadata
 }
 
 // EpochCommittableEvent is a container that acts as a dictionary for the EpochCommittable event related parameters.
 type EpochCommittableEvent struct {
 	// EI is the index of committable epoch.
 	EI epoch.Index
+	// ECRecord is the ec root of committable epoch.
+	ECRecord *epoch.ECRecord
 }
 
 // ManaVectorUpdateEvent is a container that acts as a dictionary for the EpochCommittable event related parameters.

packages/notarization/proofs.go

@@ -106,4 +106,4 @@ func (f *EpochCommitmentFactory) VerifyStateMutationRoot(proof CommitmentProof,
 	return f.verifyRoot(proof, key, key)
 }
 
-// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////

packages/tangle/ratesetter_test.go

@@ -1,10 +1,11 @@
 package tangle
 
 import (
-	"github.com/iotaledger/goshimmer/packages/epoch"
 	"testing"
 	"time"
 
+	"github.com/iotaledger/goshimmer/packages/epoch"
+
 	"github.com/iotaledger/goshimmer/packages/tangle/payload"
 
 	"github.com/iotaledger/hive.go/crypto/ed25519"