added config setting to prune warpdb

plugin/evm/config.go

@@ -17,6 +17,7 @@ import (
 const (
 	defaultAcceptorQueueLimit                         = 64 // Provides 2 minutes of buffer (2s block target) for a commit delay
 	defaultPruningEnabled                             = true
+	defaultPruneWarpDB                                = false
 	defaultCommitInterval                             = 4096
 	defaultTrieCleanCache                             = 512
 	defaultTrieDirtyCache                             = 512
@@ -122,6 +123,7 @@ type Config struct {
 	AllowMissingTries               bool    `json:"allow-missing-tries"`                // If enabled, warnings preventing an incomplete trie index are suppressed
 	PopulateMissingTries            *uint64 `json:"populate-missing-tries,omitempty"`   // Sets the starting point for re-populating missing tries. Disables re-generation if nil.
 	PopulateMissingTriesParallelism int     `json:"populate-missing-tries-parallelism"` // Number of concurrent readers to use when re-populating missing tries on startup.
+	PruneWarpDB                     bool    `json:"prune-warp-db-enabled"`              // Determines if the warpDb should be cleared when re-initialzing subnet-evm
 
 	// Metric Settings
 	MetricsExpensiveEnabled bool `json:"metrics-expensive-enabled"` // Debug-level metrics that might impact runtime performance

plugin/evm/vm.go

@@ -416,6 +416,13 @@ func (vm *VM) Initialize(
 	// initialize warp backend
 	vm.warpBackend = warp.NewWarpBackend(vm.ctx, vm.warpDB, warpSignatureCacheSize)
 
+	// clear warpdb on initialization if config enabled
+	if vm.config.PruneWarpDB {
+		if err := vm.warpBackend.Clear(); err != nil {
+			return fmt.Errorf("failed to prune warpDB: %w", err)
+		}
+	}
+
 	if err := vm.initializeChain(lastAcceptedHash, vm.ethConfig); err != nil {
 		return err
 	}

warp/backend.go

@@ -25,6 +25,9 @@ type WarpBackend interface {
 
 	// GetSignature returns the signature of the requested message hash.
 	GetSignature(messageHash ids.ID) ([bls.SignatureLen]byte, error)
+
+	// Clear clears the entire db
+	Clear() error
 }
 
 // warpBackend implements WarpBackend, keeps track of warp messages, and generates message signatures.
@@ -43,6 +46,11 @@ func NewWarpBackend(snowCtx *snow.Context, db database.Database, signatureCacheS
 	}
 }
 
+func (w *warpBackend) Clear() error {
+	w.signatureCache.Flush()
+	return database.Clear(w.db, w.db)
+}
+
 func (w *warpBackend) AddMessage(unsignedMessage *avalancheWarp.UnsignedMessage) error {
 	messageID := hashing.ComputeHash256Array(unsignedMessage.Bytes())
 

warp/backend_test.go

@@ -21,6 +21,42 @@ var (
 	payload            = []byte("test")
 )
 
+func TestClearDB(t *testing.T) {
+	db := memdb.New()
+
+	snowCtx := snow.DefaultContextTest()
+	sk, err := bls.NewSecretKey()
+	require.NoError(t, err)
+	snowCtx.WarpSigner = avalancheWarp.NewSigner(sk, sourceChainID)
+	backend := NewWarpBackend(snowCtx, db, 500)
+
+	// use multiple messages to test that all messages get cleared
+	payloads := [][]byte{[]byte("test1"), []byte("test2"), []byte("test3"), []byte("test4"), []byte("test5")}
+	messageIDs := []ids.ID{}
+
+	// add all messages
+	for _, payload := range payloads {
+		unsignedMsg, err := avalancheWarp.NewUnsignedMessage(sourceChainID, destinationChainID, payload)
+		require.NoError(t, err)
+		messageID := hashing.ComputeHash256Array(unsignedMsg.Bytes())
+		messageIDs = append(messageIDs, messageID)
+		err = backend.AddMessage(unsignedMsg)
+		require.NoError(t, err)
+		// ensure that the message was added
+		_, err = backend.GetSignature(messageID)
+		require.NoError(t, err)
+	}
+
+	err = backend.Clear()
+	require.NoError(t, err)
+
+	// ensure all messages have been deleted
+	for _, messageID := range messageIDs {
+		_, err := backend.GetSignature(messageID)
+		require.ErrorContains(t, err, "failed to get warp message")
+	}
+}
+
 func TestAddAndGetValidMessage(t *testing.T) {
 	db := memdb.New()