Serve API to return poet registrations state

activation/activation.go

@@ -104,9 +104,12 @@
 
 	posAtxFinder positioningAtxFinder
 
-	// states of each known identity
+	// post states of each known identity
 	postStates PostStates
 
+	// identity states of each known identity
+	identitiesStates IdentityStates
+
 	// smeshingMutex protects methods like `StartSmeshing` and `StopSmeshing` from concurrent execution
 	// since they (can) modify the fields below.
 	smeshingMutex sync.Mutex
@@ -172,6 +175,12 @@
 	}
 }
 
+func WithIdentityStates(is IdentityStates) BuilderOption {
+	return func(b *Builder) {
+		b.identitiesStates = is
+	}
+}
+
 func BuilderAtxVersions(v AtxVersions) BuilderOption {
 	return func(h *Builder) {
 		h.versions = append([]atxVersion{{0, types.AtxV1}}, v.asSlice()...)
@@ -206,6 +215,7 @@
 		poetRetryInterval: defaultPoetRetryInterval,
 		postValidityDelay: 12 * time.Hour,
 		postStates:        NewPostStates(log),
+		identitiesStates:  NewIdentityStateStorage(),
 		versions:          []atxVersion{{0, types.AtxV1}},
 	}
 	for _, opt := range opts {
@@ -239,7 +249,7 @@
 	return b.stop != nil
 }
 
-// PostState returns the current state of the post service for each registered smesher.
+// PostStates returns the current state of the post service for each registered smesher.
 func (b *Builder) PostStates() map[types.IdentityDescriptor]types.PostState {
 	states := b.postStates.Get()
 	res := make(map[types.IdentityDescriptor]types.PostState, len(states))
@@ -253,6 +263,20 @@
 	return res
 }
 
+// IdentityStates returns the current state of the identity for each smesher.
+func (b *Builder) IdentityStates() map[types.IdentityDescriptor]IdentityState {
+	states := b.identitiesStates.All()
+	res := make(map[types.IdentityDescriptor]IdentityState, len(states))
+	b.smeshingMutex.Lock()
+	defer b.smeshingMutex.Unlock()
+	for id, state := range states {
+		if sig, exists := b.signers[id]; exists {
+			res[sig] = state
+		}
+	}
+	return res
+}
+
 // StartSmeshing is the main entry point of the atx builder. It runs the main
 // loop of the builder in a new go-routine and shouldn't be called more than
 // once without calling StopSmeshing in between. If the post data is incomplete
@@ -340,7 +364,7 @@
 	}
 }
 
-// SmesherID returns the ID of the smesher that created this activation.
+// SmesherIDs returns the ID of the smesher that created this activation.
 func (b *Builder) SmesherIDs() []types.NodeID {
 	b.smeshingMutex.Lock()
 	defer b.smeshingMutex.Unlock()
@@ -442,6 +466,14 @@
 	}
 	eg.Wait()
 
+	if err := b.identitiesStates.Set(sig.NodeID(), IdentityStateWaitForATXSyncing); err != nil {
+		b.logger.Warn("failed to switch identity state",
+			zap.Stringer("smesherID", sig.NodeID()),
+			zap.Error(err),
+		)
+		return
+	}
+
 	for {
 		err := b.PublishActivationTx(ctx, sig)
 		if err == nil {
@@ -510,14 +542,22 @@
 
 func (b *Builder) BuildNIPostChallenge(ctx context.Context, nodeID types.NodeID) (*types.NIPostChallenge, error) {
 	logger := b.logger.With(log.ZShortStringer("smesherID", nodeID))
+
 	select {
 	case <-ctx.Done():
 		return nil, ctx.Err()
 	case <-b.syncer.RegisterForATXSynced():
 	}
-
 	currentEpochId := b.layerClock.CurrentLayer().GetEpoch()
 
+	if err := b.identitiesStates.Set(nodeID, IdentityStateWaitForPoetRoundStart); err != nil {
+		b.logger.Warn("failed to switch identity state",
+			zap.Stringer("smesherID", nodeID),
+			zap.Error(err),
+		)
+		return nil, err
+	}
+
 	// Try to get existing challenge
 	existingChallenge, err := b.getExistingChallenge(logger, currentEpochId, nodeID)
 	if err != nil {
@@ -733,6 +773,7 @@
 	targetEpoch := challenge.PublishEpoch.Add(1)
 	ctx, cancel := context.WithDeadline(ctx, b.layerClock.LayerToTime(targetEpoch.FirstLayer()))
 	defer cancel()
+
 	atx, err := b.createAtx(ctx, sig, challenge)
 	if err != nil {
 		return fmt.Errorf("create ATX: %w", err)
@@ -803,8 +844,9 @@
 	sig *signing.EdSigner,
 	challenge *types.NIPostChallenge,
 ) (builtAtx, error) {
-	version := b.version(challenge.PublishEpoch)
 	var challengeHash types.Hash32
+
+	version := b.version(challenge.PublishEpoch)
 	switch version {
 	case types.AtxV1:
 		challengeHash = wire.NIPostChallengeToWireV1(challenge).Hash()
@@ -814,6 +856,7 @@
 		return nil, fmt.Errorf("unknown ATX version: %v", version)
 	}
 	b.logger.Info("building ATX", zap.Stringer("smesherID", sig.NodeID()), zap.Stringer("version", version))
+
 	nipostState, err := b.nipostBuilder.BuildNIPost(ctx, sig, challengeHash, challenge)
 	if err != nil {
 		return nil, fmt.Errorf("build NIPost: %w", err)

activation/activation_test.go

@@ -176,14 +176,17 @@ func publishAtx(
 		NumUnits:      DefaultPostSetupOpts().NumUnits,
 		LabelsPerUnit: DefaultPostConfig().LabelsPerUnit,
 	}, nil).AnyTimes()
+
 	tab.mnipost.EXPECT().BuildNIPost(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(
 		func(_ context.Context, _ *signing.EdSigner, _ types.Hash32, _ *types.NIPostChallenge,
 		) (*nipost.NIPostState, error) {
 			*currLayer = currLayer.Add(buildNIPostLayerDuration)
 			return newNIPostWithPoet(tb, types.RandomHash().Bytes()), nil
 		})
+
 	ch := make(chan struct{})
 	close(ch)
+
 	tab.mclock.EXPECT().AwaitLayer(publishEpoch.FirstLayer()).DoAndReturn(
 		func(got types.LayerID) <-chan struct{} {
 			// advance to publish layer
@@ -349,7 +352,14 @@ func TestBuilder_StopSmeshing_failsWhenNotStarted(t *testing.T) {
 }
 
 func TestBuilder_PublishActivationTx_HappyFlow(t *testing.T) {
-	tab := newTestBuilder(t, 1, WithPoetConfig(PoetConfig{PhaseShift: layerDuration}))
+	ctrl := gomock.NewController(t)
+	idStates := NewMockIdentityStates(ctrl)
+	idStates.EXPECT().Set(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+
+	tab := newTestBuilder(t, 1,
+		WithPoetConfig(PoetConfig{PhaseShift: layerDuration}),
+		WithIdentityStates(idStates))
+
 	sig := maps.Values(tab.signers)[0]
 
 	posEpoch := postGenesisEpoch
@@ -434,7 +444,13 @@ func TestBuilder_Loop_WaitsOnStaleChallenge(t *testing.T) {
 }
 
 func TestBuilder_PublishActivationTx_FaultyNet(t *testing.T) {
-	tab := newTestBuilder(t, 1, WithPoetConfig(PoetConfig{PhaseShift: layerDuration * 4}))
+	ctrl := gomock.NewController(t)
+	idStates := NewMockIdentityStates(ctrl)
+	idStates.EXPECT().Set(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+
+	tab := newTestBuilder(t, 1,
+		WithPoetConfig(PoetConfig{PhaseShift: layerDuration * 4}),
+		WithIdentityStates(idStates))
 	sig := maps.Values(tab.signers)[0]
 
 	posEpoch := postGenesisEpoch
@@ -509,7 +525,14 @@ func TestBuilder_PublishActivationTx_UsesExistingChallengeOnLatePublish(t *testi
 	poetCfg := PoetConfig{
 		PhaseShift: layerDuration * 4,
 	}
-	tab := newTestBuilder(t, 1, WithPoetConfig(poetCfg))
+
+	ctrl := gomock.NewController(t)
+	idStates := NewMockIdentityStates(ctrl)
+	idStates.EXPECT().Set(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+
+	tab := newTestBuilder(t, 1,
+		WithPoetConfig(poetCfg),
+		WithIdentityStates(idStates))
 	sig := maps.Values(tab.signers)[0]
 
 	currLayer := (postGenesisEpoch + 1).FirstLayer().Add(5) // late for poet round start
@@ -585,7 +608,13 @@ func TestBuilder_PublishActivationTx_UsesExistingChallengeOnLatePublish(t *testi
 }
 
 func TestBuilder_PublishActivationTx_RebuildNIPostWhenTargetEpochPassed(t *testing.T) {
-	tab := newTestBuilder(t, 1, WithPoetConfig(PoetConfig{PhaseShift: layerDuration * 4}))
+	ctrl := gomock.NewController(t)
+	idStates := NewMockIdentityStates(ctrl)
+	idStates.EXPECT().Set(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+
+	tab := newTestBuilder(t, 1,
+		WithPoetConfig(PoetConfig{PhaseShift: layerDuration * 4}),
+		WithIdentityStates(idStates))
 	sig := maps.Values(tab.signers)[0]
 
 	posEpoch := types.EpochID(2)
@@ -670,7 +699,13 @@ func TestBuilder_PublishActivationTx_RebuildNIPostWhenTargetEpochPassed(t *testi
 }
 
 func TestBuilder_PublishActivationTx_NoPrevATX(t *testing.T) {
-	tab := newTestBuilder(t, 1, WithPoetConfig(PoetConfig{PhaseShift: layerDuration * 4}))
+	ctrl := gomock.NewController(t)
+	idStates := NewMockIdentityStates(ctrl)
+	idStates.EXPECT().Set(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+
+	tab := newTestBuilder(t, 1,
+		WithPoetConfig(PoetConfig{PhaseShift: layerDuration * 4}),
+		WithIdentityStates(idStates))
 	sig := maps.Values(tab.signers)[0]
 
 	posEpoch := postGenesisEpoch
@@ -784,7 +819,14 @@ func TestBuilder_PublishActivationTx_PrevATXWithoutPrevATX(t *testing.T) {
 	r := require.New(t)
 
 	// Arrange
-	tab := newTestBuilder(t, 1, WithPoetConfig(PoetConfig{PhaseShift: layerDuration * 4}))
+	ctrl := gomock.NewController(t)
+	idStates := NewMockIdentityStates(ctrl)
+	idStates.EXPECT().Set(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+
+	tab := newTestBuilder(t, 1,
+		WithPoetConfig(PoetConfig{PhaseShift: layerDuration * 4}),
+		WithIdentityStates(idStates),
+	)
 	sig := maps.Values(tab.signers)[0]
 
 	otherSigner, err := signing.NewEdSigner()
@@ -878,7 +920,14 @@ func TestBuilder_PublishActivationTx_TargetsEpochBasedOnPosAtx(t *testing.T) {
 	r := require.New(t)
 
 	// Arrange
-	tab := newTestBuilder(t, 1, WithPoetConfig(PoetConfig{PhaseShift: layerDuration * 4}))
+	ctrl := gomock.NewController(t)
+	idStates := NewMockIdentityStates(ctrl)
+	idStates.EXPECT().Set(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+
+	tab := newTestBuilder(t, 1,
+		WithPoetConfig(PoetConfig{PhaseShift: layerDuration * 4}),
+		WithIdentityStates(idStates))
+
 	sig := maps.Values(tab.signers)[0]
 
 	otherSigner, err := signing.NewEdSigner()
@@ -975,7 +1024,14 @@ func TestBuilder_PublishActivationTx_TargetsEpochBasedOnPosAtx(t *testing.T) {
 }
 
 func TestBuilder_PublishActivationTx_FailsWhenNIPostBuilderFails(t *testing.T) {
-	tab := newTestBuilder(t, 1, WithPoetConfig(PoetConfig{PhaseShift: layerDuration * 4}))
+	ctrl := gomock.NewController(t)
+	idStates := NewMockIdentityStates(ctrl)
+	idStates.EXPECT().Set(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+
+	tab := newTestBuilder(t, 1,
+		WithPoetConfig(PoetConfig{PhaseShift: layerDuration * 4}),
+		WithIdentityStates(idStates))
+
 	sig := maps.Values(tab.signers)[0]
 
 	posEpoch := postGenesisEpoch
@@ -1279,10 +1335,14 @@ func TestWaitPositioningAtx(t *testing.T) {
 		{"round started", 0, 0, 3},
 	} {
 		t.Run(tc.desc, func(t *testing.T) {
+			ctrl := gomock.NewController(t)
+			idStates := NewMockIdentityStates(ctrl)
+			idStates.EXPECT().Set(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+
 			tab := newTestBuilder(t, 1, WithPoetConfig(PoetConfig{
 				PhaseShift:  tc.shift,
 				GracePeriod: tc.grace,
-			}))
+			}), WithIdentityStates(idStates))
 			sig := maps.Values(tab.signers)[0]
 
 			tab.mclock.EXPECT().CurrentLayer().Return(types.LayerID(0)).AnyTimes()

activation/builder_v2_test.go

@@ -18,8 +18,13 @@ import (
 )
 
 func TestBuilder_BuildsInitialAtxV2(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	idStates := NewMockIdentityStates(ctrl)
+	idStates.EXPECT().Set(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+
 	tab := newTestBuilder(t, 1,
 		WithPoetConfig(PoetConfig{PhaseShift: layerDuration}),
+		WithIdentityStates(idStates),
 		BuilderAtxVersions(AtxVersions{1: types.AtxV2}))
 
 	tab.SetCoinbase(types.Address{1, 2, 3, 4})
@@ -72,8 +77,13 @@ func TestBuilder_BuildsInitialAtxV2(t *testing.T) {
 }
 
 func TestBuilder_SwitchesToBuildV2(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	idStates := NewMockIdentityStates(ctrl)
+	idStates.EXPECT().Set(gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
+
 	tab := newTestBuilder(t, 1,
 		WithPoetConfig(PoetConfig{PhaseShift: layerDuration}),
+		WithIdentityStates(idStates),
 		BuilderAtxVersions(AtxVersions{4: types.AtxV2}))
 	sig := maps.Values(tab.signers)[0]
 

activation/e2e/activation_test.go

@@ -142,6 +142,8 @@ func Test_BuilderWithMultipleClients(t *testing.T) {
 		verifier,
 	)
 
+	idStates := activation.NewIdentityStateStorage()
+
 	nb, err := activation.NewNIPostBuilder(
 		localDB,
 		svc,
@@ -150,6 +152,7 @@ func Test_BuilderWithMultipleClients(t *testing.T) {
 		clock,
 		validator,
 		activation.WithPoetServices(client),
+		activation.NipostbuilderWithIdentityStates(idStates),
 	)
 	require.NoError(t, err)
 
@@ -202,6 +205,7 @@ func Test_BuilderWithMultipleClients(t *testing.T) {
 		activation.WithPoetConfig(poetCfg),
 		activation.WithValidator(validator),
 		activation.WithPoets(client),
+		activation.WithIdentityStates(idStates),
 	)
 	for _, sig := range signers {
 		tab.Register(sig)
@@ -225,7 +229,7 @@ func Test_BuilderWithMultipleClients(t *testing.T) {
 				err := validator.VRFNonce(
 					sig.NodeID(),
 					commitment,
-					uint64(*atx.VRFNonce),
+					*atx.VRFNonce,
 					atx.NIPost.PostMetadata.LabelsPerUnit,
 					atx.NumUnits,
 				)

activation/e2e/atx_merge_test.go

@@ -259,6 +259,8 @@ func Test_MarryAndMerge(t *testing.T) {
 	require.NoError(t, err)
 	t.Cleanup(clock.Close)
 
+	idStates := activation.NewIdentityStateStorage()
+
 	nb, err := activation.NewNIPostBuilder(
 		localDB,
 		svc,
@@ -267,6 +269,7 @@ func Test_MarryAndMerge(t *testing.T) {
 		clock,
 		validator,
 		activation.WithPoetServices(poetSvc),
+		activation.NipostbuilderWithIdentityStates(idStates),
 	)
 	require.NoError(t, err)
 
@@ -311,6 +314,13 @@ func Test_MarryAndMerge(t *testing.T) {
 				InitialPost:    post,
 			}
 			challenge := wire.NIPostChallengeToWireV2(postChallenge).Hash()
+
+			err = idStates.Set(signer.NodeID(), activation.IdentityStateWaitForATXSyncing)
+			require.NoError(t, err)
+
+			err = idStates.Set(signer.NodeID(), activation.IdentityStateWaitForPoetRoundStart)
+			require.NoError(t, err)
+
 			nipost, err := nb.BuildNIPost(context.Background(), signer, challenge, postChallenge)
 			if err != nil {
 				return err