Substate interface

cmd/aida-sdb/record.go

@@ -6,6 +6,7 @@ import (
 	"github.com/Fantom-foundation/Aida/executor/extension/statedb"
 	"github.com/Fantom-foundation/Aida/executor/extension/tracker"
 	"github.com/Fantom-foundation/Aida/executor/extension/validator"
+	"github.com/Fantom-foundation/Aida/executor/transaction"
 	"github.com/Fantom-foundation/Aida/logger"
 	"github.com/Fantom-foundation/Aida/utils"
 	substate "github.com/Fantom-foundation/Substate"
@@ -58,13 +59,13 @@ func RecordStateDbTrace(ctx *cli.Context) error {
 
 func record(
 	cfg *utils.Config,
-	provider executor.Provider[*substate.Substate],
-	processor executor.Processor[*substate.Substate],
-	extra []executor.Extension[*substate.Substate],
+	provider executor.Provider[transaction.SubstateData],
+	processor executor.Processor[transaction.SubstateData],
+	extra []executor.Extension[transaction.SubstateData],
 ) error {
-	var extensions = []executor.Extension[*substate.Substate]{
-		profiler.MakeCpuProfiler[*substate.Substate](cfg),
-		tracker.MakeProgressLogger[*substate.Substate](cfg, 0),
+	var extensions = []executor.Extension[transaction.SubstateData]{
+		profiler.MakeCpuProfiler[transaction.SubstateData](cfg),
+		tracker.MakeProgressLogger[transaction.SubstateData](cfg, 0),
 		tracker.MakeProgressTracker(cfg, 0),
 		statedb.MakeTemporaryStatePrepper(cfg),
 		statedb.MakeProxyRecorderPrepper(cfg),

cmd/aida-sdb/record_test.go

@@ -5,8 +5,10 @@ import (
 	"testing"
 
 	"github.com/Fantom-foundation/Aida/executor"
+	"github.com/Fantom-foundation/Aida/executor/transaction"
 	"github.com/Fantom-foundation/Aida/utils"
-	substate "github.com/Fantom-foundation/Substate"
+	substateCommon "github.com/Fantom-foundation/Substate/geth/common"
+	"github.com/Fantom-foundation/Substate/substate"
 	"github.com/ethereum/go-ethereum/common"
 	"go.uber.org/mock/gomock"
 )
@@ -15,9 +17,9 @@ var testingAddress = common.Address{1}
 
 func TestSdbRecord_AllDbEventsAreIssuedInOrder(t *testing.T) {
 	ctrl := gomock.NewController(t)
-	provider := executor.NewMockProvider[*substate.Substate](ctrl)
-	processor := executor.NewMockProcessor[*substate.Substate](ctrl)
-	ext := executor.NewMockExtension[*substate.Substate](ctrl)
+	provider := executor.NewMockProvider[transaction.SubstateData](ctrl)
+	processor := executor.NewMockProcessor[transaction.SubstateData](ctrl)
+	ext := executor.NewMockExtension[transaction.SubstateData](ctrl)
 	path := t.TempDir() + "test_trace"
 	cfg := &utils.Config{
 		First:            10,
@@ -30,63 +32,63 @@ func TestSdbRecord_AllDbEventsAreIssuedInOrder(t *testing.T) {
 
 	provider.EXPECT().
 		Run(10, 12, gomock.Any()).
-		DoAndReturn(func(from int, to int, consumer executor.Consumer[*substate.Substate]) error {
+		DoAndReturn(func(from int, to int, consumer executor.Consumer[transaction.SubstateData]) error {
 			for i := from; i < to; i++ {
-				consumer(executor.TransactionInfo[*substate.Substate]{Block: i, Transaction: 3, Data: emptyTx})
-				consumer(executor.TransactionInfo[*substate.Substate]{Block: i, Transaction: utils.PseudoTx, Data: emptyTx})
+				consumer(executor.TransactionInfo[transaction.SubstateData]{Block: i, Transaction: 3, Data: transaction.NewSubstateData(emptyTx)})
+				consumer(executor.TransactionInfo[transaction.SubstateData]{Block: i, Transaction: utils.PseudoTx, Data: transaction.NewSubstateData(emptyTx)})
 			}
 			return nil
 		})
 
 	// All transactions are processed in order
 	gomock.InOrder(
-		ext.EXPECT().PreRun(executor.AtBlock[*substate.Substate](10), gomock.Any()),
+		ext.EXPECT().PreRun(executor.AtBlock[transaction.SubstateData](10), gomock.Any()),
 
 		// block 10
-		ext.EXPECT().PreTransaction(executor.AtTransaction[*substate.Substate](10, 3), gomock.Any()),
-		processor.EXPECT().Process(executor.AtTransaction[*substate.Substate](10, 3), gomock.Any()),
-		ext.EXPECT().PostTransaction(executor.AtTransaction[*substate.Substate](10, 3), gomock.Any()),
+		ext.EXPECT().PreTransaction(executor.AtTransaction[transaction.SubstateData](10, 3), gomock.Any()),
+		processor.EXPECT().Process(executor.AtTransaction[transaction.SubstateData](10, 3), gomock.Any()),
+		ext.EXPECT().PostTransaction(executor.AtTransaction[transaction.SubstateData](10, 3), gomock.Any()),
 
-		ext.EXPECT().PreTransaction(executor.AtTransaction[*substate.Substate](10, utils.PseudoTx), gomock.Any()),
-		processor.EXPECT().Process(executor.AtTransaction[*substate.Substate](10, utils.PseudoTx), gomock.Any()),
-		ext.EXPECT().PostTransaction(executor.AtTransaction[*substate.Substate](10, utils.PseudoTx), gomock.Any()),
+		ext.EXPECT().PreTransaction(executor.AtTransaction[transaction.SubstateData](10, utils.PseudoTx), gomock.Any()),
+		processor.EXPECT().Process(executor.AtTransaction[transaction.SubstateData](10, utils.PseudoTx), gomock.Any()),
+		ext.EXPECT().PostTransaction(executor.AtTransaction[transaction.SubstateData](10, utils.PseudoTx), gomock.Any()),
 
 		// block 11
-		ext.EXPECT().PreTransaction(executor.AtTransaction[*substate.Substate](11, 3), gomock.Any()),
-		processor.EXPECT().Process(executor.AtTransaction[*substate.Substate](11, 3), gomock.Any()),
-		ext.EXPECT().PostTransaction(executor.AtTransaction[*substate.Substate](11, 3), gomock.Any()),
+		ext.EXPECT().PreTransaction(executor.AtTransaction[transaction.SubstateData](11, 3), gomock.Any()),
+		processor.EXPECT().Process(executor.AtTransaction[transaction.SubstateData](11, 3), gomock.Any()),
+		ext.EXPECT().PostTransaction(executor.AtTransaction[transaction.SubstateData](11, 3), gomock.Any()),
 
-		ext.EXPECT().PreTransaction(executor.AtTransaction[*substate.Substate](11, utils.PseudoTx), gomock.Any()),
-		processor.EXPECT().Process(executor.AtTransaction[*substate.Substate](11, utils.PseudoTx), gomock.Any()),
-		ext.EXPECT().PostTransaction(executor.AtTransaction[*substate.Substate](11, utils.PseudoTx), gomock.Any()),
+		ext.EXPECT().PreTransaction(executor.AtTransaction[transaction.SubstateData](11, utils.PseudoTx), gomock.Any()),
+		processor.EXPECT().Process(executor.AtTransaction[transaction.SubstateData](11, utils.PseudoTx), gomock.Any()),
+		ext.EXPECT().PostTransaction(executor.AtTransaction[transaction.SubstateData](11, utils.PseudoTx), gomock.Any()),
 
-		ext.EXPECT().PostRun(executor.AtBlock[*substate.Substate](12), gomock.Any(), nil),
+		ext.EXPECT().PostRun(executor.AtBlock[transaction.SubstateData](12), gomock.Any(), nil),
 	)
 
-	if err := record(cfg, provider, processor, []executor.Extension[*substate.Substate]{ext}); err != nil {
+	if err := record(cfg, provider, processor, []executor.Extension[transaction.SubstateData]{ext}); err != nil {
 		t.Errorf("record failed: %v", err)
 	}
 }
 
 // emptyTx is a dummy substate that will be processed without crashing.
 var emptyTx = &substate.Substate{
-	Env: &substate.SubstateEnv{},
-	Message: &substate.SubstateMessage{
+	Env: &substate.Env{},
+	Message: &substate.Message{
 		GasPrice: big.NewInt(12),
 	},
-	Result: &substate.SubstateResult{
+	Result: &substate.Result{
 		GasUsed: 1,
 	},
 }
 
 // testTx is a dummy substate used for testing validation.
 var testTx = &substate.Substate{
-	InputAlloc: substate.SubstateAlloc{testingAddress: substate.NewSubstateAccount(1, new(big.Int).SetUint64(1), []byte{})},
-	Env:        &substate.SubstateEnv{},
-	Message: &substate.SubstateMessage{
+	InputAlloc: substate.Alloc{substateCommon.Address(testingAddress): substate.NewAccount(1, new(big.Int).SetUint64(1), []byte{})},
+	Env:        &substate.Env{},
+	Message: &substate.Message{
 		GasPrice: big.NewInt(12),
 	},
-	Result: &substate.SubstateResult{
+	Result: &substate.Result{
 		GasUsed: 1,
 	},
 }

cmd/aida-sdb/trace/replay_substate.go

@@ -7,11 +7,11 @@ import (
 	"github.com/Fantom-foundation/Aida/executor/extension/statedb"
 	"github.com/Fantom-foundation/Aida/executor/extension/tracker"
 	"github.com/Fantom-foundation/Aida/executor/extension/validator"
+	"github.com/Fantom-foundation/Aida/executor/transaction"
 	"github.com/Fantom-foundation/Aida/state"
 	"github.com/Fantom-foundation/Aida/tracer/context"
 	"github.com/Fantom-foundation/Aida/tracer/operation"
 	"github.com/Fantom-foundation/Aida/utils"
-	substate "github.com/Fantom-foundation/Substate"
 	"github.com/urfave/cli/v2"
 )
 
@@ -37,8 +37,8 @@ func ReplaySubstate(ctx *cli.Context) error {
 
 	processor := makeSubstateProcessor(cfg, rCtx, operationProvider)
 
-	var extra = []executor.Extension[*substate.Substate]{
-		profiler.MakeReplayProfiler[*substate.Substate](cfg, rCtx),
+	var extra = []executor.Extension[transaction.SubstateData]{
+		profiler.MakeReplayProfiler[transaction.SubstateData](cfg, rCtx),
 	}
 
 	return replaySubstate(cfg, substateProvider, processor, nil, extra)
@@ -56,7 +56,7 @@ type substateProcessor struct {
 	operationProvider executor.Provider[[]operation.Operation]
 }
 
-func (p substateProcessor) Process(state executor.State[*substate.Substate], ctx *executor.Context) error {
+func (p substateProcessor) Process(state executor.State[transaction.SubstateData], ctx *executor.Context) error {
 	return p.operationProvider.Run(state.Block, state.Block, func(t executor.TransactionInfo[[]operation.Operation]) error {
 		p.runTransaction(uint64(state.Block), t.Data, ctx.State)
 		return nil
@@ -65,21 +65,21 @@ func (p substateProcessor) Process(state executor.State[*substate.Substate], ctx
 
 func replaySubstate(
 	cfg *utils.Config,
-	provider executor.Provider[*substate.Substate],
-	processor executor.Processor[*substate.Substate],
+	provider executor.Provider[transaction.SubstateData],
+	processor executor.Processor[transaction.SubstateData],
 	stateDb state.StateDB,
-	extra []executor.Extension[*substate.Substate],
+	extra []executor.Extension[transaction.SubstateData],
 ) error {
-	var extensionList = []executor.Extension[*substate.Substate]{
-		profiler.MakeCpuProfiler[*substate.Substate](cfg),
-		tracker.MakeProgressLogger[*substate.Substate](cfg, 0),
-		profiler.MakeMemoryUsagePrinter[*substate.Substate](cfg),
-		profiler.MakeMemoryProfiler[*substate.Substate](cfg),
+	var extensionList = []executor.Extension[transaction.SubstateData]{
+		profiler.MakeCpuProfiler[transaction.SubstateData](cfg),
+		tracker.MakeProgressLogger[transaction.SubstateData](cfg, 0),
+		profiler.MakeMemoryUsagePrinter[transaction.SubstateData](cfg),
+		profiler.MakeMemoryProfiler[transaction.SubstateData](cfg),
 		validator.MakeLiveDbValidator(cfg),
 	}
 
 	if stateDb == nil {
-		extensionList = append(extensionList, statedb.MakeStateDbManager[*substate.Substate](cfg))
+		extensionList = append(extensionList, statedb.MakeStateDbManager[transaction.SubstateData](cfg))
 	}
 
 	if cfg.DbImpl == "memory" {

cmd/aida-sdb/trace/replay_substate_test.go

@@ -5,11 +5,12 @@ import (
 	"testing"
 
 	"github.com/Fantom-foundation/Aida/executor"
+	"github.com/Fantom-foundation/Aida/executor/transaction"
 	"github.com/Fantom-foundation/Aida/state"
 	"github.com/Fantom-foundation/Aida/tracer/context"
 	"github.com/Fantom-foundation/Aida/tracer/operation"
 	"github.com/Fantom-foundation/Aida/utils"
-	substate "github.com/Fantom-foundation/Substate"
+	"github.com/Fantom-foundation/Substate/substate"
 	"github.com/ethereum/go-ethereum/common"
 	"go.uber.org/mock/gomock"
 )
@@ -18,9 +19,9 @@ var testingAddress = common.Address{1}
 
 func TestSdbReplaySubstate_AllDbEventsAreIssuedInOrder(t *testing.T) {
 	ctrl := gomock.NewController(t)
-	provider := executor.NewMockProvider[*substate.Substate](ctrl)
-	processor := executor.NewMockProcessor[*substate.Substate](ctrl)
-	ext := executor.NewMockExtension[*substate.Substate](ctrl)
+	provider := executor.NewMockProvider[transaction.SubstateData](ctrl)
+	processor := executor.NewMockProcessor[transaction.SubstateData](ctrl)
+	ext := executor.NewMockExtension[transaction.SubstateData](ctrl)
 
 	cfg := &utils.Config{}
 	cfg.DbImpl = "carmen"
@@ -31,39 +32,39 @@ func TestSdbReplaySubstate_AllDbEventsAreIssuedInOrder(t *testing.T) {
 
 	provider.EXPECT().
 		Run(0, 1, gomock.Any()).
-		DoAndReturn(func(from int, to int, consumer executor.Consumer[*substate.Substate]) error {
+		DoAndReturn(func(from int, to int, consumer executor.Consumer[transaction.SubstateData]) error {
 			for i := from; i < to; i++ {
-				consumer(executor.TransactionInfo[*substate.Substate]{Block: 0, Transaction: 0, Data: testTx})
-				consumer(executor.TransactionInfo[*substate.Substate]{Block: 0, Transaction: 1, Data: testTx})
+				consumer(executor.TransactionInfo[transaction.SubstateData]{Block: 0, Transaction: 0, Data: transaction.NewSubstateData(testTx)})
+				consumer(executor.TransactionInfo[transaction.SubstateData]{Block: 0, Transaction: 1, Data: transaction.NewSubstateData(testTx)})
 			}
 			return nil
 		})
 
 	// All transactions are processed in order
 	gomock.InOrder(
-		ext.EXPECT().PreRun(executor.AtBlock[*substate.Substate](0), gomock.Any()),
+		ext.EXPECT().PreRun(executor.AtBlock[transaction.SubstateData](0), gomock.Any()),
 
 		// tx 0
-		ext.EXPECT().PreTransaction(executor.AtTransaction[*substate.Substate](0, 0), gomock.Any()),
-		processor.EXPECT().Process(executor.AtTransaction[*substate.Substate](0, 0), gomock.Any()),
-		ext.EXPECT().PostTransaction(executor.AtTransaction[*substate.Substate](0, 0), gomock.Any()),
+		ext.EXPECT().PreTransaction(executor.AtTransaction[transaction.SubstateData](0, 0), gomock.Any()),
+		processor.EXPECT().Process(executor.AtTransaction[transaction.SubstateData](0, 0), gomock.Any()),
+		ext.EXPECT().PostTransaction(executor.AtTransaction[transaction.SubstateData](0, 0), gomock.Any()),
 
 		// tx 1
-		ext.EXPECT().PreTransaction(executor.AtTransaction[*substate.Substate](0, 1), gomock.Any()),
-		processor.EXPECT().Process(executor.AtTransaction[*substate.Substate](0, 1), gomock.Any()),
-		ext.EXPECT().PostTransaction(executor.AtTransaction[*substate.Substate](0, 1), gomock.Any()),
+		ext.EXPECT().PreTransaction(executor.AtTransaction[transaction.SubstateData](0, 1), gomock.Any()),
+		processor.EXPECT().Process(executor.AtTransaction[transaction.SubstateData](0, 1), gomock.Any()),
+		ext.EXPECT().PostTransaction(executor.AtTransaction[transaction.SubstateData](0, 1), gomock.Any()),
 
-		ext.EXPECT().PostRun(executor.AtBlock[*substate.Substate](1), gomock.Any(), nil),
+		ext.EXPECT().PostRun(executor.AtBlock[transaction.SubstateData](1), gomock.Any(), nil),
 	)
 
-	if err := replaySubstate(cfg, provider, processor, nil, []executor.Extension[*substate.Substate]{ext}); err != nil {
+	if err := replaySubstate(cfg, provider, processor, nil, []executor.Extension[transaction.SubstateData]{ext}); err != nil {
 		t.Errorf("record failed: %v", err)
 	}
 }
 
 func TestSdbReplaySubstate_StateDbPrepperIsAddedIfDbImplIsMemory(t *testing.T) {
 	ctrl := gomock.NewController(t)
-	substateProvider := executor.NewMockProvider[*substate.Substate](ctrl)
+	substateProvider := executor.NewMockProvider[transaction.SubstateData](ctrl)
 	operationProvider := executor.NewMockProvider[[]operation.Operation](ctrl)
 	db := state.NewMockStateDB(ctrl)
 
@@ -76,9 +77,9 @@ func TestSdbReplaySubstate_StateDbPrepperIsAddedIfDbImplIsMemory(t *testing.T) {
 
 	substateProvider.EXPECT().
 		Run(0, 1, gomock.Any()).
-		DoAndReturn(func(from int, to int, consumer executor.Consumer[*substate.Substate]) error {
+		DoAndReturn(func(from int, to int, consumer executor.Consumer[transaction.SubstateData]) error {
 			for i := from; i < to; i++ {
-				consumer(executor.TransactionInfo[*substate.Substate]{Block: 0, Transaction: 0, Data: testTx})
+				consumer(executor.TransactionInfo[transaction.SubstateData]{Block: 0, Transaction: 0, Data: transaction.NewSubstateData(testTx)})
 			}
 			return nil
 		})
@@ -103,7 +104,7 @@ func TestSdbReplaySubstate_StateDbPrepperIsAddedIfDbImplIsMemory(t *testing.T) {
 
 func TestSdbReplaySubstate_TxPrimerIsAddedIfDbImplIsNotMemory(t *testing.T) {
 	ctrl := gomock.NewController(t)
-	substateProvider := executor.NewMockProvider[*substate.Substate](ctrl)
+	substateProvider := executor.NewMockProvider[transaction.SubstateData](ctrl)
 	operationProvider := executor.NewMockProvider[[]operation.Operation](ctrl)
 	db := state.NewMockStateDB(ctrl)
 	bulkLoad := state.NewMockBulkLoad(ctrl)
@@ -117,9 +118,9 @@ func TestSdbReplaySubstate_TxPrimerIsAddedIfDbImplIsNotMemory(t *testing.T) {
 
 	substateProvider.EXPECT().
 		Run(1, 2, gomock.Any()).
-		DoAndReturn(func(from int, to int, consumer executor.Consumer[*substate.Substate]) error {
+		DoAndReturn(func(from int, to int, consumer executor.Consumer[transaction.SubstateData]) error {
 			for i := from; i < to; i++ {
-				consumer(executor.TransactionInfo[*substate.Substate]{Block: 1, Transaction: 0, Data: testTx})
+				consumer(executor.TransactionInfo[transaction.SubstateData]{Block: 1, Transaction: 0, Data: transaction.NewSubstateData(testTx)})
 			}
 			return nil
 		})
@@ -158,12 +159,12 @@ var testOperationsB = []operation.Operation{
 
 // testTx is a dummy substate that will be processed without crashing.
 var testTx = &substate.Substate{
-	Env: &substate.SubstateEnv{},
-	Message: &substate.SubstateMessage{
+	Env: &substate.Env{},
+	Message: &substate.Message{
 		Gas:      10000,
 		GasPrice: big.NewInt(0),
 	},
-	Result: &substate.SubstateResult{
+	Result: &substate.Result{
 		GasUsed: 1,
 	},
 }

cmd/aida-stochastic-sdb/stochastic/record.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/Fantom-foundation/Aida/executor"
+	"github.com/Fantom-foundation/Aida/executor/transaction"
 	"github.com/Fantom-foundation/Aida/state"
 	"github.com/Fantom-foundation/Aida/stochastic"
 	"github.com/Fantom-foundation/Aida/utils"
@@ -102,9 +103,9 @@ func stochasticRecordAction(ctx *cli.Context) error {
 		}
 
 		var statedb state.StateDB
-		statedb = state.MakeInMemoryStateDB(&tx.Substate.InputAlloc, tx.Block)
+		statedb = state.MakeInMemoryStateDB(transaction.NewOldSubstateAlloc(tx.Substate.InputAlloc), tx.Block)
 		statedb = stochastic.NewEventProxy(statedb, &eventRegistry)
-		if err = processor.ProcessTransaction(statedb, int(tx.Block), tx.Transaction, tx.Substate); err != nil {
+		if err = processor.ProcessTransaction(statedb, int(tx.Block), tx.Transaction, transaction.NewOldSubstateData(tx.Substate)); err != nil {
 			return err
 		}