feat: add minimum version check

cmd/zetaclientd/start.go

@@ -94,11 +94,6 @@ func Start(_ *cobra.Command, _ []string) error {
 		Telemetry:           telemetry,
 	}
 
-	tss, err := zetatss.Setup(ctx, tssSetupProps, logger.Std)
-	if err != nil {
-		return errors.Wrap(err, "unable to setup TSS service")
-	}
-
 	isObserver, err := isObserverNode(ctx, zetacoreClient)
 	switch {
 	case err != nil:
@@ -115,11 +110,23 @@ func Start(_ *cobra.Command, _ []string) error {
 		graceful.ShutdownNow()
 	})
 
-	maintenance.NewShutdownListener(zetacoreClient, logger.Std).Listen(ctx, func() {
+	shutdownListener := maintenance.NewShutdownListener(zetacoreClient, logger.Std)
+	err = shutdownListener.RunPreStartCheck(ctx)
+	if err != nil {
+		return errors.Wrap(err, "pre start check failed")
+	}
+	shutdownListener.Listen(ctx, func() {
 		logger.Std.Info().Msg("Shutdown listener received an action to shutdown zetaclientd.")
 		graceful.ShutdownNow()
 	})
 
+	// This will start p2p communication so it should only happen after
+	// preflight checks have completed
+	tss, err := zetatss.Setup(ctx, tssSetupProps, logger.Std)
+	if err != nil {
+		return errors.Wrap(err, "unable to setup TSS service")
+	}
+
 	// CreateSignerMap: This creates a map of all signers for each chain.
 	// Each signer is responsible for signing transactions for a particular chain
 	signerMap, err := orchestrator.CreateSignerMap(ctx, tss, logger)

docs/openapi/openapi.swagger.yaml

@@ -58115,6 +58115,11 @@ definitions:
         description: |-
           Offset from the zetacore block time to initiate signing.
           Should be calculated and set based on max(zetaclient_core_block_latency).
+      minimum_version:
+        type: string
+        description: |-
+          Minimum version of zetaclient that is allowed to run. This must be either
+          a valid semver string (v23.0.1) or empty.
     description: Flags for the top-level operation of zetaclient.
   observerPendingNonces:
     type: object

proto/zetachain/zetacore/observer/operational.proto

@@ -16,4 +16,8 @@ message OperationalFlags {
   // Should be calculated and set based on max(zetaclient_core_block_latency).
   google.protobuf.Duration signer_block_time_offset = 2
       [ (gogoproto.stdduration) = true ];
+
+  // Minimum version of zetaclient that is allowed to run. This must be either
+  // a valid semver string (v23.0.1) or empty.
+  string minimum_version = 3;
 }

typescript/zetachain/zetacore/observer/operational_pb.d.ts

@@ -28,6 +28,14 @@ export declare class OperationalFlags extends Message<OperationalFlags> {
    */
   signerBlockTimeOffset?: Duration;
 
+  /**
+   * Minimum version of zetaclient that is allowed to run. This must be either
+   * a valid semver string (v23.0.1) or empty.
+   *
+   * @generated from field: string minimum_version = 3;
+   */
+  minimumVersion: string;
+
   constructor(data?: PartialMessage<OperationalFlags>);
 
   static readonly runtime: typeof proto3;

x/observer/types/errors.go

@@ -71,4 +71,9 @@ var (
 		1140,
 		"signer block time offset exceeds limit",
 	)
+	ErrOperationalFlagsInvalidMinimumVersion = errorsmod.Register(
+		ModuleName,
+		1141,
+		"minimum version is not a valid semver string",
+	)
 )

x/observer/types/operational.go

@@ -4,6 +4,7 @@ import (
 	"time"
 
 	cosmoserrors "cosmossdk.io/errors"
+	"golang.org/x/mod/semver"
 )
 
 const (
@@ -23,5 +24,8 @@ func (f *OperationalFlags) Validate() error {
 			return cosmoserrors.Wrapf(ErrOperationalFlagsSignerBlockTimeOffsetLimit, "(%s)", signerBlockTimeOffset)
 		}
 	}
+	if f.MinimumVersion != "" && !semver.IsValid(f.MinimumVersion) {
+		return ErrOperationalFlagsInvalidMinimumVersion
+	}
 	return nil
 }

x/observer/types/operational_test.go

@@ -15,6 +15,10 @@ func TestOperationalFlags_Validate(t *testing.T) {
 		of          types.OperationalFlags
 		errContains string
 	}{
+		{
+			name: "empty is valid",
+			of:   types.OperationalFlags{},
+		},
 		{
 			name: "invalid restart height",
 			of: types.OperationalFlags{
@@ -48,11 +52,18 @@ func TestOperationalFlags_Validate(t *testing.T) {
 			},
 			errContains: types.ErrOperationalFlagsSignerBlockTimeOffsetLimit.Error(),
 		},
+		{
+			name: "minimum version valid",
+			of: types.OperationalFlags{
+				MinimumVersion: "v1.1.1",
+			},
+		},
 		{
 			name: "all flags valid",
 			of: types.OperationalFlags{
 				RestartHeight:         1,
 				SignerBlockTimeOffset: ptr.Ptr(time.Second),
+				MinimumVersion:        "v1.1.1",
 			},
 		},
 	}

zetaclient/maintenance/shutdown_listener.go

@@ -2,12 +2,16 @@ package maintenance
 
 import (
 	"context"
+	"fmt"
+	"strings"
 	"time"
 
 	"cosmossdk.io/errors"
 	"github.com/rs/zerolog"
+	"golang.org/x/mod/semver"
 
 	"github.com/zeta-chain/node/pkg/bg"
+	"github.com/zeta-chain/node/pkg/constant"
 	"github.com/zeta-chain/node/pkg/retry"
 	observertypes "github.com/zeta-chain/node/x/observer/types"
 	"github.com/zeta-chain/node/zetaclient/chains/interfaces"
@@ -22,17 +26,32 @@ type ShutdownListener struct {
 	logger zerolog.Logger
 
 	lastRestartHeightMissed int64
+	getVersion              func() string
 }
 
 // NewShutdownListener creates a new ShutdownListener.
 func NewShutdownListener(client interfaces.ZetacoreClient, logger zerolog.Logger) *ShutdownListener {
 	log := logger.With().Str("module", "shutdown_listener").Logger()
 	return &ShutdownListener{
-		client: client,
-		logger: log,
+		client:     client,
+		logger:     log,
+		getVersion: getVersionDefault,
 	}
 }
 
+// RunPreStartCheck runs any checks that must run before fully starting zetaclient.
+// Specifically this should be run before any TSS P2P is started.
+func (o *ShutdownListener) RunPreStartCheck(ctx context.Context) error {
+	operationalFlags, err := o.getOperationalFlagsWithRetry(ctx)
+	if err != nil {
+		return errors.Wrap(err, "unable to get initial operational flags")
+	}
+	if err := o.checkMinimumVersion(operationalFlags); err != nil {
+		return err
+	}
+	return nil
+}
+
 func (o *ShutdownListener) Listen(ctx context.Context, action func()) {
 	var (
 		withLogger = bg.WithLogger(o.logger)
@@ -43,12 +62,9 @@ func (o *ShutdownListener) Listen(ctx context.Context, action func()) {
 }
 
 func (o *ShutdownListener) waitForUpdate(ctx context.Context) error {
-	operationalFlags, err := retry.DoTypedWithBackoffAndRetry(
-		func() (observertypes.OperationalFlags, error) { return o.client.GetOperationalFlags(ctx) },
-		retry.DefaultConstantBackoff(),
-	)
+	operationalFlags, err := o.getOperationalFlagsWithRetry(ctx)
 	if err != nil {
-		return errors.Wrap(err, "unable to get initial operational flags")
+		return errors.Wrap(err, "get initial operational flags")
 	}
 	if o.handleNewFlags(ctx, operationalFlags) {
 		return nil
@@ -74,8 +90,19 @@ func (o *ShutdownListener) waitForUpdate(ctx context.Context) error {
 	}
 }
 
+func (o *ShutdownListener) getOperationalFlagsWithRetry(ctx context.Context) (observertypes.OperationalFlags, error) {
+	return retry.DoTypedWithBackoffAndRetry(
+		func() (observertypes.OperationalFlags, error) { return o.client.GetOperationalFlags(ctx) },
+		retry.DefaultConstantBackoff(),
+	)
+}
+
 // handleNewFlags processes the flags and returns true if a shutdown should be signaled
 func (o *ShutdownListener) handleNewFlags(ctx context.Context, f observertypes.OperationalFlags) bool {
+	if err := o.checkMinimumVersion(f); err != nil {
+		o.logger.Error().Err(err).Msg("minimum version check")
+		return true
+	}
 	if f.RestartHeight < 1 {
 		return false
 	}
@@ -123,3 +150,29 @@ func (o *ShutdownListener) handleNewFlags(ctx context.Context, f observertypes.O
 		}
 	}
 }
+
+func (o *ShutdownListener) checkMinimumVersion(f observertypes.OperationalFlags) error {
+	if f.MinimumVersion != "" {
+		// we typically store the version without the required v prefix
+		currentVersion := ensurePrefix(o.getVersion(), "v")
+		if semver.Compare(currentVersion, f.MinimumVersion) == -1 {
+			return fmt.Errorf(
+				"current version (%s) is less than minimum version (%s)",
+				currentVersion,
+				f.MinimumVersion,
+			)
+		}
+	}
+	return nil
+}
+
+func getVersionDefault() string {
+	return constant.Version
+}
+
+func ensurePrefix(s, prefix string) string {
+	if !strings.HasPrefix(s, prefix) {
+		return prefix + s
+	}
+	return s
+}