Generalize expiry based de-duplication, dsmr

x/dsmr/assembler.go

@@ -57,7 +57,7 @@ func (b *BlockHandler[T, S, B, R]) Accept(ctx context.Context, block *Block) err
 	}
 
 	// Assemble and execute the block
-	innerBlock, result, state, err := b.Assembler.AssembleBlock(ctx, b.lastAcceptedState, b.lastAcceptedBlock, block.Timestamp, block.Height+1, txs)
+	innerBlock, result, state, err := b.Assembler.AssembleBlock(ctx, b.lastAcceptedState, b.lastAcceptedBlock, block.Tmstmp, block.Hght+1, txs)
 	if err != nil {
 		return err
 	}

x/dsmr/block.go

@@ -11,14 +11,14 @@
 
 	"github.com/ava-labs/hypersdk/codec"
 	"github.com/ava-labs/hypersdk/consts"
+	"github.com/ava-labs/hypersdk/internal/emap"
 	"github.com/ava-labs/hypersdk/utils"
 )
 
 const InitialChunkSize = 250 * 1024
 
 type Tx interface {
-	GetID() ids.ID
-	GetExpiry() int64
+	emap.Item
 	GetSponsor() codec.Address
 }
 
@@ -51,6 +51,14 @@
 	return nil
 }
 
+func (c Chunk[T]) GetID() ids.ID {
+	return c.id
+}
+
+func (c Chunk[T]) GetExpiry() int64 {
+	return c.Expiry
+}
+
 func signChunk[T Tx](
 	chunk UnsignedChunk[T],
 	networkID uint32,
@@ -106,9 +114,9 @@
 }
 
 type Block struct {
-	ParentID  ids.ID `serialize:"true"`
-	Height    uint64 `serialize:"true"`
-	Timestamp int64  `serialize:"true"`
+	ParentID ids.ID `serialize:"true"`
+	Hght     uint64 `serialize:"true"`
+	Tmstmp   int64  `serialize:"true"`
 
 	ChunkCerts []*ChunkCertificate `serialize:"true"`
 
@@ -119,3 +127,28 @@
 func (b Block) GetID() ids.ID {
 	return b.blkID
 }
+
+func (b Block) Parent() ids.ID {
+	return b.ParentID
+}
+
+func (b Block) Timestamp() int64 {
+	return b.Tmstmp
+}
+
+func (b Block) Height() uint64 {
+	return uint64(b.Hght)
+}
+
+func (b Block) Txs() []*ChunkCertificate {
+	return b.ChunkCerts
+}
+
+func (b Block) ContainsTx(id ids.ID) bool {
+	for _, c := range b.ChunkCerts {
+		if c.ChunkID == id {
+			return true
+		}
+	}
+	return false
+}

x/dsmr/certificate.go

@@ -54,7 +54,8 @@ type ChunkCertificate struct {
 	Signature NoVerifyChunkSignature `serialize:"true"`
 }
 
-func (c *ChunkCertificate) GetChunkID() ids.ID { return c.ChunkID }
+func (c ChunkCertificate) GetID() ids.ID    { return c.ChunkID }
+func (c ChunkCertificate) GetExpiry() int64 { return c.Expiry }
 
 func (c *ChunkCertificate) GetSlot() int64 { return c.Expiry }
 
@@ -209,7 +210,7 @@ func ParseWarpChunkCertificate(b []byte) (*WarpChunkCertificate, error) {
 	}, nil
 }
 
-func (c *WarpChunkCertificate) GetChunkID() ids.ID { return c.UnsignedCertificate.ChunkID() }
+func (c *WarpChunkCertificate) GetID() ids.ID { return c.UnsignedCertificate.ChunkID() }
 
 func (c *WarpChunkCertificate) GetSlot() int64 { return c.UnsignedCertificate.Slot() }
 

x/dsmr/node.go

@@ -14,12 +14,15 @@
 	"github.com/ava-labs/avalanchego/ids"
 	"github.com/ava-labs/avalanchego/network/p2p"
 	"github.com/ava-labs/avalanchego/network/p2p/acp118"
+	"github.com/ava-labs/avalanchego/trace"
 	"github.com/ava-labs/avalanchego/utils/crypto/bls"
+	"github.com/ava-labs/avalanchego/utils/logging"
 	"github.com/ava-labs/avalanchego/utils/wrappers"
 	"github.com/ava-labs/avalanchego/vms/platformvm/warp"
 
 	"github.com/ava-labs/hypersdk/codec"
 	"github.com/ava-labs/hypersdk/consts"
+	"github.com/ava-labs/hypersdk/internal/validitywindow"
 	"github.com/ava-labs/hypersdk/proto/pb/dsmr"
 	"github.com/ava-labs/hypersdk/utils"
 )
@@ -52,7 +55,7 @@
 		return nil, err
 	}
 
-	return &Node[T]{
+	node := &Node[T]{
 		nodeID:         nodeID,
 		networkID:      networkID,
 		chainID:        chainID,
@@ -80,25 +83,36 @@
 			storage: storage,
 		},
 		storage: storage,
-	}, nil
+		log:     logging.NewLogger("dsmr"),
+	}
+	node.tracer, err = trace.New(trace.Config{})
+	node.validityWindow = validitywindow.NewTimeValidityWindow(node.log, node.tracer, node)
+	return node, err
 }
 
-type Node[T Tx] struct {
-	nodeID                       ids.NodeID
-	networkID                    uint32
-	chainID                      ids.ID
-	pk                           *bls.PublicKey
-	signer                       warp.Signer
-	getChunkClient               *TypedClient[*dsmr.GetChunkRequest, Chunk[T], []byte]
-	getChunkSignatureClient      *TypedClient[*dsmr.GetChunkSignatureRequest, *dsmr.GetChunkSignatureResponse, []byte]
-	chunkCertificateGossipClient *TypedClient[[]byte, []byte, *dsmr.ChunkCertificateGossip]
-	validators                   []Validator
-
-	GetChunkHandler               *GetChunkHandler[T]
-	GetChunkSignatureHandler      *acp118.Handler
-	ChunkCertificateGossipHandler *ChunkCertificateGossipHandler[T]
-	storage                       *chunkStorage[T]
-}
+type (
+	timeValidityWindow = *validitywindow.TimeValidityWindow[*ChunkCertificate]
+
+	Node[T Tx] struct {
+		nodeID                       ids.NodeID
+		networkID                    uint32
+		chainID                      ids.ID
+		pk                           *bls.PublicKey
+		signer                       warp.Signer
+		getChunkClient               *TypedClient[*dsmr.GetChunkRequest, Chunk[T], []byte]
+		getChunkSignatureClient      *TypedClient[*dsmr.GetChunkSignatureRequest, *dsmr.GetChunkSignatureResponse, []byte]
+		chunkCertificateGossipClient *TypedClient[[]byte, []byte, *dsmr.ChunkCertificateGossip]
+		validators                   []Validator
+		validityWindow               timeValidityWindow
+
+		GetChunkHandler               *GetChunkHandler[T]
+		GetChunkSignatureHandler      *acp118.Handler
+		ChunkCertificateGossipHandler *ChunkCertificateGossipHandler[T]
+		storage                       *chunkStorage[T]
+		log                           logging.Logger
+		tracer                        trace.Tracer
+	}
+)
 
 // BuildChunk builds transactions into a Chunk
 // TODO handle frozen sponsor + validator assignments
@@ -172,29 +186,40 @@
 	return chunk, n.storage.AddLocalChunkWithCert(chunk, &chunkCert)
 }
 
-func (n *Node[T]) BuildBlock(parent Block, timestamp int64) (Block, error) {
-	if timestamp <= parent.Timestamp {
+const validityWindowDuration = int64(5)
+
+// BuildBlock(ctx context.Context, parentView state.View, parent *ExecutionBlock) (*ExecutionBlock, *ExecutedBlock, merkledb.View, error)
+func (n *Node[T]) BuildBlock(ctx context.Context, parent Block, timestamp int64) (Block, error) {
+	if timestamp <= parent.Tmstmp {
 		return Block{}, ErrTimestampNotMonotonicallyIncreasing
 	}
 
 	chunkCerts := n.storage.GatherChunkCerts()
+	oldestAllowed := timestamp - validityWindowDuration
+	if oldestAllowed < 0 {
+		oldestAllowed = 0
+	}
+	dup, err := n.validityWindow.IsRepeat(ctx, parent, chunkCerts, oldestAllowed)
+	if err != nil {
+		return Block{}, err
+	}
+
+	if dup.Len() == len(chunkCerts) {
+		return Block{}, ErrNoAvailableChunkCerts
+	}
+
 	availableChunkCerts := make([]*ChunkCertificate, 0)
-	for _, chunkCert := range chunkCerts {
-		// avoid building blocks with expired chunk certs
-		if chunkCert.Expiry < timestamp {
+	for i, chunkCert := range chunkCerts {
+		if dup.Contains(i) {
 			continue
 		}
-
 		availableChunkCerts = append(availableChunkCerts, chunkCert)
 	}
-	if len(availableChunkCerts) == 0 {
-		return Block{}, ErrNoAvailableChunkCerts
-	}
 
 	blk := Block{
 		ParentID:   parent.GetID(),
-		Height:     parent.Height + 1,
-		Timestamp:  timestamp,
+		Hght:       parent.Hght + 1,
+		Tmstmp:     timestamp,
 		ChunkCerts: availableChunkCerts,
 	}
 
@@ -208,9 +233,14 @@
 	return blk, nil
 }
 
-func (*Node[T]) Execute(ctx context.Context, _ Block, block Block) error {
+func (n *Node[T]) Execute(ctx context.Context, parentBlock Block, block Block) error {
 	// TODO: Verify header fields
-	// TODO: de-duplicate chunk certificates (internal to block and across history)
+
+	// Find repeats
+	if err := n.validityWindow.VerifyExpiryReplayProtection(ctx, block, parentBlock.Tmstmp); err != nil {
+		return err
+	}
+
 	for _, chunkCert := range block.ChunkCerts {
 		// TODO: verify chunks within a provided context
 		if err := chunkCert.Verify(ctx, struct{}{}); err != nil {
@@ -263,6 +293,12 @@
 			}
 		}
 	}
+	// update the validity window with the accepted block.
+	n.validityWindow.Accept(block)
+
+	return n.storage.SetMin(block.Tmstmp, chunkIDs)
+}
 
-	return n.storage.SetMin(block.Timestamp, chunkIDs)
+func (n *Node[T]) GetExecutionBlock(ctx context.Context, blkID ids.ID) (validitywindow.ExecutionBlock[*ChunkCertificate], error) {
+	return nil, nil
 }