Merge pull request #6 from OffchainLabs/store-modules-rawdb

Store User Modules in Geth's Database

Author: rachel-bousfield

arbitrum/recordingdb.go

@@ -47,6 +47,9 @@ func (db *RecordingKV) Get(key []byte) ([]byte, error) {
 		// Retrieving code
 		copy(hash[:], key[len(rawdb.CodePrefix):])
 		res, err = db.inner.DiskDB().Get(key)
+	} else if ok, _, _ := rawdb.IsCompiledWasmCodeKey(key); ok {
+		// Just return the compiled wasm without recording it since it's not in consensus and the replay will regenerate it
+		return db.inner.DiskDB().Get(key)
 	} else {
 		err = fmt.Errorf("recording KV attempted to access non-hash key %v", hex.EncodeToString(key))
 	}

core/rawdb/accessors_state_arbitrum.go

@@ -0,0 +1,30 @@
+// Copyright 2020 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package rawdb
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/log"
+)
+
+// WriteCompiledWasmCode writes the provided contract compiled wasm code database.
+func WriteCompiledWasmCode(db ethdb.KeyValueWriter, version uint32, hash common.Hash, code []byte) {
+	if err := db.Put(CompiledWasmCodeKey(version, hash), code); err != nil {
+		log.Crit("Failed to store compiled wasm contract code", "err", err)
+	}
+}

core/rawdb/schema_arbitrum.go

@@ -0,0 +1,52 @@
+// Copyright 2018 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+// Package rawdb contains a collection of low level database accessors.
+
+package rawdb
+
+import (
+	"bytes"
+	"encoding/binary"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+var (
+	CompiledWasmCodePrefix = []byte{0x00, 'w'} // (prefix, version, code_hash) -> account compiled wasm code
+)
+
+// CompiledWasmCodeKey = CompiledWasmCodePrefix + version + hash
+func CompiledWasmCodeKey(version uint32, hash common.Hash) []byte {
+	var versionBytes [4]byte
+	binary.BigEndian.PutUint32(versionBytes[:], version)
+	return append(append(CompiledWasmCodePrefix, versionBytes[:]...), hash.Bytes()...)
+}
+
+// IsCompiledWasmCodeKey reports whether the given byte slice is the key of compiled wasm contract code,
+// if so return the raw code hash and version as well.
+func IsCompiledWasmCodeKey(key []byte) (bool, common.Hash, uint32) {
+
+	wasmKeyLen := len(CompiledWasmCodePrefix) + 4 + common.HashLength
+	start := len(CompiledWasmCodePrefix)
+
+	if bytes.HasPrefix(key, CompiledWasmCodePrefix) && len(key) == wasmKeyLen {
+		version := binary.BigEndian.Uint32(key[start : start+4])
+		codeHash := common.BytesToHash(key[start+4:])
+		return true, codeHash, version
+	}
+	return false, common.Hash{}, 0
+}

core/state/database.go

@@ -31,6 +31,9 @@ import (
 )
 
 const (
+	// Arbitrum: Cache size granted for caching clean compiled wasm code.
+	compiledWasmCodeCacheSize = 64 * 1024 * 1024
+
 	// Number of codehash->size associations to keep.
 	codeSizeCacheSize = 100000
 
@@ -40,6 +43,9 @@ const (
 
 // Database wraps access to tries and contract code.
 type Database interface {
+	// Arbitrum: CompiledWasmContractCode retrieves a particular contract's user wasm code.
+	CompiledWasmContractCode(version uint32, codeHash common.Hash) ([]byte, error)
+
 	// OpenTrie opens the main account trie.
 	OpenTrie(root common.Hash) (Trie, error)
 
@@ -133,12 +139,18 @@ func NewDatabaseWithConfig(db ethdb.Database, config *trie.Config) Database {
 		db:            trie.NewDatabaseWithConfig(db, config),
 		codeSizeCache: csc,
 		codeCache:     fastcache.New(codeCacheSize),
+
+		// Arbitrum only
+		compiledWasmCache: fastcache.New(compiledWasmCodeCacheSize),
 	}
 	runtime.SetFinalizer(cdb, (*cachingDB).finalizer)
 	return cdb
 }
 
 type cachingDB struct {
+	// Arbitrum
+	compiledWasmCache *fastcache.Cache
+
 	db            *trie.Database
 	codeSizeCache *lru.Cache
 	codeCache     *fastcache.Cache
@@ -156,6 +168,9 @@ func (db *cachingDB) OpenTrie(root common.Hash) (Trie, error) {
 // fastcache chunks are not mannaged by GC.
 func (db *cachingDB) finalizer() {
 	db.codeCache.Reset()
+
+	// Arbitrum Only
+	db.compiledWasmCache.Reset()
 }
 
 // OpenStorageTrie opens the storage trie of an account.

core/state/database_arbitrum.go

@@ -0,0 +1,25 @@
+package state
+
+import (
+	"errors"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
+)
+
+// CompiledWasmContractCode retrieves a particular contract's compiled wasm code.
+func (db *cachingDB) CompiledWasmContractCode(version uint32, codeHash common.Hash) ([]byte, error) {
+	wasmKey := rawdb.CompiledWasmCodeKey(version, codeHash)
+	if code := db.compiledWasmCache.Get(nil, wasmKey); len(code) > 0 {
+		return code, nil
+	}
+	code, err := db.db.DiskDB().Get(wasmKey)
+	if err != nil {
+		return nil, err
+	}
+	if len(code) > 0 {
+		db.compiledWasmCache.Set(wasmKey, code)
+		return code, nil
+	}
+	return nil, errors.New("not found")
+}

core/state/journal_arbitrum.go

@@ -0,0 +1,16 @@
+package state
+
+import "github.com/ethereum/go-ethereum/common"
+
+type wasmCodeChange struct {
+	account *common.Address
+	version uint32
+}
+
+func (ch wasmCodeChange) revert(s *StateDB) {
+	s.getStateObject(*ch.account).setWASMCode(nil, ch.version)
+}
+
+func (ch wasmCodeChange) dirtied() *common.Address {
+	return ch.account
+}

core/state/snapshot/conversion.go

@@ -79,6 +79,8 @@ func GenerateTrie(snaptree *Tree, root common.Hash, src ethdb.Database, dst ethd
 				return common.Hash{}, errors.New("failed to read contract code")
 			}
 			rawdb.WriteCode(dst, codeHash, code)
+
+			// TODO: How do we migrate the compiled wasm code
 		}
 		// Then migrate all storage trie nodes into the tmp db.
 		storageIt, err := snaptree.StorageIterator(root, accountHash, common.Hash{})

core/state/state_object.go

@@ -66,6 +66,9 @@ func (s Storage) Copy() Storage {
 // Account values can be accessed and modified through the object.
 // Finally, call CommitTrie to write the modified storage trie into a database.
 type stateObject struct {
+	// Arbitrum: write caches and cache flags
+	compiledWasmCode CompiledWasms // compiled wasm bytecode which gets set when wasm is loaded
+
 	address  common.Address
 	addrHash common.Hash // hash of ethereum address of the account
 	data     types.StateAccount
@@ -119,6 +122,9 @@ func newObject(db *StateDB, address common.Address, data types.StateAccount) *st
 		originStorage:  make(Storage),
 		pendingStorage: make(Storage),
 		dirtyStorage:   make(Storage),
+
+		// Arbitrum Only
+		compiledWasmCode: make(CompiledWasms),
 	}
 }
 
@@ -455,6 +461,10 @@ func (s *stateObject) deepCopy(db *StateDB) *stateObject {
 	stateObject.suicided = s.suicided
 	stateObject.dirtyCode = s.dirtyCode
 	stateObject.deleted = s.deleted
+
+	// Arbitrum Only
+	stateObject.compiledWasmCode = s.compiledWasmCode.Copy()
+
 	return stateObject
 }
 

core/state/state_object_arbitrum.go

@@ -0,0 +1,73 @@
+// Copyright 2014 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package state
+
+import (
+	"fmt"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+type CompiledWasmCache struct {
+	code  Code
+	dirty bool
+}
+type CompiledWasms map[uint32]CompiledWasmCache
+
+func (c CompiledWasms) Copy() CompiledWasms {
+	cpy := make(CompiledWasms, len(c))
+	for key, value := range c {
+		cpy[key] = value
+	}
+
+	return cpy
+}
+
+// CompiledWasmCode returns the user wasm contract code associated with this object, if any.
+func (s *stateObject) CompiledWasmCode(db Database, version uint32) []byte {
+	if wasm, ok := s.compiledWasmCode[version]; ok {
+		return wasm.code
+	}
+	if version == 0 {
+		return nil
+	}
+	compiledWasmCode, err := db.CompiledWasmContractCode(version, common.BytesToHash(s.CodeHash()))
+	if err != nil {
+		s.setError(fmt.Errorf("can't load code hash %x: %v", s.CodeHash(), err))
+	}
+	s.compiledWasmCode[version] = CompiledWasmCache{
+		code:  compiledWasmCode,
+		dirty: false,
+	}
+	return compiledWasmCode
+}
+
+func (s *stateObject) SetCompiledWasmCode(code []byte, version uint32) {
+	// Can only be compiled once, so if it's being compiled, it was previous empty
+	s.db.journal.append(wasmCodeChange{
+		account: &s.address,
+		version: version,
+	})
+	s.setWASMCode(code, version)
+}
+
+func (s *stateObject) setWASMCode(code []byte, version uint32) {
+	s.compiledWasmCode[version] = CompiledWasmCache{
+		code:  code,
+		dirty: true,
+	}
+}

core/state/statedb.go

@@ -39,6 +39,7 @@ import (
 type revision struct {
 	id           int
 	journalIndex int
+
 	// Arbitrum: track the total balance change across all accounts
 	unexpectedBalanceDelta *big.Int
 }
@@ -65,9 +66,10 @@ func (n *proofList) Delete(key []byte) error {
 // * Contracts
 // * Accounts
 type StateDB struct {
-	// Arbitrum: track the total balance change across all accounts
-	unexpectedBalanceDelta *big.Int
-	userWasms              UserWasms
+	// Arbitrum
+	unexpectedBalanceDelta *big.Int  // total balance change across all accounts
+	userWasms              UserWasms // user wasms encountered during execution
+	deterministic          bool      // whether the order in which deletes are committed should be deterministic
 
 	db         Database
 	prefetcher *triePrefetcher
@@ -132,8 +134,6 @@ type StateDB struct {
 	StorageUpdated int
 	AccountDeleted int
 	StorageDeleted int
-
-	deterministic bool
 }
 
 // New creates a new state from a given trie.
@@ -168,15 +168,6 @@ func New(root common.Hash, db Database, snaps *snapshot.Tree) (*StateDB, error)
 	return sdb, nil
 }
 
-func NewDeterministic(root common.Hash, db Database) (*StateDB, error) {
-	sdb, err := New(root, db, nil)
-	if err != nil {
-		return nil, err
-	}
-	sdb.deterministic = true
-	return sdb, nil
-}
-
 // StartPrefetcher initializes a new trie prefetcher to pull in nodes from the
 // state trie concurrently while the state is mutated so that when we reach the
 // commit phase, most of the needed data is already hot.
@@ -967,6 +958,16 @@ func (s *StateDB) Commit(deleteEmptyObjects bool) (common.Hash, error) {
 				rawdb.WriteCode(codeWriter, common.BytesToHash(obj.CodeHash()), obj.code)
 				obj.dirtyCode = false
 			}
+
+			// Arbitrum Only
+			for version, wasm := range obj.compiledWasmCode {
+				if wasm.dirty {
+					codeHash := common.BytesToHash(obj.CodeHash())
+					rawdb.WriteCompiledWasmCode(codeWriter, version, codeHash, wasm.code)
+					wasm.dirty = false
+				}
+			}
+
 			// Write any storage changes in the state object to its storage trie
 			set, err := obj.CommitTrie(s.db)
 			if err != nil {