Implement eviction of the new ConflictDAG

packages/protocol/engine/ledger/mempool/newconflictdag/conflict.go

@@ -4,6 +4,8 @@ import (
 	"bytes"
 	"sync"
 
+	"go.uber.org/atomic"
+
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/mempool/newconflictdag/acceptance"
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/mempool/newconflictdag/vote"
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/mempool/newconflictdag/weight"
@@ -59,6 +61,9 @@ type Conflict[ConflictID, ResourceID IDType, VotePower constraints.Comparable[Vo
 	// preferredInstead is the preferred instead value of the Conflict.
 	preferredInstead *Conflict[ConflictID, ResourceID, VotePower]
 
+	// evicted
+	evicted atomic.Bool
+
 	// preferredInsteadMutex is used to synchronize access to the preferred instead value of the Conflict.
 	preferredInsteadMutex sync.RWMutex
 
@@ -165,6 +170,10 @@ func (c *Conflict[ConflictID, ResourceID, VotePower]) ApplyVote(vote *vote.Vote[
 
 // JoinConflictSets registers the Conflict with the given ConflictSets.
 func (c *Conflict[ConflictID, ResourceID, VotePower]) JoinConflictSets(conflictSets ...*ConflictSet[ConflictID, ResourceID, VotePower]) (joinedConflictSets map[ResourceID]*ConflictSet[ConflictID, ResourceID, VotePower]) {
+	if c.evicted.Load() {
+		return
+	}
+
 	registerConflictingConflict := func(c, conflict *Conflict[ConflictID, ResourceID, VotePower]) {
 		c.structureMutex.Lock()
 		defer c.structureMutex.Unlock()
@@ -260,25 +269,48 @@ func (c *Conflict[ConflictID, ResourceID, VotePower]) LikedInstead() *advancedse
 	return c.likedInstead.Clone()
 }
 
-// Dispose cleans up the sortedConflict.
-func (c *Conflict[ConflictID, ResourceID, VotePower]) Dispose() {
+// Evict cleans up the sortedConflict.
+func (c *Conflict[ConflictID, ResourceID, VotePower]) Evict() []ConflictID {
+	// TODO: make other methods respect c.evicted flag
+	c.evicted.Store(true)
+
+	// iterate through the children and dispose of them
+	_ = c.Children.ForEach(func(childConflict *Conflict[ConflictID, ResourceID, VotePower]) (err error) {
+		if !childConflict.IsPending() {
+			childConflict.Evict()
+		}
+
+		return nil
+	})
+
 	c.structureMutex.Lock()
 	defer c.structureMutex.Unlock()
 
-	c.ConflictingConflicts.Dispose()
+	for _, parentConflict := range c.Parents.Slice() {
+		parentConflict.unregisterChild(c)
+	}
+	c.Parents.Clear()
 
-	_ = c.Children.ForEach(func(childConflict *Conflict[ConflictID, ResourceID, VotePower]) (err error) {
-		childConflict.structureMutex.Lock()
-		defer childConflict.structureMutex.Unlock()
+	// deattach all events etc.
+
+	for _, conflictSet := range c.ConflictSets.Slice() {
+		conflictSet.Remove(c)
+	}
 
-		if childConflict.Parents.Delete(c) {
-			c.unregisterChild(childConflict)
+	c.ConflictSets.Clear()
+
+	for _, conflict := range c.ConflictingConflicts.Shutdown() {
+		if conflict != c {
+			conflict.ConflictingConflicts.EvictConflict(c.ID)
+			c.ConflictingConflicts.EvictConflict(conflict.ID)
 		}
+	}
 
-		return nil
-	})
+	c.ConflictingConflicts.EvictConflict(c.ID)
 
 	c.acceptanceUnhook()
+
+	return nil
 }
 
 // Compare compares the Conflict to the given other Conflict.

packages/protocol/engine/ledger/mempool/newconflictdag/conflict_set.go

@@ -3,6 +3,8 @@ package newconflictdag
 import (
 	"sync"
 
+	"go.uber.org/atomic"
+
 	"github.com/iotaledger/hive.go/constraints"
 	"github.com/iotaledger/hive.go/ds/advancedset"
 )
@@ -15,6 +17,8 @@ type ConflictSet[ConflictID, ResourceID IDType, VotePower constraints.Comparable
 	// members is the set of Conflicts that are conflicting over the shared resource.
 	members *advancedset.AdvancedSet[*Conflict[ConflictID, ResourceID, VotePower]]
 
+	allMembersEvicted atomic.Bool
+
 	mutex sync.RWMutex
 }
 
@@ -41,17 +45,15 @@ func (c *ConflictSet[ConflictID, ResourceID, VotePower]) Add(addedConflict *Conf
 }
 
 // Remove removes a Conflict from the ConflictSet and returns all remaining members of the set.
-func (c *ConflictSet[ConflictID, ResourceID, VotePower]) Remove(removedConflict *Conflict[ConflictID, ResourceID, VotePower]) (otherMembers []*Conflict[ConflictID, ResourceID, VotePower]) {
+func (c *ConflictSet[ConflictID, ResourceID, VotePower]) Remove(removedConflict *Conflict[ConflictID, ResourceID, VotePower]) (removed bool) {
 	c.mutex.Lock()
 	defer c.mutex.Unlock()
 
-	if !c.members.Delete(removedConflict) {
-		return nil
-	}
-
-	if c.members.IsEmpty() {
-		// TODO: trigger conflict set removal
+	if removed = !c.members.Delete(removedConflict); removed && c.members.IsEmpty() {
+		if wasShutdown := c.allMembersEvicted.Swap(true); !wasShutdown {
+			// TODO: trigger conflict set removal
+		}
 	}
 
-	return c.members.Slice()
+	return removed
 }

packages/protocol/engine/ledger/mempool/newconflictdag/conflictdag.go

@@ -61,28 +61,43 @@ func New[ConflictID, ResourceID IDType, VotePower constraints.Comparable[VotePow
 }
 
 // CreateConflict creates a new Conflict that is conflicting over the given ResourceIDs and that has the given parents.
-func (c *ConflictDAG[ConflictID, ResourceID, VotePower]) CreateConflict(id ConflictID, parentIDs []ConflictID, resourceIDs []ResourceID, initialWeight *weight.Weight) *Conflict[ConflictID, ResourceID, VotePower] {
-	createdConflict := func() *Conflict[ConflictID, ResourceID, VotePower] {
+func (c *ConflictDAG[ConflictID, ResourceID, VotePower]) CreateConflict(id ConflictID, parentIDs []ConflictID, resourceIDs []ResourceID, initialWeight *weight.Weight) error {
+	createdConflict, err := func() (*Conflict[ConflictID, ResourceID, VotePower], error) {
 		c.mutex.RLock()
 		defer c.mutex.RUnlock()
 
 		parents := lo.Values(c.Conflicts(parentIDs...))
-		conflictSets := lo.Values(c.ConflictSets(resourceIDs...))
 
-		createdConflict, isNew := c.conflictsByID.GetOrCreate(id, func() *Conflict[ConflictID, ResourceID, VotePower] {
-			return NewConflict[ConflictID, ResourceID, VotePower](id, parents, conflictSets, initialWeight, c.pendingTasks, c.acceptanceThresholdProvider)
-		})
+		conflictSetsMap := make(map[ResourceID]*ConflictSet[ConflictID, ResourceID, VotePower])
+		for _, resourceID := range resourceIDs {
+			if initialWeight.AcceptanceState().IsRejected() {
+				conflictSet, exists := c.conflictSetsByID.Get(resourceID)
+				if !exists {
+					return nil, xerrors.Errorf("tried to create a Conflict with evicted Resource: %w", EvictionError)
+				}
+
+				conflictSetsMap[resourceID] = conflictSet
+			} else {
+				conflictSetsMap[resourceID] = lo.Return1(c.conflictSetsByID.GetOrCreate(resourceID, func() *ConflictSet[ConflictID, ResourceID, VotePower] {
+					// TODO: hook to conflictSet event that is triggered when it becomes empty
+					return NewConflictSet[ConflictID, ResourceID, VotePower](resourceID)
+				}))
+			}
+		}
+
+		if createdConflict, isNew := c.conflictsByID.GetOrCreate(id, func() *Conflict[ConflictID, ResourceID, VotePower] {
+			return NewConflict[ConflictID, ResourceID, VotePower](id, parents, lo.Values(conflictSetsMap), initialWeight, c.pendingTasks, c.acceptanceThresholdProvider)
+		}); isNew {
+			return createdConflict, nil
 
-		if !isNew {
-			panic("tried to re-create an already existing conflict")
 		}
 
-		return createdConflict
+		return nil, xerrors.Errorf("tried to create conflict with %s twice: %w", id, RuntimeError)
 	}()
 
 	c.ConflictCreated.Trigger(createdConflict)
 
-	return createdConflict
+	return err
 }
 
 // JoinConflictSets adds the Conflict to the given ConflictSets and returns true if the conflict membership was modified during this operation.
@@ -169,6 +184,7 @@ func (c *ConflictDAG[ConflictID, ResourceID, VotePower]) ConflictSets(resourceID
 	conflictSets := make(map[ResourceID]*ConflictSet[ConflictID, ResourceID, VotePower])
 	for _, resourceID := range resourceIDs {
 		conflictSets[resourceID] = lo.Return1(c.conflictSetsByID.GetOrCreate(resourceID, func() *ConflictSet[ConflictID, ResourceID, VotePower] {
+			// TODO: hook to conflictSet event that is triggered when it becomes empty
 			return NewConflictSet[ConflictID, ResourceID, VotePower](resourceID)
 		}))
 	}
@@ -198,6 +214,32 @@ func (c *ConflictDAG[ConflictID, ResourceID, VotePower]) CastVotes(vote *vote.Vo
 	return nil
 }
 
+// EvictConflict removes conflict with given ConflictID from ConflictDAG.
+func (c *ConflictDAG[ConflictID, ResourceID, VotePower]) EvictConflict(conflictID ConflictID) {
+	c.mutex.Lock()
+	defer c.mutex.Unlock()
+	// TODO: make locking more fine-grained on conflictset level
+
+	conflict, exists := c.conflictsByID.Get(conflictID)
+	if !exists {
+		return
+	}
+
+	evictedConflictIDs := conflict.Evict()
+
+	for _, evictedConflictID := range evictedConflictIDs {
+		c.conflictsByID.Delete(evictedConflictID)
+	}
+
+	//_ = conflictSets.ForEach(func(conflictSet *ConflictSet[ConflictID, ResourceID, VotePower]) (err error) {
+	//	if conflictSet.members.IsEmpty() {
+	//		c.conflictSetsByID.Delete(conflictSet.ID)
+	//	}
+	//
+	//	return nil
+	//})
+}
+
 func (c *ConflictDAG[ConflictID, ResourceID, VotePower]) determineVotes(conflictIDs ...ConflictID) (supportedConflicts, revokedConflicts *advancedset.AdvancedSet[*Conflict[ConflictID, ResourceID, VotePower]], err error) {
 	supportedConflicts = advancedset.New[*Conflict[ConflictID, ResourceID, VotePower]]()
 	revokedConflicts = advancedset.New[*Conflict[ConflictID, ResourceID, VotePower]]()

packages/protocol/engine/ledger/mempool/newconflictdag/errors.go

@@ -0,0 +1,8 @@
+package newconflictdag
+
+import "golang.org/x/xerrors"
+
+var (
+	EvictionError = xerrors.New("tried to operate on evicted entity")
+	RuntimeError  = xerrors.New("unexpected operation")
+)

packages/protocol/engine/ledger/mempool/newconflictdag/sorted_conflict.go

@@ -61,7 +61,7 @@ func newSortedConflict[ConflictID, ResourceID IDType, VotePower constraints.Comp
 		Conflict:                conflict,
 	}
 
-	if conflict != set.owner {
+	if set.owner != nil {
 		s.onAcceptanceStateUpdatedHook = conflict.AcceptanceStateUpdated.Hook(s.onAcceptanceStateUpdated)
 	}
 
@@ -101,14 +101,22 @@ func (s *sortedConflict[ConflictID, ResourceID, VotePower]) IsPreferred() bool {
 	return s.PreferredInstead() == s.Conflict
 }
 
-// Dispose cleans up the sortedConflict.
-func (s *sortedConflict[ConflictID, ResourceID, VotePower]) Dispose() {
+// Unhook cleans up the sortedConflict.
+func (s *sortedConflict[ConflictID, ResourceID, VotePower]) Unhook() {
 	if s.onAcceptanceStateUpdatedHook != nil {
 		s.onAcceptanceStateUpdatedHook.Unhook()
+		s.onAcceptanceStateUpdatedHook = nil
 	}
 
-	s.onWeightUpdatedHook.Unhook()
-	s.onPreferredUpdatedHook.Unhook()
+	if s.onWeightUpdatedHook != nil {
+		s.onWeightUpdatedHook.Unhook()
+		s.onWeightUpdatedHook = nil
+	}
+
+	if s.onPreferredUpdatedHook != nil {
+		s.onPreferredUpdatedHook.Unhook()
+		s.onPreferredUpdatedHook = nil
+	}
 }
 
 func (s *sortedConflict[ConflictID, ResourceID, VotePower]) onAcceptanceStateUpdated(_, newState acceptance.State) {
@@ -158,7 +166,7 @@ func (s *sortedConflict[ConflictID, ResourceID, VotePower]) queuePreferredInstea
 
 	if (s.queuedPreferredInstead == nil && s.currentPreferredInstead == conflict) ||
 		(s.queuedPreferredInstead != nil && s.queuedPreferredInstead == conflict) ||
-		s.sortedSet.owner == conflict {
+		s.sortedSet.owner.Conflict == conflict {
 		return
 	}
 

packages/protocol/engine/ledger/mempool/newconflictdag/sorted_conflicts.go

@@ -15,7 +15,7 @@ import (
 // SortedConflicts is a set of Conflicts that is sorted by their weight.
 type SortedConflicts[ConflictID, ResourceID IDType, VotePower constraints.Comparable[VotePower]] struct {
 	// owner is the Conflict that owns this SortedConflicts.
-	owner *Conflict[ConflictID, ResourceID, VotePower]
+	owner *sortedConflict[ConflictID, ResourceID, VotePower]
 
 	// members is a map of ConflictIDs to their corresponding sortedConflict.
 	members *shrinkingmap.ShrinkingMap[ConflictID, *sortedConflict[ConflictID, ResourceID, VotePower]]
@@ -59,7 +59,6 @@ type SortedConflicts[ConflictID, ResourceID IDType, VotePower constraints.Compar
 // NewSortedConflicts creates a new SortedConflicts that is owned by the given Conflict.
 func NewSortedConflicts[ConflictID, ResourceID IDType, VotePower constraints.Comparable[VotePower]](owner *Conflict[ConflictID, ResourceID, VotePower], pendingUpdatesCounter *syncutils.Counter) *SortedConflicts[ConflictID, ResourceID, VotePower] {
 	s := &SortedConflicts[ConflictID, ResourceID, VotePower]{
-		owner:                          owner,
 		members:                        shrinkingmap.New[ConflictID, *sortedConflict[ConflictID, ResourceID, VotePower]](),
 		pendingWeightUpdates:           shrinkingmap.New[ConflictID, *sortedConflict[ConflictID, ResourceID, VotePower]](),
 		pendingUpdatesCounter:          pendingUpdatesCounter,
@@ -68,11 +67,11 @@ func NewSortedConflicts[ConflictID, ResourceID IDType, VotePower constraints.Com
 	s.pendingWeightUpdatesSignal = sync.NewCond(&s.pendingWeightUpdatesMutex)
 	s.pendingPreferredInsteadSignal = sync.NewCond(&s.pendingPreferredInsteadMutex)
 
-	newMember := newSortedConflict[ConflictID, ResourceID, VotePower](s, owner)
-	s.members.Set(owner.ID, newMember)
+	s.owner = newSortedConflict[ConflictID, ResourceID, VotePower](s, owner)
+	s.members.Set(owner.ID, s.owner)
 
-	s.heaviestMember = newMember
-	s.heaviestPreferredMember = newMember
+	s.heaviestMember = s.owner
+	s.heaviestPreferredMember = s.owner
 
 	// TODO: move to WorkerPool so we are consistent with the rest of the codebase
 	go s.fixMemberPositionWorker()
@@ -86,6 +85,10 @@ func (s *SortedConflicts[ConflictID, ResourceID, VotePower]) Add(conflict *Confl
 	s.mutex.Lock()
 	defer s.mutex.Unlock()
 
+	if s.isShutdown.Load() {
+		return false
+	}
+
 	newMember, isNew := s.members.GetOrCreate(conflict.ID, func() *sortedConflict[ConflictID, ResourceID, VotePower] {
 		return newSortedConflict[ConflictID, ResourceID, VotePower](s, conflict)
 	})
@@ -138,7 +141,7 @@ func (s *SortedConflicts[ConflictID, ResourceID, VotePower]) ForEach(callback fu
 	defer s.mutex.RUnlock()
 
 	for currentMember := s.heaviestMember; currentMember != nil; currentMember = currentMember.lighterMember {
-		if !lo.First(optIncludeOwner) && currentMember.Conflict == s.owner {
+		if !lo.First(optIncludeOwner) && currentMember == s.owner {
 			continue
 		}
 
@@ -150,20 +153,37 @@ func (s *SortedConflicts[ConflictID, ResourceID, VotePower]) ForEach(callback fu
 	return nil
 }
 
-func (s *SortedConflicts[ConflictID, ResourceID, VotePower]) Dispose() {
+func (s *SortedConflicts[ConflictID, ResourceID, VotePower]) EvictConflict(id ConflictID) bool {
 	s.mutex.Lock()
 	defer s.mutex.Unlock()
-	s.pendingWeightUpdatesMutex.Lock()
-	defer s.pendingWeightUpdatesMutex.Unlock()
-	s.pendingPreferredInsteadMutex.Lock()
-	defer s.pendingPreferredInsteadMutex.Unlock()
 
-	s.members.ForEach(func(conflictID ConflictID, sortedConflict *sortedConflict[ConflictID, ResourceID, VotePower]) bool {
-		sortedConflict.Dispose()
-		return true
-	})
+	conflict, exists := s.members.Get(id)
+	if !exists || !s.members.Delete(id) {
+		return false
+	}
 
-	s.isShutdown.Store(true)
+	conflict.Unhook()
+
+	if conflict.heavierMember != nil {
+		conflict.heavierMember.lighterMember = conflict.lighterMember
+	}
+
+	if conflict.lighterMember != nil {
+		conflict.lighterMember.heavierMember = conflict.heavierMember
+	}
+
+	if s.heaviestMember == conflict {
+		s.heaviestMember = conflict.lighterMember
+	}
+
+	if s.heaviestPreferredMember == conflict {
+		s.findLowerHeaviestPreferredMember(conflict.lighterMember)
+	}
+
+	conflict.lighterMember = nil
+	conflict.heavierMember = nil
+
+	return true
 }
 
 // String returns a human-readable representation of the SortedConflicts.
@@ -240,7 +260,7 @@ func (s *SortedConflicts[ConflictID, ResourceID, VotePower]) fixMemberPosition(m
 	for currentMember := member.heavierMember; currentMember != nil && currentMember.Compare(member) == weight.Lighter; currentMember = member.heavierMember {
 		s.swapNeighbors(member, currentMember)
 
-		if currentMember == s.heaviestPreferredMember && (preferredConflict == currentMember.Conflict || memberIsPreferred || member.Conflict == s.owner) {
+		if currentMember == s.heaviestPreferredMember && (preferredConflict == currentMember.Conflict || memberIsPreferred || member == s.owner) {
 			s.heaviestPreferredMember = member
 			s.owner.setPreferredInstead(member.Conflict)
 		}
@@ -250,7 +270,7 @@ func (s *SortedConflicts[ConflictID, ResourceID, VotePower]) fixMemberPosition(m
 	for currentMember := member.lighterMember; currentMember != nil && currentMember.Compare(member) == weight.Heavier; currentMember = member.lighterMember {
 		s.swapNeighbors(currentMember, member)
 
-		if member == s.heaviestPreferredMember && (currentMember.IsPreferred() || currentMember.PreferredInstead() == member.Conflict || currentMember.Conflict == s.owner) {
+		if member == s.heaviestPreferredMember && (currentMember.IsPreferred() || currentMember.PreferredInstead() == member.Conflict || currentMember == s.owner) {
 			s.heaviestPreferredMember = currentMember
 			s.owner.setPreferredInstead(currentMember.Conflict)
 		}
@@ -318,15 +338,21 @@ func (s *SortedConflicts[ConflictID, ResourceID, VotePower]) fixHeaviestPreferre
 	}
 
 	if s.heaviestPreferredMember == member {
-		for currentMember := member; ; currentMember = currentMember.lighterMember {
-			if currentMember.Conflict == s.owner || currentMember.IsPreferred() || currentMember.PreferredInstead() == member.Conflict {
-				s.heaviestPreferredMember = currentMember
-				s.owner.setPreferredInstead(currentMember.Conflict)
+		s.findLowerHeaviestPreferredMember(member)
+	}
+}
 
-				return
-			}
+func (s *SortedConflicts[ConflictID, ResourceID, VotePower]) findLowerHeaviestPreferredMember(member *sortedConflict[ConflictID, ResourceID, VotePower]) {
+	for currentMember := member; currentMember != nil; currentMember = currentMember.lighterMember {
+		if currentMember == s.owner || currentMember.IsPreferred() || currentMember.PreferredInstead() == member.Conflict {
+			s.heaviestPreferredMember = currentMember
+			s.owner.setPreferredInstead(currentMember.Conflict)
+
+			return
 		}
 	}
+
+	s.heaviestPreferredMember = nil
 }
 
 // swapNeighbors swaps the given members in the SortedConflicts.
@@ -347,3 +373,22 @@ func (s *SortedConflicts[ConflictID, ResourceID, VotePower]) swapNeighbors(heavi
 		s.heaviestMember = heavierMember
 	}
 }
+
+func (s *SortedConflicts[ConflictID, ResourceID, VotePower]) Shutdown() []*Conflict[ConflictID, ResourceID, VotePower] {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+
+	s.isShutdown.Store(true)
+
+	s.pendingWeightUpdatesMutex.Lock()
+	s.pendingWeightUpdates.Clear()
+	s.pendingWeightUpdatesMutex.Unlock()
+
+	s.pendingPreferredInsteadMutex.Lock()
+	s.pendingPreferredInsteadUpdates.Clear()
+	s.pendingPreferredInsteadMutex.Unlock()
+
+	return lo.Map(s.members.Values(), func(conflict *sortedConflict[ConflictID, ResourceID, VotePower]) *Conflict[ConflictID, ResourceID, VotePower] {
+		return conflict.Conflict
+	})
+}

packages/protocol/engine/ledger/mempool/newconflictdag/testframework.go

@@ -0,0 +1,137 @@
+package newconflictdag
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"golang.org/x/crypto/blake2b"
+
+	"github.com/iotaledger/goshimmer/packages/core/votes"
+	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/mempool/newconflictdag/acceptance"
+	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/mempool/newconflictdag/vote"
+	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/mempool/newconflictdag/weight"
+	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/utxo"
+	"github.com/iotaledger/goshimmer/packages/protocol/engine/sybilprotection"
+	"github.com/iotaledger/hive.go/kvstore/mapdb"
+	"github.com/iotaledger/hive.go/lo"
+	"github.com/iotaledger/hive.go/runtime/options"
+)
+
+type TestFramework struct {
+	test        *testing.T
+	ConflictDAG *ConflictDAG[TestID, TestID, votes.MockedVotePower]
+	Weights     *sybilprotection.Weights
+
+	conflictsByAlias    map[string]*Conflict[TestID, TestID, votes.MockedVotePower]
+	conflictSetsByAlias map[string]*ConflictSet[TestID, TestID, votes.MockedVotePower]
+}
+
+// NewTestFramework creates a new instance of the TestFramework with one default output "Genesis" which has to be
+// consumed by the first transaction.
+func NewTestFramework(test *testing.T, opts ...options.Option[TestFramework]) *TestFramework {
+	return options.Apply(&TestFramework{
+		test:                test,
+		conflictsByAlias:    make(map[string]*Conflict[TestID, TestID, votes.MockedVotePower]),
+		conflictSetsByAlias: make(map[string]*ConflictSet[TestID, TestID, votes.MockedVotePower]),
+	}, opts, func(t *TestFramework) {
+		if t.Weights == nil {
+			t.Weights = sybilprotection.NewWeights(mapdb.NewMapDB())
+		}
+
+		if t.ConflictDAG == nil {
+			t.ConflictDAG = New[TestID, TestID, votes.MockedVotePower](acceptance.ThresholdProvider(t.Weights.TotalWeight))
+		}
+	})
+}
+
+func (t *TestFramework) CreateConflict(alias string, parentIDs []string, resourceAliases []string, initialWeight *weight.Weight) (*Conflict[TestID, TestID, votes.MockedVotePower], error) {
+	if err := t.ConflictDAG.CreateConflict(NewTestID(alias), t.ConflictIDs(parentIDs...), t.ConflictSetIDs(resourceAliases...), initialWeight); err != nil {
+		return nil, err
+	}
+
+	t.conflictsByAlias[alias] = lo.Return1(t.ConflictDAG.conflictsByID.Get(NewTestID(alias)))
+
+	for _, resourceAlias := range resourceAliases {
+		t.conflictSetsByAlias[resourceAlias] = lo.Return1(t.ConflictDAG.conflictSetsByID.Get(NewTestID(resourceAlias)))
+	}
+
+	return t.conflictsByAlias[alias], nil
+}
+
+func (t *TestFramework) ConflictIDs(aliases ...string) (conflictIDs []TestID) {
+	for _, alias := range aliases {
+		conflictIDs = append(conflictIDs, NewTestID(alias))
+	}
+
+	return conflictIDs
+}
+
+func (t *TestFramework) ConflictSetIDs(aliases ...string) (conflictSetIDs []TestID) {
+	for _, alias := range aliases {
+		conflictSetIDs = append(conflictSetIDs, NewTestID(alias))
+	}
+
+	return conflictSetIDs
+}
+
+func (t *TestFramework) Conflict(alias string) *Conflict[TestID, TestID, votes.MockedVotePower] {
+	conflict, ok := t.conflictsByAlias[alias]
+	if !ok {
+		panic(fmt.Sprintf("Conflict alias %s not registered", alias))
+	}
+
+	return conflict
+}
+
+func (t *TestFramework) ConflictSet(alias string) *ConflictSet[TestID, TestID, votes.MockedVotePower] {
+	conflictSet, ok := t.conflictSetsByAlias[alias]
+	if !ok {
+		panic(fmt.Sprintf("ConflictSet alias %s not registered", alias))
+	}
+
+	return conflictSet
+}
+
+func (t *TestFramework) Weight() *weight.Weight {
+	return weight.New(t.Weights)
+}
+
+func (t *TestFramework) UpdateConflictParents(conflictAlias string, addedParentID string, removedParentIDs ...string) bool {
+	return t.ConflictDAG.UpdateConflictParents(NewTestID(conflictAlias), NewTestID(addedParentID), t.ConflictIDs(removedParentIDs...)...)
+}
+
+func (t *TestFramework) JoinConflictSets(conflictAlias string, resourceAliases ...string) []*ConflictSet[TestID, TestID, votes.MockedVotePower] {
+	return lo.Values(t.ConflictDAG.JoinConflictSets(NewTestID(conflictAlias), t.ConflictSetIDs(resourceAliases...)...))
+}
+
+func (t *TestFramework) LikedInstead(conflictAliases ...string) []*Conflict[TestID, TestID, votes.MockedVotePower] {
+	return lo.Values(t.ConflictDAG.LikedInstead(t.ConflictIDs(conflictAliases...)...))
+}
+
+func (t *TestFramework) CastVotes(vote *vote.Vote[votes.MockedVotePower], conflictAliases ...string) error {
+	return t.ConflictDAG.CastVotes(vote, t.ConflictIDs(conflictAliases...)...)
+}
+
+func WithWeights(weights *sybilprotection.Weights) options.Option[TestFramework] {
+	return func(t *TestFramework) {
+		t.Weights = weights
+	}
+}
+
+type TestID struct {
+	utxo.TransactionID
+}
+
+func NewTestID(alias string) TestID {
+	hashedAlias := blake2b.Sum256([]byte(alias))
+
+	testID := utxo.NewTransactionID(hashedAlias[:])
+	testID.RegisterAlias(alias)
+
+	return TestID{testID}
+}
+
+func (id TestID) String() string {
+	return strings.Replace(id.TransactionID.String(), "TransactionID", "TestID", 1)
+}