removed go-ethereum from dependencies

destroyed_account_db.go → db/destroyed_account_db.go

@@ -1,34 +1,35 @@
-package substate
+package db
 
 import (
 	"encoding/binary"
 	"fmt"
 	"log"
 
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/rawdb"
-	"github.com/ethereum/go-ethereum/rlp"
+	"github.com/syndtr/goleveldb/leveldb/opt"
+
+	"github.com/Fantom-foundation/Substate/types"
+	"github.com/Fantom-foundation/Substate/types/rlp"
 )
 
 type DestroyedAccountDB struct {
-	backend BackendDatabase
+	backend BaseDB
 }
 
-func NewDestroyedAccountDB(backend BackendDatabase) *DestroyedAccountDB {
+func NewDestroyedAccountDB(backend BaseDB) *DestroyedAccountDB {
 	return &DestroyedAccountDB{backend: backend}
 }
 
 func OpenDestroyedAccountDB(destroyedAccountDir string) (*DestroyedAccountDB, error) {
-	return openDestroyedAccountDB(destroyedAccountDir, false)
+	return openDestroyedAccountDB(destroyedAccountDir, &opt.Options{ReadOnly: false}, nil, nil)
 }
 
 func OpenDestroyedAccountDBReadOnly(destroyedAccountDir string) (*DestroyedAccountDB, error) {
-	return openDestroyedAccountDB(destroyedAccountDir, true)
+	return openDestroyedAccountDB(destroyedAccountDir, &opt.Options{ReadOnly: true}, nil, nil)
 }
 
-func openDestroyedAccountDB(destroyedAccountDir string, readOnly bool) (*DestroyedAccountDB, error) {
+func openDestroyedAccountDB(destroyedAccountDir string, o *opt.Options, wo *opt.WriteOptions, ro *opt.ReadOptions) (*DestroyedAccountDB, error) {
 	log.Println("substate: OpenDestroyedAccountDB")
-	backend, err := rawdb.NewLevelDBDatabase(destroyedAccountDir, 1024, 100, "destroyed_accounts", readOnly)
+	backend, err := newBaseDB(destroyedAccountDir, o, wo, ro)
 	if err != nil {
 		return nil, fmt.Errorf("error opening deletion-db %s: %v", destroyedAccountDir, err)
 	}
@@ -40,11 +41,11 @@ func (db *DestroyedAccountDB) Close() error {
 }
 
 type SuicidedAccountLists struct {
-	DestroyedAccounts   []common.Address
-	ResurrectedAccounts []common.Address
+	DestroyedAccounts   []types.Address
+	ResurrectedAccounts []types.Address
 }
 
-func (db *DestroyedAccountDB) SetDestroyedAccounts(block uint64, tx int, des []common.Address, res []common.Address) error {
+func (db *DestroyedAccountDB) SetDestroyedAccounts(block uint64, tx int, des []types.Address, res []types.Address) error {
 	accountList := SuicidedAccountLists{DestroyedAccounts: des, ResurrectedAccounts: res}
 	value, err := rlp.EncodeToBytes(accountList)
 	if err != nil {
@@ -53,7 +54,7 @@ func (db *DestroyedAccountDB) SetDestroyedAccounts(block uint64, tx int, des []c
 	return db.backend.Put(encodeDestroyedAccountKey(block, tx), value)
 }
 
-func (db *DestroyedAccountDB) GetDestroyedAccounts(block uint64, tx int) ([]common.Address, []common.Address, error) {
+func (db *DestroyedAccountDB) GetDestroyedAccounts(block uint64, tx int) ([]types.Address, []types.Address, error) {
 	data, err := db.backend.Get(encodeDestroyedAccountKey(block, tx))
 	if err != nil {
 		return nil, nil, err
@@ -63,13 +64,13 @@ func (db *DestroyedAccountDB) GetDestroyedAccounts(block uint64, tx int) ([]comm
 }
 
 // GetAccountsDestroyedInRange get list of all accounts between block from and to (including from and to).
-func (db *DestroyedAccountDB) GetAccountsDestroyedInRange(from, to uint64) ([]common.Address, error) {
+func (db *DestroyedAccountDB) GetAccountsDestroyedInRange(from, to uint64) ([]types.Address, error) {
 	startingBlockBytes := make([]byte, 8)
 	binary.BigEndian.PutUint64(startingBlockBytes, from)
 
 	iter := db.backend.NewIterator([]byte(DestroyedAccountPrefix), startingBlockBytes)
 	defer iter.Release()
-	isDestroyed := make(map[common.Address]bool)
+	isDestroyed := make(map[types.Address]bool)
 	for iter.Next() {
 		block, _, err := DecodeDestroyedAccountKey(iter.Key())
 		if err != nil {
@@ -90,7 +91,7 @@ func (db *DestroyedAccountDB) GetAccountsDestroyedInRange(from, to uint64) ([]co
 		}
 	}
 
-	var accountList []common.Address
+	var accountList []types.Address
 	for addr, isDeleted := range isDestroyed {
 		if isDeleted {
 			accountList = append(accountList, addr)

metadata.go → db/metadata.go

@@ -1,4 +1,4 @@
-package substate
+package db
 
 import (
 	"encoding/binary"
@@ -12,33 +12,33 @@ const (
 )
 
 // PutMetadata into db
-func (db *UpdateDB) PutMetadata(interval, size uint64) error {
+func (db *updateDB) PutMetadata(interval, size uint64) error {
 
 	byteInterval := make([]byte, 8)
 	binary.BigEndian.PutUint64(byteInterval, interval)
 
-	if err := db.backend.Put([]byte(UpdatesetIntervalKey), byteInterval); err != nil {
+	if err := db.backend.Put([]byte(UpdatesetIntervalKey), byteInterval, db.wo); err != nil {
 		return err
 	}
 
 	sizeInterval := make([]byte, 8)
 	binary.BigEndian.PutUint64(sizeInterval, size)
 
-	if err := db.backend.Put([]byte(UpdatesetSizeKey), sizeInterval); err != nil {
+	if err := db.backend.Put([]byte(UpdatesetSizeKey), sizeInterval, db.wo); err != nil {
 		return err
 	}
 
 	return nil
 }
 
 // GetMetadata from db
-func (db *UpdateDB) GetMetadata() (uint64, uint64, error) {
-	byteInterval, err := db.backend.Get([]byte(UpdatesetIntervalKey))
+func (db *updateDB) GetMetadata() (uint64, uint64, error) {
+	byteInterval, err := db.backend.Get([]byte(UpdatesetIntervalKey), db.ro)
 	if err != nil {
 		return 0, 0, err
 	}
 
-	byteSize, err := db.backend.Get([]byte(UpdatesetSizeKey))
+	byteSize, err := db.backend.Get([]byte(UpdatesetSizeKey), db.ro)
 	if err != nil {
 		return 0, 0, err
 	}

db/substate_db.go

@@ -3,6 +3,7 @@ package db
 import (
 	"encoding/binary"
 	"fmt"
+	"github.com/syndtr/goleveldb/leveldb/util"
 
 	"github.com/syndtr/goleveldb/leveldb"
 	"github.com/syndtr/goleveldb/leveldb/opt"
@@ -24,6 +25,8 @@ type SubstateDB interface {
 	// GetSubstate gets the Substate for given block and tx number.
 	GetSubstate(block uint64, tx int) (*substate.Substate, error)
 
+	GetBlockSubstates(block uint64) map[int]*substate.Substate
+
 	// PutSubstate inserts given substate to DB.
 	PutSubstate(substate *substate.Substate) error
 
@@ -88,6 +91,48 @@ func (db *substateDB) GetSubstate(block uint64, tx int) (*substate.Substate, err
 	return rlpSubstate.ToSubstate(db.GetCode, block, tx)
 }
 
+func (db *substateDB) GetBlockSubstates(block uint64) map[int]*substate.Substate {
+	var err error
+
+	txSubstate := make(map[int]*substate.Substate)
+
+	prefix := SubstateDBBlockPrefix(block)
+
+	iter := db.backend.NewIterator(util.BytesPrefix(prefix), nil)
+	for iter.Next() {
+		key := iter.Key()
+		value := iter.Value()
+
+		b, tx, err := DecodeSubstateDBKey(key)
+		if err != nil {
+			panic(fmt.Errorf("record-replay: invalid substate key found for block %v: %v", block, err))
+		}
+
+		if block != b {
+			panic(fmt.Errorf("record-replay: GetBlockSubstates(%v) iterated substates from block %v", block, b))
+		}
+
+		rlpSubstate, err := rlp.Decode(value)
+		if err != nil {
+			panic(fmt.Errorf("cannot decode data into rlp block: %v, tx %v; %v", block, tx, err))
+		}
+
+		sbstt, err := rlpSubstate.ToSubstate(db.GetCode, block, tx)
+		if err != nil {
+			panic(fmt.Errorf("cannot decode data into substate: %v", err))
+		}
+
+		txSubstate[tx] = sbstt
+	}
+	iter.Release()
+	err = iter.Error()
+	if err != nil {
+		panic(err)
+	}
+
+	return txSubstate
+}
+
 func (db *substateDB) PutSubstate(ss *substate.Substate) error {
 	for i, account := range ss.InputSubstate {
 		err := db.PutCode(account.Code)

substate_task.go → db/substate_task.go

@@ -1,7 +1,8 @@
-package substate
+package db
 
 import (
 	"fmt"
+	"github.com/Fantom-foundation/Substate/substate"
 	"runtime"
 	"sort"
 	"sync"
@@ -31,8 +32,8 @@ var (
 	}
 )
 
-type SubstateBlockFunc func(block uint64, transactions map[int]*Substate, taskPool *SubstateTaskPool) error
-type SubstateTaskFunc func(block uint64, tx int, substate *Substate, taskPool *SubstateTaskPool) error
+type SubstateBlockFunc func(block uint64, transactions map[int]*substate.Substate, taskPool *SubstateTaskPool) error
+type SubstateTaskFunc func(block uint64, tx int, substate *substate.Substate, taskPool *SubstateTaskPool) error
 
 type SubstateTaskPool struct {
 	Name      string
@@ -49,10 +50,10 @@ type SubstateTaskPool struct {
 
 	Ctx *cli.Context // CLI context required to read additional flags
 
-	DB *DB
+	DB SubstateDB
 }
 
-func NewSubstateTaskPool(name string, taskFunc SubstateTaskFunc, first, last uint64, ctx *cli.Context) *SubstateTaskPool {
+func NewSubstateTaskPool(name string, taskFunc SubstateTaskFunc, first, last uint64, ctx *cli.Context, database SubstateDB) *SubstateTaskPool {
 	return &SubstateTaskPool{
 		Name:     name,
 		TaskFunc: taskFunc,
@@ -67,7 +68,7 @@ func NewSubstateTaskPool(name string, taskFunc SubstateTaskFunc, first, last uin
 
 		Ctx: ctx,
 
-		DB: staticSubstateDB,
+		DB: database,
 	}
 }
 
@@ -95,7 +96,7 @@ func (pool *SubstateTaskPool) ExecuteBlock(block uint64) (numTx int64, gas int64
 
 	for _, tx := range txNumbers {
 		substate := transactions[tx]
-		alloc := substate.InputAlloc
+		alloc := substate.InputSubstate
 		msg := substate.Message
 
 		to := msg.To