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          = 8
 )
 
 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
 					}
@@ -97,7 +97,7 @@ func firstDiffByteIdx(stem1 []byte, stem2 []byte) int {
 	panic("stems are equal")
 }
 
-func (n *InternalNode) InsertMigratedLeaves(leaves []LeafNode, resolver NodeResolverFn) error {
+func (n *InternalNode) InsertMigratedLeaves(leaves []LeafNode, curPeriod StatePeriod, resolver NodeResolverFn) error {
 	sort.Slice(leaves, func(i, j int) bool {
 		return bytes.Compare(leaves[i].stem, leaves[j].stem) < 0
 	})
@@ -132,13 +132,13 @@ func (n *InternalNode) InsertMigratedLeaves(leaves []LeafNode, resolver NodeReso
 			start := currStemFirstByte
 			end := i
 			group.Go(func() error {
-				return n.insertMigratedLeavesSubtree(leaves[start:end], resolver)
+				return n.insertMigratedLeavesSubtree(leaves[start:end], curPeriod, resolver)
 			})
 			currStemFirstByte = i
 		}
 	}
 	group.Go(func() error {
-		return n.insertMigratedLeavesSubtree(leaves[currStemFirstByte:], resolver)
+		return n.insertMigratedLeavesSubtree(leaves[currStemFirstByte:], curPeriod, resolver)
 	})
 	if err := group.Wait(); err != nil {
 		return fmt.Errorf("inserting migrated leaves: %w", err)
@@ -147,7 +147,7 @@ func (n *InternalNode) InsertMigratedLeaves(leaves []LeafNode, resolver NodeReso
 	return nil
 }
 
-func (n *InternalNode) insertMigratedLeavesSubtree(leaves []LeafNode, resolver NodeResolverFn) error { // skipcq: GO-R1005
+func (n *InternalNode) insertMigratedLeavesSubtree(leaves []LeafNode, curPeriod StatePeriod, resolver NodeResolverFn) error { // skipcq: GO-R1005
 	for i := range leaves {
 		ln := leaves[i]
 		parent := n
@@ -192,7 +192,7 @@ func (n *InternalNode) insertMigratedLeavesSubtree(leaves []LeafNode, resolver N
 					}
 				}
 
-				if err := node.updateMultipleLeaves(nonPresentValues); err != nil {
+				if err := node.updateMultipleLeaves(nonPresentValues, curPeriod); 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"`
+		LastPeriod StatePeriod `json:"last_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,11 +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")
 )
 
 const (
 	// Extension status
 	extStatusAbsentEmpty = byte(iota) // missing child node along the path
 	extStatusAbsentOther              // path led to a node with a different stem
 	extStatusPresent                  // stem was present
+	extStatusExpired                  // stem was present but expired
 )

empty.go

@@ -31,15 +31,15 @@ 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
 }
 

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")
 	}

encoding.go

@@ -56,11 +56,13 @@ const (
 	leafC1CommitmentOffset = leafCommitmentOffset + banderwagon.UncompressedSize
 	leafC2CommitmentOffset = leafC1CommitmentOffset + banderwagon.UncompressedSize
 	leafChildrenOffset     = leafC2CommitmentOffset + banderwagon.UncompressedSize
+	leafLastEpochOffset    = leafChildrenOffset + 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><lastPeriod><children...>
+// - EoA nodes:        <nodeType><stem><comm><c1comm><lastPeriod><balance><nonce>
+// - single slot node: <nodeType><stem><comm><cncomm><lastPeriod><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[leafLastEpochOffset:leafLastEpochOffset+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.stem = serialized[leafStemOffset : leafStemOffset+StemSize]
+	l.setDepth(depth)
+	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,6 @@ 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,35 @@ func TestParseNodeSingleSlot(t *testing.T) {
 		t.Fatalf("invalid commitment, got %x, expected %x", lnd.commitment, ln.commitment)
 	}
 }
+
+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)
+	}
+}

epoch.go

@@ -0,0 +1,19 @@
+package verkle
+
+import (
+	"encoding/binary"
+)
+
+type StatePeriod uint16
+
+const (
+	NumActiveEpochs = 2
+)
+
+func IsExpired(prev StatePeriod, cur StatePeriod) bool {
+	return cur >= prev+NumActiveEpochs // TODO(weiihann): deal with overflow
+}
+
+func StatePeriodFromBytes(b []byte) StatePeriod {
+	return StatePeriod(binary.BigEndian.Uint16(b))
+}