wip

cmd/cartesi-rollups-advancer/main.go

@@ -0,0 +1,105 @@
+// (c) Cartesi and individual authors (see AUTHORS)
+// SPDX-License-Identifier: Apache-2.0 (see LICENSE)
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/cartesi/rollups-node/internal/node/advancer"
+	"github.com/cartesi/rollups-node/internal/node/advancer/machines"
+	"github.com/cartesi/rollups-node/internal/node/config"
+	"github.com/cartesi/rollups-node/internal/node/startup"
+	"github.com/cartesi/rollups-node/internal/repository"
+	"github.com/spf13/cobra"
+)
+
+const CMD_NAME = "advancer"
+
+var (
+	buildVersion = "devel"
+	Cmd          = &cobra.Command{
+		Use:   CMD_NAME,
+		Short: "Runs the Advancer",
+		Long:  "Runs the Advancer in standalone mode",
+		Run:   run,
+	}
+)
+
+func init() {
+	flags := Cmd.Flags()
+	flags.BytesHex("application-address", nil, "")
+	flags.String("server-address", "", "")
+	flags.String("snapshot", "", "")
+	flags.Int64("snapshot-input-index", -1, "")
+	flags.Uint64("machine-inc-cycles", 50_000_000, "")
+	flags.Uint64("machine-max-cycles", 5_000_000_000, "")
+	flags.Uint64("machine-advance-timeout", 60, "")
+	flags.Uint64("machine-inspect-timeout", 10, "")
+}
+
+func main() {
+	err := Cmd.Execute()
+	if err != nil {
+		os.Exit(1)
+	}
+}
+
+func getDatabase(ctx context.Context, c config.NodeConfig) (*repository.Database, error) {
+	err := startup.ValidateSchema(c)
+	if err != nil {
+		return nil, fmt.Errorf("invalid database schema: %w", err)
+	}
+
+	database, err := repository.Connect(ctx, c.PostgresEndpoint.Value)
+	if err != nil {
+		return nil, fmt.Errorf("failed to connect to the database: %w", err)
+	}
+
+	return database, nil
+}
+
+func run(cmd *cobra.Command, args []string) {
+	startTime := time.Now()
+
+	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
+	defer stop()
+
+	c := config.FromEnv()
+	startup.ConfigLogs(c)
+
+	slog.Info("Starting the Cartesi Rollups Node Advancer", "version", buildVersion, "config", c)
+
+	database, err := getDatabase(ctx, c)
+	if err != nil {
+		slog.Error(err.Error())
+		os.Exit(1)
+	}
+	defer database.Close()
+
+	repo := &repository.AdvancerRepository{Database: database}
+
+	machines, err := machines.Load(ctx, c, repo)
+	if err != nil {
+		slog.Error(err.Error())
+		os.Exit(1)
+	}
+	defer machines.Close()
+
+	advancer, err := advancer.New(machines, repo)
+
+	poller, err := advancer.Poller(5 * time.Second)
+
+	ready := make(chan struct{}, 1)
+
+	if err := poller.Start(ctx, ready); err != nil {
+		slog.Error("advancer exited with an error", "error", err)
+		os.Exit(1)
+	}
+}

cmd/cartesi-rollups-cli/root/app/add/add.go

@@ -118,7 +118,7 @@ func run(cmd *cobra.Command, args []string) {
 		IConsensusAddress:  common.HexToAddress(iConsensusAddress),
 	}
 
-	err := cmdcommom.Database.InsertApplication(ctx, &application)
+	_, err := cmdcommom.Database.InsertApplication(ctx, &application)
 	cobra.CheckErr(err)
 	fmt.Printf("Application %v successfully added\n", application.ContractAddress)
 }

docs/config.md

@@ -223,6 +223,13 @@ When enabled, will connect to postgres database via SSL.
 * **Type:** `bool`
 * **Default:** `"true"`
 
+## `CARTESI_ADVANCER_POLLING_INTERVAL`
+
+How many seconds the node will wait before querying the database for new inputs.
+
+* **Type:** `Duration`
+* **Default:** `"30"`
+
 ## `CARTESI_EPOCH_LENGTH`
 
 Length of a rollups epoch in blocks.
@@ -234,7 +241,7 @@ At the end of each epoch, the node will send claims to the blockchain.
 
 ## `CARTESI_EVM_READER_RETRY_POLICY_MAX_DELAY`
 
-How seconds the retry policy will wait between retries.
+How many seconds the retry policy will wait between retries.
 
 * **Type:** `Duration`
 * **Default:** `"3"`
@@ -246,6 +253,13 @@ How many times some functions should be retried after an error.
 * **Type:** `uint64`
 * **Default:** `"3"`
 
+## `CARTESI_MAX_CONCURRENT_INSPECTS`
+
+Maximum number of inspect-state requests that can be concurrently active.
+
+* **Type:** `uint8`
+* **Default:** `"10"`
+
 ## `CARTESI_VALIDATOR_POLLING_INTERVAL`
 
 How many seconds the node will wait before trying to finish epochs for all applications.
@@ -258,3 +272,38 @@ How many seconds the node will wait before trying to finish epochs for all appli
 Path to the directory with the cartesi-machine snapshot that will be loaded by the node.
 
 * **Type:** `string`
+
+## `CARTESI_MACHINE_ADVANCE_TIMEOUT`
+
+TODO.
+
+* **Type:** `Duration`
+* **Default:** `"60"`
+
+## `CARTESI_MACHINE_INC_CYCLES`
+
+TODO.
+
+* **Type:** `uint64`
+* **Default:** `"50000000"`
+
+## `CARTESI_MACHINE_INSPECT_TIMEOUT`
+
+TODO.
+
+* **Type:** `Duration`
+* **Default:** `"10"`
+
+## `CARTESI_MACHINE_MAX_CYCLES`
+
+TODO.
+
+* **Type:** `uint64`
+* **Default:** `"5000000000"`
+
+## `CARTESI_MACHINE_SERVER_VERBOSITY`
+
+TODO.
+
+* **Type:** `string`
+* **Default:** `"info"`

internal/node/config/config.go

@@ -8,6 +8,8 @@ package config
 import (
 	"fmt"
 	"os"
+
+	"github.com/cartesi/rollups-node/pkg/rollupsmachine/cartesimachine"
 )
 
 // NodeConfig contains all the Node variables.
@@ -39,7 +41,15 @@ type NodeConfig struct {
 	ExperimentalSunodoValidatorEnabled        bool
 	ExperimentalSunodoValidatorRedisEndpoint  string
 	Auth                                      Auth
+	MaxConcurrentInspects                     uint8
+	AdvancerPollingInterval                   Duration
 	ValidatorPollingInterval                  Duration
+	// Temporary
+	MachineServerVerbosity cartesimachine.ServerVerbosity
+	MachineIncCycles       uint64
+	MachineMaxCycles       uint64
+	MachineAdvanceTimeout  Duration
+	MachineInspectTimeout  Duration
 }
 
 // Auth is used to sign transactions.
@@ -106,7 +116,15 @@ func FromEnv() NodeConfig {
 	if getFeatureClaimerEnabled() && !getExperimentalSunodoValidatorEnabled() {
 		config.Auth = authFromEnv()
 	}
+	config.MaxConcurrentInspects = getMaxConcurrentInspects()
+	config.AdvancerPollingInterval = getAdvancerPollingInterval()
 	config.ValidatorPollingInterval = getValidatorPollingInterval()
+	// Temporary.
+	config.MachineServerVerbosity = cartesimachine.ServerVerbosity(getMachineServerVerbosity())
+	config.MachineIncCycles = getMachineIncCycles()
+	config.MachineMaxCycles = getMachineMaxCycles()
+	config.MachineAdvanceTimeout = getMachineAdvanceTimeout()
+	config.MachineInspectTimeout = getMachineInspectTimeout()
 	return config
 }
 

internal/node/config/generate/Config.toml

@@ -54,7 +54,19 @@ How many times some functions should be retried after an error."""
 default = "3"
 go-type = "Duration"
 description = """
-How seconds the retry policy will wait between retries."""
+How many seconds the retry policy will wait between retries."""
+
+[rollups.CARTESI_MAX_CONCURRENT_INSPECTS]
+default = "10"
+go-type = "uint8"
+description = """
+Maximum number of inspect-state requests that can be concurrently active."""
+
+[rollups.CARTESI_ADVANCER_POLLING_INTERVAL]
+default = "30"
+go-type = "Duration"
+description = """
+How many seconds the node will wait before querying the database for new inputs."""
 
 [rollups.CARTESI_VALIDATOR_POLLING_INTERVAL]
 default = "30"
@@ -250,3 +262,37 @@ go-type = "bool"
 description = """
 When enabled, prints server-manager output to stdout and stderr directly.
 All other log configurations are ignored."""
+
+#
+# Temporary
+#
+
+[temp.CARTESI_MACHINE_SERVER_VERBOSITY]
+default = "info"
+go-type = "string"
+description = """
+TODO."""
+
+[temp.CARTESI_MACHINE_INC_CYCLES]
+default = "50000000"
+go-type = "uint64"
+description = """
+TODO."""
+
+[temp.CARTESI_MACHINE_MAX_CYCLES]
+default = "5000000000"
+go-type = "uint64"
+description = """
+TODO."""
+
+[temp.CARTESI_MACHINE_ADVANCE_TIMEOUT]
+default = "60"
+go-type = "Duration"
+description = """
+TODO."""
+
+[temp.CARTESI_MACHINE_INSPECT_TIMEOUT]
+default = "10"
+go-type = "Duration"
+description = """
+TODO."""

internal/node/config/generate/code.go

@@ -100,6 +100,16 @@ func ToInt64FromString(s string) (int64, error) {
 	return strconv.ParseInt(s, 10, 64)
 }
 
+func ToUint8FromString(s string) (uint8, error) {
+       value, err := strconv.ParseUint(s, 10, 8)
+       return uint8(value), err
+}
+
+func ToUint32FromString(s string) (uint32, error) {
+       value, err := strconv.ParseUint(s, 10, 32)
+       return uint32(value), err
+}
+
 func ToUint64FromString(s string) (uint64, error) {
        value, err := strconv.ParseUint(s, 10, 64)
        return value, err
@@ -164,6 +174,8 @@ var (
 	toBool         = strconv.ParseBool
 	toInt          = strconv.Atoi
 	toInt64        = ToInt64FromString
+	toUint8        = ToUint8FromString
+	toUint32       = ToUint32FromString
 	toUint64       = ToUint64FromString
 	toString       = ToStringFromString
 	toDuration     = ToDurationFromSeconds