diff --git a/consensus/dummy/README.md b/consensus/dummy/README.md
index 23ff20072a..cca69cf239 100644
--- a/consensus/dummy/README.md
+++ b/consensus/dummy/README.md
@@ -18,7 +18,7 @@ The dynamic fee algorithm aims to adjust the base fee to handle network congesti
 
 - EIP-1559 is intended for Ethereum where a block is produced roughly every 10s
 - C-Chain typically produces blocks every 2 seconds, but the dynamic fee algorithm needs to handle the case that the network quiesces and there are no blocks for a long period of time
-- Since C-Chain produces blocks at a different cadence, it adapts EIP-1559 to sum the amount of gas consumed within a 10 second interval instead of using only the amount of gas consumed in the parent block
+- Since C-Chain produces blocks at a different cadence, it adapts EIP-1559 to sum the amount of gas consumed within a 10-second interval instead of using only the amount of gas consumed in the parent block
 
 ## Consensus Engine Callbacks
 
diff --git a/core/state/pruner/pruner.go b/core/state/pruner/pruner.go
index 29431a0ecd..090b7ac6af 100644
--- a/core/state/pruner/pruner.go
+++ b/core/state/pruner/pruner.go
@@ -52,7 +52,7 @@ const (
 	// stateBloomFilePrefix is the filename prefix of state bloom filter.
 	stateBloomFilePrefix = "statebloom"
 
-	// stateBloomFilePrefix is the filename suffix of state bloom filter.
+	// stateBloomFileSuffix is the filename suffix of state bloom filter.
 	stateBloomFileSuffix = "bf.gz"
 
 	// stateBloomFileTempSuffix is the filename suffix of state bloom filter
diff --git a/eth/tracers/js/tracer_test.go b/eth/tracers/js/tracer_test.go
index 7e46c0aa20..746fc0eb0e 100644
--- a/eth/tracers/js/tracer_test.go
+++ b/eth/tracers/js/tracer_test.go
@@ -206,7 +206,7 @@ func TestHaltBetweenSteps(t *testing.T) {
 	}
 }
 
-// testNoStepExec tests a regular value transfer (no exec), and accessing the statedb
+// TestNoStepExec tests a regular value transfer (no exec), and accessing the statedb
 // in 'result'
 func TestNoStepExec(t *testing.T) {
 	execTracer := func(code string) []byte {
diff --git a/eth/tracers/logger/access_list_tracer.go b/eth/tracers/logger/access_list_tracer.go
index e2bb12f2d7..d43198a2ff 100644
--- a/eth/tracers/logger/access_list_tracer.go
+++ b/eth/tracers/logger/access_list_tracer.go
@@ -87,7 +87,7 @@ func (al accessList) equal(other accessList) bool {
 	return true
 }
 
-// accesslist converts the accesslist to a types.AccessList.
+// accessList converts the accesslist to a types.AccessList.
 func (al accessList) accessList() types.AccessList {
 	acl := make(types.AccessList, 0, len(al))
 	for addr, slots := range al {
diff --git a/plugin/evm/service.go b/plugin/evm/api.go
similarity index 100%
rename from plugin/evm/service.go
rename to plugin/evm/api.go
diff --git a/plugin/evm/atomic_trie.go b/plugin/evm/atomic_trie.go
index d734268e23..f6add46623 100644
--- a/plugin/evm/atomic_trie.go
+++ b/plugin/evm/atomic_trie.go
@@ -9,7 +9,7 @@ import (
 
 	avalancheatomic "github.com/ava-labs/avalanchego/chains/atomic"
 	"github.com/ava-labs/avalanchego/codec"
-	"github.com/ava-labs/avalanchego/database"
+	avalanchedatabase "github.com/ava-labs/avalanchego/database"
 	"github.com/ava-labs/avalanchego/ids"
 	"github.com/ava-labs/avalanchego/utils/units"
 	"github.com/ava-labs/avalanchego/utils/wrappers"
@@ -18,6 +18,7 @@ import (
 	"github.com/ava-labs/coreth/core/rawdb"
 	"github.com/ava-labs/coreth/core/types"
 	"github.com/ava-labs/coreth/plugin/evm/atomic"
+	"github.com/ava-labs/coreth/plugin/evm/database"
 	"github.com/ava-labs/coreth/trie"
 	"github.com/ava-labs/coreth/trie/trienode"
 	"github.com/ava-labs/coreth/triedb"
@@ -117,12 +118,12 @@ type AtomicTrieIterator interface {
 
 // atomicTrie implements the AtomicTrie interface
 type atomicTrie struct {
-	commitInterval      uint64            // commit interval, same as commitHeightInterval by default
-	metadataDB          database.Database // Underlying database containing the atomic trie metadata
-	trieDB              *triedb.Database  // Trie database
-	lastCommittedRoot   common.Hash       // trie root of the most recent commit
-	lastCommittedHeight uint64            // index height of the most recent commit
-	lastAcceptedRoot    common.Hash       // most recent trie root passed to accept trie or the root of the atomic trie on intialization.
+	commitInterval      uint64                     // commit interval, same as commitHeightInterval by default
+	metadataDB          avalanchedatabase.Database // Underlying database containing the atomic trie metadata
+	trieDB              *triedb.Database           // Trie database
+	lastCommittedRoot   common.Hash                // trie root of the most recent commit
+	lastCommittedHeight uint64                     // index height of the most recent commit
+	lastAcceptedRoot    common.Hash                // most recent trie root passed to accept trie or the root of the atomic trie on intialization.
 	codec               codec.Manager
 	memoryCap           common.StorageSize
 	tipBuffer           *core.BoundedBuffer[common.Hash]
@@ -131,7 +132,7 @@ type atomicTrie struct {
 // newAtomicTrie returns a new instance of a atomicTrie with a configurable commitHeightInterval, used in testing.
 // Initializes the trie before returning it.
 func newAtomicTrie(
-	atomicTrieDB database.Database, metadataDB database.Database,
+	atomicTrieDB avalanchedatabase.Database, metadataDB avalanchedatabase.Database,
 	codec codec.Manager, lastAcceptedHeight uint64, commitHeightInterval uint64,
 ) (*atomicTrie, error) {
 	root, height, err := lastCommittedRootIfExists(metadataDB)
@@ -153,7 +154,7 @@ func newAtomicTrie(
 	}
 
 	trieDB := triedb.NewDatabase(
-		rawdb.NewDatabase(Database{atomicTrieDB}),
+		rawdb.NewDatabase(database.WrapDatabase(atomicTrieDB)),
 		&triedb.Config{
 			HashDB: &hashdb.Config{
 				CleanCacheSize: 64 * units.MiB, // Allocate 64MB of memory for clean cache
@@ -182,17 +183,17 @@ func newAtomicTrie(
 // else returns empty common.Hash{} and 0
 // returns error only if there are issues with the underlying data store
 // or if values present in the database are not as expected
-func lastCommittedRootIfExists(db database.Database) (common.Hash, uint64, error) {
+func lastCommittedRootIfExists(db avalanchedatabase.Database) (common.Hash, uint64, error) {
 	// read the last committed entry if it exists and set the root hash
 	lastCommittedHeightBytes, err := db.Get(lastCommittedKey)
 	switch {
-	case err == database.ErrNotFound:
+	case err == avalanchedatabase.ErrNotFound:
 		return common.Hash{}, 0, nil
 	case err != nil:
 		return common.Hash{}, 0, err
 	}
 
-	height, err := database.ParseUInt64(lastCommittedHeightBytes)
+	height, err := avalanchedatabase.ParseUInt64(lastCommittedHeightBytes)
 	if err != nil {
 		return common.Hash{}, 0, fmt.Errorf("expected value at lastCommittedKey to be a valid uint64: %w", err)
 	}
@@ -251,7 +252,7 @@ func (a *atomicTrie) LastCommitted() (common.Hash, uint64) {
 // updateLastCommitted adds [height] -> [root] to the index and marks it as the last committed
 // root/height pair.
 func (a *atomicTrie) updateLastCommitted(root common.Hash, height uint64) error {
-	heightBytes := database.PackUInt64(height)
+	heightBytes := avalanchedatabase.PackUInt64(height)
 
 	// now save the trie hash against the height it was committed at
 	if err := a.metadataDB.Put(heightBytes, root[:]); err != nil {
@@ -297,7 +298,7 @@ func (a *atomicTrie) Root(height uint64) (common.Hash, error) {
 
 // getRoot is a helper function to return the committed atomic trie root hash at [height]
 // from [metadataDB].
-func getRoot(metadataDB database.Database, height uint64) (common.Hash, error) {
+func getRoot(metadataDB avalanchedatabase.Database, height uint64) (common.Hash, error) {
 	if height == 0 {
 		// if root is queried at height == 0, return the empty root hash
 		// this may occur if peers ask for the most recent state summary
@@ -305,10 +306,10 @@ func getRoot(metadataDB database.Database, height uint64) (common.Hash, error) {
 		return types.EmptyRootHash, nil
 	}
 
-	heightBytes := database.PackUInt64(height)
+	heightBytes := avalanchedatabase.PackUInt64(height)
 	hash, err := metadataDB.Get(heightBytes)
 	switch {
-	case err == database.ErrNotFound:
+	case err == avalanchedatabase.ErrNotFound:
 		return common.Hash{}, nil
 	case err != nil:
 		return common.Hash{}, err
diff --git a/plugin/evm/block.go b/plugin/evm/block.go
index 9a2de32601..f94f3ebd81 100644
--- a/plugin/evm/block.go
+++ b/plugin/evm/block.go
@@ -143,7 +143,7 @@ func (b *Block) Accept(context.Context) error {
 
 	// Although returning an error from Accept is considered fatal, it is good
 	// practice to cleanup the batch we were modifying in the case of an error.
-	defer vm.db.Abort()
+	defer vm.versiondb.Abort()
 
 	log.Debug(fmt.Sprintf("Accepting block %s (%s) at height %d", b.ID().Hex(), b.ID(), b.Height()))
 
@@ -176,7 +176,7 @@ func (b *Block) Accept(context.Context) error {
 	}
 	// Get pending operations on the vm's versionDB so we can apply them atomically
 	// with the shared memory changes.
-	vdbBatch, err := b.vm.db.CommitBatch()
+	vdbBatch, err := b.vm.versiondb.CommitBatch()
 	if err != nil {
 		return fmt.Errorf("could not create commit batch processing block[%s]: %w", b.ID(), err)
 	}
diff --git a/plugin/evm/database.go b/plugin/evm/database/wrapped_database.go
similarity index 55%
rename from plugin/evm/database.go
rename to plugin/evm/database/wrapped_database.go
index 479c995ba3..f8a36913bb 100644
--- a/plugin/evm/database.go
+++ b/plugin/evm/database/wrapped_database.go
@@ -1,7 +1,7 @@
 // (c) 2019-2020, Ava Labs, Inc. All rights reserved.
 // See the file LICENSE for licensing terms.
 
-package evm
+package database
 
 import (
 	"errors"
@@ -11,25 +11,29 @@ import (
 )
 
 var (
-	_ ethdb.KeyValueStore = &Database{}
+	_ ethdb.KeyValueStore = &ethDbWrapper{}
 
 	ErrSnapshotNotSupported = errors.New("snapshot is not supported")
 )
 
-// Database implements ethdb.Database
-type Database struct{ database.Database }
+// ethDbWrapper implements ethdb.Database
+type ethDbWrapper struct{ database.Database }
+
+func WrapDatabase(db database.Database) ethdb.KeyValueStore { return ethDbWrapper{db} }
 
 // Stat implements ethdb.Database
-func (db Database) Stat(string) (string, error) { return "", database.ErrNotFound }
+func (db ethDbWrapper) Stat(string) (string, error) { return "", database.ErrNotFound }
 
 // NewBatch implements ethdb.Database
-func (db Database) NewBatch() ethdb.Batch { return Batch{db.Database.NewBatch()} }
+func (db ethDbWrapper) NewBatch() ethdb.Batch { return wrappedBatch{db.Database.NewBatch()} }
 
 // NewBatchWithSize implements ethdb.Database
 // TODO: propagate size through avalanchego Database interface
-func (db Database) NewBatchWithSize(size int) ethdb.Batch { return Batch{db.Database.NewBatch()} }
+func (db ethDbWrapper) NewBatchWithSize(size int) ethdb.Batch {
+	return wrappedBatch{db.Database.NewBatch()}
+}
 
-func (db Database) NewSnapshot() (ethdb.Snapshot, error) {
+func (db ethDbWrapper) NewSnapshot() (ethdb.Snapshot, error) {
 	return nil, ErrSnapshotNotSupported
 }
 
@@ -37,7 +41,7 @@ func (db Database) NewSnapshot() (ethdb.Snapshot, error) {
 //
 // Note: This method assumes that the prefix is NOT part of the start, so there's
 // no need for the caller to prepend the prefix to the start.
-func (db Database) NewIterator(prefix []byte, start []byte) ethdb.Iterator {
+func (db ethDbWrapper) NewIterator(prefix []byte, start []byte) ethdb.Iterator {
 	// avalanchego's database implementation assumes that the prefix is part of the
 	// start, so it is added here (if it is provided).
 	if len(prefix) > 0 {
@@ -50,15 +54,15 @@ func (db Database) NewIterator(prefix []byte, start []byte) ethdb.Iterator {
 }
 
 // NewIteratorWithStart implements ethdb.Database
-func (db Database) NewIteratorWithStart(start []byte) ethdb.Iterator {
+func (db ethDbWrapper) NewIteratorWithStart(start []byte) ethdb.Iterator {
 	return db.Database.NewIteratorWithStart(start)
 }
 
-// Batch implements ethdb.Batch
-type Batch struct{ database.Batch }
+// wrappedBatch implements ethdb.wrappedBatch
+type wrappedBatch struct{ database.Batch }
 
 // ValueSize implements ethdb.Batch
-func (batch Batch) ValueSize() int { return batch.Batch.Size() }
+func (batch wrappedBatch) ValueSize() int { return batch.Batch.Size() }
 
 // Replay implements ethdb.Batch
-func (batch Batch) Replay(w ethdb.KeyValueWriter) error { return batch.Batch.Replay(w) }
+func (batch wrappedBatch) Replay(w ethdb.KeyValueWriter) error { return batch.Batch.Replay(w) }
diff --git a/plugin/evm/export_tx_test.go b/plugin/evm/export_tx_test.go
index 36b74ab45a..8e6c5d689b 100644
--- a/plugin/evm/export_tx_test.go
+++ b/plugin/evm/export_tx_test.go
@@ -1011,7 +1011,7 @@ func TestExportTxAccept(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	commitBatch, err := vm.db.CommitBatch()
+	commitBatch, err := vm.versiondb.CommitBatch()
 	if err != nil {
 		t.Fatalf("Failed to create commit batch for VM due to %s", err)
 	}
@@ -1800,7 +1800,7 @@ func TestNewExportTx(t *testing.T) {
 				t.Fatalf("burned wrong amount of AVAX - expected %d burned %d", test.expectedBurnedAVAX, burnedAVAX)
 			}
 
-			commitBatch, err := vm.db.CommitBatch()
+			commitBatch, err := vm.versiondb.CommitBatch()
 			if err != nil {
 				t.Fatalf("Failed to create commit batch for VM due to %s", err)
 			}
@@ -2000,7 +2000,7 @@ func TestNewExportTxMulticoin(t *testing.T) {
 				t.Fatal("newExportTx created an invalid transaction", err)
 			}
 
-			commitBatch, err := vm.db.CommitBatch()
+			commitBatch, err := vm.versiondb.CommitBatch()
 			if err != nil {
 				t.Fatalf("Failed to create commit batch for VM due to %s", err)
 			}
diff --git a/plugin/evm/syncervm_test.go b/plugin/evm/syncervm_test.go
index bd7f993cb5..7c8e76fa0a 100644
--- a/plugin/evm/syncervm_test.go
+++ b/plugin/evm/syncervm_test.go
@@ -16,7 +16,7 @@ import (
 	"github.com/stretchr/testify/require"
 
 	avalancheatomic "github.com/ava-labs/avalanchego/chains/atomic"
-	"github.com/ava-labs/avalanchego/database"
+	avalanchedatabase "github.com/ava-labs/avalanchego/database"
 	"github.com/ava-labs/avalanchego/database/prefixdb"
 	"github.com/ava-labs/avalanchego/ids"
 	"github.com/ava-labs/avalanchego/snow"
@@ -36,6 +36,7 @@ import (
 	"github.com/ava-labs/coreth/metrics"
 	"github.com/ava-labs/coreth/params"
 	"github.com/ava-labs/coreth/plugin/evm/atomic"
+	"github.com/ava-labs/coreth/plugin/evm/database"
 	"github.com/ava-labs/coreth/predicate"
 	statesyncclient "github.com/ava-labs/coreth/sync/client"
 	"github.com/ava-labs/coreth/sync/statesync"
@@ -334,7 +335,7 @@ func createSyncServerAndClientVMs(t *testing.T, test syncTest, numBlocks int) *s
 	serverAtomicTrie := serverVM.atomicTrie.(*atomicTrie)
 	serverAtomicTrie.commitInterval = test.syncableInterval
 	require.NoError(serverAtomicTrie.commit(test.syncableInterval, serverAtomicTrie.LastAcceptedRoot()))
-	require.NoError(serverVM.db.Commit())
+	require.NoError(serverVM.versiondb.Commit())
 
 	serverSharedMemories := newSharedMemories(serverAtomicMemory, serverVM.ctx.ChainID, serverVM.ctx.XChainID)
 	serverSharedMemories.assertOpsApplied(t, mustAtomicOps(importTx))
@@ -430,7 +431,7 @@ type syncVMSetup struct {
 	fundedAccounts    map[*keystore.Key]*types.StateAccount
 
 	syncerVM             *VM
-	syncerDB             database.Database
+	syncerDB             avalanchedatabase.Database
 	syncerEngineChan     <-chan commonEng.Message
 	syncerAtomicMemory   *avalancheatomic.Memory
 	shutdownOnceSyncerVM *shutdownOnceVM
@@ -491,7 +492,7 @@ func testSyncerVM(t *testing.T, vmSetup *syncVMSetup, test syncTest) {
 	if test.expectedErr != nil {
 		require.ErrorIs(err, test.expectedErr)
 		// Note we re-open the database here to avoid a closed error when the test is for a shutdown VM.
-		chaindb := Database{prefixdb.NewNested(ethDBPrefix, syncerVM.db)}
+		chaindb := database.WrapDatabase(prefixdb.NewNested(ethDBPrefix, syncerVM.db))
 		assertSyncPerformedHeights(t, chaindb, map[uint64]struct{}{})
 		return
 	}
diff --git a/plugin/evm/vm.go b/plugin/evm/vm.go
index 6900c26ea0..89c8ea4629 100644
--- a/plugin/evm/vm.go
+++ b/plugin/evm/vm.go
@@ -76,7 +76,6 @@ import (
 	"github.com/ava-labs/avalanchego/codec"
 	"github.com/ava-labs/avalanchego/codec/linearcodec"
 	"github.com/ava-labs/avalanchego/database"
-	"github.com/ava-labs/avalanchego/database/prefixdb"
 	"github.com/ava-labs/avalanchego/database/versiondb"
 	"github.com/ava-labs/avalanchego/ids"
 	"github.com/ava-labs/avalanchego/snow"
@@ -225,8 +224,11 @@ type VM struct {
 	blockChain *core.BlockChain
 	miner      *miner.Miner
 
-	// [db] is the VM's current database managed by ChainState
-	db *versiondb.Database
+	// [versiondb] is the VM's current versioned database
+	versiondb *versiondb.Database
+
+	// [db] is the VM's current database
+	db database.Database
 
 	// metadataDB is used to store one off keys.
 	metadataDB database.Database
@@ -274,7 +276,7 @@ type VM struct {
 	client       peer.NetworkClient
 	networkCodec codec.Manager
 
-	validators *p2p.Validators
+	p2pValidators *p2p.Validators
 
 	// Metrics
 	sdkMetrics *prometheus.Registry
@@ -396,14 +398,10 @@ func (vm *VM) Initialize(
 	if err := vm.initializeDBs(db); err != nil {
 		return fmt.Errorf("failed to initialize databases: %w", err)
 	}
-
 	if vm.config.InspectDatabase {
-		start := time.Now()
-		log.Info("Starting database inspection")
-		if err := rawdb.InspectDatabase(vm.chaindb, nil, nil); err != nil {
+		if err := vm.inspectDatabases(); err != nil {
 			return err
 		}
-		log.Info("Completed database inspection", "elapsed", time.Since(start))
 	}
 
 	g := new(core.Genesis)
@@ -542,7 +540,7 @@ func (vm *VM) Initialize(
 	if err != nil {
 		return fmt.Errorf("failed to initialize p2p network: %w", err)
 	}
-	vm.validators = p2p.NewValidators(p2pNetwork.Peers, vm.ctx.Log, vm.ctx.SubnetID, vm.ctx.ValidatorState, maxValidatorSetStaleness)
+	vm.p2pValidators = p2p.NewValidators(p2pNetwork.Peers, vm.ctx.Log, vm.ctx.SubnetID, vm.ctx.ValidatorState, maxValidatorSetStaleness)
 	vm.networkCodec = message.Codec
 	vm.Network = peer.NewNetwork(p2pNetwork, appSender, vm.networkCodec, chainCtx.NodeID, vm.config.MaxOutboundActiveRequests)
 	vm.client = peer.NewNetworkClient(vm.Network)
@@ -592,12 +590,12 @@ func (vm *VM) Initialize(
 	}
 
 	// initialize atomic repository
-	vm.atomicTxRepository, err = NewAtomicTxRepository(vm.db, atomic.Codec, lastAcceptedHeight)
+	vm.atomicTxRepository, err = NewAtomicTxRepository(vm.versiondb, atomic.Codec, lastAcceptedHeight)
 	if err != nil {
 		return fmt.Errorf("failed to create atomic repository: %w", err)
 	}
 	vm.atomicBackend, err = NewAtomicBackend(
-		vm.db, vm.ctx.SharedMemory, bonusBlockHeights,
+		vm.versiondb, vm.ctx.SharedMemory, bonusBlockHeights,
 		vm.atomicTxRepository, lastAcceptedHeight, lastAcceptedHash,
 		vm.config.CommitInterval,
 	)
@@ -723,7 +721,7 @@ func (vm *VM) initializeStateSyncClient(lastAcceptedHeight uint64) error {
 		chaindb:              vm.chaindb,
 		metadataDB:           vm.metadataDB,
 		acceptedBlockDB:      vm.acceptedBlockDB,
-		db:                   vm.db,
+		db:                   vm.versiondb,
 		atomicBackend:        vm.atomicBackend,
 		toEngine:             vm.toEngine,
 	})
@@ -1047,7 +1045,7 @@ func (vm *VM) initBlockBuilding() error {
 	vm.cancel = cancel
 
 	ethTxGossipMarshaller := GossipEthTxMarshaller{}
-	ethTxGossipClient := vm.Network.NewClient(p2p.TxGossipHandlerID, p2p.WithValidatorSampling(vm.validators))
+	ethTxGossipClient := vm.Network.NewClient(p2p.TxGossipHandlerID, p2p.WithValidatorSampling(vm.p2pValidators))
 	ethTxGossipMetrics, err := gossip.NewMetrics(vm.sdkMetrics, ethTxGossipNamespace)
 	if err != nil {
 		return fmt.Errorf("failed to initialize eth tx gossip metrics: %w", err)
@@ -1063,7 +1061,7 @@ func (vm *VM) initBlockBuilding() error {
 	}()
 
 	atomicTxGossipMarshaller := atomic.GossipAtomicTxMarshaller{}
-	atomicTxGossipClient := vm.Network.NewClient(p2p.AtomicTxGossipHandlerID, p2p.WithValidatorSampling(vm.validators))
+	atomicTxGossipClient := vm.Network.NewClient(p2p.AtomicTxGossipHandlerID, p2p.WithValidatorSampling(vm.p2pValidators))
 	atomicTxGossipMetrics, err := gossip.NewMetrics(vm.sdkMetrics, atomicTxGossipNamespace)
 	if err != nil {
 		return fmt.Errorf("failed to initialize atomic tx gossip metrics: %w", err)
@@ -1084,7 +1082,7 @@ func (vm *VM) initBlockBuilding() error {
 		ethTxPushGossiper, err = gossip.NewPushGossiper[*GossipEthTx](
 			ethTxGossipMarshaller,
 			ethTxPool,
-			vm.validators,
+			vm.p2pValidators,
 			ethTxGossipClient,
 			ethTxGossipMetrics,
 			pushGossipParams,
@@ -1103,7 +1101,7 @@ func (vm *VM) initBlockBuilding() error {
 		vm.atomicTxPushGossiper, err = gossip.NewPushGossiper[*atomic.GossipAtomicTx](
 			atomicTxGossipMarshaller,
 			vm.mempool,
-			vm.validators,
+			vm.p2pValidators,
 			atomicTxGossipClient,
 			atomicTxGossipMetrics,
 			pushGossipParams,
@@ -1130,7 +1128,7 @@ func (vm *VM) initBlockBuilding() error {
 			txGossipTargetMessageSize,
 			txGossipThrottlingPeriod,
 			txGossipThrottlingLimit,
-			vm.validators,
+			vm.p2pValidators,
 		)
 	}
 
@@ -1147,7 +1145,7 @@ func (vm *VM) initBlockBuilding() error {
 			txGossipTargetMessageSize,
 			txGossipThrottlingPeriod,
 			txGossipThrottlingLimit,
-			vm.validators,
+			vm.p2pValidators,
 		)
 	}
 
@@ -1168,7 +1166,7 @@ func (vm *VM) initBlockBuilding() error {
 		vm.ethTxPullGossiper = gossip.ValidatorGossiper{
 			Gossiper:   ethTxPullGossiper,
 			NodeID:     vm.ctx.NodeID,
-			Validators: vm.validators,
+			Validators: vm.p2pValidators,
 		}
 	}
 
@@ -1195,7 +1193,7 @@ func (vm *VM) initBlockBuilding() error {
 		vm.atomicTxPullGossiper = &gossip.ValidatorGossiper{
 			Gossiper:   atomicTxPullGossiper,
 			NodeID:     vm.ctx.NodeID,
-			Validators: vm.validators,
+			Validators: vm.p2pValidators,
 		}
 	}
 
@@ -1457,6 +1455,7 @@ func (vm *VM) CreateHandlers(context.Context) (map[string]http.Handler, error) {
 		enabledAPIs = append(enabledAPIs, "coreth-admin")
 	}
 
+	// RPC APIs
 	if vm.config.SnowmanAPIEnabled {
 		if err := handler.RegisterName("snowman", &SnowmanAPI{vm}); err != nil {
 			return nil, err
@@ -1484,22 +1483,6 @@ func (vm *VM) CreateHandlers(context.Context) (map[string]http.Handler, error) {
 	return apis, nil
 }
 
-// initializeDBs initializes the databases used by the VM.
-// coreth always uses the avalanchego provided database.
-func (vm *VM) initializeDBs(db database.Database) error {
-	// Use NewNested rather than New so that the structure of the database
-	// remains the same regardless of the provided baseDB type.
-	vm.chaindb = rawdb.NewDatabase(Database{prefixdb.NewNested(ethDBPrefix, db)})
-	vm.db = versiondb.New(db)
-	vm.acceptedBlockDB = prefixdb.New(acceptedPrefix, vm.db)
-	vm.metadataDB = prefixdb.New(metadataPrefix, vm.db)
-	// Note warpDB is not part of versiondb because it is not necessary
-	// that warp signatures are committed to the database atomically with
-	// the last accepted block.
-	vm.warpDB = prefixdb.New(warpPrefix, db)
-	return nil
-}
-
 // CreateStaticHandlers makes new http handlers that can handle API calls
 func (vm *VM) CreateStaticHandlers(context.Context) (map[string]http.Handler, error) {
 	handler := rpc.NewServer(0)
diff --git a/plugin/evm/vm_database.go b/plugin/evm/vm_database.go
new file mode 100644
index 0000000000..f2a5b4c344
--- /dev/null
+++ b/plugin/evm/vm_database.go
@@ -0,0 +1,82 @@
+// (c) 2019-2021, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package evm
+
+import (
+	"time"
+
+	avalanchedatabase "github.com/ava-labs/avalanchego/database"
+	"github.com/ava-labs/avalanchego/database/prefixdb"
+	"github.com/ava-labs/avalanchego/database/versiondb"
+	"github.com/ava-labs/coreth/core/rawdb"
+	"github.com/ava-labs/coreth/plugin/evm/database"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
+)
+
+// initializeDBs initializes the databases used by the VM.
+// coreth always uses the avalanchego provided database.
+func (vm *VM) initializeDBs(db avalanchedatabase.Database) error {
+	// Use NewNested rather than New so that the structure of the database
+	// remains the same regardless of the provided baseDB type.
+	vm.chaindb = rawdb.NewDatabase(database.WrapDatabase(prefixdb.NewNested(ethDBPrefix, db)))
+	vm.versiondb = versiondb.New(db)
+	vm.acceptedBlockDB = prefixdb.New(acceptedPrefix, vm.versiondb)
+	vm.metadataDB = prefixdb.New(metadataPrefix, vm.versiondb)
+	vm.db = db
+	// Note warpDB is not part of versiondb because it is not necessary
+	// that warp signatures are committed to the database atomically with
+	// the last accepted block.
+	vm.warpDB = prefixdb.New(warpPrefix, db)
+	return nil
+}
+
+func (vm *VM) inspectDatabases() error {
+	start := time.Now()
+	log.Info("Starting database inspection")
+	if err := rawdb.InspectDatabase(vm.chaindb, nil, nil); err != nil {
+		return err
+	}
+	if err := inspectDB(vm.acceptedBlockDB, "acceptedBlockDB"); err != nil {
+		return err
+	}
+	if err := inspectDB(vm.metadataDB, "metadataDB"); err != nil {
+		return err
+	}
+	if err := inspectDB(vm.warpDB, "warpDB"); err != nil {
+		return err
+	}
+	log.Info("Completed database inspection", "elapsed", time.Since(start))
+	return nil
+}
+
+func inspectDB(db avalanchedatabase.Database, label string) error {
+	it := db.NewIterator()
+	defer it.Release()
+
+	var (
+		count  int64
+		start  = time.Now()
+		logged = time.Now()
+
+		// Totals
+		total common.StorageSize
+	)
+	// Inspect key-value database first.
+	for it.Next() {
+		var (
+			key  = it.Key()
+			size = common.StorageSize(len(key) + len(it.Value()))
+		)
+		total += size
+		count++
+		if count%1000 == 0 && time.Since(logged) > 8*time.Second {
+			log.Info("Inspecting database", "label", label, "count", count, "elapsed", common.PrettyDuration(time.Since(start)))
+			logged = time.Now()
+		}
+	}
+	// Display the database statistic.
+	log.Info("Database statistics", "label", label, "total", total.String(), "count", count)
+	return nil
+}
diff --git a/plugin/evm/vm_test.go b/plugin/evm/vm_test.go
index 56b56cf93c..2a79f3fb6f 100644
--- a/plugin/evm/vm_test.go
+++ b/plugin/evm/vm_test.go
@@ -3170,7 +3170,7 @@ func TestConfigureLogLevel(t *testing.T) {
 				}
 			}
 
-			// If the VM was not initialized, do not attept to shut it down
+			// If the VM was not initialized, do not attempt to shut it down
 			if err == nil {
 				shutdownChan := make(chan error, 1)
 				shutdownFunc := func() {
diff --git a/precompile/contract/interfaces.go b/precompile/contract/interfaces.go
index b3ffb02fe2..44c3cfa633 100644
--- a/precompile/contract/interfaces.go
+++ b/precompile/contract/interfaces.go
@@ -62,7 +62,7 @@ type ConfigurationBlockContext interface {
 
 type BlockContext interface {
 	ConfigurationBlockContext
-	// GetResults returns an arbitrary byte array result of verifying the predicates
+	// GetPredicateResults returns an arbitrary byte array result of verifying the predicates
 	// of the given transaction, precompile address pair.
 	GetPredicateResults(txHash common.Hash, precompileAddress common.Address) []byte
 }
diff --git a/precompile/contracts/warp/README.md b/precompile/contracts/warp/README.md
index 10e1daaa38..73ca165224 100644
--- a/precompile/contracts/warp/README.md
+++ b/precompile/contracts/warp/README.md
@@ -57,7 +57,7 @@ To use this function, the transaction must include the signed Avalanche Warp Mes
 This leads to the following advantages:
 
 1. The EVM execution does not need to verify the Warp Message at runtime (no signature verification or external calls to the P-Chain)
-2. The EVM can deterministically re-execute and re-verify blocks assuming the predicate was verified by the network (eg., in bootstrapping)
+2. The EVM can deterministically re-execute and re-verify blocks assuming the predicate was verified by the network (e.g., in bootstrapping)
 
 This pre-verification is performed using the ProposerVM Block header during [block verification](../../../plugin/evm/block.go#L220) and [block building](../../../miner/worker.go#L200).
 
diff --git a/rpc/handler.go b/rpc/handler.go
index a15f6b20be..ef35a61ca8 100644
--- a/rpc/handler.go
+++ b/rpc/handler.go
@@ -479,7 +479,7 @@ func (h *handler) startCallProc(fn func(*callProc)) {
 	}
 }
 
-// handleResponse processes method call responses.
+// handleResponses processes method call responses.
 func (h *handler) handleResponses(batch []*jsonrpcMessage, handleCall func(*jsonrpcMessage)) {
 	var resolvedops []*requestOp
 	handleResp := func(msg *jsonrpcMessage) {
diff --git a/rpc/types.go b/rpc/types.go
index b2f5b98528..c96e7bc74f 100644
--- a/rpc/types.go
+++ b/rpc/types.go
@@ -62,7 +62,7 @@ type ServerCodec interface {
 type jsonWriter interface {
 	// writeJSON writes a message to the connection.
 	writeJSON(ctx context.Context, msg interface{}, isError bool) error
-	// writeJSON writes a message to the connection with the option of skipping the deadline.
+	// writeJSONSkipDeadline writes a message to the connection with the option of skipping the deadline.
 	writeJSONSkipDeadline(ctx context.Context, msg interface{}, isError bool, skip bool) error
 	// Closed returns a channel which is closed when the connection is closed.
 	closed() <-chan interface{}
diff --git a/scripts/build_docker_image.sh b/scripts/build_docker_image.sh
deleted file mode 100755
index 9126a47a8d..0000000000
--- a/scripts/build_docker_image.sh
+++ /dev/null
@@ -1,23 +0,0 @@
-#!/usr/bin/env bash
-
-set -euo pipefail
-
-# Avalanche root directory
-CORETH_PATH=$(
-  cd "$(dirname "${BASH_SOURCE[0]}")"
-  cd .. && pwd
-)
-
-# Load the constants
-source "$CORETH_PATH"/scripts/constants.sh
-
-# Load the versions
-source "$CORETH_PATH"/scripts/versions.sh
-
-# WARNING: this will use the most recent commit even if there are un-committed changes present
-BUILD_IMAGE_ID=${BUILD_IMAGE_ID:-"${CURRENT_BRANCH}"}
-echo "Building Docker Image: $DOCKERHUB_REPO:$BUILD_IMAGE_ID based of AvalancheGo@$AVALANCHE_VERSION"
-docker build -t "$DOCKERHUB_REPO:$BUILD_IMAGE_ID" "$CORETH_PATH" -f "$CORETH_PATH/Dockerfile" \
-  --build-arg AVALANCHE_VERSION="$AVALANCHE_VERSION" \
-  --build-arg CORETH_COMMIT="$CORETH_COMMIT" \
-  --build-arg CURRENT_BRANCH="$CURRENT_BRANCH"
diff --git a/scripts/known_flakes.txt b/scripts/known_flakes.txt
index b28b4e710c..0f324a6714 100644
--- a/scripts/known_flakes.txt
+++ b/scripts/known_flakes.txt
@@ -5,6 +5,7 @@ TestMempoolAtmTxsAppGossipHandlingDiscardedTx
 TestMempoolEthTxsAppGossipHandling
 TestResumeSyncAccountsTrieInterrupted
 TestResyncNewRootAfterDeletes
+TestTimedUnlock
 TestTransactionSkipIndexing
 TestVMShutdownWhileSyncing
 TestWaitDeployedCornerCases
diff --git a/sync/statesync/trie_sync_stats.go b/sync/statesync/trie_sync_stats.go
index bb4770e28c..c55fc8da35 100644
--- a/sync/statesync/trie_sync_stats.go
+++ b/sync/statesync/trie_sync_stats.go
@@ -79,7 +79,7 @@ func (t *trieSyncStats) incLeafs(segment *trieSegment, count uint64, remaining u
 	}
 }
 
-// estimateSegmentsInProgressTime retrns the ETA for all trie segments
+// estimateSegmentsInProgressTime returns the ETA for all trie segments
 // in progress to finish (uses the one with most remaining leafs to estimate).
 func (t *trieSyncStats) estimateSegmentsInProgressTime() time.Duration {
 	if len(t.remainingLeafs) == 0 {
diff --git a/warp/aggregator/aggregator_test.go b/warp/aggregator/aggregator_test.go
index 98e90607db..055d3edfa8 100644
--- a/warp/aggregator/aggregator_test.go
+++ b/warp/aggregator/aggregator_test.go
@@ -230,7 +230,7 @@ func TestAggregateSignatures(t *testing.T) {
 			expectedErr:     nil,
 		},
 		{
-			name: "early termination of signature fetching on parent context cancelation",
+			name: "early termination of signature fetching on parent context cancellation",
 			contextWithCancelFunc: func() (context.Context, context.CancelFunc) {
 				ctx, cancel := context.WithCancel(context.Background())
 				cancel()
diff --git a/warp/backend.go b/warp/backend.go
index 6e1f6a9553..d35c96b8fb 100644
--- a/warp/backend.go
+++ b/warp/backend.go
@@ -180,7 +180,7 @@ func (b *backend) GetMessage(messageID ids.ID) (*avalancheWarp.UnsignedMessage,
 
 	unsignedMessageBytes, err := b.db.Get(messageID[:])
 	if err != nil {
-		return nil, fmt.Errorf("failed to get warp message %s from db: %w", messageID.String(), err)
+		return nil, err
 	}
 
 	unsignedMessage, err := avalancheWarp.ParseUnsignedMessage(unsignedMessageBytes)
diff --git a/warp/backend_test.go b/warp/backend_test.go
index 4935875ece..cd7aa1ea76 100644
--- a/warp/backend_test.go
+++ b/warp/backend_test.go
@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/ava-labs/avalanchego/cache"
+	"github.com/ava-labs/avalanchego/database"
 	"github.com/ava-labs/avalanchego/database/memdb"
 	"github.com/ava-labs/avalanchego/ids"
 	"github.com/ava-labs/avalanchego/utils"
@@ -157,6 +158,12 @@ func TestOffChainMessages(t *testing.T) {
 				require.Equal(expectedSignatureBytes, signature[:])
 			},
 		},
+		"unknown message": {
+			check: func(require *require.Assertions, b Backend) {
+				_, err := b.GetMessage(testUnsignedMessage.ID())
+				require.ErrorIs(err, database.ErrNotFound)
+			},
+		},
 		"invalid message": {
 			offchainMessages: [][]byte{{1, 2, 3}},
 			err:              errParsingOffChainMessage,
diff --git a/warp/verifier_backend.go b/warp/verifier_backend.go
index c70563c585..3c8427b8ff 100644
--- a/warp/verifier_backend.go
+++ b/warp/verifier_backend.go
@@ -7,6 +7,7 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/ava-labs/avalanchego/database"
 	"github.com/ava-labs/avalanchego/snow/engine/common"
 	avalancheWarp "github.com/ava-labs/avalanchego/vms/platformvm/warp"
 	"github.com/ava-labs/avalanchego/vms/platformvm/warp/payload"
@@ -24,6 +25,11 @@ func (b *backend) Verify(ctx context.Context, unsignedMessage *avalancheWarp.Uns
 	// Known on-chain messages should be signed
 	if _, err := b.GetMessage(messageID); err == nil {
 		return nil
+	} else if err != database.ErrNotFound {
+		return &common.AppError{
+			Code:    ParseErrCode,
+			Message: fmt.Sprintf("failed to get message %s: %s", messageID, err.Error()),
+		}
 	}
 
 	parsed, err := payload.Parse(unsignedMessage.Payload)
@@ -53,7 +59,7 @@ func (b *backend) verifyBlockMessage(ctx context.Context, blockHashPayload *payl
 	blockID := blockHashPayload.Hash
 	_, err := b.blockClient.GetAcceptedBlock(ctx, blockID)
 	if err != nil {
-		b.stats.IncBlockSignatureValidationFail()
+		b.stats.IncBlockValidationFail()
 		return &common.AppError{
 			Code:    VerifyErrCode,
 			Message: fmt.Sprintf("failed to get block %s: %s", blockID, err.Error()),
diff --git a/warp/verifier_backend_test.go b/warp/verifier_backend_test.go
index 4bf11541b0..a58726aa0f 100644
--- a/warp/verifier_backend_test.go
+++ b/warp/verifier_backend_test.go
@@ -56,7 +56,7 @@ func TestAddressedCallSignatures(t *testing.T) {
 			},
 			verifyStats: func(t *testing.T, stats *verifierStats) {
 				require.EqualValues(t, 0, stats.messageParseFail.Snapshot().Count())
-				require.EqualValues(t, 0, stats.blockSignatureValidationFail.Snapshot().Count())
+				require.EqualValues(t, 0, stats.blockValidationFail.Snapshot().Count())
 			},
 		},
 		"offchain message": {
@@ -65,7 +65,7 @@ func TestAddressedCallSignatures(t *testing.T) {
 			},
 			verifyStats: func(t *testing.T, stats *verifierStats) {
 				require.EqualValues(t, 0, stats.messageParseFail.Snapshot().Count())
-				require.EqualValues(t, 0, stats.blockSignatureValidationFail.Snapshot().Count())
+				require.EqualValues(t, 0, stats.blockValidationFail.Snapshot().Count())
 			},
 		},
 		"unknown message": {
@@ -78,7 +78,7 @@ func TestAddressedCallSignatures(t *testing.T) {
 			},
 			verifyStats: func(t *testing.T, stats *verifierStats) {
 				require.EqualValues(t, 1, stats.messageParseFail.Snapshot().Count())
-				require.EqualValues(t, 0, stats.blockSignatureValidationFail.Snapshot().Count())
+				require.EqualValues(t, 0, stats.blockValidationFail.Snapshot().Count())
 			},
 			err: &common.AppError{Code: ParseErrCode},
 		},
@@ -177,7 +177,7 @@ func TestBlockSignatures(t *testing.T) {
 				return toMessageBytes(knownBlkID), signature[:]
 			},
 			verifyStats: func(t *testing.T, stats *verifierStats) {
-				require.EqualValues(t, 0, stats.blockSignatureValidationFail.Snapshot().Count())
+				require.EqualValues(t, 0, stats.blockValidationFail.Snapshot().Count())
 				require.EqualValues(t, 0, stats.messageParseFail.Snapshot().Count())
 			},
 		},
@@ -187,7 +187,7 @@ func TestBlockSignatures(t *testing.T) {
 				return toMessageBytes(unknownBlockID), nil
 			},
 			verifyStats: func(t *testing.T, stats *verifierStats) {
-				require.EqualValues(t, 1, stats.blockSignatureValidationFail.Snapshot().Count())
+				require.EqualValues(t, 1, stats.blockValidationFail.Snapshot().Count())
 				require.EqualValues(t, 0, stats.messageParseFail.Snapshot().Count())
 			},
 			err: &common.AppError{Code: VerifyErrCode},
diff --git a/warp/verifier_stats.go b/warp/verifier_stats.go
index 3ee90312d9..980d464429 100644
--- a/warp/verifier_stats.go
+++ b/warp/verifier_stats.go
@@ -10,18 +10,18 @@ import (
 type verifierStats struct {
 	messageParseFail metrics.Counter
 	// BlockRequest metrics
-	blockSignatureValidationFail metrics.Counter
+	blockValidationFail metrics.Counter
 }
 
 func newVerifierStats() *verifierStats {
 	return &verifierStats{
-		messageParseFail:             metrics.NewRegisteredCounter("message_parse_fail", nil),
-		blockSignatureValidationFail: metrics.NewRegisteredCounter("block_signature_validation_fail", nil),
+		messageParseFail:    metrics.NewRegisteredCounter("warp_backend_message_parse_fail", nil),
+		blockValidationFail: metrics.NewRegisteredCounter("warp_backend_block_validation_fail", nil),
 	}
 }
 
-func (h *verifierStats) IncBlockSignatureValidationFail() {
-	h.blockSignatureValidationFail.Inc(1)
+func (h *verifierStats) IncBlockValidationFail() {
+	h.blockValidationFail.Inc(1)
 }
 
 func (h *verifierStats) IncMessageParseFail() {