State Expiry + Online Pruning

.golangci.yml

@@ -30,7 +30,6 @@ linters:
     - exhaustive
     - exportloopref
     - forcetypeassert
-    - gocognit
     - goconst
     - gocritic
     - gofmt
@@ -72,6 +71,7 @@ linters:
     # - exhaustivestruct
     # - forbidigo
     # - funlen
+    # - gocognit
     # - godot
     # - goerr113
     # - gomnd
@@ -84,8 +84,6 @@ linters:
     # - wsl
 
 linters-settings:
-  gocognit:
-    min-complexity: 37
   gocritic:
     disabled-checks:
       - appendAssign

chain/block.go

@@ -150,6 +150,14 @@ func (b *StatelessBlock) verify() (*StatelessBlock, *versiondb.Database, error)
 		return nil, nil, err
 	}
 	onAcceptDB := versiondb.New(parentState)
+
+	// Remove all expired prefixes
+	if err := ExpireNext(onAcceptDB, parent.Tmstmp, b.Tmstmp); err != nil {
+		return nil, nil, err
+	}
+
+	// Process new transactions
+	log.Debug("build context", "next difficulty", context.NextDifficulty, "next cost", context.NextCost)
 	var surplusDifficulty uint64
 	for _, tx := range b.Txs {
 		if err := tx.Execute(onAcceptDB, b.Tmstmp, context); err != nil {
@@ -159,7 +167,9 @@ func (b *StatelessBlock) verify() (*StatelessBlock, *versiondb.Database, error)
 		surplusDifficulty += tx.Difficulty() - context.NextDifficulty
 	}
 	// Ensure enough work is performed to compensate for block production speed
-	if surplusDifficulty < b.Difficulty*b.Cost {
+	requiredSurplus := b.Difficulty * b.Cost
+	if surplusDifficulty < requiredSurplus {
+		log.Debug("insufficient block surplus", "found", surplusDifficulty, "required", requiredSurplus)
 		return nil, nil, ErrInsufficientSurplus
 	}
 	return parent, onAcceptDB, nil
@@ -195,7 +205,6 @@ func (b *StatelessBlock) Accept() error {
 	}
 	b.st = choices.Accepted
 	b.vm.Accepted(b)
-	// TODO: clear expired state (using index from timestamp to prefix)
 	return nil
 }
 
@@ -221,6 +230,15 @@ func (b *StatelessBlock) Height() uint64 { return b.StatefulBlock.Hght }
 // implements "snowman.Block"
 func (b *StatelessBlock) Timestamp() time.Time { return b.t }
 
+func (b *StatelessBlock) SetChildrenDB(db database.Database) error {
+	for _, child := range b.children {
+		if err := child.onAcceptDB.SetDatabase(db); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 func (b *StatelessBlock) onAccept() (database.Database, error) {
 	if b.st == choices.Accepted || b.Hght == 0 /* genesis */ {
 		return b.vm.State(), nil

chain/claim_tx.go

@@ -24,30 +24,25 @@ func (c *ClaimTx) Execute(db database.Database, blockTime int64) error {
 		return ErrPublicKeyMismatch
 	}
 
-	prevInfo, infoExists, err := GetPrefixInfo(db, c.Prefix)
+	// Prefix keys only exist if they are still valid
+	exists, err := HasPrefix(db, c.Prefix)
 	if err != nil {
 		return err
 	}
-	if infoExists && prevInfo.Expiry >= blockTime {
+	if exists {
 		return ErrPrefixNotExpired
 	}
 
-	// every successful "claim" deletes the existing keys
-	// whether "c.Sender" is same as or different than "prevInfo.Owner"
-	// now write with either prefix expired or new prefix owner
+	// Anything previously at the prefix was previously removed...
 	newInfo := &PrefixInfo{
 		Owner:       c.Sender,
+		Created:     blockTime,
 		LastUpdated: blockTime,
 		Expiry:      blockTime + expiryTime,
 		Keys:        1,
 	}
-	if err := PutPrefixInfo(db, c.Prefix, newInfo); err != nil {
+	if err := PutPrefixInfo(db, c.Prefix, newInfo, -1); err != nil {
 		return err
 	}
-
-	// Remove anything that is stored in value prefix
-	// overwrite even if claimed by the same owner
-	// TODO(patrick-ogrady): free things async for faster block verification loops
-	// e.g., lazily free what is said to be freed in the block?
-	return DeleteAllPrefixKeys(db, c.Prefix)
+	return nil
 }

chain/claim_tx_test.go

@@ -67,6 +67,12 @@ func TestClaimTx(t *testing.T) {
 		},
 	}
 	for i, tv := range tt {
+		if i > 0 {
+			// Expire old prefixes between txs
+			if err := ExpireNext(db, tt[i-1].blockTime, tv.blockTime); err != nil {
+				t.Fatalf("#%d: ExpireNext errored %v", i, err)
+			}
+		}
 		err := tv.tx.Execute(db, tv.blockTime)
 		if !errors.Is(err, tv.err) {
 			t.Fatalf("#%d: tx.Execute err expected %v, got %v", i, tv.err, err)
@@ -85,4 +91,19 @@ func TestClaimTx(t *testing.T) {
 			t.Fatalf("#%d: unexpected owner found (expected pub key %q)", i, string(pub.PublicKey))
 		}
 	}
+
+	// Cleanup DB after all txs submitted
+	if err := ExpireNext(db, 0, 1000); err != nil {
+		t.Fatal(err)
+	}
+	if err := PruneNext(db, 100); err != nil {
+		t.Fatal(err)
+	}
+	_, exists, err := GetPrefixInfo(db, []byte("foo"))
+	if err != nil {
+		t.Fatalf("failed to get prefix info %v", err)
+	}
+	if exists {
+		t.Fatal("prefix should not exist")
+	}
 }

chain/lifeline_tx.go

@@ -23,6 +23,7 @@ func (l *LifelineTx) Execute(db database.Database, blockTime int64) error {
 		return ErrPrefixMissing
 	}
 	// If you are "in debt", lifeline only adds but doesn't reset to new
+	lastExpiry := i.Expiry
 	i.Expiry += expiryTime / i.Keys
-	return PutPrefixInfo(db, l.Prefix, i)
+	return PutPrefixInfo(db, l.Prefix, i, lastExpiry)
 }

chain/lifeline_tx_test.go

@@ -38,7 +38,7 @@ func TestLifelineTx(t *testing.T) {
 			blockTime: 1,
 			err:       nil,
 		},
-		{ // successful lifeline when prefix info is missing
+		{ // successful lifeline when prefix info is not missing
 			utx:       &LifelineTx{BaseTx: &BaseTx{Sender: pub.Bytes(), Prefix: []byte("foo")}},
 			blockTime: 1,
 			err:       nil,

chain/prefix_info.go

@@ -4,12 +4,16 @@
 package chain
 
 import (
+	"github.com/ava-labs/avalanchego/ids"
 	"github.com/ava-labs/quarkvm/crypto"
 )
 
 type PrefixInfo struct {
 	Owner       [crypto.PublicKeySize]byte `serialize:"true" json:"owner"`
+	Created     int64                      `serialize:"true" json:"created"`
 	LastUpdated int64                      `serialize:"true" json:"lastUpdated"`
 	Expiry      int64                      `serialize:"true" json:"expiry"`
 	Keys        int64                      `serialize:"true" json:"keys"` // decays faster the more keys you have
+
+	RawPrefix ids.ShortID `serialize:"true" json:"rawPrefix"`
 }

chain/set_tx.go

@@ -65,7 +65,7 @@ func (s *SetTx) Execute(db database.Database, blockTime int64) error {
 	return s.updatePrefix(db, blockTime, i)
 }
 
-func (s *SetTx) updatePrefix(db database.KeyValueWriter, blockTime int64, i *PrefixInfo) error {
+func (s *SetTx) updatePrefix(db database.Database, blockTime int64, i *PrefixInfo) error {
 	timeRemaining := (i.Expiry - i.LastUpdated) * i.Keys
 	if len(s.Value) == 0 {
 		i.Keys--
@@ -80,6 +80,7 @@ func (s *SetTx) updatePrefix(db database.KeyValueWriter, blockTime int64, i *Pre
 	}
 	newTimeRemaining := timeRemaining / i.Keys
 	i.LastUpdated = blockTime
+	lastExpiry := i.Expiry
 	i.Expiry = blockTime + newTimeRemaining
-	return PutPrefixInfo(db, s.Prefix, i)
+	return PutPrefixInfo(db, s.Prefix, i, lastExpiry)
 }

chain/set_tx_test.go

@@ -188,7 +188,11 @@ func TestSetTx(t *testing.T) {
 				t.Fatalf("#%d: unexpected owner found (expected pub key %q)", i, string(pub.PublicKey))
 			}
 			// each claim must delete all existing keys with the value key
-			if kvs := Range(db, tp.Prefix, nil, WithPrefix()); len(kvs) > 0 {
+			kvs, err := Range(db, tp.Prefix, nil, WithPrefix())
+			if err != nil {
+				t.Fatalf("#%d: unexpected error when fetching range %v", i, err)
+			}
+			if len(kvs) > 0 {
 				t.Fatalf("#%d: unexpected key-values for the prefix after claim", i)
 			}