[Feature] add a way to switch between RLP and Protobuf for substateDB decoding

db/code_db.go

@@ -88,6 +88,7 @@ func (db *codeDB) GetCode(codeHash types.Hash) ([]byte, error) {
 	if err != nil {
 		return nil, fmt.Errorf("cannot get code %s: %w", codeHash, err)
 	}
+
 	return code, nil
 }
 

db/substate_db.go

@@ -43,6 +43,9 @@ type SubstateDB interface {
 
 	// GetLastSubstate returns last substate (block and transaction wise) inside given DB.
 	GetLastSubstate() (*substate.Substate, error)
+
+	// SetDecoder sets the decoder func to the provided encoding
+	SetDecoder(encoding string) *substateDB
 }
 
 // NewDefaultSubstateDB creates new instance of SubstateDB with default options.
@@ -57,11 +60,11 @@ func NewSubstateDB(path string, o *opt.Options, wo *opt.WriteOptions, ro *opt.Re
 }
 
 func MakeDefaultSubstateDB(db *leveldb.DB) SubstateDB {
-	return &substateDB{&codeDB{&baseDB{backend: db}}}
+	return &substateDB{&codeDB{&baseDB{backend: db}}, nil}
 }
 
 func MakeDefaultSubstateDBFromBaseDB(db BaseDB) SubstateDB {
-	return &substateDB{&codeDB{&baseDB{backend: db.getBackend()}}}
+	return &substateDB{&codeDB{&baseDB{backend: db.getBackend()}}, nil}
 }
 
 // NewReadOnlySubstateDB creates a new instance of read-only SubstateDB.
@@ -70,19 +73,20 @@ func NewReadOnlySubstateDB(path string) (SubstateDB, error) {
 }
 
 func MakeSubstateDB(db *leveldb.DB, wo *opt.WriteOptions, ro *opt.ReadOptions) SubstateDB {
-	return &substateDB{&codeDB{&baseDB{backend: db, wo: wo, ro: ro}}}
+	return &substateDB{&codeDB{&baseDB{backend: db, wo: wo, ro: ro}}, nil}
 }
 
 func newSubstateDB(path string, o *opt.Options, wo *opt.WriteOptions, ro *opt.ReadOptions) (*substateDB, error) {
 	base, err := newCodeDB(path, o, wo, ro)
 	if err != nil {
 		return nil, err
 	}
-	return &substateDB{base}, nil
+	return &substateDB{base, nil}, nil
 }
 
 type substateDB struct {
 	*codeDB
+	decodeSubstate decoderFunc
 }
 
 func (db *substateDB) GetFirstSubstate() *substate.Substate {
@@ -108,12 +112,7 @@ func (db *substateDB) GetSubstate(block uint64, tx int) (*substate.Substate, err
 		return nil, fmt.Errorf("cannot get substate block: %v, tx: %v from db; %w", block, tx, err)
 	}
 
-	rlpSubstate, err := rlp.Decode(val)
-	if err != nil {
-		return nil, fmt.Errorf("cannot decode data into rlp block: %v, tx %v; %w", block, tx, err)
-	}
-
-	return rlpSubstate.ToSubstate(db.GetCode, block, tx)
+	return db.DecodeSubstate(val, block, tx)
 }
 
 // GetBlockSubstates returns substates for given block if exists within DB.
@@ -138,14 +137,9 @@ func (db *substateDB) GetBlockSubstates(block uint64) (map[int]*substate.Substat
 			return nil, fmt.Errorf("record-replay: GetBlockSubstates(%v) iterated substates from block %v", block, b)
 		}
 
-		rlpSubstate, err := rlp.Decode(value)
-		if err != nil {
-			return nil, fmt.Errorf("cannot decode data into rlp block: %v, tx %v; %w", block, tx, err)
-		}
-
-		sbstt, err := rlpSubstate.ToSubstate(db.GetCode, block, tx)
+		sbstt, err := db.DecodeSubstate(value, block, tx)
 		if err != nil {
-			return nil, fmt.Errorf("cannot decode data into substate: %w", err)
+			return nil, fmt.Errorf("Error decoding block %d, tx %d; %w", block, tx, err)
 		}
 
 		txSubstate[tx] = sbstt

db/substate_decoder.go

@@ -0,0 +1,76 @@
+package db
+
+import (
+	"fmt"
+
+	pb "github.com/Fantom-foundation/Substate/protobuf"
+	"github.com/Fantom-foundation/Substate/rlp"
+	"github.com/Fantom-foundation/Substate/substate"
+	"github.com/Fantom-foundation/Substate/types"
+	"github.com/golang/protobuf/proto"
+)
+
+// SetDecoder sets the runtime parsing behavior of substateDB
+// intended usage:
+//
+//	db := &substateDB{..}           // initializing db
+//	        .SetDecoder(<encoding>) // end of init, or right before decoding
+func (db *substateDB) SetDecoder(encoding string) *substateDB {
+	db.decodeSubstate = getDecoderFunc(encoding, db.GetCode)
+	return db
+}
+
+type substateDecoder interface {
+	DecodeSubstate(bytes []byte, block uint64, tx int) (*substate.Substate, error)
+}
+
+func (db *substateDB) DecodeSubstate(bytes []byte, block uint64, tx int) (*substate.Substate, error) {
+	if db.decodeSubstate == nil {
+		db.SetDecoder("default")
+	}
+	return db.decodeSubstate(bytes, block, tx)
+}
+
+// decoderFunc aliases the common function used to decode substate
+type decoderFunc func([]byte, uint64, int) (*substate.Substate, error)
+
+func (decode decoderFunc) DecodeSubstate(bytes []byte, block uint64, tx int) {
+	decode(bytes, block, tx)
+}
+
+type codeLookup = func(types.Hash) ([]byte, error)
+
+func getDecoderFunc(encoding string, lookup codeLookup) decoderFunc {
+	switch encoding {
+	case "protobuf", "pb":
+		return func(bytes []byte, block uint64, tx int) (*substate.Substate, error) {
+			return decodeProtobuf(bytes, lookup, block, tx)
+		}
+	default:
+		fallthrough
+	case "rlp":
+		return func(bytes []byte, block uint64, tx int) (*substate.Substate, error) {
+			return decodeRlp(bytes, lookup, block, tx)
+		}
+	}
+}
+
+// decodeRlp decodes into substate the provided rlp-encoded bytecode
+func decodeRlp(bytes []byte, lookup codeLookup, block uint64, tx int) (*substate.Substate, error) {
+	rlpSubstate, err := rlp.Decode(bytes)
+	if err != nil {
+		return nil, fmt.Errorf("cannot decode data into rlp block: %v, tx %v; %w", block, tx, err)
+	}
+
+	return rlpSubstate.ToSubstate(lookup, block, tx)
+}
+
+// decodeProtobuf decodes into substate the provided protobuf-encoded bytecode
+func decodeProtobuf(bytes []byte, lookup codeLookup, block uint64, tx int) (*substate.Substate, error) {
+	pbSubstate := &pb.Substate{}
+	if err := proto.Unmarshal(bytes, pbSubstate); err != nil {
+		return nil, fmt.Errorf("cannot decode data into protobuf block: %v, tx %v; %w", block, tx, err)
+	}
+
+	return pbSubstate.Decode(lookup, block, tx)
+}

db/substate_iterator.go

@@ -3,10 +3,8 @@ package db
 import (
 	"fmt"
 
-	"github.com/syndtr/goleveldb/leveldb/util"
-
-	"github.com/Fantom-foundation/Substate/rlp"
 	"github.com/Fantom-foundation/Substate/substate"
+	"github.com/syndtr/goleveldb/leveldb/util"
 )
 
 func newSubstateIterator(db *substateDB, start []byte) *substateIterator {
@@ -33,12 +31,7 @@ func (i *substateIterator) decode(data rawEntry) (*substate.Substate, error) {
 		return nil, fmt.Errorf("invalid substate key: %v; %w", key, err)
 	}
 
-	rlpSubstate, err := rlp.Decode(value)
-	if err != nil {
-		return nil, err
-	}
-
-	return rlpSubstate.ToSubstate(i.db.GetCode, block, tx)
+	return i.db.DecodeSubstate(value, block, tx)
 }
 
 func (i *substateIterator) start(numWorkers int) {