Mana vector fixes

packages/core/epoch/types.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"github.com/cockroachdb/errors"
 	"github.com/iotaledger/hive.go/core/generics/set"
+	"github.com/iotaledger/hive.go/core/generics/shrinkingmap"
 	"github.com/iotaledger/hive.go/core/identity"
 	"strings"
 	"time"
@@ -23,6 +24,13 @@ var (
 	Duration int64 = 10
 )
 
+func init() {
+	err := serix.DefaultAPI.RegisterTypeSettings(nodesActivitySerializableMap{}, serix.TypeSettings{}.WithLengthPrefixType(serix.LengthPrefixTypeAsUint32))
+	if err != nil {
+		panic(fmt.Errorf("error registering NodesActivityLog type settings: %w", err))
+	}
+}
+
 // Index is the ID of an epoch.
 type Index int64
 
@@ -227,9 +235,9 @@ func ComputeECR(tangleRoot, stateMutationRoot, stateRoot, manaRoot MerkleRoot) E
 
 // region NodesActivityLog //////////////////////////////////////////////////////////////////////////////////////////////////
 
-type NodesActivityLog map[Index]*ActivityLog
+type nodesActivitySerializableMap map[Index]*ActivityLog
 
-func (al *NodesActivityLog) FromBytes(data []byte) (err error) {
+func (al *nodesActivitySerializableMap) FromBytes(data []byte) (err error) {
 	_, err = serix.DefaultAPI.Decode(context.Background(), data, al, serix.WithValidation())
 	if err != nil {
 		err = errors.Errorf("failed to parse activeNodes: %w", err)
@@ -238,47 +246,94 @@ func (al *NodesActivityLog) FromBytes(data []byte) (err error) {
 	return
 }
 
-func (al *NodesActivityLog) Bytes() []byte {
+func (al *nodesActivitySerializableMap) Bytes() []byte {
 	objBytes, err := serix.DefaultAPI.Encode(context.Background(), *al, serix.WithValidation())
 	if err != nil {
 		panic(err)
 	}
 	return objBytes
 }
 
+func (al *nodesActivitySerializableMap) nodesActivityLog() *NodesActivityLog {
+	activity := NewNodesActivityLog()
+	for ei, a := range *al {
+		activity.Set(ei, a)
+	}
+	return activity
+}
+
+type NodesActivityLog struct {
+	shrinkingmap.ShrinkingMap[Index, *ActivityLog] `serix:"0,lengthPrefixType=uint32"`
+}
+
+func (al *NodesActivityLog) FromBytes(data []byte) (err error) {
+	m := make(nodesActivitySerializableMap)
+	err = m.FromBytes(data)
+	if err != nil {
+		return err
+	}
+	al.loadActivityLogsMap(m)
+	return
+}
+
+func (al *NodesActivityLog) Bytes() []byte {
+	m := al.activityLogsMap()
+	return m.Bytes()
+}
+
+func NewNodesActivityLog() *NodesActivityLog {
+	return &NodesActivityLog{*shrinkingmap.New[Index, *ActivityLog]()}
+}
+
+func (al *NodesActivityLog) activityLogsMap() *nodesActivitySerializableMap {
+	activityMap := make(nodesActivitySerializableMap)
+	al.ForEach(func(ei Index, activity *ActivityLog) bool {
+		activityMap[ei] = activity
+		return true
+	})
+	return &activityMap
+}
+
+func (al *NodesActivityLog) loadActivityLogsMap(m nodesActivitySerializableMap) {
+	for ei, a := range m {
+		al.Set(ei, a)
+	}
+	return
+}
+
 // endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 // region ActivityLog //////////////////////////////////////////////////////////////////////////////////////////////////
 
 // ActivityLog is a time-based log of node activity. It stores information when a node is active and provides
 // functionality to query for certain timeframes.
 type ActivityLog struct {
-	SetEpochs *set.AdvancedSet[identity.ID] `serix:"0,lengthPrefixType=uint32"`
+	model.Mutable[ActivityLog, *ActivityLog, activityLogModel] `serix:"0"`
+}
+
+// nodeActivityModel stores node identities and corresponding accepted block counters indicating how many blocks node issued in a given epoch.
+type activityLogModel struct {
+	ActivityLog *set.AdvancedSet[identity.ID] `serix:"0,lengthPrefixType=uint32"`
 }
 
 // NewActivityLog is the constructor for ActivityLog.
 func NewActivityLog() *ActivityLog {
-
-	a := &ActivityLog{
-		SetEpochs: set.NewAdvancedSet[identity.ID](),
-	}
-
-	return a
+	return model.NewMutable[ActivityLog](&activityLogModel{ActivityLog: set.NewAdvancedSet[identity.ID]()})
 }
 
 // Add adds a node to the activity log.
 func (a *ActivityLog) Add(nodeID identity.ID) (added bool) {
-	return a.SetEpochs.Add(nodeID)
+	return a.InnerModel().ActivityLog.Add(nodeID)
 }
 
 // Remove removes a node from the activity log.
 func (a *ActivityLog) Remove(nodeID identity.ID) (removed bool) {
-	return a.SetEpochs.Delete(nodeID)
+	return a.InnerModel().ActivityLog.Delete(nodeID)
 }
 
 // Active returns true if the provided node was active.
 func (a *ActivityLog) Active(nodeID identity.ID) (active bool) {
-	if a.SetEpochs.Has(nodeID) {
+	if a.InnerModel().ActivityLog.Has(nodeID) {
 		return true
 	}
 
@@ -288,8 +343,8 @@ func (a *ActivityLog) Active(nodeID identity.ID) (active bool) {
 // String returns a human-readable version of ActivityLog.
 func (a *ActivityLog) String() string {
 	var builder strings.Builder
-	builder.WriteString(fmt.Sprintf("ActivityLog(len=%d, elements=", a.SetEpochs.Size()))
-	a.SetEpochs.ForEach(func(nodeID identity.ID) (err error) {
+	builder.WriteString(fmt.Sprintf("ActivityLog(len=%d, elements=", a.Size()))
+	a.InnerModel().ActivityLog.ForEach(func(nodeID identity.ID) (err error) {
 		builder.WriteString(fmt.Sprintf("%s, ", nodeID.String()))
 		return
 	})
@@ -300,10 +355,20 @@ func (a *ActivityLog) String() string {
 // Clone clones the ActivityLog.
 func (a *ActivityLog) Clone() *ActivityLog {
 	clone := NewActivityLog()
-	clone.SetEpochs = a.SetEpochs.Clone()
+	clone.InnerModel().ActivityLog = a.InnerModel().ActivityLog.Clone()
 	return clone
 }
 
+// ForEach iterates through the activity set and calls the callback for every element.
+func (a *ActivityLog) ForEach(callback func(nodeID identity.ID) (err error)) (err error) {
+	return a.InnerModel().ActivityLog.ForEach(callback)
+}
+
+// Size returns the size of the activity log.
+func (a *ActivityLog) Size() int {
+	return a.InnerModel().ActivityLog.Size()
+}
+
 // endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 // SnapshotEpochActivity is the data structure to store node activity for the snapshot.
@@ -321,7 +386,7 @@ type SnapshotNodeActivity struct {
 
 // NewSnapshotNodeActivity creates a new SnapshotNodeActivity instance.
 func NewSnapshotNodeActivity() *SnapshotNodeActivity {
-	return model.NewImmutable[SnapshotNodeActivity](&nodeActivityModel{NodesLog: make(map[identity.ID]uint64)})
+	return model.NewMutable[SnapshotNodeActivity](&nodeActivityModel{NodesLog: make(map[identity.ID]uint64)})
 }
 
 // nodeActivityModel stores node identities and corresponding accepted block counters indicating how many blocks node issued in a given epoch.

packages/core/notarization/events.go

@@ -38,10 +38,9 @@ type Events struct {
 	// SyncRange is an event that gets triggered when an entire range of epochs needs to be requested, validated and solidified
 	SyncRange *event.Event[*SyncRangeEvent]
 	// ActivityTreeInserted is an event that gets triggered when nodeID is added to the activity tree.
-        ActivityTreeInserted *event.Event[*ActivityTreeUpdatedEvent]
-        // ActivityTreeRemoved is an event that gets triggered when nodeID is removed from activity tree.
-        ActivityTreeRemoved *event.Event[*ActivityTreeUpdatedEvent]
-
+	ActivityTreeInserted *event.Event[*ActivityTreeUpdatedEvent]
+	// ActivityTreeRemoved is an event that gets triggered when nodeID is removed from activity tree.
+	ActivityTreeRemoved *event.Event[*ActivityTreeUpdatedEvent]
 }
 
 // TangleTreeUpdatedEvent is a container that acts as a dictionary for the TangleTree inserted/removed event related parameters.
@@ -100,10 +99,6 @@ type CompetingCommitmentDetectedEvent struct {
 type ManaVectorUpdateEvent struct {
 	// EI is the index of committable epoch.
 	EI epoch.Index
-	// EpochDiffCreated is the list of outputs created in the epoch.
-	EpochDiffCreated []*ledger.OutputWithMetadata
-	// EpochDiffSpent is the list of outputs spent in the epoch.
-	EpochDiffSpent []*ledger.OutputWithMetadata
 }
 
 // SyncRangeEvent is a container that acts as a dictionary for the SyncRange event related parameters.
@@ -116,10 +111,10 @@ type SyncRangeEvent struct {
 
 // ActivityTreeUpdatedEvent is a container that acts as a dictionary for the ActivityTree inserted/removed event related parameters.
 type ActivityTreeUpdatedEvent struct {
-        // EI is the index of the epoch.
-        EI epoch.Index
-        // NodeID is the issuer nodeID.
-        NodeID identity.ID
+	// EI is the index of the epoch.
+	EI epoch.Index
+	// NodeID is the issuer nodeID.
+	NodeID identity.ID
 }
 
 // endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////

packages/core/notarization/manager.go

@@ -539,6 +539,14 @@ func (m *Manager) PendingConflictsCountAll() (pendingConflicts map[epoch.Index]u
 	return pendingConflicts
 }
 
+// GetEpochDiff returns the epoch diff of an epoch.
+func (m *Manager) GetEpochDiff(ei epoch.Index) (spent []*ledger.OutputWithMetadata, created []*ledger.OutputWithMetadata) {
+	m.epochCommitmentFactoryMutex.Lock()
+	defer m.epochCommitmentFactoryMutex.Unlock()
+	spent, created = m.epochCommitmentFactory.loadDiffUTXOs(ei)
+	return
+}
+
 // Bootstrapped returns the current value of pendingConflictsCount per epoch.
 func (m *Manager) Bootstrapped() bool {
 	m.bootstrapMutex.RLock()
@@ -668,15 +676,8 @@ func (m *Manager) resolveOutputs(tx utxo.Transaction) (spentOutputsWithMetadata,
 }
 
 func (m *Manager) manaVectorUpdate(ei epoch.Index) (event *ManaVectorUpdateEvent) {
-	epochForManaVector := ei - epoch.Index(m.options.ManaEpochDelay)
-	if epochForManaVector < 1 {
-		return
-	}
-	spent, created := m.epochCommitmentFactory.loadDiffUTXOs(epochForManaVector)
 	return &ManaVectorUpdateEvent{
-		EI:               ei,
-		EpochDiffCreated: created,
-		EpochDiffSpent:   spent,
+		EI: ei,
 	}
 }
 
@@ -737,8 +738,8 @@ func (m *Manager) updateEpochsBootstrapped(ei epoch.Index) {
 }
 
 // SnapshotEpochActivity snapshots accepted block counts from activity tree and updates provided SnapshotEpochActivity.
-func (m *Manager) SnapshotEpochActivity() (epochActivity epoch.SnapshotEpochActivity, err error) {
-	epochActivity = m.tangle.WeightProvider.SnapshotEpochActivity()
+func (m *Manager) SnapshotEpochActivity(epochDiffIndex epoch.Index) (epochActivity epoch.SnapshotEpochActivity, err error) {
+	epochActivity = m.tangle.WeightProvider.SnapshotEpochActivity(epochDiffIndex)
 	return
 }
 
@@ -753,7 +754,6 @@ type ManagerOption func(options *ManagerOptions)
 type ManagerOptions struct {
 	MinCommittableEpochAge time.Duration
 	BootstrapWindow        time.Duration
-	ManaEpochDelay         uint
 	Log                    *logger.Logger
 }
 
@@ -771,13 +771,6 @@ func BootstrapWindow(d time.Duration) ManagerOption {
 	}
 }
 
-// ManaDelay specifies the epoch offset for mana vector from the last committable epoch.
-func ManaDelay(d uint) ManagerOption {
-	return func(options *ManagerOptions) {
-		options.ManaEpochDelay = d
-	}
-}
-
 // Log provides the logger.
 func Log(log *logger.Logger) ManagerOption {
 	return func(options *ManagerOptions) {