statemanager: cache and other refactors

packages/client/src/execution/vmexecution.ts

@@ -4,10 +4,15 @@
   DBSetHashToNumber,
   DBSetTD,
 } from '@ethereumjs/blockchain'
-import { CacheType, ConsensusType, Hardfork } from '@ethereumjs/common'
+import { ConsensusType, Hardfork } from '@ethereumjs/common'
 import { MCLBLS, RustBN254 } from '@ethereumjs/evm'
 import { getGenesis } from '@ethereumjs/genesis'
-import { DefaultStateManager, StatelessVerkleStateManager } from '@ethereumjs/statemanager'
+import {
+  CacheType,
+  Caches,
+  DefaultStateManager,
+  StatelessVerkleStateManager,
+} from '@ethereumjs/statemanager'
 import { createTrie } from '@ethereumjs/trie'
 import {
   BIGINT_0,
@@ -160,21 +165,23 @@
     const stateManager = new DefaultStateManager({
       trie,
       prefixStorageTrieKeys: this.config.prefixStorageTrieKeys,
-      accountCacheOpts: {
-        deactivate: false,
-        type: CacheType.LRU,
-        size: this.config.accountCache,
-      },
-      storageCacheOpts: {
-        deactivate: false,
-        type: CacheType.LRU,
-        size: this.config.storageCache,
-      },
-      codeCacheOpts: {
-        deactivate: false,
-        type: CacheType.LRU,
-        size: this.config.codeCache,
-      },
+      caches: new Caches({
+        accountCacheOpts: {
+          deactivate: false,
+          type: CacheType.LRU,
+          size: this.config.accountCache,
+        },
+        storageCacheOpts: {
+          deactivate: false,
+          type: CacheType.LRU,
+          size: this.config.storageCache,
+        },
+        codeCacheOpts: {
+          deactivate: false,
+          type: CacheType.LRU,
+          size: this.config.codeCache,
+        },
+      }),
       common: this.config.chainCommon,
     })
 

packages/client/src/rpc/modules/eth.ts

@@ -45,8 +45,8 @@
 import type { FullEthereumService, Service } from '../../service/index.js'
 import type { RpcTx } from '../types.js'
 import type { Block, JsonRpcBlock } from '@ethereumjs/block'
-import type { Proof } from '@ethereumjs/common'
 import type { Log } from '@ethereumjs/evm'
+import type { Proof } from '@ethereumjs/statemanager'
 import type {
   FeeMarketEIP1559Transaction,
   LegacyTransaction,

packages/common/src/interfaces.ts

@@ -209,35 +209,4 @@ export interface StateManagerInterface {
    */
   clearCaches(): void
   shallowCopy(downlevelCaches?: boolean): StateManagerInterface
-
-  /*
-   * Cache properties
-   */
-  _accountCache?: Cache
-  _storageCache?: Cache
-  _codeCache?: Cache
-
-  _accountCacheSettings?: CacheSettings
-  _storageCacheSettings?: CacheSettings
-  _codeCacheSettings?: CacheSettings
-}
-
-/**
- * Cache related
- */
-export enum CacheType {
-  LRU = 'lru',
-  ORDERED_MAP = 'ordered_map',
-}
-
-export type CacheSettings = {
-  deactivate: boolean
-  type: CacheType
-  size: number
-}
-
-interface Cache {
-  checkpoint(): void
-  commit(): void
-  revert(): void
 }

packages/statemanager/src/cache/account.ts

@@ -1,10 +1,10 @@
-import { CacheType } from '@ethereumjs/common'
 import { bytesToUnprefixedHex } from '@ethereumjs/util'
 import { OrderedMap } from '@js-sdsl/ordered-map'
 import debugDefault from 'debug'
 import { LRUCache } from 'lru-cache'
 
 import { Cache } from './cache.js'
+import { CacheType } from './types.js'
 
 import type { CacheOpts } from './types.js'
 import type { Account, Address } from '@ethereumjs/util'
@@ -68,14 +68,14 @@ export class AccountCache extends Cache {
   put(
     address: Address,
     account: Account | undefined,
-    couldBeParitalAccount: boolean = false,
+    couldBePartialAccount: boolean = false,
   ): void {
     const addressHex = bytesToUnprefixedHex(address.bytes)
     this._saveCachePreState(addressHex)
     const elem = {
       accountRLP:
         account !== undefined
-          ? couldBeParitalAccount
+          ? couldBePartialAccount
             ? account.serializeWithPartialInfo()
             : account.serialize()
           : undefined,

packages/statemanager/src/cache/caches.ts

@@ -0,0 +1,93 @@
+import { AccountCache } from './account.js'
+import { CodeCache } from './code.js'
+import { StorageCache } from './storage.js'
+import { type CacheSettings, CacheType, type CachesStateManagerOpts } from './types.js'
+
+import type { Address } from '@ethereumjs/util'
+
+export class Caches {
+  account?: AccountCache
+  code?: CodeCache
+  storage?: StorageCache
+
+  settings: Record<'account' | 'code' | 'storage', CacheSettings>
+
+  constructor(opts: CachesStateManagerOpts = {}) {
+    const accountSettings = {
+      deactivate:
+        (opts.accountCacheOpts?.deactivate === true || opts.accountCacheOpts?.size === 0) ?? false,
+      type: opts.accountCacheOpts?.type ?? CacheType.ORDERED_MAP,
+      size: opts.accountCacheOpts?.size ?? 100000,
+    }
+    const storageSettings = {
+      deactivate:
+        (opts.storageCacheOpts?.deactivate === true || opts.storageCacheOpts?.size === 0) ?? false,
+      type: opts.storageCacheOpts?.type ?? CacheType.ORDERED_MAP,
+      size: opts.storageCacheOpts?.size ?? 20000,
+    }
+
+    const codeSettings = {
+      deactivate:
+        (opts.codeCacheOpts?.deactivate === true || opts.codeCacheOpts?.size === 0) ?? false,
+      type: opts.codeCacheOpts?.type ?? CacheType.ORDERED_MAP,
+      size: opts.codeCacheOpts?.size ?? 20000,
+    }
+
+    this.settings = {
+      account: accountSettings,
+      code: codeSettings,
+      storage: storageSettings,
+    }
+
+    if (this.settings.account.deactivate === false) {
+      this.account = new AccountCache({
+        size: this.settings.account.size,
+        type: this.settings.account.type,
+      })
+    }
+
+    if (this.settings.storage.deactivate === false) {
+      this.storage = new StorageCache({
+        size: this.settings.storage.size,
+        type: this.settings.storage.type,
+      })
+    }
+
+    if (this.settings.code.deactivate === false) {
+      this.code = new CodeCache({
+        size: this.settings.code.size,
+        type: this.settings.code.type,
+      })
+    }
+  }
+
+  checkpoint() {
+    this.account?.checkpoint()
+    this.storage?.checkpoint()
+    this.code?.checkpoint()
+  }
+
+  clear() {
+    this.account?.clear()
+    this.storage?.clear()
+    this.code?.clear()
+  }
+
+  commit() {
+    this.account?.commit()
+    this.storage?.commit()
+    this.code?.commit()
+  }
+
+  deleteAccount(address: Address) {
+    this.code?.del(address)
+    this.account?.del(address)
+    this.storage?.clearStorage(address)
+  }
+
+  revert() {
+    this.account?.revert()
+    this.storage?.revert()
+    this.code?.revert()
+  }
+}

packages/statemanager/src/cache/code.ts

@@ -1,10 +1,10 @@
-import { CacheType } from '@ethereumjs/common'
 import { bytesToUnprefixedHex } from '@ethereumjs/util'
 import { OrderedMap } from '@js-sdsl/ordered-map'
 import debugDefault from 'debug'
 import { LRUCache } from 'lru-cache'
 
 import { Cache } from './cache.js'
+import { CacheType } from './types.js'
 
 import type { CacheOpts } from './types.js'
 import type { Address } from '@ethereumjs/util'

packages/statemanager/src/cache/index.ts

@@ -1,4 +1,5 @@
 export * from './account.js'
+export * from './caches.js'
 export * from './code.js'
 export * from './originalStorageCache.js'
 export * from './storage.js'

packages/statemanager/src/cache/storage.ts

@@ -1,10 +1,10 @@
-import { CacheType } from '@ethereumjs/common'
 import { bytesToUnprefixedHex, hexToBytes } from '@ethereumjs/util'
 import { OrderedMap } from '@js-sdsl/ordered-map'
 import debugDefault from 'debug'
 import { LRUCache } from 'lru-cache'
 
 import { Cache } from './cache.js'
+import { CacheType } from './types.js'
 
 import type { CacheOpts } from './types.js'
 import type { Address } from '@ethereumjs/util'

packages/statemanager/src/cache/types.ts

@@ -1,6 +1,58 @@
-import type { CacheType } from '@ethereumjs/common'
+export enum CacheType {
+  LRU = 'lru',
+  ORDERED_MAP = 'ordered_map',
+}
 
 export interface CacheOpts {
   size: number
   type: CacheType
 }
+
+export type CacheSettings = {
+  deactivate: boolean
+  type: CacheType
+  size: number
+}
+
+export interface CacheStateManagerOpts {
+  /**
+   * Allows for cache deactivation
+   *
+   * Depending on the use case and underlying datastore (and eventual concurrent cache
+   * mechanisms there), usage with or without cache can be faster
+   *
+   * Default: false
+   */
+  deactivate?: boolean
+
+  /**
+   * Cache type to use.
+   *
+   * Available options:
+   *
+   * ORDERED_MAP: Cache with no fixed upper bound and dynamic allocation,
+   * use for dynamic setups like testing or similar.
+   *
+   * LRU: LRU cache with pre-allocation of memory and a fixed size.
+   * Use for larger and more persistent caches.
+   */
+  type?: CacheType
+
+  /**
+   * Size of the cache (only for LRU cache)
+   *
+   * Default: 100000 (account cache) / 20000 (storage cache) / 20000 (code cache)
+   *
+   * Note: the cache/trie interplay mechanism is designed in a way that
+   * the theoretical number of max modified accounts between two flush operations
+   * should be smaller than the cache size, otherwise the cache will "forget" the
+   * old modifications resulting in an incomplete set of trie-flushed accounts.
+   */
+  size?: number
+}
+
+export interface CachesStateManagerOpts {
+  accountCacheOpts?: CacheStateManagerOpts
+  codeCacheOpts?: CacheStateManagerOpts
+  storageCacheOpts?: CacheStateManagerOpts
+}