[Merged by Bors] - Retry registration timeout fix

activation/activation.go

@@ -39,14 +39,18 @@ var (
 
 // PoetConfig is the configuration to interact with the poet server.
 type PoetConfig struct {
-	PhaseShift                     time.Duration `mapstructure:"phase-shift"`
-	CycleGap                       time.Duration `mapstructure:"cycle-gap"`
-	GracePeriod                    time.Duration `mapstructure:"grace-period"`
-	RequestTimeout                 time.Duration `mapstructure:"poet-request-timeout"`
-	RequestRetryDelay              time.Duration `mapstructure:"retry-delay"`
+	RequestTimeout        time.Duration `mapstructure:"poet-request-timeout"`
+	RequestRetryDelay     time.Duration `mapstructure:"retry-delay"`
+	CertifierInfoCacheTTL time.Duration `mapstructure:"certifier-info-cache-ttl"`
+	MaxRequestRetries     int           `mapstructure:"retry-max"`
+	// Start of new PoET round
+	PhaseShift time.Duration `mapstructure:"phase-shift"`
+	// A gap between end of old PoET round and start of new one
+	CycleGap time.Duration `mapstructure:"cycle-gap"`
+	// Time in the end of cycle gap, when PoST challenge must be build and send to PoET server
+	GracePeriod time.Duration `mapstructure:"grace-period"`
+	// Period to find positioning ATX. Must be less, than GracePeriod
 	PositioningATXSelectionTimeout time.Duration `mapstructure:"positioning-atx-selection-timeout"`
-	CertifierInfoCacheTTL          time.Duration `mapstructure:"certifier-info-cache-ttl"`
-	MaxRequestRetries              int           `mapstructure:"retry-max"`
 }
 
 func DefaultPoetConfig() PoetConfig {
@@ -547,7 +551,6 @@ func (b *Builder) BuildNIPostChallenge(ctx context.Context, nodeID types.NodeID)
 		case <-time.After(time.Until(wait)):
 		}
 	}
-
 	if b.poetCfg.PositioningATXSelectionTimeout > 0 {
 		var cancel context.CancelFunc
 

activation/activation_multi_test.go

@@ -232,7 +232,10 @@ func TestRegossip(t *testing.T) {
 }
 
 func Test_Builder_Multi_InitialPost(t *testing.T) {
-	tab := newTestBuilder(t, 5, WithPoetConfig(PoetConfig{PhaseShift: layerDuration * 4}))
+	tab := newTestBuilder(t, 5, WithPoetConfig(
+		PoetConfig{
+			PhaseShift: layerDuration * 4,
+		}))
 
 	var eg errgroup.Group
 	for _, sig := range tab.signers {
@@ -271,7 +274,11 @@ func Test_Builder_Multi_InitialPost(t *testing.T) {
 
 func Test_Builder_Multi_HappyPath(t *testing.T) {
 	layerDuration := 2 * time.Second
-	tab := newTestBuilder(t, 3, WithPoetConfig(PoetConfig{PhaseShift: layerDuration * 4, CycleGap: layerDuration}))
+	tab := newTestBuilder(t, 3, WithPoetConfig(
+		PoetConfig{
+			PhaseShift: layerDuration * 4,
+			CycleGap:   layerDuration,
+		}))
 
 	// step 1: build initial posts
 	initialPostChan := make(chan struct{})

activation/activation_test.go

@@ -344,7 +344,10 @@ func TestBuilder_StopSmeshing_failsWhenNotStarted(t *testing.T) {
 }
 
 func TestBuilder_PublishActivationTx_HappyFlow(t *testing.T) {
-	tab := newTestBuilder(t, 1, WithPoetConfig(PoetConfig{PhaseShift: layerDuration}))
+	tab := newTestBuilder(t, 1, WithPoetConfig(
+		PoetConfig{
+			PhaseShift: layerDuration,
+		}))
 	sig := maps.Values(tab.signers)[0]
 
 	posEpoch := postGenesisEpoch
@@ -380,7 +383,9 @@ func TestBuilder_PublishActivationTx_HappyFlow(t *testing.T) {
 // failing with ErrATXChallengeExpired.
 func TestBuilder_Loop_WaitsOnStaleChallenge(t *testing.T) {
 	// Arrange
-	tab := newTestBuilder(t, 1, WithPoetConfig(PoetConfig{PhaseShift: layerDuration * 4}))
+	tab := newTestBuilder(t, 1, WithPoetConfig(PoetConfig{
+		PhaseShift: layerDuration * 4,
+	}))
 	sig := maps.Values(tab.signers)[0]
 
 	// current layer is too late to be able to build a nipost on time
@@ -429,7 +434,9 @@ func TestBuilder_Loop_WaitsOnStaleChallenge(t *testing.T) {
 }
 
 func TestBuilder_PublishActivationTx_FaultyNet(t *testing.T) {
-	tab := newTestBuilder(t, 1, WithPoetConfig(PoetConfig{PhaseShift: layerDuration * 4}))
+	tab := newTestBuilder(t, 1, WithPoetConfig(PoetConfig{
+		PhaseShift: layerDuration * 4,
+	}))
 	sig := maps.Values(tab.signers)[0]
 
 	posEpoch := postGenesisEpoch
@@ -501,9 +508,7 @@ func TestBuilder_PublishActivationTx_FaultyNet(t *testing.T) {
 }
 
 func TestBuilder_PublishActivationTx_UsesExistingChallengeOnLatePublish(t *testing.T) {
-	poetCfg := PoetConfig{
-		PhaseShift: layerDuration * 4,
-	}
+	poetCfg := PoetConfig{PhaseShift: layerDuration * 4}
 	tab := newTestBuilder(t, 1, WithPoetConfig(poetCfg))
 	sig := maps.Values(tab.signers)[0]
 
@@ -1140,7 +1145,7 @@ func TestBuilder_RetryPublishActivationTx(t *testing.T) {
 }
 
 func TestBuilder_InitialProofGeneratedOnce(t *testing.T) {
-	tab := newTestBuilder(t, 1, WithPoetConfig(PoetConfig{PhaseShift: layerDuration * 4}))
+	tab := newTestBuilder(t, 1, WithPoetConfig(PoetConfig{PhaseShift: layerDuration}))
 	sig := maps.Values(tab.signers)[0]
 
 	post := nipost.Post{
@@ -1179,7 +1184,7 @@ func TestBuilder_InitialProofGeneratedOnce(t *testing.T) {
 }
 
 func TestBuilder_InitialPostIsPersisted(t *testing.T) {
-	tab := newTestBuilder(t, 1, WithPoetConfig(PoetConfig{PhaseShift: layerDuration * 4}))
+	tab := newTestBuilder(t, 1, WithPoetConfig(PoetConfig{PhaseShift: layerDuration}))
 	sig := maps.Values(tab.signers)[0]
 
 	commitmentATX := types.RandomATXID()

activation/e2e/activation_test.go

@@ -85,12 +85,12 @@ func Test_BuilderWithMultipleClients(t *testing.T) {
 	epoch := layerDuration * layersPerEpoch
 	genesis := time.Now().Add(layerDuration).Round(layerDuration)
 	poetCfg := activation.PoetConfig{
-		PhaseShift:        epoch,
-		CycleGap:          3 * epoch / 4,
-		GracePeriod:       epoch / 4,
 		RequestTimeout:    epoch / 5,
 		RequestRetryDelay: epoch / 50,
 		MaxRequestRetries: 10,
+		PhaseShift:        epoch,
+		CycleGap:          3 * epoch / 4,
+		GracePeriod:       epoch / 4,
 	}
 
 	scrypt := testPostSetupOpts(t).Scrypt

activation/nipost.go

@@ -281,7 +281,7 @@ func (nb *NIPostBuilder) BuildNIPost(
 		}
 
 		events.EmitPoetWaitProof(signer.NodeID(), postChallenge.PublishEpoch, poetRoundEnd)
-		poetProofRef, membership, err = nb.getBestProof(ctx, signer.NodeID(), challenge, postChallenge.PublishEpoch)
+		poetProofRef, membership, err = nb.getBestProof(ctx, signer.NodeID(), challenge)
 		if err != nil {
 			return nil, &PoetSvcUnstableError{msg: "getBestProof failed", source: err}
 		}
@@ -372,10 +372,7 @@ func (nb *NIPostBuilder) submitPoetChallenge(
 
 	logger.Debug("submitting challenge to poet proving service")
 
-	submitCtx, cancel := withConditionalTimeout(ctx, nb.poetCfg.RequestTimeout)
-	defer cancel()
-
-	round, err := client.Submit(submitCtx, deadline, prefix, challenge, signature, nodeID)
+	round, err := client.Submit(ctx, deadline, prefix, challenge, signature, nodeID)
 	if err != nil {
 		return &PoetSvcUnstableError{msg: "failed to submit challenge to poet service", source: err}
 	}
@@ -451,7 +448,6 @@ func (nb *NIPostBuilder) getBestProof(
 	ctx context.Context,
 	nodeID types.NodeID,
 	challenge types.Hash32,
-	publishEpoch types.EpochID,
 ) (types.PoetProofRef, *types.MerkleProof, error) {
 	type poetProof struct {
 		poet       *types.PoetProof

activation/poet.go

@@ -340,9 +340,10 @@ type certifierInfo struct {
 // poetService is a higher-level interface to communicate with a PoET service.
 // It wraps the HTTP client, adding additional functionality.
 type poetService struct {
-	db             poetDbAPI
-	logger         *zap.Logger
-	client         PoetClient
+	db     poetDbAPI
+	logger *zap.Logger
+	client PoetClient
+
 	requestTimeout time.Duration
 
 	// Used to avoid concurrent requests for proof.
@@ -480,9 +481,7 @@ func (c *poetService) Submit(
 
 	logger.Debug("submitting challenge to poet proving service")
 
-	submitCtx, cancel := withConditionalTimeout(ctx, c.requestTimeout)
-	defer cancel()
-	round, err := c.client.Submit(submitCtx, deadline, prefix, challenge, signature, nodeID, *auth)
+	round, err := c.client.Submit(ctx, deadline, prefix, challenge, signature, nodeID, *auth)
 	switch {
 	case err == nil:
 		return round, nil
@@ -492,15 +491,14 @@ func (c *poetService) Submit(
 		if err != nil {
 			return nil, fmt.Errorf("recertifying: %w", err)
 		}
-		return c.client.Submit(submitCtx, deadline, prefix, challenge, signature, nodeID, *auth)
+		return c.client.Submit(ctx, deadline, prefix, challenge, signature, nodeID, *auth)
+	case errors.Is(err, context.DeadlineExceeded):
+		logger.Warn("failed to submit challenge: probably submit challenge timeout is too short", zap.Error(err))
 	}
 	return nil, fmt.Errorf("submitting challenge: %w", err)
 }
 
 func (c *poetService) Proof(ctx context.Context, roundID string) (*types.PoetProof, []types.Hash32, error) {
-	getProofsCtx, cancel := withConditionalTimeout(ctx, c.requestTimeout)
-	defer cancel()
-
 	c.gettingProof.Lock()
 	defer c.gettingProof.Unlock()
 
@@ -513,7 +511,7 @@ func (c *poetService) Proof(ctx context.Context, roundID string) (*types.PoetPro
 		c.logger.Warn("cached members found but proof not found in db", zap.String("round_id", roundID), zap.Error(err))
 	}
 
-	proof, members, err := c.client.Proof(getProofsCtx, roundID)
+	proof, members, err := c.client.Proof(ctx, roundID)
 	if err != nil {
 		return nil, nil, fmt.Errorf("getting proof: %w", err)
 	}

activation/poet_client_test.go

@@ -30,20 +30,22 @@ func Test_HTTPPoetClient_ParsesURL(t *testing.T) {
 
 	t.Run("add http if missing", func(t *testing.T) {
 		t.Parallel()
-		client, err := NewHTTPPoetClient(types.PoetServer{Address: "bla"}, PoetConfig{
-			PhaseShift: cfg.PhaseShift,
-			CycleGap:   cfg.CycleGap,
-		})
+		client, err := NewHTTPPoetClient(types.PoetServer{Address: "bla"},
+			PoetConfig{
+				PhaseShift: cfg.PhaseShift,
+				CycleGap:   cfg.CycleGap,
+			})
 		require.NoError(t, err)
 		require.Equal(t, "http://bla", client.baseURL.String())
 	})
 
 	t.Run("do not change scheme if present", func(t *testing.T) {
 		t.Parallel()
-		client, err := NewHTTPPoetClient(types.PoetServer{Address: "https://bla"}, PoetConfig{
-			PhaseShift: cfg.PhaseShift,
-			CycleGap:   cfg.CycleGap,
-		})
+		client, err := NewHTTPPoetClient(types.PoetServer{Address: "https://bla"},
+			PoetConfig{
+				PhaseShift: cfg.PhaseShift,
+				CycleGap:   cfg.CycleGap,
+			})
 		require.NoError(t, err)
 		require.Equal(t, "https://bla", client.baseURL.String())
 	})
@@ -113,10 +115,11 @@ func Test_HTTPPoetClient_Address_Mainnet(t *testing.T) {
 
 	for _, url := range poETServers {
 		t.Run(url, func(t *testing.T) {
-			client, err := NewHTTPPoetClient(types.PoetServer{Address: url}, PoetConfig{
-				PhaseShift: poetCfg.PhaseShift,
-				CycleGap:   poetCfg.CycleGap,
-			})
+			client, err := NewHTTPPoetClient(types.PoetServer{Address: url},
+				PoetConfig{
+					PhaseShift: poetCfg.PhaseShift,
+					CycleGap:   poetCfg.CycleGap,
+				})
 			require.NoError(t, err)
 			require.Equal(t, url, client.Address())
 		})

cmd/root.go

@@ -320,13 +320,13 @@ func AddFlags(flagSet *pflag.FlagSet, cfg *config.Config) (configPath *string) {
 	/**======================== PoET Flags ========================== **/
 
 	flagSet.DurationVar(&cfg.POET.PhaseShift, "phase-shift",
-		cfg.POET.PhaseShift, "phase shift of poet server")
+		cfg.POET.PhaseShift, "phase shift of poet server: duration after epoch start, at which poet round starts")
 	flagSet.DurationVar(&cfg.POET.CycleGap, "cycle-gap",
-		cfg.POET.CycleGap, "cycle gap of poet server")
+		cfg.POET.CycleGap, "cycle gap of poet server: gap between poet rounds")
 	flagSet.DurationVar(&cfg.POET.GracePeriod, "grace-period",
-		cfg.POET.GracePeriod, "time before PoET round starts when the node builds and submits a challenge")
-	flagSet.DurationVar(&cfg.POET.RequestTimeout, "poet-request-timeout",
-		cfg.POET.RequestTimeout, "timeout for poet requests")
+		cfg.POET.GracePeriod, "time before poet round starts, when the node builds and submits a challenge")
+	flagSet.DurationVar(&cfg.POET.RequestTimeout, "poet-default-request-timeout",
+		cfg.POET.RequestTimeout, "default timeout for poet requests")
 
 	/**======================== bootstrap data updater Flags ========================== **/
 

config/mainnet.go

@@ -160,14 +160,13 @@ func MainnetConfig() Config {
 			BeaconSyncWeightUnits:    800,
 		},
 		POET: activation.PoetConfig{
-			PhaseShift:                     240 * time.Hour,
-			CycleGap:                       12 * time.Hour,
-			GracePeriod:                    1 * time.Hour,
-			PositioningATXSelectionTimeout: 50 * time.Minute,
 			// RequestTimeout = RequestRetryDelay * 2 * MaxRequestRetries*(MaxRequestRetries+1)/2
 			RequestTimeout:    1100 * time.Second,
 			RequestRetryDelay: 10 * time.Second,
 			MaxRequestRetries: 10,
+			PhaseShift:        240 * time.Hour,
+			CycleGap:          12 * time.Hour,
+			GracePeriod:       1 * time.Hour,
 		},
 		POST: activation.PostConfig{
 			MinNumUnits:   4,

config/presets/fastnet.go

@@ -94,7 +94,8 @@ func fastnet() config.Config {
 	conf.POET.GracePeriod = 10 * time.Second
 	conf.POET.CycleGap = 30 * time.Second
 	conf.POET.PhaseShift = 30 * time.Second
-	conf.POET.RequestTimeout = 12 * time.Second // RequestRetryDelay * 2 * MaxRequestRetries*(MaxRequestRetries+1)/2
+	// RequestTimeout = RequestRetryDelay * 2 * MaxRequestRetries*(MaxRequestRetries+1)/2
+	conf.POET.RequestTimeout = 12 * time.Second
 	conf.POET.RequestRetryDelay = 1 * time.Second
 	conf.POET.MaxRequestRetries = 3
 	return conf

config/presets/standalone.go

@@ -80,7 +80,8 @@ func standalone() config.Config {
 	conf.POET.GracePeriod = 12 * time.Second
 	conf.POET.CycleGap = 30 * time.Second
 	conf.POET.PhaseShift = 30 * time.Second
-	conf.POET.RequestTimeout = 12 * time.Second // RequestRetryDelay * 2 * MaxRequestRetries*(MaxRequestRetries+1)/2
+	// RequestTimeout = RequestRetryDelay * 2 * MaxRequestRetries*(MaxRequestRetries+1)/2
+	conf.POET.RequestTimeout = 12 * time.Second
 	conf.POET.RequestRetryDelay = 1 * time.Second
 	conf.POET.MaxRequestRetries = 3
 

config/presets/testnet.go

@@ -112,12 +112,13 @@ func testnet() config.Config {
 			BeaconSyncWeightUnits:    800,
 		},
 		POET: activation.PoetConfig{
+			// RequestTimeout = RequestRetryDelay * 2 * MaxRequestRetries*(MaxRequestRetries+1)/2
+			RequestTimeout:    550 * time.Second,
+			RequestRetryDelay: 5 * time.Second,
+			MaxRequestRetries: 10,
 			PhaseShift:        12 * time.Hour,
 			CycleGap:          2 * time.Hour,
 			GracePeriod:       10 * time.Minute,
-			RequestTimeout:    550 * time.Second, // RequestRetryDelay * 2 * MaxRequestRetries*(MaxRequestRetries+1)/2
-			RequestRetryDelay: 5 * time.Second,
-			MaxRequestRetries: 10,
 		},
 		POST: activation.PostConfig{
 			MinNumUnits:   2,