Generalize expiry based de-duplication, dsmr

chain/processor.go

@@ -53,23 +53,11 @@ func NewExecutionBlock(block *StatelessBlock) (*ExecutionBlock, error) {
 	}, nil
 }
 
-func (b *ExecutionBlock) ContainsTx(id ids.ID) bool {
+func (b *ExecutionBlock) Contains(id ids.ID) bool {
 	return b.txsSet.Contains(id)
 }
 
-func (b *ExecutionBlock) Height() uint64 {
-	return b.Hght
-}
-
-func (b *ExecutionBlock) Parent() ids.ID {
-	return b.Prnt
-}
-
-func (b *ExecutionBlock) Timestamp() int64 {
-	return b.Tmstmp
-}
-
-func (b *ExecutionBlock) Txs() []*Transaction {
+func (b *ExecutionBlock) GetContainers() []*Transaction {
 	return b.StatelessBlock.Txs
 }
 

chain/stateless_block.go

@@ -63,6 +63,9 @@ func (b *StatelessBlock) ID() ids.ID           { return b.id }
 func (b *StatelessBlock) Bytes() []byte        { return b.bytes }
 func (b *StatelessBlock) Size() int            { return len(b.bytes) }
 func (b *StatelessBlock) GetStateRoot() ids.ID { return b.StateRoot }
+func (b *StatelessBlock) GetHeight() uint64    { return b.Hght }
+func (b *StatelessBlock) GetTimestamp() int64  { return b.Tmstmp }
+func (b *StatelessBlock) GetParent() ids.ID    { return b.Prnt }
 
 func (b *StatelessBlock) String() string {
 	return fmt.Sprintf("(BlockID=%s, Height=%d, ParentRoot=%s, Size=%d)", b.id, b.Hght, b.Prnt, len(b.bytes))

internal/validitywindow/dependencies.go

@@ -12,11 +12,11 @@ import (
 )
 
 type ExecutionBlock[Container emap.Item] interface {
-	Parent() ids.ID
-	Timestamp() int64
-	Height() uint64
-	Txs() []Container
-	ContainsTx(ids.ID) bool
+	GetParent() ids.ID
+	GetTimestamp() int64
+	GetHeight() uint64
+	GetContainers() []Container
+	Contains(ids.ID) bool
 }
 
 type ChainIndex[Container emap.Item] interface {

internal/validitywindow/syncer.go

@@ -37,23 +37,23 @@ func (s *Syncer[Container]) start(ctx context.Context, lastAcceptedBlock Executi
 		parent             = s.initialBlock
 		parents            = []ExecutionBlock[Container]{parent}
 		seenValidityWindow = false
-		validityWindow     = s.getValidityWindow(lastAcceptedBlock.Timestamp())
+		validityWindow     = s.getValidityWindow(lastAcceptedBlock.GetTimestamp())
 		err                error
 	)
 	for {
-		parent, err = s.chainIndex.GetExecutionBlock(ctx, parent.Parent())
+		parent, err = s.chainIndex.GetExecutionBlock(ctx, parent.GetParent())
 		if err != nil {
 			break // If we can't fetch far enough back or we've gone past genesis, execute what we can
 		}
 		parents = append(parents, parent)
-		seenValidityWindow = lastAcceptedBlock.Timestamp()-parent.Timestamp() > validityWindow
+		seenValidityWindow = lastAcceptedBlock.GetTimestamp()-parent.GetTimestamp() > validityWindow
 		if seenValidityWindow {
 			break
 		}
 	}
 
 	s.initialBlock = parents[len(parents)-1]
-	if s.initialBlock.Height() == 0 {
+	if s.initialBlock.GetHeight() == 0 {
 		seenValidityWindow = true
 	}
 	for i := len(parents) - 1; i >= 0; i-- {
@@ -68,7 +68,7 @@ func (s *Syncer[Container]) Accept(ctx context.Context, blk ExecutionBlock[Conta
 	if s.initialBlock == nil {
 		return s.start(ctx, blk)
 	}
-	seenValidityWindow := blk.Timestamp()-s.initialBlock.Timestamp() > s.getValidityWindow(blk.Timestamp())
+	seenValidityWindow := blk.GetTimestamp()-s.initialBlock.GetTimestamp() > s.getValidityWindow(blk.GetTimestamp())
 	s.timeValidityWindow.Accept(blk)
 	return seenValidityWindow, nil
 }

internal/validitywindow/validitywindow.go

@@ -9,6 +9,7 @@ import (
 	"fmt"
 	"sync"
 
+	"github.com/ava-labs/avalanchego/ids"
 	"github.com/ava-labs/avalanchego/trace"
 	"github.com/ava-labs/avalanchego/utils/logging"
 	"github.com/ava-labs/avalanchego/utils/set"
@@ -43,32 +44,41 @@ func (v *TimeValidityWindow[Container]) Accept(blk ExecutionBlock[Container]) {
 	v.lock.Lock()
 	defer v.lock.Unlock()
 
-	evicted := v.seen.SetMin(blk.Timestamp())
+	evicted := v.seen.SetMin(blk.GetTimestamp())
 	v.log.Debug("txs evicted from seen", zap.Int("len", len(evicted)))
-	v.seen.Add(blk.Txs())
-	v.lastAcceptedBlockHeight = blk.Height()
+	v.seen.Add(blk.GetContainers())
+	v.lastAcceptedBlockHeight = blk.GetHeight()
 }
 
 func (v *TimeValidityWindow[Container]) VerifyExpiryReplayProtection(
 	ctx context.Context,
 	blk ExecutionBlock[Container],
 	oldestAllowed int64,
 ) error {
-	if blk.Height() <= v.lastAcceptedBlockHeight {
+	if blk.GetHeight() <= v.lastAcceptedBlockHeight {
 		return nil
 	}
-	parent, err := v.chainIndex.GetExecutionBlock(ctx, blk.Parent())
+	parent, err := v.chainIndex.GetExecutionBlock(ctx, blk.GetParent())
 	if err != nil {
 		return err
 	}
 
-	dup, err := v.isRepeat(ctx, parent, oldestAllowed, blk.Txs(), true)
+	dup, err := v.isRepeat(ctx, parent, oldestAllowed, blk.GetContainers(), true)
 	if err != nil {
 		return err
 	}
 	if dup.Len() > 0 {
 		return fmt.Errorf("%w: duplicate in ancestry", ErrDuplicateContainer)
 	}
+	// make sure we have no repeats within the block itself.
+	blkContainerIDs := set.NewSet[ids.ID](len(blk.GetContainers()))
+	for _, container := range blk.GetContainers() {
+		id := container.GetID()
+		if blkContainerIDs.Contains(id) {
+			return fmt.Errorf("%w: duplicate in block", ErrDuplicateContainer)
+		}
+		blkContainerIDs.Add(id)
+	}
 	return nil
 }
 
@@ -85,7 +95,7 @@ func (v *TimeValidityWindow[Container]) isRepeat(
 	ctx context.Context,
 	ancestorBlk ExecutionBlock[Container],
 	oldestAllowed int64,
-	txs []Container,
+	containers []Container,
 	stop bool,
 ) (set.Bits, error) {
 	marker := set.NewBits()
@@ -98,27 +108,27 @@ func (v *TimeValidityWindow[Container]) isRepeat(
 
 	var err error
 	for {
-		if ancestorBlk.Timestamp() < oldestAllowed {
+		if ancestorBlk.GetTimestamp() < oldestAllowed {
 			return marker, nil
 		}
 
-		if ancestorBlk.Height() <= v.lastAcceptedBlockHeight || ancestorBlk.Height() == 0 {
-			return v.seen.Contains(txs, marker, stop), nil
+		if ancestorBlk.GetHeight() <= v.lastAcceptedBlockHeight || ancestorBlk.GetHeight() == 0 {
+			return v.seen.Contains(containers, marker, stop), nil
 		}
 
-		for i, tx := range txs {
+		for i, container := range containers {
 			if marker.Contains(i) {
 				continue
 			}
-			if ancestorBlk.ContainsTx(tx.GetID()) {
+			if ancestorBlk.Contains(container.GetID()) {
 				marker.Add(i)
 				if stop {
 					return marker, nil
 				}
 			}
 		}
 
-		ancestorBlk, err = v.chainIndex.GetExecutionBlock(ctx, ancestorBlk.Parent())
+		ancestorBlk, err = v.chainIndex.GetExecutionBlock(ctx, ancestorBlk.GetParent())
 		if err != nil {
 			return marker, err
 		}