Rewrite ConflictDAG

client/evilwallet/connector.go

@@ -183,7 +183,7 @@ type Client interface {
 	GetUnspentOutputForAddress(addr devnetvm.Address) *jsonmodels.WalletOutput
 	// GetAddressUnspentOutputs gets the unspent outputs of an address.
 	GetAddressUnspentOutputs(address string) (outputIDs []utxo.OutputID, err error)
-	// GetTransactionConfirmationState returns the ConfirmationState of a given transaction ID.
+	// GetTransactionConfirmationState returns the AcceptanceState of a given transaction ID.
 	GetTransactionConfirmationState(txID string) confirmation.State
 	// GetOutput gets the output of a given outputID.
 	GetOutput(outputID utxo.OutputID) devnetvm.Output
@@ -338,7 +338,7 @@ func (c *WebClient) GetOutput(outputID utxo.OutputID) devnetvm.Output {
 	return output
 }
 
-// GetTransactionConfirmationState returns the ConfirmationState of a given transaction ID.
+// GetTransactionConfirmationState returns the AcceptanceState of a given transaction ID.
 func (c *WebClient) GetTransactionConfirmationState(txID string) confirmation.State {
 	resp, err := c.api.GetTransactionMetadata(txID)
 	if err != nil {

client/wallet/webconnector.go

@@ -118,7 +118,7 @@ func (webConnector WebConnector) SendTransaction(tx *devnetvm.Transaction) (err
 	return
 }
 
-// GetTransactionConfirmationState fetches the ConfirmationState of the transaction.
+// GetTransactionConfirmationState fetches the AcceptanceState of the transaction.
 func (webConnector WebConnector) GetTransactionConfirmationState(txID utxo.TransactionID) (confirmationState confirmation.State, err error) {
 	txmeta, err := webConnector.client.GetTransactionMetadata(txID.Base58())
 	if err != nil {

packages/app/blockissuer/blockfactory/referenceprovider.go

@@ -1,17 +1,20 @@
 package blockfactory
 
 import (
-	"fmt"
 	"time"
 
 	"github.com/pkg/errors"
+	"golang.org/x/xerrors"
 
 	"github.com/iotaledger/goshimmer/packages/protocol"
+	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/mempool/conflictdag"
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/utxo"
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/tangle/booker"
 	"github.com/iotaledger/goshimmer/packages/protocol/models"
 	"github.com/iotaledger/goshimmer/packages/protocol/models/payload"
 	"github.com/iotaledger/hive.go/core/slot"
+	"github.com/iotaledger/hive.go/ds/advancedset"
+	"github.com/iotaledger/hive.go/lo"
 )
 
 // region ReferenceProvider ////////////////////////////////////////////////////////////////////////////////////////////
@@ -39,58 +42,59 @@ func (r *ReferenceProvider) References(payload payload.Payload, strongParents mo
 
 	excludedConflictIDs := utxo.NewTransactionIDs()
 
-	r.protocol.Engine().Ledger.MemPool().ConflictDAG().WeightsMutex.Lock()
-	defer r.protocol.Engine().Ledger.MemPool().ConflictDAG().WeightsMutex.Unlock()
+	err = r.protocol.Engine().Ledger.MemPool().ConflictDAG().ReadConsistent(func(conflictDAG conflictdag.ReadLockedConflictDAG[utxo.TransactionID, utxo.OutputID, models.BlockVotePower]) error {
+		for strongParent := range strongParents {
+			excludedConflictIDsCopy := excludedConflictIDs.Clone()
+			referencesToAdd, validStrongParent := r.addedReferencesForBlock(strongParent, excludedConflictIDsCopy, conflictDAG)
+			if !validStrongParent {
+				if !r.payloadLiked(strongParent, conflictDAG) {
+					continue
+				}
 
-	for strongParent := range strongParents {
-		excludedConflictIDsCopy := excludedConflictIDs.Clone()
-		referencesToAdd, validStrongParent := r.addedReferencesForBlock(strongParent, excludedConflictIDsCopy)
-		if !validStrongParent {
-			if !r.payloadLiked(strongParent) {
-				continue
+				referencesToAdd = models.NewParentBlockIDs().Add(models.WeakParentType, strongParent)
+			} else {
+				referencesToAdd.AddStrong(strongParent)
 			}
 
-			referencesToAdd = models.NewParentBlockIDs().Add(models.WeakParentType, strongParent)
-		} else {
-			referencesToAdd.AddStrong(strongParent)
+			if combinedReferences, success := r.tryExtendReferences(references, referencesToAdd); success {
+				references = combinedReferences
+				excludedConflictIDs = excludedConflictIDsCopy
+			}
 		}
 
-		if combinedReferences, success := r.tryExtendReferences(references, referencesToAdd); success {
-			references = combinedReferences
-			excludedConflictIDs = excludedConflictIDsCopy
+		if len(references[models.StrongParentType]) == 0 {
+			return errors.Errorf("none of the provided strong parents can be referenced. Strong parents provided: %+v.", strongParents)
 		}
-	}
 
-	if len(references[models.StrongParentType]) == 0 {
-		return nil, errors.Errorf("none of the provided strong parents can be referenced. Strong parents provided: %+v.", strongParents)
-	}
+		// This should be liked anyway, or at least it should be corrected by shallow like if we spend.
+		// If a node spends something it doesn't like, then the payload is invalid as well.
+		weakReferences, likeInsteadReferences, err := r.referencesFromUnacceptedInputs(payload, excludedConflictIDs, conflictDAG)
+		if err != nil {
+			return errors.Wrapf(err, "failed to create references for unnaccepted inputs")
+		}
 
-	// This should be liked anyway, or at least it should be corrected by shallow like if we spend.
-	// If a node spends something it doesn't like, then the payload is invalid as well.
-	weakReferences, likeInsteadReferences, err := r.referencesFromUnacceptedInputs(payload, excludedConflictIDs)
-	if err != nil {
-		return nil, errors.Wrapf(err, "failed to create references for unnaccepted inputs")
-	}
+		references.AddAll(models.WeakParentType, weakReferences)
+		references.AddAll(models.ShallowLikeParentType, likeInsteadReferences)
 
-	references.AddAll(models.WeakParentType, weakReferences)
-	references.AddAll(models.ShallowLikeParentType, likeInsteadReferences)
+		// Include censored, pending conflicts if there are free weak parent spots.
+		references.AddAll(models.WeakParentType, r.referencesToMissingConflicts(models.MaxParentsCount-len(references[models.WeakParentType]), conflictDAG))
 
-	// Include censored, pending conflicts if there are free weak parent spots.
-	references.AddAll(models.WeakParentType, r.referencesToMissingConflicts(models.MaxParentsCount-len(references[models.WeakParentType])))
+		// Make sure that there's no duplicate between strong and weak parents.
+		references.CleanupReferences()
 
-	// Make sure that there's no duplicate between strong and weak parents.
-	references.CleanupReferences()
+		return nil
+	})
 
-	return references, nil
+	return references, err
 }
 
-func (r *ReferenceProvider) referencesToMissingConflicts(amount int) (blockIDs models.BlockIDs) {
+func (r *ReferenceProvider) referencesToMissingConflicts(amount int, conflictDAG conflictdag.ReadLockedConflictDAG[utxo.TransactionID, utxo.OutputID, models.BlockVotePower]) (blockIDs models.BlockIDs) {
 	blockIDs = models.NewBlockIDs()
 	if amount == 0 {
 		return blockIDs
 	}
 
-	for it := r.protocol.TipManager.TipsConflictTracker.MissingConflicts(amount).Iterator(); it.HasNext(); {
+	for it := r.protocol.TipManager.TipsConflictTracker.MissingConflicts(amount, conflictDAG).Iterator(); it.HasNext(); {
 		conflictID := it.Next()
 
 		// TODO: make sure that timestamp monotonicity is not broken
@@ -113,7 +117,7 @@ func (r *ReferenceProvider) referencesToMissingConflicts(amount int) (blockIDs m
 	return blockIDs
 }
 
-func (r *ReferenceProvider) referencesFromUnacceptedInputs(payload payload.Payload, excludedConflictIDs utxo.TransactionIDs) (weakParents models.BlockIDs, likeInsteadParents models.BlockIDs, err error) {
+func (r *ReferenceProvider) referencesFromUnacceptedInputs(payload payload.Payload, excludedConflictIDs utxo.TransactionIDs, conflictDAG conflictdag.ReadLockedConflictDAG[utxo.TransactionID, utxo.OutputID, models.BlockVotePower]) (weakParents models.BlockIDs, likeInsteadParents models.BlockIDs, err error) {
 	weakParents = models.NewBlockIDs()
 	likeInsteadParents = models.NewBlockIDs()
 
@@ -155,7 +159,7 @@ func (r *ReferenceProvider) referencesFromUnacceptedInputs(payload payload.Paylo
 					continue
 				}
 
-				if adjust, referencedBlk, referenceErr := r.adjustOpinion(transactionConflictID, excludedConflictIDs); referenceErr != nil {
+				if adjust, referencedBlk, referenceErr := r.adjustOpinion(transactionConflictID, excludedConflictIDs, conflictDAG); referenceErr != nil {
 					return nil, nil, errors.Wrapf(referenceErr, "failed to correct opinion for weak parent with unaccepted output %s", referencedTransactionID)
 				} else if adjust {
 					if referencedBlk != models.EmptyBlockID {
@@ -174,7 +178,7 @@ func (r *ReferenceProvider) referencesFromUnacceptedInputs(payload payload.Paylo
 }
 
 // addedReferenceForBlock returns the reference that is necessary to correct our opinion on the given block.
-func (r *ReferenceProvider) addedReferencesForBlock(blockID models.BlockID, excludedConflictIDs utxo.TransactionIDs) (addedReferences models.ParentBlockIDs, success bool) {
+func (r *ReferenceProvider) addedReferencesForBlock(blockID models.BlockID, excludedConflictIDs utxo.TransactionIDs, conflictDAG conflictdag.ReadLockedConflictDAG[utxo.TransactionID, utxo.OutputID, models.BlockVotePower]) (addedReferences models.ParentBlockIDs, success bool) {
 	engineInstance := r.protocol.Engine()
 
 	block, exists := engineInstance.Tangle.Booker().Block(blockID)
@@ -189,27 +193,27 @@ func (r *ReferenceProvider) addedReferencesForBlock(blockID models.BlockID, excl
 	}
 
 	var err error
-	if addedReferences, err = r.addedReferencesForConflicts(blockConflicts, excludedConflictIDs); err != nil {
+	if addedReferences, err = r.addedReferencesForConflicts(blockConflicts, excludedConflictIDs, conflictDAG); err != nil {
 		// Delete the tip if we could not pick it up.
 		if schedulerBlock, schedulerBlockExists := r.protocol.CongestionControl.Scheduler().Block(blockID); schedulerBlockExists {
-			r.protocol.TipManager.DeleteTip(schedulerBlock)
+			r.protocol.TipManager.InvalidateTip(schedulerBlock)
 		}
 		return nil, false
 	}
 
-	// We could not refer to any block to fix the opinion, so we add the tips' strong parents to the tip pool.
-	if addedReferences == nil {
-		if block, exists := r.protocol.Engine().Tangle.Booker().Block(blockID); exists {
-			block.ForEachParentByType(models.StrongParentType, func(parentBlockID models.BlockID) bool {
-				if schedulerBlock, schedulerBlockExists := r.protocol.CongestionControl.Scheduler().Block(parentBlockID); schedulerBlockExists {
-					r.protocol.TipManager.AddTipNonMonotonic(schedulerBlock)
-				}
-				return true
-			})
-		}
-		fmt.Println(">> could not fix opinion", blockID)
-		return nil, false
-	}
+	//// We could not refer to any block to fix the opinion, so we add the tips' strong parents to the tip pool.
+	//if addedReferences == nil {
+	//	if block, exists := r.protocol.Engine().Tangle.Booker().Block(blockID); exists {
+	//		block.ForEachParentByType(models.StrongParentType, func(parentBlockID models.BlockID) bool {
+	//			if schedulerBlock, schedulerBlockExists := r.protocol.CongestionControl.Scheduler().Block(parentBlockID); schedulerBlockExists {
+	//				r.protocol.TipManager.AddTipNonMonotonic(schedulerBlock)
+	//			}
+	//			return true
+	//		})
+	//	}
+	//	fmt.Println(">> could not fix opinion", blockID)
+	//	return nil, false
+	//}
 
 	// A block might introduce too many references and cannot be picked up as a strong parent.
 	if _, success = r.tryExtendReferences(models.NewParentBlockIDs(), addedReferences); !success {
@@ -220,7 +224,7 @@ func (r *ReferenceProvider) addedReferencesForBlock(blockID models.BlockID, excl
 }
 
 // addedReferencesForConflicts returns the references that are necessary to correct our opinion on the given conflicts.
-func (r *ReferenceProvider) addedReferencesForConflicts(conflictIDs utxo.TransactionIDs, excludedConflictIDs utxo.TransactionIDs) (referencesToAdd models.ParentBlockIDs, err error) {
+func (r *ReferenceProvider) addedReferencesForConflicts(conflictIDs utxo.TransactionIDs, excludedConflictIDs utxo.TransactionIDs, conflictDAG conflictdag.ReadLockedConflictDAG[utxo.TransactionID, utxo.OutputID, models.BlockVotePower]) (referencesToAdd models.ParentBlockIDs, err error) {
 	referencesToAdd = models.NewParentBlockIDs()
 
 	for it := conflictIDs.Iterator(); it.HasNext(); {
@@ -231,45 +235,49 @@ func (r *ReferenceProvider) addedReferencesForConflicts(conflictIDs utxo.Transac
 			continue
 		}
 
-		if adjust, referencedBlk, referenceErr := r.adjustOpinion(conflictID, excludedConflictIDs); referenceErr != nil {
+		adjust, referencedBlk, referenceErr := r.adjustOpinion(conflictID, excludedConflictIDs, conflictDAG)
+		if referenceErr != nil {
 			return nil, errors.Wrapf(referenceErr, "failed to create reference for %s", conflictID)
-		} else if adjust {
-			if referencedBlk != models.EmptyBlockID {
-				referencesToAdd.Add(models.ShallowLikeParentType, referencedBlk)
-			} else {
-				// We could not find a block that we could reference to fix this strong parent, but we don't want to delete the tip.
-				return nil, nil
-			}
+		}
+
+		if adjust {
+			referencesToAdd.Add(models.ShallowLikeParentType, referencedBlk)
 		}
 	}
 
 	return referencesToAdd, nil
 }
 
 // adjustOpinion returns the reference that is necessary to correct our opinion on the given conflict.
-func (r *ReferenceProvider) adjustOpinion(conflictID utxo.TransactionID, excludedConflictIDs utxo.TransactionIDs) (adjust bool, attachmentID models.BlockID, err error) {
+func (r *ReferenceProvider) adjustOpinion(conflictID utxo.TransactionID, excludedConflictIDs utxo.TransactionIDs, conflictDAG conflictdag.ReadLockedConflictDAG[utxo.TransactionID, utxo.OutputID, models.BlockVotePower]) (adjust bool, attachmentID models.BlockID, err error) {
 	engineInstance := r.protocol.Engine()
 
-	likedConflictID, dislikedConflictIDs := engineInstance.Consensus.ConflictResolver().AdjustOpinion(conflictID)
-
+	likedConflictID := conflictDAG.LikedInstead(advancedset.New(conflictID))
+	// if likedConflictID is empty, then conflictID is liked and doesn't need to be corrected
 	if likedConflictID.IsEmpty() {
-		// TODO: make conflictset and conflict creation atomic to always prevent this.
-		return false, models.EmptyBlockID, errors.Errorf("likedConflictID empty when trying to adjust opinion for %s", conflictID)
-	}
-
-	if likedConflictID == conflictID {
 		return false, models.EmptyBlockID, nil
 	}
 
-	attachment, err := r.latestValidAttachment(likedConflictID)
-	// TODO: make sure that timestamp monotonicity is held
-	if err != nil {
+	if err = likedConflictID.ForEach(func(likedConflictID utxo.TransactionID) (err error) {
+		attachment, err := r.latestValidAttachment(likedConflictID)
+		// TODO: make sure that timestamp monotonicity is held
+		if err != nil {
+			return err
+		}
+
+		attachmentID = attachment.ID()
+
+		excludedConflictIDs.AddAll(engineInstance.Ledger.MemPool().Utils().ConflictIDsInFutureCone(lo.Return1(conflictDAG.ConflictingConflicts(likedConflictID))))
+
+		return nil
+	}); err != nil {
 		return false, models.EmptyBlockID, err
 	}
 
-	excludedConflictIDs.AddAll(engineInstance.Ledger.MemPool().Utils().ConflictIDsInFutureCone(dislikedConflictIDs))
-
-	return true, attachment.ID(), nil
+	if attachmentID == models.EmptyBlockID {
+		return false, attachmentID, xerrors.Errorf("could not find attachment to fix conflict %s", conflictID)
+	}
+	return true, attachmentID, nil
 }
 
 // latestValidAttachment returns the first valid attachment of the given transaction.
@@ -291,21 +299,16 @@ func (r *ReferenceProvider) latestValidAttachment(txID utxo.TransactionID) (bloc
 }
 
 // payloadLiked checks if the payload of a Block is liked.
-func (r *ReferenceProvider) payloadLiked(blockID models.BlockID) (liked bool) {
+func (r *ReferenceProvider) payloadLiked(blockID models.BlockID, conflictDAG conflictdag.ReadLockedConflictDAG[utxo.TransactionID, utxo.OutputID, models.BlockVotePower]) (liked bool) {
 	engineInstance := r.protocol.Engine()
 
 	block, exists := engineInstance.Tangle.Booker().Block(blockID)
 	if !exists {
 		return false
 	}
-	conflictIDs := engineInstance.Tangle.Booker().TransactionConflictIDs(block)
 
-	for it := conflictIDs.Iterator(); it.HasNext(); {
-		conflict, exists := engineInstance.Ledger.MemPool().ConflictDAG().Conflict(it.Next())
-		if !exists {
-			continue
-		}
-		if !engineInstance.Consensus.ConflictResolver().ConflictLiked(conflict) {
+	for conflicts := engineInstance.Tangle.Booker().TransactionConflictIDs(block).Iterator(); conflicts.HasNext(); {
+		if !conflictDAG.LikedInstead(advancedset.New(conflicts.Next())).IsEmpty() {
 			return false
 		}
 	}

packages/app/jsonmodels/ledgerstate.go

@@ -2,14 +2,14 @@
 
 import (
 	"encoding/json"
+	"github.com/iotaledger/hive.go/ds/advancedset"
 	"time"
 
 	"github.com/mr-tron/base58"
 	"github.com/pkg/errors"
 
 	"github.com/iotaledger/goshimmer/packages/core/confirmation"
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/mempool"
-	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/mempool/conflictdag"
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/utxo"
 	"github.com/iotaledger/goshimmer/packages/protocol/engine/ledger/vm/devnetvm"
 	"github.com/iotaledger/goshimmer/packages/typeutils"
@@ -531,21 +531,21 @@
 }
 
 // NewConflictWeight returns a Conflict from the given ledger.Conflict.
-func NewConflictWeight(conflict *conflictdag.Conflict[utxo.TransactionID, utxo.OutputID], confirmationState confirmation.State, aw int64) ConflictWeight {
+func NewConflictWeight(conflictID utxo.TransactionID, conflictParentsIDs *advancedset.AdvancedSet[utxo.TransactionID], conflictSets *advancedset.AdvancedSet[utxo.OutputID], confirmationState confirmation.State, aw int64) ConflictWeight {
 	return ConflictWeight{
-		ID: conflict.ID().Base58(),
+		ID: conflictID.Base58(),
 		Parents: func() []string {
 			parents := make([]string, 0)
-			for it := conflict.Parents().Iterator(); it.HasNext(); {
+			for it := conflictParentsIDs.Iterator(); it.HasNext(); {
 				parents = append(parents, it.Next().Base58())
 			}
 
 			return parents
 		}(),
 		ConflictIDs: func() []string {
 			conflictIDs := make([]string, 0)
-			for it := conflict.ConflictSets().Iterator(); it.HasNext(); {
-				conflictIDs = append(conflictIDs, it.Next().ID().Base58())
+			for it := conflictSets.Iterator(); it.HasNext(); {
+				conflictIDs = append(conflictIDs, it.Next().Base58())
 			}
 
 			return conflictIDs
@@ -563,9 +563,9 @@
 }
 
 // NewChildConflict returns a ChildConflict from the given ledger.ChildConflict.
-func NewChildConflict(childConflict *conflictdag.Conflict[utxo.TransactionID, utxo.OutputID]) *ChildConflict {
+func NewChildConflict(childConflictID utxo.TransactionID) *ChildConflict {
 	return &ChildConflict{
-		ConflictID: childConflict.ID().Base58(),
+		ConflictID: childConflictID.Base58(),
 	}
 }