Add EIP7736 support

benchs/main.go

@@ -49,7 +49,7 @@ func benchmarkInsertInExisting() {
 		for i := 0; i < 5; i++ {
 			root := verkle.New()
 			for _, k := range keys {
-				if err := root.Insert(k, value, nil); err != nil {
+				if err := root.Insert(k, value, 0, nil); err != nil {
 					panic(err)
 				}
 			}
@@ -58,7 +58,7 @@ func benchmarkInsertInExisting() {
 			// Now insert the 10k leaves and measure time
 			start := time.Now()
 			for _, k := range toInsertKeys {
-				if err := root.Insert(k, value, nil); err != nil {
+				if err := root.Insert(k, value, 0, nil); err != nil {
 					panic(err)
 				}
 			}

config.go

@@ -35,6 +35,7 @@ const (
 	NodeWidth          = 256
 	NodeBitWidth  byte = 8
 	StemSize           = 31
+	periodSize         = 2
 )
 
 func equalPaths(key1, key2 []byte) bool {

conversion.go

@@ -45,7 +45,7 @@ func BatchNewLeafNode(nodesValues []BatchNewLeafNodeData) ([]LeafNode, error) {
 					}
 
 					var leaf *LeafNode
-					leaf, err := NewLeafNode(nv.Stem, valsslice)
+					leaf, err := NewLeafNode(nv.Stem, valsslice, 0)
 					if err != nil {
 						return err
 					}
@@ -192,7 +192,7 @@ func (n *InternalNode) insertMigratedLeavesSubtree(leaves []LeafNode, resolver N
 					}
 				}
 
-				if err := node.updateMultipleLeaves(nonPresentValues); err != nil {
+				if err := node.updateMultipleLeaves(nonPresentValues, 0); err != nil {
 					return fmt.Errorf("updating leaves: %s", err)
 				}
 				continue

debug.go

@@ -39,8 +39,14 @@ type (
 		Stem   Stem     `json:"stem"`
 		Values [][]byte `json:"values"`
 
-		C  [32]byte `json:"commitment"`
-		C1 [32]byte `json:"c1"`
-		C2 [32]byte `json:"c2"`
+		C      [32]byte        `json:"commitment"`
+		C1     [32]byte        `json:"c1"`
+		C2     [32]byte        `json:"c2"`
+		Period StatePeriod 	   `json:"period"`
+	}
+
+	ExportableExpiredLeafNode struct {
+		Stem       Stem     `json:"stem"`
+		Commitment [32]byte `json:"commitment"`
 	}
 )

debug_test.go

@@ -33,16 +33,16 @@ func TestJSON(t *testing.T) {
 	t.Parallel()
 
 	root := New()
-	if err := root.Insert(zeroKeyTest, fourtyKeyTest, nil); err != nil {
+	if err := root.Insert(zeroKeyTest, fourtyKeyTest, 0, nil); err != nil {
 		t.Fatal(err)
 	}
-	if err := root.Insert(oneKeyTest, zeroKeyTest, nil); err != nil {
+	if err := root.Insert(oneKeyTest, zeroKeyTest, 0, nil); err != nil {
 		t.Fatal(err)
 	}
-	if err := root.Insert(forkOneKeyTest, zeroKeyTest, nil); err != nil { // Force an internal node in the first layer.
+	if err := root.Insert(forkOneKeyTest, zeroKeyTest, 0, nil); err != nil { // Force an internal node in the first layer.
 		t.Fatal(err)
 	}
-	if err := root.Insert(fourtyKeyTest, oneKeyTest, nil); err != nil {
+	if err := root.Insert(fourtyKeyTest, oneKeyTest, 0, nil); err != nil {
 		t.Fatal(err)
 	}
 	root.(*InternalNode).children[152] = HashedNode{}

doc.go

@@ -38,6 +38,13 @@ var (
 	errUnknownNodeType        = errors.New("unknown node type detected")
 	errMissingNodeInStateless = errors.New("trying to access a node that is missing from the stateless view")
 	errIsPOAStub              = errors.New("trying to read/write a proof of absence leaf node")
+	errExpired                = errors.New("trying to access an expired leaf node")
+	errExpiredPruned           = errors.New("leaf node is expired and pruned")
+	errReviveCommitmentMismatch = errors.New("commitment mismatch in revive")
+	errReviveValuesMismatch   	= errors.New("values mismatch in revive")
+	errReviveStemMismatch    	= errors.New("stem mismatch in revive")
+	errRevivePeriodMismatch 	= errors.New("period mismatch in revive")
+	errRevivePeriodOlderThanNew = errors.New("revive old period is older than the new period")
 )
 
 const (

empty.go

@@ -31,18 +31,22 @@ type Empty struct{}
 
 var errDirectInsertIntoEmptyNode = errors.New("an empty node should not be inserted directly into")
 
-func (Empty) Insert([]byte, []byte, NodeResolverFn) error {
+func (Empty) Insert([]byte, []byte, StatePeriod, NodeResolverFn) error {
 	return errDirectInsertIntoEmptyNode
 }
 
-func (Empty) Delete([]byte, NodeResolverFn) (bool, error) {
+func (Empty) Delete([]byte, StatePeriod, NodeResolverFn) (bool, error) {
 	return false, errors.New("cant delete an empty node")
 }
 
-func (Empty) Get([]byte, NodeResolverFn) ([]byte, error) {
+func (Empty) Get([]byte, StatePeriod, NodeResolverFn) ([]byte, error) {
 	return nil, nil
 }
 
+func (Empty) Revive(Stem, [][]byte, StatePeriod, StatePeriod, bool, NodeResolverFn) error {
+	return errors.New("cannot revive an empty node")
+}
+
 func (n Empty) Commit() *Point {
 	return n.Commitment()
 }
@@ -53,8 +57,8 @@ func (Empty) Commitment() *Point {
 	return &id
 }
 
-func (Empty) GetProofItems(keylist, NodeResolverFn) (*ProofElements, []byte, []Stem, error) {
-	return nil, nil, nil, errors.New("trying to produce a commitment for an empty subtree")
+func (Empty) GetProofItems(keylist, NodeResolverFn) (*ProofElements, []byte, []Stem, []StatePeriod, error) {
+	return nil, nil, nil, nil, errors.New("trying to produce a commitment for an empty subtree")
 }
 
 func (Empty) Serialize() ([]byte, error) {

empty_test.go

@@ -31,15 +31,15 @@ func TestEmptyFuncs(t *testing.T) {
 	t.Parallel()
 
 	var e Empty
-	err := e.Insert(zeroKeyTest, zeroKeyTest, nil)
+	err := e.Insert(zeroKeyTest, zeroKeyTest, 0, nil)
 	if err == nil {
 		t.Fatal("got nil error when inserting into empty")
 	}
-	_, err = e.Delete(zeroKeyTest, nil)
+	_, err = e.Delete(zeroKeyTest, 0, nil)
 	if err == nil {
 		t.Fatal("got nil error when deleting from empty")
 	}
-	v, err := e.Get(zeroKeyTest, nil)
+	v, err := e.Get(zeroKeyTest, 0, nil)
 	if err != nil {
 		t.Fatal("got non-nil error when getting from empty")
 	}
@@ -51,7 +51,7 @@ func TestEmptyFuncs(t *testing.T) {
 		t.Fatal("commitment and commit mismatch")
 	}
 
-	if _, _, _, err := e.GetProofItems(nil, nil); err == nil {
+	if _, _, _, _, err := e.GetProofItems(nil, nil); err == nil {
 		t.Fatal("get proof items should error")
 	}
 

encoding.go

@@ -55,12 +55,14 @@ const (
 	leafCommitmentOffset   = leafBitlistOffset + bitlistSize
 	leafC1CommitmentOffset = leafCommitmentOffset + banderwagon.UncompressedSize
 	leafC2CommitmentOffset = leafC1CommitmentOffset + banderwagon.UncompressedSize
-	leafChildrenOffset     = leafC2CommitmentOffset + banderwagon.UncompressedSize
+	leafLastPeriodOffset   = leafC2CommitmentOffset + banderwagon.UncompressedSize
+	leafChildrenOffset     = leafLastPeriodOffset + periodSize
 	leafBasicDataSize      = 32
 	leafSlotSize           = 32
 	leafValueIndexSize     = 1
-	singleSlotLeafSize     = nodeTypeSize + StemSize + 2*banderwagon.UncompressedSize + leafValueIndexSize + leafSlotSize
-	eoaLeafSize            = nodeTypeSize + StemSize + 2*banderwagon.UncompressedSize + leafBasicDataSize
+	singleSlotLeafSize     = nodeTypeSize + StemSize + 2*banderwagon.UncompressedSize + leafValueIndexSize + leafSlotSize + periodSize
+	eoaLeafSize            = nodeTypeSize + StemSize + 2*banderwagon.UncompressedSize + leafBasicDataSize + periodSize
+	expiredLeafSize        = nodeTypeSize + StemSize + banderwagon.UncompressedSize
 )
 
 func bit(bitlist []byte, nr int) bool {
@@ -75,9 +77,10 @@ var errSerializedPayloadTooShort = errors.New("verkle payload is too short")
 // ParseNode deserializes a node into its proper VerkleNode instance.
 // The serialized bytes have the format:
 // - Internal nodes:   <nodeType><bitlist><commitment>
-// - Leaf nodes:       <nodeType><stem><bitlist><comm><c1comm><c2comm><children...>
-// - EoA nodes:        <nodeType><stem><comm><c1comm><balance><nonce>
-// - single slot node: <nodeType><stem><comm><cncomm><leaf index><slot>
+// - Leaf nodes:       <nodeType><stem><bitlist><comm><c1comm><c2comm><period><children...>
+// - EoA nodes:        <nodeType><stem><comm><c1comm><period><balance><nonce>
+// - single slot node: <nodeType><stem><comm><cncomm><period><leaf index><slot>
+// - Expired leaf nodes:       <nodeType><stem><commitment>
 func ParseNode(serializedNode []byte, depth byte) (VerkleNode, error) {
 	// Check that the length of the serialized node is at least the smallest possible serialized node.
 	if len(serializedNode) < nodeTypeSize+banderwagon.UncompressedSize {
@@ -93,6 +96,8 @@ func ParseNode(serializedNode []byte, depth byte) (VerkleNode, error) {
 		return parseEoAccountNode(serializedNode, depth)
 	case singleSlotType:
 		return parseSingleSlotNode(serializedNode, depth)
+	case expiredLeafType:
+		return parseExpiredLeafNode(serializedNode, depth)
 	default:
 		return nil, ErrInvalidNodeEncoding
 	}
@@ -111,7 +116,10 @@ func parseLeafNode(serialized []byte, depth byte) (VerkleNode, error) {
 			offset += LeafValueSize
 		}
 	}
-	ln := NewLeafNodeWithNoComms(serialized[leafStemOffset:leafStemOffset+StemSize], values[:])
+	ln := NewLeafNodeWithNoComms(
+		serialized[leafStemOffset:leafStemOffset+StemSize],
+		values[:],
+		StatePeriodFromBytes(serialized[leafLastPeriodOffset:leafLastPeriodOffset+periodSize]))
 	ln.setDepth(depth)
 	ln.c1 = new(Point)
 
@@ -136,10 +144,11 @@ func parseLeafNode(serialized []byte, depth byte) (VerkleNode, error) {
 
 func parseEoAccountNode(serialized []byte, depth byte) (VerkleNode, error) {
 	var values [NodeWidth][]byte
-	offset := leafStemOffset + StemSize + 2*banderwagon.UncompressedSize
+	offset := leafStemOffset + StemSize + 2*banderwagon.UncompressedSize + periodSize
+	periodOffset := offset - periodSize
 	values[0] = serialized[offset : offset+leafBasicDataSize] // basic data
 	values[1] = EmptyCodeHash[:]
-	ln := NewLeafNodeWithNoComms(serialized[leafStemOffset:leafStemOffset+StemSize], values[:])
+	ln := NewLeafNodeWithNoComms(serialized[leafStemOffset:leafStemOffset+StemSize], values[:], StatePeriodFromBytes(serialized[periodOffset:periodOffset+periodSize]))
 	ln.setDepth(depth)
 	ln.c1 = new(Point)
 	if err := ln.c1.SetBytesUncompressed(serialized[leafStemOffset+StemSize:leafStemOffset+StemSize+banderwagon.UncompressedSize], true); err != nil {
@@ -156,12 +165,13 @@ func parseEoAccountNode(serialized []byte, depth byte) (VerkleNode, error) {
 func parseSingleSlotNode(serialized []byte, depth byte) (VerkleNode, error) {
 	var values [NodeWidth][]byte
 	offset := leafStemOffset
-	ln := NewLeafNodeWithNoComms(serialized[offset:offset+StemSize], values[:])
+	periodOffset := leafStemOffset + StemSize + 2*banderwagon.UncompressedSize
+	ln := NewLeafNodeWithNoComms(serialized[offset:offset+StemSize], values[:], StatePeriodFromBytes(serialized[periodOffset:periodOffset+periodSize]))
 	offset += StemSize
 	cnCommBytes := serialized[offset : offset+banderwagon.UncompressedSize]
 	offset += banderwagon.UncompressedSize
 	rootCommBytes := serialized[offset : offset+banderwagon.UncompressedSize]
-	offset += banderwagon.UncompressedSize
+	offset += banderwagon.UncompressedSize + periodSize
 	idx := serialized[offset]
 	offset += leafValueIndexSize
 	values[idx] = serialized[offset : offset+leafSlotSize] // copy slot
@@ -186,6 +196,17 @@ func parseSingleSlotNode(serialized []byte, depth byte) (VerkleNode, error) {
 	return ln, nil
 }
 
+func parseExpiredLeafNode(serialized []byte, depth byte) (VerkleNode, error) {
+	l := &ExpiredLeafNode{}
+	l.setDepth(depth)
+	l.stem = serialized[leafStemOffset : leafStemOffset+StemSize]
+	l.commitment = new(Point)
+	if err := l.commitment.SetBytesUncompressed(serialized[leafStemOffset+StemSize:], true); err != nil {
+		return nil, fmt.Errorf("setting commitment: %w", err)
+	}
+	return l, nil
+}
+
 func CreateInternalNode(bitlist []byte, raw []byte, depth byte) (*InternalNode, error) {
 	// GetTreeConfig caches computation result, hence
 	// this op has low overhead
@@ -203,7 +224,7 @@ func CreateInternalNode(bitlist []byte, raw []byte, depth byte) (*InternalNode,
 			if b&mask[j] != 0 {
 				node.children[8*i+j] = HashedNode{}
 			} else {
-
+				
 				node.children[8*i+j] = Empty(struct{}{})
 			}
 		}

encoding_test.go

@@ -22,15 +22,15 @@ func TestLeafStemLength(t *testing.T) {
 	// Serialize a leaf with no values, but whose stem is 32 bytes. The
 	// serialization should trim the extra byte.
 	toolong := make([]byte, 32)
-	leaf, err := NewLeafNode(toolong, make([][]byte, NodeWidth))
+	leaf, err := NewLeafNode(toolong, make([][]byte, NodeWidth), 0)
 	if err != nil {
 		t.Fatal(err)
 	}
 	ser, err := leaf.Serialize()
 	if err != nil {
 		t.Fatal(err)
 	}
-	if len(ser) != nodeTypeSize+StemSize+bitlistSize+3*banderwagon.UncompressedSize {
+	if len(ser) != nodeTypeSize+StemSize+bitlistSize+3*banderwagon.UncompressedSize+periodSize {
 		t.Fatalf("invalid serialization when the stem is longer than 31 bytes: %x (%d bytes != %d)", ser, len(ser), nodeTypeSize+StemSize+bitlistSize+2*banderwagon.UncompressedSize)
 	}
 }
@@ -46,7 +46,7 @@ func TestInvalidNodeEncoding(t *testing.T) {
 	// Test an invalid node type.
 	values := make([][]byte, NodeWidth)
 	values[42] = testValue
-	ln, err := NewLeafNode(ffx32KeyTest, values)
+	ln, err := NewLeafNode(ffx32KeyTest, values, 0)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -67,7 +67,7 @@ func TestParseNodeEoA(t *testing.T) {
 	values[2] = fourtyKeyTest[:] // set nonce to 64
 	values[3] = EmptyCodeHash[:] // set empty code hash
 	values[4] = zero32[:]        // zero-size
-	ln, err := NewLeafNode(ffx32KeyTest[:31], values)
+	ln, err := NewLeafNode(ffx32KeyTest[:31], values, 0)
 	if err != nil {
 		t.Fatalf("error creating leaf node: %v", err)
 	}
@@ -131,10 +131,11 @@ func TestParseNodeEoA(t *testing.T) {
 		t.Fatalf("invalid commitment, got %x, expected %x", lnd.commitment, ln.commitment)
 	}
 }
+
 func TestParseNodeSingleSlot(t *testing.T) {
 	values := make([][]byte, 256)
 	values[153] = EmptyCodeHash
-	ln, err := NewLeafNode(ffx32KeyTest[:31], values)
+	ln, err := NewLeafNode(ffx32KeyTest[:31], values, 0)
 	if err != nil {
 		t.Fatalf("error creating leaf node: %v", err)
 	}
@@ -190,3 +191,67 @@ func TestParseNodeSingleSlot(t *testing.T) {
 		t.Fatalf("invalid commitment, got %x, expected %x", lnd.commitment, ln.commitment)
 	}
 }
+
+func TestLeafWithPeriod(t *testing.T) {
+	t.Parallel()
+
+	toolong := make([]byte, 32)
+	period10 := StatePeriod(10)
+	leaf, err := NewLeafNode(toolong, make([][]byte, NodeWidth), period10)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ser, err := leaf.Serialize()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(ser) != nodeTypeSize+StemSize+bitlistSize+3*banderwagon.UncompressedSize+periodSize {
+		t.Fatalf("invalid serialization when the stem is longer than 31 bytes: %x (%d bytes != %d)", ser, len(ser), nodeTypeSize+StemSize+bitlistSize+2*banderwagon.UncompressedSize)
+	}
+
+	deserialized, err := ParseNode(ser, 0)
+	if err != nil {
+		t.Fatalf("error deserializing leaf node: %v", err)
+	}
+
+	leaf, ok := deserialized.(*LeafNode)
+	if !ok {
+		t.Fatalf("expected leaf node, got %T", deserialized)
+	}
+
+	if leaf.period != period10 {
+		t.Fatalf("invalid period, got %d, expected %d", leaf.period, period10)
+	}
+}
+
+func TestParseExpiredLeaf(t *testing.T) {
+	cfg := GetConfig()
+	srs := cfg.conf.SRS
+
+	comm := srs[0]
+	stem := ffx32KeyTest[:StemSize]
+	el := NewExpiredLeafNode(stem, &comm)
+
+	serialized, err := el.Serialize()
+	if err != nil {
+		t.Fatalf("error serializing expired leaf node: %v", err)
+	}
+
+	deserialized, err := ParseNode(serialized, 0)
+	if err != nil {
+		t.Fatalf("error deserializing expired leaf node: %v", err)
+	}
+
+	el2, ok := deserialized.(*ExpiredLeafNode)
+	if !ok {
+		t.Fatalf("expected expired leaf node, got %T", deserialized)
+	}
+
+	if !bytes.Equal(el2.stem, stem) {
+		t.Fatalf("invalid stem, got %x, expected %x", el2.stem, stem)
+	}
+
+	if !el2.commitment.Equal(&comm) {
+		t.Fatalf("invalid commitment, got %x, expected %x", el2.commitment, comm)
+	}
+}