Fixed tip counts for validator blocks so that the full amount of like…

… parents can be selected instead of 8. And add some more debug information

components/inx/server_issuance.go

@@ -11,7 +11,7 @@ import (
 )
 
 func (s *Server) RequestTips(_ context.Context, req *inx.TipsRequest) (*inx.TipsResponse, error) {
-	references := deps.Protocol.Engines.Main.Get().TipSelection.SelectTips(int(req.GetCount()))
+	references := deps.Protocol.Engines.Main.Get().TipSelection.SelectTips(int(req.GetCount()), int(req.GetCount()), int(req.GetCount()))
 
 	return &inx.TipsResponse{
 		StrongTips:      inx.NewBlockIds(references[iotago.StrongParentType]),

pkg/protocol/engine/blockdag/inmemoryblockdag/blockdag.go

@@ -211,9 +211,9 @@ func (b *BlockDAG) shouldAppend(modelBlock *model.Block) (shouldAppend bool, err
 // canAppendToParents determines if the Block references parents in a non-pruned slot. If a Block is found to violate
 // this condition but exists as a missing entry, we mark it as invalid.
 func (b *BlockDAG) canAppendToParents(modelBlock *model.Block) (parentsValid bool, err error) {
-	for _, parentID := range modelBlock.ProtocolBlock().Parents() {
-		if isBelowRange, isInRange := b.evictionState.BelowOrInActiveRootBlockRange(parentID); isBelowRange || isInRange && !b.evictionState.IsActiveRootBlock(parentID) {
-			return false, ierrors.Errorf("parent %s of block %s is too old", parentID, modelBlock.ID())
+	for _, parent := range modelBlock.ProtocolBlock().ParentsWithType() {
+		if isBelowRange, isInRange := b.evictionState.BelowOrInActiveRootBlockRange(parent.ID); isBelowRange || isInRange && !b.evictionState.IsActiveRootBlock(parent.ID) {
+			return false, ierrors.Errorf("parent %s with type %s of block %s is too old", parent.ID, parent.Type, modelBlock.ID())
 		}
 	}
 

pkg/protocol/engine/tipselection/tipselection.go

@@ -10,7 +10,7 @@ import (
 // TipSelection is a component that is used to abstract away the tip selection strategy, used to issuing new blocks.
 type TipSelection interface {
 	// SelectTips selects the tips that should be used as references for a new block.
-	SelectTips(count int) (references model.ParentReferences)
+	SelectTips(maxStrongParents int, maxLikedInsteadParents int, maxWeakParents int) (references model.ParentReferences)
 
 	// SetAcceptanceTime updates the acceptance time of the TipSelection.
 	SetAcceptanceTime(acceptanceTime time.Time) (previousTime time.Time)

pkg/protocol/engine/tipselection/v1/tip_selection.go

@@ -44,19 +44,6 @@ type TipSelection struct {
 	// acceptanceTime holds the current acceptance time.
 	acceptanceTime reactive.Variable[time.Time]
 
-	// optMaxStrongParents contains the maximum number of strong parents that are allowed.
-	optMaxStrongParents int
-
-	// optMaxLikedInsteadReferences contains the maximum number of liked instead references that are allowed.
-	optMaxLikedInsteadReferences int
-
-	// optMaxLikedInsteadReferencesPerParent contains the maximum number of liked instead references that are allowed
-	// per parent.
-	optMaxLikedInsteadReferencesPerParent int
-
-	// optMaxWeakReferences contains the maximum number of weak references that are allowed.
-	optMaxWeakReferences int
-
 	// livenessThresholdQueueMutex is used to synchronize access to the liveness threshold queue.
 	livenessThresholdQueueMutex syncutils.RWMutex
 
@@ -70,13 +57,9 @@ type TipSelection struct {
 // New is the constructor for the TipSelection.
 func New(subModule module.Module, opts ...options.Option[TipSelection]) *TipSelection {
 	return options.Apply(&TipSelection{
-		Module:                                subModule,
-		livenessThresholdQueue:                timed.NewPriorityQueue[tipmanager.TipMetadata](true),
-		acceptanceTime:                        reactive.NewVariable[time.Time](monotonicallyIncreasing),
-		optMaxStrongParents:                   8,
-		optMaxLikedInsteadReferences:          8,
-		optMaxLikedInsteadReferencesPerParent: 4,
-		optMaxWeakReferences:                  8,
+		Module:                 subModule,
+		livenessThresholdQueue: timed.NewPriorityQueue[tipmanager.TipMetadata](true),
+		acceptanceTime:         reactive.NewVariable[time.Time](monotonicallyIncreasing),
 	}, opts, func(t *TipSelection) {
 		t.ShutdownEvent().OnTrigger(func() {
 			t.StoppedEvent().Trigger()
@@ -108,35 +91,41 @@ func (t *TipSelection) Construct(tipManager tipmanager.TipManager, spendDAG spen
 }
 
 // SelectTips selects the tips that should be used as references for a new block.
-func (t *TipSelection) SelectTips(amount int) (references model.ParentReferences) {
+func (t *TipSelection) SelectTips(maxStrongParents int, maxLikedInsteadParents int, maxWeakParents int) (references model.ParentReferences) {
 	references = make(model.ParentReferences)
 	strongParents := ds.NewSet[iotago.BlockID]()
 	shallowLikesParents := ds.NewSet[iotago.BlockID]()
+	maxLikedInsteadReferencesPerParent := maxLikedInsteadParents / 2
+
 	_ = t.spendDAG.ReadConsistent(func(_ spenddag.ReadLockedSpendDAG[iotago.TransactionID, mempool.StateID, ledger.BlockVoteRank]) error {
 		previousLikedInsteadConflicts := ds.NewSet[iotago.TransactionID]()
 
 		if t.collectReferences(func(tip tipmanager.TipMetadata) {
-			addedLikedInsteadReferences, updatedLikedInsteadConflicts, err := t.likedInsteadReferences(previousLikedInsteadConflicts, tip)
+			addedLikedInsteadReferences, updatedLikedInsteadConflicts, err := t.likedInsteadReferences(maxLikedInsteadReferencesPerParent, previousLikedInsteadConflicts, tip)
 			if err != nil {
 				tip.TipPool().Set(tipmanager.WeakTipPool)
-			} else if len(addedLikedInsteadReferences) <= t.optMaxLikedInsteadReferences-len(references[iotago.ShallowLikeParentType]) {
+			} else if len(addedLikedInsteadReferences) <= maxLikedInsteadParents-len(references[iotago.ShallowLikeParentType]) {
 				references[iotago.StrongParentType] = append(references[iotago.StrongParentType], tip.ID())
 				references[iotago.ShallowLikeParentType] = append(references[iotago.ShallowLikeParentType], addedLikedInsteadReferences...)
 
 				shallowLikesParents.AddAll(ds.NewSet(addedLikedInsteadReferences...))
 				strongParents.Add(tip.ID())
 
 				previousLikedInsteadConflicts = updatedLikedInsteadConflicts
+			} else {
+				t.LogTrace("could not add liked instead references to tip", "tip", tip.ID(), "addedLikedInsteadReferences", addedLikedInsteadReferences)
 			}
 		}, func() int {
 			return len(references[iotago.StrongParentType])
 		},
 			// We select one validation tip as a strong parent. This is a security step to ensure that the tangle maintains
 			// acceptance by stitching together validation blocks.
 			types.NewTuple[func(optAmount ...int) []tipmanager.TipMetadata, int](t.tipManager.ValidationTips, 2),
-			types.NewTuple[func(optAmount ...int) []tipmanager.TipMetadata, int](t.tipManager.StrongTips, amount-2),
+			types.NewTuple[func(optAmount ...int) []tipmanager.TipMetadata, int](t.tipManager.StrongTips, maxStrongParents-2),
 		); len(references[iotago.StrongParentType]) == 0 {
-			references[iotago.StrongParentType] = iotago.BlockIDs{t.rootBlock()}
+			rootBlock := t.rootBlock()
+			t.LogDebug("no strong parents found, using root block as strong parent", "rootBlock", rootBlock)
+			references[iotago.StrongParentType] = iotago.BlockIDs{rootBlock}
 		}
 
 		t.collectReferences(func(tip tipmanager.TipMetadata) {
@@ -147,7 +136,7 @@ func (t *TipSelection) SelectTips(amount int) (references model.ParentReferences
 			}
 		}, func() int {
 			return len(references[iotago.WeakParentType])
-		}, types.NewTuple[func(optAmount ...int) []tipmanager.TipMetadata, int](t.tipManager.WeakTips, t.optMaxWeakReferences))
+		}, types.NewTuple[func(optAmount ...int) []tipmanager.TipMetadata, int](t.tipManager.WeakTips, maxWeakParents))
 
 		return nil
 	})
@@ -189,7 +178,7 @@ func (t *TipSelection) classifyTip(tipMetadata tipmanager.TipMetadata) {
 }
 
 // likedInsteadReferences returns the liked instead references that are required to be able to reference the given tip.
-func (t *TipSelection) likedInsteadReferences(likedConflicts ds.Set[iotago.TransactionID], tipMetadata tipmanager.TipMetadata) (references []iotago.BlockID, updatedLikedConflicts ds.Set[iotago.TransactionID], err error) {
+func (t *TipSelection) likedInsteadReferences(maxLikedInsteadReferencesPerParent int, likedConflicts ds.Set[iotago.TransactionID], tipMetadata tipmanager.TipMetadata) (references []iotago.BlockID, updatedLikedConflicts ds.Set[iotago.TransactionID], err error) {
 	necessaryReferences := make(map[iotago.TransactionID]iotago.BlockID)
 	if err = t.spendDAG.LikedInstead(tipMetadata.Block().SpenderIDs()).ForEach(func(likedSpenderID iotago.TransactionID) error {
 		transactionMetadata, exists := t.transactionMetadata(likedSpenderID)
@@ -211,7 +200,7 @@ func (t *TipSelection) likedInsteadReferences(likedConflicts ds.Set[iotago.Trans
 		}
 	}
 
-	if len(references) > t.optMaxLikedInsteadReferencesPerParent {
+	if len(references) > maxLikedInsteadReferencesPerParent {
 		return nil, nil, ierrors.Errorf("too many liked instead references (%d) for block %s", len(references), tipMetadata.ID())
 	}
 
@@ -309,28 +298,6 @@ func (t *TipSelection) resetAcceptanceTime() {
 	})
 }
 
-// WithMaxStrongParents is an option for the TipSelection that allows to configure the maximum number of strong parents.
-func WithMaxStrongParents(maxStrongParents int) options.Option[TipSelection] {
-	return func(tipManager *TipSelection) {
-		tipManager.optMaxStrongParents = maxStrongParents
-	}
-}
-
-// WithMaxLikedInsteadReferences is an option for the TipSelection that allows to configure the maximum number of liked
-// instead references.
-func WithMaxLikedInsteadReferences(maxLikedInsteadReferences int) options.Option[TipSelection] {
-	return func(tipManager *TipSelection) {
-		tipManager.optMaxLikedInsteadReferences = maxLikedInsteadReferences
-	}
-}
-
-// WithMaxWeakReferences is an option for the TipSelection that allows to configure the maximum number of weak references.
-func WithMaxWeakReferences(maxWeakReferences int) options.Option[TipSelection] {
-	return func(tipManager *TipSelection) {
-		tipManager.optMaxWeakReferences = maxWeakReferences
-	}
-}
-
 // monotonicallyIncreasing returns the maximum of the two given times which is used as a transformation function to make
 // the acceptance time of the TipSelection monotonically increasing.
 func monotonicallyIncreasing(currentTime time.Time, newTime time.Time) time.Time {

pkg/requesthandler/blocks.go

@@ -61,7 +61,7 @@ func (r *RequestHandler) BlockWithMetadataFromBlockID(blockID iotago.BlockID) (*
 }
 
 func (r *RequestHandler) BlockIssuance() (*api.IssuanceBlockHeaderResponse, error) {
-	references := r.protocol.Engines.Main.Get().TipSelection.SelectTips(iotago.BasicBlockMaxParents)
+	references := r.protocol.Engines.Main.Get().TipSelection.SelectTips(iotago.BasicBlockMaxParents, iotago.BasicBlockMaxParents, iotago.BasicBlockMaxParents)
 	if len(references[iotago.StrongParentType]) == 0 {
 		return nil, ierrors.WithMessage(echo.ErrServiceUnavailable, "no strong parents available")
 	}