Separate Wasmstore from normal db: initial

arbitrum/recordingdb.go

@@ -32,12 +32,13 @@ var (
 type RecordingKV struct {
 	inner         *trie.Database
 	diskDb        ethdb.KeyValueStore
+	wasmDb        ethdb.KeyValueStore
 	readDbEntries map[common.Hash][]byte
 	enableBypass  bool
 }
 
-func newRecordingKV(inner *trie.Database, diskDb ethdb.KeyValueStore) *RecordingKV {
-	return &RecordingKV{inner, diskDb, make(map[common.Hash][]byte), false}
+func newRecordingKV(inner *trie.Database, diskDb ethdb.KeyValueStore, wasmDb ethdb.KeyValueStore) *RecordingKV {
+	return &RecordingKV{inner, diskDb, wasmDb, make(map[common.Hash][]byte), false}
 }
 
 func (db *RecordingKV) Has(key []byte) (bool, error) {
@@ -57,10 +58,10 @@ func (db *RecordingKV) Get(key []byte) ([]byte, error) {
 		res, err = db.diskDb.Get(key)
 	} else if ok, _ := rawdb.IsActivatedAsmKey(key); ok {
 		// Arbitrum: the asm is non-consensus
-		return db.diskDb.Get(key)
+		return db.wasmDb.Get(key)
 	} else if ok, _ := rawdb.IsActivatedModuleKey(key); ok {
 		// Arbitrum: the module is non-consensus (only its hash is)
-		return db.diskDb.Get(key)
+		return db.wasmDb.Get(key)
 	} else {
 		err = fmt.Errorf("recording KV attempted to access non-hash key %v", hex.EncodeToString(key))
 	}
@@ -273,7 +274,7 @@ func (r *RecordingDatabase) PrepareRecording(ctx context.Context, lastBlockHeade
 	}
 	finalDereference := lastBlockHeader // dereference in case of error
 	defer func() { r.Dereference(finalDereference) }()
-	recordingKeyValue := newRecordingKV(r.db.TrieDB(), r.db.DiskDB())
+	recordingKeyValue := newRecordingKV(r.db.TrieDB(), r.db.DiskDB(), r.db.WasmStore())
 
 	recordingStateDatabase := state.NewDatabase(rawdb.NewDatabase(recordingKeyValue))
 	var prevRoot common.Hash

core/rawdb/database.go

@@ -40,6 +40,15 @@ type freezerdb struct {
 	ancientRoot string
 	ethdb.KeyValueStore
 	ethdb.AncientStore
+	wasmDB ethdb.KeyValueStore
+}
+
+// AncientDatadir returns the path of root ancient directory.
+func (frdb *freezerdb) WasmDataBase() ethdb.KeyValueStore {
+	if frdb.wasmDB == nil {
+		return frdb
+	}
+	return frdb.wasmDB
 }
 
 // AncientDatadir returns the path of root ancient directory.
@@ -165,6 +174,11 @@ func (db *nofreezedb) AncientDatadir() (string, error) {
 	return "", errNotSupported
 }
 
+// AncientDatadir returns the path of root ancient directory.
+func (db *nofreezedb) WasmDataBase() ethdb.KeyValueStore {
+	return db
+}
+
 // NewDatabase creates a high level database on top of a given key-value data
 // store without a freezer moving immutable chain segments into cold storage.
 func NewDatabase(db ethdb.KeyValueStore) ethdb.Database {
@@ -360,6 +374,7 @@ type OpenOptions struct {
 	Directory         string // the datadir
 	AncientsDirectory string // the ancients-dir
 	Namespace         string // the namespace for database relevant metrics
+	WasmDirectory     string // the wasm-dir
 	Cache             int    // the capacity(in megabytes) of the data caching
 	Handles           int    // number of files to be open simultaneously
 	ReadOnly          bool
@@ -416,6 +431,15 @@ func Open(o OpenOptions) (ethdb.Database, error) {
 		kvdb.Close()
 		return nil, err
 	}
+	if len(o.WasmDirectory) != 0 {
+		wasmOptions := o
+		wasmOptions.Directory = o.WasmDirectory
+		wasmDb, err := openKeyValueDatabase(wasmOptions)
+		if err != nil {
+			return nil, err
+		}
+		frdb.(*freezerdb).wasmDB = wasmDb
+	}
 	return frdb, nil
 }
 

core/rawdb/table.go

@@ -40,6 +40,10 @@ func (t *table) Close() error {
 	return nil
 }
 
+func (t *table) WasmDataBase() ethdb.KeyValueStore {
+	return t.db.WasmDataBase()
+}
+
 // Has retrieves if a prefixed version of a key is present in the database.
 func (t *table) Has(key []byte) (bool, error) {
 	return t.db.Has(append([]byte(t.prefix), key...))

core/state/database.go

@@ -54,6 +54,7 @@ type Database interface {
 	// Arbitrum: Read activated Stylus contracts
 	ActivatedAsm(moduleHash common.Hash) (asm []byte, err error)
 	ActivatedModule(moduleHash common.Hash) (module []byte, err error)
+	WasmStore() ethdb.KeyValueStore
 
 	// OpenTrie opens the main account trie.
 	OpenTrie(root common.Hash) (Trie, error)
@@ -164,6 +165,7 @@ func NewDatabaseWithConfig(db ethdb.Database, config *trie.Config) Database {
 		activatedModuleCache: lru.NewSizeConstrainedCache[common.Hash, []byte](activatedWasmCacheSize),
 
 		disk:          db,
+		wasmdb:        db.WasmDataBase(),
 		codeSizeCache: lru.NewCache[common.Hash, int](codeSizeCacheSize),
 		codeCache:     lru.NewSizeConstrainedCache[common.Hash, []byte](codeCacheSize),
 		triedb:        trie.NewDatabase(db, config),
@@ -179,6 +181,7 @@ func NewDatabaseWithNodeDB(db ethdb.Database, triedb *trie.Database) Database {
 		activatedModuleCache: lru.NewSizeConstrainedCache[common.Hash, []byte](activatedWasmCacheSize),
 
 		disk:          db,
+		wasmdb:        db.WasmDataBase(),
 		codeSizeCache: lru.NewCache[common.Hash, int](codeSizeCacheSize),
 		codeCache:     lru.NewSizeConstrainedCache[common.Hash, []byte](codeCacheSize),
 		triedb:        triedb,
@@ -192,11 +195,16 @@ type cachingDB struct {
 	activatedModuleCache *lru.SizeConstrainedCache[common.Hash, []byte]
 
 	disk          ethdb.KeyValueStore
+	wasmdb        ethdb.KeyValueStore
 	codeSizeCache *lru.Cache[common.Hash, int]
 	codeCache     *lru.SizeConstrainedCache[common.Hash, []byte]
 	triedb        *trie.Database
 }
 
+func (db *cachingDB) WasmStore() ethdb.KeyValueStore {
+	return db.wasmdb
+}
+
 // OpenTrie opens the main account trie at a specific root hash.
 func (db *cachingDB) OpenTrie(root common.Hash) (Trie, error) {
 	if db.triedb.IsVerkle() {

core/state/database_arbitrum.go

@@ -12,7 +12,7 @@ func (db *cachingDB) ActivatedAsm(moduleHash common.Hash) ([]byte, error) {
 		return asm, nil
 	}
 	wasmKey := rawdb.ActivatedAsmKey(moduleHash)
-	asm, err := db.disk.Get(wasmKey[:])
+	asm, err := db.wasmdb.Get(wasmKey[:])
 	if err != nil {
 		return nil, err
 	}
@@ -28,7 +28,7 @@ func (db *cachingDB) ActivatedModule(moduleHash common.Hash) ([]byte, error) {
 		return module, nil
 	}
 	wasmKey := rawdb.ActivatedModuleKey(moduleHash)
-	module, err := db.disk.Get(wasmKey[:])
+	module, err := db.wasmdb.Get(wasmKey[:])
 	if err != nil {
 		return nil, err
 	}

core/state/statedb.go

@@ -1249,6 +1249,7 @@ func (s *StateDB) Commit(block uint64, deleteEmptyObjects bool) (common.Hash, er
 		storageTrieNodesDeleted int
 		nodes                   = trienode.NewMergedNodeSet()
 		codeWriter              = s.db.DiskDB().NewBatch()
+		wasmCodeWriter          = s.db.WasmStore().NewBatch()
 	)
 	// Handle all state deletions first
 	incomplete, err := s.handleDestruction(nodes)
@@ -1286,7 +1287,7 @@ func (s *StateDB) Commit(block uint64, deleteEmptyObjects bool) (common.Hash, er
 
 	// Arbitrum: write Stylus programs to disk
 	for moduleHash, info := range s.arbExtraData.activatedWasms {
-		rawdb.WriteActivation(codeWriter, moduleHash, info.Asm, info.Module)
+		rawdb.WriteActivation(wasmCodeWriter, moduleHash, info.Asm, info.Module)
 	}
 	if len(s.arbExtraData.activatedWasms) > 0 {
 		s.arbExtraData.activatedWasms = make(map[common.Hash]*ActivatedWasm)
@@ -1297,6 +1298,11 @@ func (s *StateDB) Commit(block uint64, deleteEmptyObjects bool) (common.Hash, er
 			log.Crit("Failed to commit dirty codes", "error", err)
 		}
 	}
+	if wasmCodeWriter.ValueSize() > 0 {
+		if err := wasmCodeWriter.Write(); err != nil {
+			log.Crit("Failed to commit dirty stylus codes", "error", err)
+		}
+	}
 	// Write the account trie changes, measuring the amount of wasted time
 	var start time.Time
 	if metrics.EnabledExpensive {

core/state/statedb_arbitrum.go

@@ -89,12 +89,16 @@ func (s *StateDB) ActivateWasm(moduleHash common.Hash, asm, module []byte) {
 	})
 }
 
-func (s *StateDB) GetActivatedAsm(moduleHash common.Hash) []byte {
+func (s *StateDB) TryGetActivatedAsm(moduleHash common.Hash) ([]byte, error) {
 	info, exists := s.arbExtraData.activatedWasms[moduleHash]
 	if exists {
-		return info.Asm
+		return info.Asm, nil
 	}
-	asm, err := s.db.ActivatedAsm(moduleHash)
+	return s.db.ActivatedAsm(moduleHash)
+}
+
+func (s *StateDB) GetActivatedAsm(moduleHash common.Hash) []byte {
+	asm, err := s.TryGetActivatedAsm(moduleHash)
 	if err != nil {
 		s.setError(fmt.Errorf("failed to load asm for %x: %v", moduleHash, err))
 	}

core/vm/interface.go

@@ -31,6 +31,7 @@ type StateDB interface {
 	// Arbitrum: manage Stylus wasms
 	ActivateWasm(moduleHash common.Hash, asm, module []byte)
 	GetActivatedAsm(moduleHash common.Hash) (asm []byte)
+	TryGetActivatedAsm(moduleHash common.Hash) (asm []byte, err error)
 	GetActivatedModule(moduleHash common.Hash) (module []byte)
 	RecordCacheWasm(wasm state.CacheWasm)
 	RecordEvictWasm(wasm state.EvictWasm)

ethdb/database.go

@@ -178,6 +178,10 @@ type AncientStore interface {
 	io.Closer
 }
 
+type WasmDataBaseRetriever interface {
+	WasmDataBase() KeyValueStore
+}
+
 // Database contains all the methods required by the high level database to not
 // only access the key-value data store but also the chain freezer.
 type Database interface {
@@ -189,4 +193,5 @@ type Database interface {
 	Compacter
 	Snapshotter
 	io.Closer
+	WasmDataBaseRetriever
 }

ethdb/remotedb/remotedb.go

@@ -39,6 +39,10 @@ func (db *Database) Has(key []byte) (bool, error) {
 	return true, nil
 }
 
+func (t *Database) WasmDataBase() ethdb.KeyValueStore {
+	return t
+}
+
 func (db *Database) Get(key []byte) ([]byte, error) {
 	var resp hexutil.Bytes
 	err := db.remote.Call(&resp, "debug_dbGet", hexutil.Bytes(key))

internal/ethapi/api.go

@@ -962,12 +962,17 @@ type OverrideAccount struct {
 // StateOverride is the collection of overridden accounts.
 type StateOverride map[common.Address]OverrideAccount
 
+var arbStorageAddress = common.HexToAddress("0xA4B05FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")
+
 // Apply overrides the fields of specified accounts into the given state.
 func (diff *StateOverride) Apply(state *state.StateDB) error {
 	if diff == nil {
 		return nil
 	}
 	for addr, account := range *diff {
+		if addr == arbStorageAddress {
+			return errors.New("overriding 0xA4B05FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF not allowed")
+		}
 		// Override account nonce.
 		if account.Nonce != nil {
 			state.SetNonce(addr, uint64(*account.Nonce))

node/node.go

@@ -797,6 +797,34 @@ func (n *Node) OpenDatabaseWithFreezer(name string, cache, handles int, ancient
 			ReadOnly:          readonly,
 		})
 	}
+	if err == nil {
+		db = n.wrapDatabase(db)
+	}
+	return db, err
+}
+
+func (n *Node) OpenDatabaseWithFreezerAndWasm(name string, wasmPath string, cache, handles int, ancient string, namespace string, readonly bool) (ethdb.Database, error) {
+	n.lock.Lock()
+	defer n.lock.Unlock()
+	if n.state == closedState {
+		return nil, ErrNodeStopped
+	}
+	var db ethdb.Database
+	var err error
+	if n.config.DataDir == "" {
+		db = rawdb.NewMemoryDatabase()
+	} else {
+		db, err = rawdb.Open(rawdb.OpenOptions{
+			Type:              n.config.DBEngine,
+			Directory:         n.ResolvePath(name),
+			AncientsDirectory: n.ResolveAncient(name, ancient),
+			Namespace:         namespace,
+			WasmDirectory:     n.ResolvePath(wasmPath),
+			Cache:             cache,
+			Handles:           handles,
+			ReadOnly:          readonly,
+		})
+	}
 
 	if err == nil {
 		db = n.wrapDatabase(db)