feat(evmreader): add support for PRT applications

Author: vfusco

internal/evmreader/application_adapter.go

@@ -17,6 +17,13 @@ import (
 	"github.com/ethereum/go-ethereum/ethclient"
 )
 
+type ApplicationContractAdapter interface {
+	RetrieveOutputExecutionEvents(
+		opts *bind.FilterOpts,
+	) ([]*iapplication.IApplicationOutputExecuted, error)
+	GetDeploymentBlockNumber(opts *bind.CallOpts) (*big.Int, error)
+}
+
 // IApplication Wrapper
 type ApplicationContractAdapterImpl struct {
 	application        *iapplication.IApplication

internal/evmreader/daveconsensus_adapter.go

@@ -0,0 +1,132 @@
+// (c) Cartesi and individual authors (see AUTHORS)
+// SPDX-License-Identifier: Apache-2.0 (see LICENSE)
+
+package evmreader
+
+import (
+	"math/big"
+
+	. "github.com/cartesi/rollups-node/internal/model"
+	"github.com/cartesi/rollups-node/pkg/contracts/daveconsensus"
+	"github.com/cartesi/rollups-node/pkg/ethutil"
+
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethclient"
+)
+
+// Interface for DaveConsensus reading
+type DaveConsensusAdapter interface {
+	GetInputBox(opts *bind.CallOpts) (common.Address, error)
+	GetCurrentSealedEpoch(opts *bind.CallOpts) (struct {
+		EpochNumber          *big.Int
+		InputIndexLowerBound *big.Int
+		InputIndexUpperBound *big.Int
+		Tournament           common.Address
+	}, error)
+	GetApplicationContract(opts *bind.CallOpts) (common.Address, error)
+	GetTournamentFactory(opts *bind.CallOpts) (common.Address, error)
+	RetrieveSealedEpochs(opts *bind.FilterOpts) ([]*daveconsensus.DaveConsensusEpochSealed, error)
+}
+
+// DaveConsensus Wrapper
+type DaveConsensusAdapterImpl struct {
+	daveConsensus        *daveconsensus.DaveConsensus
+	client               *ethclient.Client
+	daveConsensusAddress common.Address
+	filter               ethutil.Filter
+}
+
+func NewDaveConsensusAdapter(
+	daveConsensusAddress common.Address,
+	client *ethclient.Client,
+	filter ethutil.Filter,
+) (DaveConsensusAdapter, error) {
+	daveConsensusContract, err := daveconsensus.NewDaveConsensus(daveConsensusAddress, client)
+	if err != nil {
+		return nil, err
+	}
+	return &DaveConsensusAdapterImpl{
+		daveConsensus:        daveConsensusContract,
+		daveConsensusAddress: daveConsensusAddress,
+		client:               client,
+		filter:               filter,
+	}, nil
+}
+
+func buildEpochSealedFilterQuery(
+	opts *bind.FilterOpts,
+	daveConsensusAddress common.Address,
+) (q ethereum.FilterQuery, err error) {
+	c, err := daveconsensus.DaveConsensusMetaData.GetAbi()
+	if err != nil {
+		return q, err
+	}
+
+	topics, err := abi.MakeTopics(
+		[]any{c.Events[MonitoredEvent_EpochSealed.String()].ID},
+	)
+	if err != nil {
+		return q, err
+	}
+
+	q = ethereum.FilterQuery{
+		Addresses: []common.Address{daveConsensusAddress},
+		FromBlock: new(big.Int).SetUint64(opts.Start),
+		Topics:    topics,
+	}
+	if opts.End != nil {
+		q.ToBlock = new(big.Int).SetUint64(*opts.End)
+	}
+	return q, err
+}
+
+func (d *DaveConsensusAdapterImpl) GetInputBox(opts *bind.CallOpts) (common.Address, error) {
+	return d.daveConsensus.GetInputBox(opts)
+}
+
+func (d *DaveConsensusAdapterImpl) GetCurrentSealedEpoch(opts *bind.CallOpts) (struct {
+	EpochNumber          *big.Int
+	InputIndexLowerBound *big.Int
+	InputIndexUpperBound *big.Int
+	Tournament           common.Address
+}, error) {
+	return d.daveConsensus.GetCurrentSealedEpoch(opts)
+}
+
+func (d *DaveConsensusAdapterImpl) GetApplicationContract(opts *bind.CallOpts) (common.Address, error) {
+	return d.daveConsensus.GetApplicationContract(opts)
+}
+
+func (d *DaveConsensusAdapterImpl) GetTournamentFactory(opts *bind.CallOpts) (common.Address, error) {
+	return d.daveConsensus.GetTournamentFactory(opts)
+}
+
+func (d *DaveConsensusAdapterImpl) RetrieveSealedEpochs(
+	opts *bind.FilterOpts,
+) ([]*daveconsensus.DaveConsensusEpochSealed, error) {
+	q, err := buildEpochSealedFilterQuery(opts, d.daveConsensusAddress)
+	if err != nil {
+		return nil, err
+	}
+
+	itr, err := d.filter.ChunkedFilterLogs(opts.Context, d.client, q)
+	if err != nil {
+		return nil, err
+	}
+
+	var events []*daveconsensus.DaveConsensusEpochSealed
+	for log, err := range itr {
+		if err != nil {
+			return nil, err
+		}
+		ev, err := d.daveConsensus.ParseEpochSealed(*log)
+		if err != nil {
+			return nil, err
+		}
+		events = append(events, ev)
+	}
+	return events, nil
+}

internal/evmreader/evmreader.go

@@ -11,16 +11,12 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/rpc"
 
 	. "github.com/cartesi/rollups-node/internal/model"
 	"github.com/cartesi/rollups-node/internal/repository"
-	"github.com/cartesi/rollups-node/pkg/contracts/iapplication"
-	"github.com/cartesi/rollups-node/pkg/contracts/iinputbox"
 	"github.com/cartesi/rollups-node/pkg/ethutil"
 )
 
@@ -40,6 +36,7 @@ type EvmReaderRepository interface {
 	) error
 	GetEpoch(ctx context.Context, nameOrAddress string, index uint64) (*Epoch, error)
 	ListEpochs(ctx context.Context, nameOrAddress string, f repository.EpochFilter, p repository.Pagination, descending bool) ([]*Epoch, uint64, error)
+	UpdateEpoch(ctx context.Context, nameOrAddress string, e *Epoch) error
 
 	// Output execution monitor
 	GetOutput(ctx context.Context, nameOrAddress string, indexKey uint64) (*Output, error)
@@ -53,22 +50,6 @@ type EthClientInterface interface {
 	ChainID(ctx context.Context) (*big.Int, error)
 }
 
-type ApplicationContractAdapter interface {
-	RetrieveOutputExecutionEvents(
-		opts *bind.FilterOpts,
-	) ([]*iapplication.IApplicationOutputExecuted, error)
-	GetDeploymentBlockNumber(opts *bind.CallOpts) (*big.Int, error)
-}
-
-// Interface for Input reading
-type InputSourceAdapter interface {
-	// Wrapper for FilterInputAdded(), which is automatically generated
-	// by go-ethereum and cannot be used for testing
-	RetrieveInputs(opts *bind.FilterOpts, appAddresses []common.Address, index []*big.Int,
-	) ([]iinputbox.IInputBoxInputAdded, error)
-	GetNumberOfInputs(opts *bind.CallOpts, appContract common.Address) (*big.Int, error)
-}
-
 type SubscriptionError struct {
 	Cause error
 }
@@ -82,6 +63,7 @@ type appContracts struct {
 	application         *Application
 	applicationContract ApplicationContractAdapter
 	inputSource         InputSourceAdapter
+	daveConsensus       DaveConsensusAdapter
 }
 
 func (r *Service) Run(ctx context.Context, ready chan struct{}) error {
@@ -151,8 +133,10 @@ func (r *Service) watchForNewBlocks(ctx context.Context, ready chan<- struct{})
 
 			// Build Contracts
 			var apps []appContracts
+			var daveConsensusApps []appContracts
+			var iconsensusApps []appContracts
 			for _, app := range runningApps {
-				applicationContract, inputSource, err := r.adapterFactory.CreateAdapters(app, r.client)
+				applicationContract, inputSource, daveConsensus, err := r.adapterFactory.CreateAdapters(app, r.client)
 
 				if err != nil {
 					r.Logger.Error("Error retrieving application contracts", "app", app, "error", err)
@@ -162,9 +146,15 @@ func (r *Service) watchForNewBlocks(ctx context.Context, ready chan<- struct{})
 					application:         app,
 					applicationContract: applicationContract,
 					inputSource:         inputSource,
+					daveConsensus:       daveConsensus,
 				}
 
 				apps = append(apps, aContracts)
+				if app.DaveConsensus {
+					daveConsensusApps = append(daveConsensusApps, aContracts)
+				} else {
+					iconsensusApps = append(iconsensusApps, aContracts)
+				}
 			}
 
 			if len(apps) == 0 {
@@ -190,7 +180,9 @@ func (r *Service) watchForNewBlocks(ctx context.Context, ready chan<- struct{})
 					mostRecentHeader.Number.Uint64(), header.Number.Uint64(), r.defaultBlock))
 			}
 
-			r.checkForNewInputs(ctx, apps, blockNumber)
+			r.checkForEpochsAndInputs(ctx, daveConsensusApps, blockNumber)
+
+			r.checkForNewInputs(ctx, iconsensusApps, blockNumber)
 
 			r.checkForOutputExecution(ctx, apps, blockNumber)
 
@@ -234,39 +226,50 @@ func (r *Service) fetchMostRecentHeader(
 }
 
 type AdapterFactory interface {
-	CreateAdapters(app *Application, client EthClientInterface) (ApplicationContractAdapter, InputSourceAdapter, error)
+	CreateAdapters(app *Application, client EthClientInterface) (ApplicationContractAdapter, InputSourceAdapter, DaveConsensusAdapter, error)
 }
 
 type DefaultAdapterFactory struct {
 	Filter ethutil.Filter
 }
 
-func (f *DefaultAdapterFactory) CreateAdapters(app *Application, client EthClientInterface) (ApplicationContractAdapter, InputSourceAdapter, error) {
+func (f *DefaultAdapterFactory) CreateAdapters(app *Application, client EthClientInterface) (ApplicationContractAdapter, InputSourceAdapter, DaveConsensusAdapter, error) {
 	if app == nil {
-		return nil, nil, fmt.Errorf("Application reference is nil. Should never happen")
+		return nil, nil, nil, fmt.Errorf("Application reference is nil. Should never happen")
 	}
 
 	// Type assertion to get the concrete client if possible
 	ethClient, ok := client.(*ethclient.Client)
 	if !ok {
-		return nil, nil, fmt.Errorf("client is not an *ethclient.Client, cannot create adapters")
+		return nil, nil, nil, fmt.Errorf("client is not an *ethclient.Client, cannot create adapters")
 	}
 
 	applicationContract, err := NewApplicationContractAdapter(app.IApplicationAddress, ethClient, f.Filter)
 	if err != nil {
-		return nil, nil, errors.Join(
+		return nil, nil, nil, errors.Join(
 			fmt.Errorf("error building application contract"),
 			err,
 		)
 	}
 
 	inputSource, err := NewInputSourceAdapter(app.IInputBoxAddress, ethClient, f.Filter)
 	if err != nil {
-		return nil, nil, errors.Join(
+		return nil, nil, nil, errors.Join(
 			fmt.Errorf("error building inputbox contract"),
 			err,
 		)
 	}
 
-	return applicationContract, inputSource, nil
+	var daveConsensus DaveConsensusAdapter
+	if app.DaveConsensus {
+		daveConsensus, err = NewDaveConsensusAdapter(app.IConsensusAddress, ethClient, f.Filter)
+		if err != nil {
+			return nil, nil, nil, errors.Join(
+				fmt.Errorf("error building daveconsensus contract"),
+				err,
+			)
+		}
+	}
+
+	return applicationContract, inputSource, daveConsensus, nil
 }

internal/evmreader/evmreader_test.go

@@ -536,6 +536,11 @@ func (m *MockRepository) GetOutput(ctx context.Context, nameOrAddress string, in
 	return obj.(*Output), args.Error(1)
 }
 
+func (m *MockRepository) UpdateEpoch(ctx context.Context, nameOrAddress string, e *Epoch) error {
+	args := m.Called(ctx, nameOrAddress, e)
+	return args.Error(0)
+}
+
 func (m *MockRepository) UpdateOutputsExecution(ctx context.Context, nameOrAddress string,
 	executedOutputs []*Output, blockNumber uint64) error {
 	args := m.Called(ctx, nameOrAddress, executedOutputs, blockNumber)
@@ -592,7 +597,7 @@ func (m *MockAdapterFactory) Unset(methodName string) {
 func (m *MockAdapterFactory) CreateAdapters(
 	app *Application,
 	client EthClientInterface,
-) (ApplicationContractAdapter, InputSourceAdapter, error) {
+) (ApplicationContractAdapter, InputSourceAdapter, DaveConsensusAdapter, error) {
 	args := m.Called(app, client)
 
 	// Safely handle nil values to prevent interface conversion panic
@@ -608,7 +613,7 @@ func (m *MockAdapterFactory) CreateAdapters(
 		inputSource = newMockInputBox()
 	}
 
-	return appContract, inputSource, args.Error(2)
+	return appContract, inputSource, nil, args.Error(2)
 }
 
 func newMockAdapterFactory() *MockAdapterFactory {

internal/evmreader/inputsource_adapter.go

@@ -17,6 +17,15 @@ import (
 	"github.com/ethereum/go-ethereum/ethclient"
 )
 
+// Interface for Input reading
+type InputSourceAdapter interface {
+	// Wrapper for FilterInputAdded(), which is automatically generated
+	// by go-ethereum and cannot be used for testing
+	RetrieveInputs(opts *bind.FilterOpts, appAddresses []common.Address, index []*big.Int,
+	) ([]iinputbox.IInputBoxInputAdded, error)
+	GetNumberOfInputs(opts *bind.CallOpts, appContract common.Address) (*big.Int, error)
+}
+
 // InputBox Wrapper
 type InputSourceAdapterImpl struct {
 	inputbox        *iinputbox.IInputBox

internal/evmreader/output.go

@@ -67,7 +67,7 @@ func (r *Service) checkForOutputExecution(
 				"most_recent_block", mostRecentBlockNumber,
 			)
 		} else {
-			r.Logger.Warn("Not reading output execution: already checked the most recent blocks",
+			r.Logger.Debug("Not reading output execution: already checked the most recent blocks",
 				"application", app.application.Name, "address", app.application.IApplicationAddress,
 				"last output check block", lastOutputCheck,
 				"most recent block", mostRecentBlockNumber,