Generalize expiry based de-duplication, dsmr

internal/validitywindow/validitywindow_test.go

@@ -0,0 +1,218 @@
+// Copyright (C) 2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package validitywindow
+
+import (
+	"context"
+	"testing"
+
+	"github.com/ava-labs/avalanchego/database"
+	"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"
+	"github.com/stretchr/testify/require"
+
+	"github.com/ava-labs/hypersdk/internal/validitywindow/validitywindowtest"
+)
+
+func TestValidityWindowVerifyExpiryReplayProtection(t *testing.T) {
+	tests := []struct {
+		Name          string
+		Accepted      []validitywindowtest.ExecutionBlock
+		VerifyBlock   validitywindowtest.ExecutionBlock
+		OldestAllowed int64
+		ExpectedError error
+	}{
+		{
+			Name: "no duplicate",
+			Accepted: []validitywindowtest.ExecutionBlock{
+				validitywindowtest.NewExecutionBlock(0, 0, 0),
+				validitywindowtest.NewExecutionBlock(1, 1, 1, 1, 2),
+			},
+			VerifyBlock:   validitywindowtest.NewExecutionBlock(2, 3, 3, 3),
+			OldestAllowed: 1,
+		},
+		{
+			Name: "expected duplicate",
+			Accepted: []validitywindowtest.ExecutionBlock{
+				validitywindowtest.NewExecutionBlock(0, 0, 0),
+				validitywindowtest.NewExecutionBlock(1, 1, 1, 1, 2),
+			},
+			VerifyBlock:   validitywindowtest.NewExecutionBlock(2, 3, 3, 2),
+			OldestAllowed: 1,
+			ExpectedError: ErrDuplicateContainer,
+		},
+		{
+			Name: "duplicate outside window",
+			Accepted: []validitywindowtest.ExecutionBlock{
+				validitywindowtest.NewExecutionBlock(0, 0, 0),
+				validitywindowtest.NewExecutionBlock(1, 1, 1, 1, 2),
+			},
+			VerifyBlock:   validitywindowtest.NewExecutionBlock(2, 3, 3, 2),
+			OldestAllowed: 2,
+			ExpectedError: nil,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.Name, func(t *testing.T) {
+			r := require.New(t)
+			r.NoError(nil)
+
+			chainIndex := &testChainIndex{}
+			tvw := NewTimeValidityWindow(&logging.NoLog{}, trace.Noop, chainIndex)
+			r.NotNil(tvw)
+			for _, acceptedBlk := range test.Accepted {
+				tvw.Accept(acceptedBlk)
+				chainIndex.set(acceptedBlk.GetID(), acceptedBlk)
+			}
+			r.ErrorIs(tvw.VerifyExpiryReplayProtection(context.Background(), test.VerifyBlock, test.OldestAllowed), test.ExpectedError)
+		})
+	}
+}
+
+func TestValidityWindowIsRepeat(t *testing.T) {
+	tests := []struct {
+		Name           string
+		Blocks         []validitywindowtest.ExecutionBlock
+		Accepted       uint64 // index into Blocks of the last accepted block.
+		ParentBlock    validitywindowtest.ExecutionBlock
+		Containers     []validitywindowtest.Container
+		OldestAllowewd int64
+		ExpectedError  error
+		ExpectedBits   set.Bits
+	}{
+		{
+			Name: "no containers",
+			Blocks: []validitywindowtest.ExecutionBlock{
+				validitywindowtest.NewExecutionBlock(0, 0, 0),
+				validitywindowtest.NewExecutionBlock(1, 1, 1, 1, 2),
+			},
+			Accepted:       1,
+			ParentBlock:    validitywindowtest.NewExecutionBlock(1, 1, 1, 1, 2),
+			Containers:     []validitywindowtest.Container{},
+			OldestAllowewd: 1,
+			ExpectedError:  nil,
+			ExpectedBits:   set.NewBits(),
+		},
+		{
+			Name: "no repeats",
+			Blocks: []validitywindowtest.ExecutionBlock{
+				validitywindowtest.NewExecutionBlock(0, 0, 0),
+				validitywindowtest.NewExecutionBlock(1, 1, 1, 1, 2),
+			},
+			Accepted:    1,
+			ParentBlock: validitywindowtest.NewExecutionBlock(2, 2, 2, 3),
+			Containers: []validitywindowtest.Container{
+				validitywindowtest.NewContainer(5),
+			},
+			OldestAllowewd: 0,
+			ExpectedError:  nil,
+			ExpectedBits:   set.NewBits(),
+		},
+		{
+			Name: "repeats outside validity window",
+			Blocks: []validitywindowtest.ExecutionBlock{
+				validitywindowtest.NewExecutionBlock(0, 0, 0),
+				validitywindowtest.NewExecutionBlock(1, 1, 1, 1, 2),
+			},
+			Accepted:    1,
+			ParentBlock: validitywindowtest.NewExecutionBlock(2, 2, 2, 3),
+			Containers: []validitywindowtest.Container{
+				validitywindowtest.NewContainer(1),
+			},
+			OldestAllowewd: 2,
+			ExpectedError:  nil,
+			ExpectedBits:   set.NewBits(),
+		},
+		{
+			Name: "repeats within latest accepted validity window block",
+			Blocks: []validitywindowtest.ExecutionBlock{
+				validitywindowtest.NewExecutionBlock(0, 0, 0),
+				validitywindowtest.NewExecutionBlock(1, 1, 1, 1, 2),
+			},
+			Accepted:    1,
+			ParentBlock: validitywindowtest.NewExecutionBlock(2, 2, 2, 3),
+			Containers: []validitywindowtest.Container{
+				validitywindowtest.NewContainer(1),
+			},
+			OldestAllowewd: 1,
+			ExpectedError:  nil,
+			ExpectedBits:   set.NewBits(0),
+		},
+		{
+			Name: "repeats after latest accepted block",
+			Blocks: []validitywindowtest.ExecutionBlock{
+				validitywindowtest.NewExecutionBlock(0, 0, 0),
+				validitywindowtest.NewExecutionBlock(1, 1, 1, 1),
+				validitywindowtest.NewExecutionBlock(2, 2, 2, 2),
+				validitywindowtest.NewExecutionBlock(3, 3, 3, 3),
+				validitywindowtest.NewExecutionBlock(4, 4, 4, 4),
+			},
+			Accepted:    1,
+			ParentBlock: validitywindowtest.NewExecutionBlock(5, 5, 5),
+			Containers: []validitywindowtest.Container{
+				validitywindowtest.NewContainer(3),
+			},
+			OldestAllowewd: 1,
+			ExpectedError:  nil,
+			ExpectedBits:   set.NewBits(0),
+		},
+		{
+			Name: "missing block in ancestery",
+			Blocks: []validitywindowtest.ExecutionBlock{
+				validitywindowtest.NewExecutionBlock(0, 0, 0),
+				validitywindowtest.NewExecutionBlock(1, 1, 1, 1),
+				validitywindowtest.NewExecutionBlock(2, 2, 2, 2),
+			},
+			Accepted:    1,
+			ParentBlock: validitywindowtest.NewExecutionBlock(5, 5, 5),
+			Containers: []validitywindowtest.Container{
+				validitywindowtest.NewContainer(3),
+			},
+			OldestAllowewd: 1,
+			ExpectedError:  database.ErrNotFound,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.Name, func(t *testing.T) {
+			r := require.New(t)
+			r.NoError(nil)
+
+			chainIndex := &testChainIndex{}
+			tvw := NewTimeValidityWindow(&logging.NoLog{}, trace.Noop, chainIndex)
+			r.NotNil(tvw)
+			for i, blk := range test.Blocks {
+				if i <= int(test.Accepted) {
+					tvw.Accept(blk)
+				}
+				chainIndex.set(blk.GetID(), blk)
+			}
+			bits, err := tvw.IsRepeat(context.Background(), test.ParentBlock, test.Containers, test.OldestAllowewd)
+			r.ErrorIs(err, test.ExpectedError)
+			if err == nil {
+				r.Equal(test.ExpectedBits.Bytes(), bits.Bytes())
+			}
+		})
+	}
+}
+
+// testing structures.
+type testChainIndex struct {
+	blocks map[ids.ID]ExecutionBlock[validitywindowtest.Container]
+}
+
+func (t testChainIndex) GetExecutionBlock(_ context.Context, blkID ids.ID) (ExecutionBlock[validitywindowtest.Container], error) {
+	if blk, ok := t.blocks[blkID]; ok {
+		return blk, nil
+	}
+	return nil, database.ErrNotFound
+}
+
+func (t *testChainIndex) set(blkID ids.ID, blk ExecutionBlock[validitywindowtest.Container]) {
+	if t.blocks == nil {
+		t.blocks = make(map[ids.ID]ExecutionBlock[validitywindowtest.Container])
+	}
+	t.blocks[blkID] = blk
+}

internal/validitywindow/validitywindowtest/container.go

@@ -0,0 +1,34 @@
+// Copyright (C) 2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package validitywindowtest
+
+import (
+	"github.com/ava-labs/avalanchego/ids"
+
+	"github.com/ava-labs/hypersdk/internal/emap"
+)
+
+var _ emap.Item = (*Container)(nil)
+
+type Container struct {
+	ID     ids.ID
+	Expiry int64
+}
+
+// method for returning an id of the item
+func (c Container) GetID() ids.ID {
+	return c.ID
+}
+
+// method for returning this items timestamp
+func (c Container) GetExpiry() int64 {
+	return c.Expiry
+}
+
+func NewContainer(expiry int64) Container {
+	return Container{
+		Expiry: expiry,
+		ID:     int64ToID(expiry),
+	}
+}

internal/validitywindow/validitywindowtest/executionblock.go

@@ -0,0 +1,66 @@
+// Copyright (C) 2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package validitywindowtest
+
+import (
+	"encoding/binary"
+
+	"github.com/ava-labs/avalanchego/ids"
+)
+
+type ExecutionBlock struct {
+	Prnt   ids.ID
+	Tmstmp int64
+	Hght   uint64
+	Ctrs   []Container
+	ID     ids.ID
+}
+
+func (e ExecutionBlock) GetID() ids.ID {
+	return e.ID
+}
+
+func (e ExecutionBlock) Parent() ids.ID {
+	return e.Prnt
+}
+
+func (e ExecutionBlock) Timestamp() int64 {
+	return e.Tmstmp
+}
+
+func (e ExecutionBlock) Height() uint64 {
+	return e.Hght
+}
+
+func (e ExecutionBlock) Containers() []Container {
+	return e.Ctrs
+}
+
+func (e ExecutionBlock) Contains(id ids.ID) bool {
+	for _, c := range e.Ctrs {
+		if c.GetID() == id {
+			return true
+		}
+	}
+	return false
+}
+
+func NewExecutionBlock(parent int64, timestamp int64, height uint64, contrainers ...int64) ExecutionBlock {
+	e := ExecutionBlock{
+		Prnt:   int64ToID(parent),
+		Tmstmp: timestamp,
+		Hght:   height,
+		ID:     int64ToID(parent + 1),
+	}
+	for _, c := range contrainers {
+		e.Ctrs = append(e.Ctrs, NewContainer(c))
+	}
+	return e
+}
+
+func int64ToID(n int64) ids.ID {
+	var id ids.ID
+	binary.LittleEndian.PutUint64(id[0:8], uint64(n))
+	return id
+}

x/dsmr/block.go

@@ -109,7 +109,8 @@ func ParseChunk[T Tx](chunkBytes []byte) (Chunk[T], error) {
 // validityWindowBlock bridge the gap between the dsmr's block implementation and the validity window's execution block interface.
 type validityWindowBlock struct {
 	Block
-	certs set.Set[ids.ID]
+	certs      set.Set[ids.ID]
+	chunkCerts []*emapChunkCertificate
 }
 
 func (e validityWindowBlock) Timestamp() int64 {
@@ -129,25 +130,24 @@ func (e validityWindowBlock) Parent() ids.ID {
 }
 
 func (e validityWindowBlock) Containers() []*emapChunkCertificate {
-	chunkCerts := make([]*emapChunkCertificate, len(e.Block.ChunkCerts))
-	for i := range chunkCerts {
-		chunkCerts[i] = &emapChunkCertificate{*e.Block.ChunkCerts[i]}
-	}
-	return chunkCerts
+	return e.chunkCerts
 }
 
 func NewValidityWindowBlock(innerBlock Block) validityWindowBlock {
 	certSet := set.Set[ids.ID]{}
-	for _, c := range innerBlock.ChunkCerts {
+	chunkCerts := make([]*emapChunkCertificate, len(innerBlock.ChunkCerts))
+	for i, c := range innerBlock.ChunkCerts {
 		certSet.Add(c.ChunkID)
+		chunkCerts[i] = &emapChunkCertificate{*c}
 	}
 	return validityWindowBlock{
-		Block: innerBlock,
-		certs: certSet,
+		Block:      innerBlock,
+		certs:      certSet,
+		chunkCerts: chunkCerts,
 	}
 }
 
-type Block struct {
+type BlockHeader struct {
 	ParentID  ids.ID `serialize:"true"`
 	Height    uint64 `serialize:"true"`
 	Timestamp int64  `serialize:"true"`