PRT tool WIP

Author: mpernambuco

internal/config/generate/Config.toml

@@ -40,7 +40,7 @@ default = "true"
 go-type = "bool"
 description = """
 If set to false, the node will not start the inspect service."""
-used-by = ["advancer", "node", "prt"]
+used-by = ["advancer", "node"]
 
 [features.CARTESI_FEATURE_JSONRPC_API_ENABLED]
 default = "true"

internal/config/generated.go

@@ -7,81 +7,36 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"net/http"
-	"time"
 
 	"github.com/cartesi/rollups-node/internal/config"
-	"github.com/cartesi/rollups-node/internal/inspect"
 	"github.com/cartesi/rollups-node/internal/manager"
-	. "github.com/cartesi/rollups-node/internal/model"
+	"github.com/cartesi/rollups-node/internal/model"
 	"github.com/cartesi/rollups-node/internal/repository"
 	"github.com/cartesi/rollups-node/pkg/service"
 )
 
 var (
 	ErrInvalidMachines   = errors.New("machines must not be nil")
 	ErrInvalidRepository = errors.New("repository must not be nil")
-
-	ErrNoApp              = errors.New("no machine for application")
-	ErrNoTournaments      = errors.New("no active tournaments")
-	ErrInvalidStageConfig = errors.New("invalid stage configuration")
 )
 
 type PRTRepository interface {
-	ListInputs(ctx context.Context, nameOrAddress string, f repository.InputFilter, p repository.Pagination, descending bool) ([]*Input, uint64, error)
-	GetLastInput(ctx context.Context, appAddress string, epochIndex uint64) (*Input, error)
-	GetEpoch(ctx context.Context, nameOrAddress string, index uint64) (*Epoch, error)
-}
-
-type Tournament struct {
-	ID            string
-	ApplicationID int64
-	StartEpoch    uint64
-	EndEpoch      uint64
-	Participants  []string
-	Teams         map[string][]string
-	Status        TournamentStatus
-	CreatedAt     time.Time
-	UpdatedAt     time.Time
-}
-
-type TournamentStatus int
-
-const (
-	TournamentStatus_Created TournamentStatus = iota
-	TournamentStatus_Active
-	TournamentStatus_Completed
-	TournamentStatus_Failed
-)
-
-type ComputationHash struct {
-	ApplicationAddress string
-	StageLevel         int // 0 for complete, 1+ for sparse stages
-	StartStep          uint64
-	EndStep            uint64
-	StateInterval      uint64 // Steps between state hashes
-	RootHash           []byte
-	CreatedAt          time.Time
+	ListApplications(ctx context.Context, f repository.ApplicationFilter, p repository.Pagination, descending bool) ([]*model.Application, uint64, error)
 }
 
 type Service struct {
 	service.Service
 	config         config.PrtConfig
 	repository     PRTRepository
 	machineManager manager.MachineProvider
-	inspector      *inspect.Inspector
-	HTTPServer     *http.Server
-	HTTPServerFunc func() error
 }
 
-// CreateInfo contains the configuration for creating a PRT service
 type CreateInfo struct {
 	service.CreateInfo
 	Config     config.PrtConfig
 	Repository repository.Repository
 }
 
-// Create initializes a new PRT service
 func Create(ctx context.Context, c *CreateInfo) (*Service, error) {
 	var err error
 	if err = ctx.Err(); err != nil {
@@ -112,38 +67,35 @@ func Create(ctx context.Context, c *CreateInfo) (*Service, error) {
 	)
 	s.machineManager = manager
 
-	// Initialize the inspect service if enabled
-	if c.Config.FeatureInspectEnabled {
-		s.inspector, s.HTTPServer, s.HTTPServerFunc = inspect.NewInspector(
-			c.Repository,
-			manager,
-			c.Config.InspectAddress,
-			c.LogLevel,
-			c.LogColor,
-		)
-	}
-
 	return s, nil
 }
 
 // Service interface implementation
 func (s *Service) Alive() bool     { return true }
 func (s *Service) Ready() bool     { return true }
 func (s *Service) Reload() []error { return nil }
-
-func (s *Service) Tick() []error {
-	s.Logger.Info("PRT service tick... (TODO)")
-	return []error{}
-}
-
 func (s *Service) Stop(b bool) []error {
 	return nil
 }
-
 func (s *Service) Serve() error {
 	return s.Service.Serve()
 }
-
 func (s *Service) String() string {
 	return s.Name
 }
+func (s *Service) Tick() []error {
+	s.Logger.Info("PRT service tick...")
+	apps, _, err := s.repository.ListApplications(context.Background(),
+		repository.ApplicationFilter{
+			State:         model.Pointer(model.ApplicationState_Enabled),
+			ConsensusType: model.Pointer(model.ConsensusType_Prt),
+		}, repository.Pagination{}, false)
+	if err != nil {
+		s.Logger.Error("Failed to list applications", "error", err)
+		return []error{err}
+	}
+	for _, app := range apps {
+		s.Logger.Info("Application found", "name", app.Name, "consensus type:", app.ConsensusType)
+	}
+	return []error{}
+}

internal/prt/prt.go

@@ -0,0 +1,102 @@
+// (c) Cartesi and individual authors (see AUTHORS)
+// SPDX-License-Identifier: Apache-2.0 (see LICENSE)
+
+package prt
+
+import (
+	"context"
+	"log/slog"
+	"os"
+	"testing"
+
+	"github.com/cartesi/rollups-node/internal/model"
+	"github.com/cartesi/rollups-node/internal/repository"
+	"github.com/cartesi/rollups-node/pkg/service"
+	"github.com/lmittmann/tint"
+
+	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+type prtRepositoryMock struct {
+	mock.Mock
+}
+
+func (m *prtRepositoryMock) ListApplications(
+	ctx context.Context,
+	f repository.ApplicationFilter,
+	pagination repository.Pagination,
+	descending bool,
+) ([]*model.Application, uint64, error) {
+	args := m.Called(ctx, f, pagination, descending)
+	return args.Get(0).([]*model.Application), args.Get(1).(uint64), args.Error(2)
+}
+
+func newServiceMock() (*Service, *prtRepositoryMock) {
+	opts := &tint.Options{
+		Level:     slog.LevelDebug,
+		AddSource: true,
+		// RFC3339 with milliseconds and without timezone
+		TimeFormat: "2006-01-02T15:04:05.000",
+	}
+	handler := tint.NewHandler(os.Stdout, opts)
+	repository := &prtRepositoryMock{}
+
+	prt := &Service{
+		Service: service.Service{
+			Name:   "prt",
+			Logger: slog.New(handler),
+		},
+		repository: repository,
+	}
+	return prt, repository
+}
+
+func makeApplication(id int64) *model.Application {
+	return &model.Application{
+		ID:                  id,
+		IApplicationAddress: common.HexToAddress("0x01"),
+		IConsensusAddress:   common.HexToAddress("0x01"),
+		IInputBoxAddress:    common.HexToAddress("0x02"),
+	}
+}
+
+// //////////////////////////////////////////////////////////////////////////////
+// Basic Service Tests
+// //////////////////////////////////////////////////////////////////////////////
+func TestServiceMethods(t *testing.T) {
+	s, _ := newServiceMock()
+
+	assert.True(t, s.Alive())
+	assert.True(t, s.Ready())
+	assert.Empty(t, s.Reload())
+	assert.Empty(t, s.Stop(false))
+	assert.NotEmpty(t, s.String())
+}
+
+func TestTick_NoApplications(t *testing.T) {
+	s, r := newServiceMock()
+	defer r.AssertExpectations(t)
+
+	r.On("ListApplications", mock.Anything, mock.Anything, mock.Anything, mock.Anything).
+		Return([]*model.Application{}, uint64(0), nil).Once()
+
+	errs := s.Tick()
+	assert.Empty(t, errs)
+}
+
+func TestTick_WithApplications(t *testing.T) {
+	s, r := newServiceMock()
+	defer r.AssertExpectations(t)
+
+	app := makeApplication(1)
+	apps := []*model.Application{app}
+
+	r.On("ListApplications", mock.Anything, mock.Anything, mock.Anything, mock.Anything).
+		Return(apps, uint64(1), nil).Once()
+
+	errs := s.Tick()
+	assert.Empty(t, errs)
+}

internal/prt/prt_test.go

@@ -39,6 +39,7 @@ DROP TYPE IF EXISTS "SnapshotPolicy";
 DROP TYPE IF EXISTS "EpochStatus";
 DROP TYPE IF EXISTS "DefaultBlock";
 DROP TYPE IF EXISTS "InputCompletionStatus";
+DROP TYPE IF EXISTS "ConsensusType";
 DROP TYPE IF EXISTS "ApplicationState";
 DROP DOMAIN IF EXISTS "data_availability";
 DROP DOMAIN IF EXISTS "hash";

internal/repository/postgres/schema/migrations/000001_create_initial_schema.down.sql

@@ -84,6 +84,7 @@ func (s *ValidatorRepositoryIntegrationSuite) TestItReturnsPristineClaim() {
 	s.Run("WhenThereAreNoOutputsAndNoPreviousEpoch", func() {
 		app := &model.Application{
 			Name:                "test-app",
+			ConsensusType:       model.ConsensusType_Authority,
 			IApplicationAddress: common.BytesToAddress([]byte("deadbeef")),
 			IConsensusAddress:   common.BytesToAddress([]byte("beadbeef")),
 			TemplateHash:        common.BytesToHash([]byte("template")),
@@ -150,6 +151,7 @@ func (s *ValidatorRepositoryIntegrationSuite) TestItReturnsPreviousClaim() {
 	s.Run("WhenThereAreNoOutputsAndThereIsAPreviousEpoch", func() {
 		app := &model.Application{
 			Name:                "test-app",
+			ConsensusType:       model.ConsensusType_Authority,
 			IApplicationAddress: common.BytesToAddress([]byte("deadbeef")),
 			IConsensusAddress:   common.BytesToAddress([]byte("beadbeef")),
 			TemplateHash:        common.BytesToHash([]byte("template")),
@@ -253,6 +255,7 @@ func (s *ValidatorRepositoryIntegrationSuite) TestItReturnsANewClaimAndProofs()
 	s.Run("WhenThereAreOutputsAndNoPreviousEpoch", func() {
 		app := &model.Application{
 			Name:                "test-app",
+			ConsensusType:       model.ConsensusType_Authority,
 			IApplicationAddress: common.BytesToAddress([]byte("deadbeef")),
 			IConsensusAddress:   common.BytesToAddress([]byte("beadbeef")),
 			TemplateHash:        common.BytesToHash([]byte("template")),
@@ -340,6 +343,7 @@ func (s *ValidatorRepositoryIntegrationSuite) TestItReturnsANewClaimAndProofs()
 	s.Run("WhenThereAreOutputsAndAPreviousEpoch", func() {
 		app := &model.Application{
 			Name:                "test-app",
+			ConsensusType:       model.ConsensusType_Authority,
 			IApplicationAddress: common.BytesToAddress([]byte("deadbeef")),
 			IConsensusAddress:   common.BytesToAddress([]byte("beadbeef")),
 			TemplateHash:        common.BytesToHash([]byte("template")),