op-chain-ops: delete memdb (ethereum-optimism#10404)

* op-chain-ops: delete memdb

The simple in memory statedb implementation that was
backed by a genesis has served us well but is no longer
required since we build the genesis files using foundry.
This was originally used to enable simple execution to
deploy contracts and then dump into a `genesis.json`.
Keeping this memdb around will only bloat PRs that update
the geth version as they may change the interface to the
statedb. Instead of using the memdb interface, the genesis
is modified directly.

* lint: fix

* style: way better

Co-authored-by: protolambda <[email protected]>

* build: fix

* build: fix

---------

Co-authored-by: protolambda <[email protected]>

Author: tynes

op-chain-ops/genesis/layer_one.go

@@ -4,16 +4,12 @@ import (
 	"fmt"
 	"math/big"
 
-	"github.com/holiman/uint256"
-
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
 
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
-	"github.com/ethereum-optimism/optimism/op-chain-ops/state"
 )
 
 // PrecompileCount represents the number of precompile addresses
@@ -61,43 +57,43 @@ func BuildL1DeveloperGenesis(config *DeployConfig, dump *ForgeAllocs, l1Deployme
 	}
 	// copy, for safety when the dump is reused (like in e2e testing)
 	genesis.Alloc = dump.Copy().Accounts
-	memDB := state.NewMemoryStateDB(genesis)
-	FundDevAccounts(memDB)
-	SetPrecompileBalances(memDB)
+	FundDevAccounts(genesis)
+	SetPrecompileBalances(genesis)
 
 	l1Deployments.ForEach(func(name string, addr common.Address) {
-		acc := memDB.GetAccount(addr)
-		if acc != nil {
+		acc, ok := genesis.Alloc[addr]
+		if ok {
 			log.Info("Included L1 deployment", "name", name, "address", addr, "balance", acc.Balance, "storage", len(acc.Storage), "nonce", acc.Nonce)
 		} else {
 			log.Info("Excluded L1 deployment", "name", name, "address", addr)
 		}
 	})
 
-	return memDB.Genesis(), nil
-}
-
-// CreateAccountNotExists creates the account in the `vm.StateDB` if it doesn't exist.
-func CreateAccountNotExists(db vm.StateDB, account common.Address) {
-	if !db.Exist(account) {
-		db.CreateAccount(account)
-	}
+	return genesis, nil
 }
 
 // FundDevAccounts will fund each of the development accounts.
-func FundDevAccounts(db vm.StateDB) {
+func FundDevAccounts(gen *core.Genesis) {
 	for _, account := range DevAccounts {
-		CreateAccountNotExists(db, account)
-		db.AddBalance(account, uint256.MustFromBig(devBalance))
+		acc := gen.Alloc[account]
+		if acc.Balance == nil {
+			acc.Balance = new(big.Int)
+		}
+		acc.Balance = acc.Balance.Add(acc.Balance, devBalance)
+		gen.Alloc[account] = acc
 	}
 }
 
 // SetPrecompileBalances will set a single wei at each precompile address.
 // This is an optimization to make calling them cheaper.
-func SetPrecompileBalances(db vm.StateDB) {
+func SetPrecompileBalances(gen *core.Genesis) {
 	for i := 0; i < PrecompileCount; i++ {
 		addr := common.BytesToAddress([]byte{byte(i)})
-		CreateAccountNotExists(db, addr)
-		db.AddBalance(addr, uint256.NewInt(1))
+		acc := gen.Alloc[addr]
+		if acc.Balance == nil {
+			acc.Balance = new(big.Int)
+		}
+		acc.Balance = acc.Balance.Add(acc.Balance, big.NewInt(1))
+		gen.Alloc[addr] = acc
 	}
 }

op-chain-ops/genesis/layer_one_test.go

@@ -0,0 +1,36 @@
+package genesis
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/stretchr/testify/require"
+)
+
+// TestFundDevAccounts ensures that the developer accounts are
+// added to the genesis state correctly.
+func TestFundDevAccounts(t *testing.T) {
+	gen := core.Genesis{
+		Alloc: make(types.GenesisAlloc),
+	}
+	FundDevAccounts(&gen)
+	require.Equal(t, len(gen.Alloc), len(DevAccounts))
+	for _, account := range gen.Alloc {
+		require.Equal(t, devBalance, account.Balance)
+	}
+}
+
+// TestSetPrecompileBalances ensures that the precompiles are
+// initialized with a balance of 1.
+func TestSetPrecompileBalances(t *testing.T) {
+	gen := core.Genesis{
+		Alloc: make(types.GenesisAlloc),
+	}
+	SetPrecompileBalances(&gen)
+	require.Equal(t, len(gen.Alloc), PrecompileCount)
+	for _, account := range gen.Alloc {
+		require.Equal(t, big.NewInt(1), account.Balance)
+	}
+}