optimistic sig share creation for managed keys by ssd04 · Pull Request #7831 · multiversx/mx-chain-go

ssd04 · 2026-04-15T09:24:49Z

Reasoning behind the pull request

In case there is a competing block and we have to wait until we send the signatures for the next round, we should trigger signature shares creation optimistically

Testing procedure

Standard system test

Pre-requisites

Based on the Contributing Guidelines the PR author and the reviewers must check the following requirements are met:

was the PR targeted to the correct branch?
if this is a larger feature that probably needs more than one PR, is there a feat branch created?
if this is a feat branch merging, do all satellite projects have a proper tag inside go.mod?

ssd04 · 2026-04-15T09:56:38Z

 	return false
 }

+func (sr *subroundSignature) createSignaturesForManagedKeys(ctx context.Context) bool {


this pre-checks here are very similar with doSignatureJobForManagedKeys but i would keep it like this for simplicity

ssd04 · 2026-04-15T09:59:20Z

-		sr.GetHeader().GetEpoch(),
-		pkBytes,
-	)
+	signatureShare, err := sr.SigningHandler().SignatureShare(uint16(idx))


in each start subround, there is a Reset for all consensus state, including SigningHandler, there should't be any index collision with the signatures from the previous round; the wait time is related to the proof arrival, not with the signatures

sstanculeanu · 2026-04-15T10:02:17Z

+		}
+	}
+
+	// Wait once for the entire node if competing block detected


shouldn't L125-128 be inside the previous if? they basically do similar loops as waitForCompetingBlockEarlyChecks

here there is also the check for single key, will check how to integrate them better

refactored to include them in the same condition branch

sstanculeanu · 2026-04-15T10:32:50Z

+		sr.signatureThrottler.StartProcessing()
+		wg.Add(1)
+
+		go func(ctx context.Context, idx int, pk string) {


this starts a goroutine, but does not handle the context, so goroutines may be hanging if the process stops

added context check in goroutine

sstanculeanu · 2026-04-15T10:35:52Z

 	if err != nil {
-		log.Debug("sendSignatureForManagedKey.CreateSignatureShareForPublicKey", "error", err.Error())
-		return false
+		// signature share not found (optimistic signature share creation was not triggered)


what if failure reason was different?

i think we should try to create the signature share (if not already created) whatever the reason; before we tried to create it directly each time, now there is additional check

codecov · 2026-05-19T09:15:17Z

Codecov Report

❌ Patch coverage is 76.14213% with 47 lines in your changes missing coverage. Please review.
✅ Project coverage is 77.56%. Comparing base (6387f16) to head (58fa573).

Files with missing lines	Patch %	Lines
consensus/spos/bls/v2/subroundSignature.go	75.67%	13 Missing and 5 partials ⚠️
consensus/spos/consensusState.go	22.22%	13 Missing and 1 partial ⚠️
consensus/spos/bls/v2/subroundBlock.go	86.56%	6 Missing and 3 partials ⚠️
factory/crypto/signingHandler.go	62.50%	5 Missing and 1 partial ⚠️

Additional details and impacted files

@@                 Coverage Diff                  @@
##           feat/testnet-fixes    #7831    +/-   ##
====================================================
  Coverage               77.55%   77.56%            
====================================================
  Files                     884      885     +1     
  Lines                  125242   125400   +158     
====================================================
+ Hits                    97132    97261   +129     
- Misses                  21655    21677    +22     
- Partials                 6455     6462     +7

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.

Copilot

Pull request overview

This PR introduces optimistic (early) creation of BLS signature shares for managed keys in SPoS v2, aiming to reduce latency when competing blocks force validators to delay sending signatures into the next round/subround. It also threads context.Context into signature-share creation to allow timeout/cancel behavior.

Changes:

Add context.Context to SigningHandler.CreateSignatureShareForPublicKey and propagate it through production code, simulator code, and tests.
Add optimistic signature-share creation triggered during the Block subround (on header send/receive), plus synchronization/cancel hooks via ConsensusState.
Update SPoS v2 Signature subround to wait for optimistic signature creation and reuse already-created shares when available.

Reviewed changes

Copilot reviewed 23 out of 23 changed files in this pull request and generated 7 comments.

Show a summary per file

File	Description
testscommon/consensus/signingHandlerStub.go	Update stub to accept `context.Context` in signature-share creation.
testscommon/consensus/consensusStateMock.go	Extend mock with optimistic-signature waitgroup/cancel hooks.
node/chainSimulator/process/processor.go	Adapt simulator to pass a context to signature-share creation.
node/chainSimulator/process/processor_test.go	Update simulator unit test stub to accept context.
factory/crypto/signingHandler.go	Add context-aware signature-share creation with timeout checks.
factory/crypto/signingHandler_test.go	Update signing-handler tests to pass context.
factory/crypto/errors.go	Add timeout error for signature handling.
consensus/spos/worker.go	Cancel optimistic signature context on `Extend()`.
consensus/spos/interface.go	Extend `ConsensusStateHandler` with waitgroup/cancel API for optimistic signatures.
consensus/spos/consensusState.go	Add optimistic-signature waitgroup and cancel-func storage.
consensus/spos/bls/v2/subroundSignatureCompetingBlock_test.go	Update stub signature-share creation callback signature.
consensus/spos/bls/v2/subroundSignature.go	Wait for optimistic signature creation; reuse pre-created shares; refactor throttler check.
consensus/spos/bls/v2/subroundSignature_test.go	Update tests and add coverage for “reuse existing sig share” behavior.
consensus/spos/bls/v2/subroundBlock.go	Trigger optimistic signature-share creation on header send/receive; require throttler in constructor.
consensus/spos/bls/v2/subroundBlock_test.go	Update constructor call sites and add tests for optimistic signature triggering.
consensus/spos/bls/v2/export_test.go	Update exported test helpers for new ctx-aware APIs.
consensus/spos/bls/v2/common.go	Introduce shared throttler-wait helper.
consensus/spos/bls/v2/blsSubroundsFactory.go	Pass signature throttler into v2 Block subround creation.
consensus/spos/bls/v2/benchmark_verify_signatures_test.go	Update benchmark to pass context.
consensus/spos/bls/v2/benchmark_send_proof_test.go	Update benchmark to pass context.
consensus/spos/bls/v1/subroundSignature.go	Thread context into v1 signature-share creation as well.
consensus/spos/bls/v1/subroundSignature_test.go	Update v1 tests for context-aware signature-share creation.
consensus/interface.go	Update `SigningHandler` interface signature for context-aware signature-share creation.

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

ssd04 · 2026-05-27T09:52:40Z

 	if message == nil {
 		return nil, ErrNilMessage
 	}

+	select {
+	case <-ctx.Done():
+		return nil, ErrTimeIsOut
+	default:
+	}


ssd04 · 2026-05-27T10:26:54Z

+func (sr *subroundSignature) waitForSingatures() {
+	done := make(chan struct{})
+	go func() {
+		sr.SignaturesWaitGroup().Wait()
+		close(done)
+	}()
+
+	timeLeft := sr.RoundHandler().RemainingTime(sr.RoundHandler().TimeStamp(), time.Duration(sr.EndTime()))
+
+	select {
+	case <-done:
+		sr.SignaturesCtxCancel()
+		return
+	case <-time.After(timeLeft):
+		log.Debug("timeout while waiting for signatures to be created")
+		return
+	}
+}
+
 func (sr *subroundSignature) doSignatureJobForManagedKeys(ctx context.Context) bool {
+	// wait for optimistic signatures creation to finish
+	sr.waitForSingatures()


+	sigCtx, cancel := context.WithTimeout(ctx, timeLeft)
+	sr.SetSignaturesCtxCancelFunc(cancel)
+
+	for idx, pk := range sr.ConsensusGroup() {
+		pkBytes := []byte(pk)
+		if !sr.IsKeyManagedBySelf(pkBytes) {
+			continue
+		}
+
+		err := checkGoRoutinesThrottler(ctx, sr.signatureThrottler)
+		if err != nil {
+			log.Debug("triggerCreateSignaturesForManagedKeys.checkGoRoutinesThrottler", "err", err)
+			return false
+		}
+		sr.signatureThrottler.StartProcessing()
+		sr.SignaturesWaitGroup().Add(1)
+


ssd04 · 2026-05-27T10:29:50Z

+	sr.triggerCreateSignaturesForManagedKeys(context.Background())
+
 	ctx, cancel := context.WithTimeout(context.Background(), sr.RoundHandler().TimeDuration())
 	defer cancel()



the other context is for process block and then it's cancelled, i think it's better to rely here only on the internal sig timeout context

ssd04 · 2026-05-27T09:53:05Z

+func (cns *ConsensusState) SignaturesWaitGroup() *sync.WaitGroup {
+	return cns.signaturesWaitGroup
+}


this was done on another PR

ssd04 · 2026-05-27T09:56:25Z

+func (cns *ConsensusState) SetSignaturesCtxCancelFunc(cancelFunc context.CancelFunc) {
+	cns.mutState.Lock()
+	defer cns.mutState.Unlock()
+
+	cns.signaturesTimeoutCtxCancel = cancelFunc
+}


ssd04 · 2026-05-27T10:00:19Z

+	select {
+	case <-ctx.Done():
+		return nil, ErrTimeIsOut
+	default:
+	}
+
 	sh.data.sigShares[index] = sigShareBytes


AdoAdoAdo · 2026-06-15T14:02:20Z

+			return
+		}
+		sr.signatureThrottler.StartProcessing()
+		sr.SignaturesWaitGroup().Add(1)


you can read the wg before the loop, and then reuse that one (defensive in case there is a reset of the subround mid process, e.g if we promote the trigger to run on a goroutine or if the timeout crosses the round boundary)

same for the header hash and epoch and header nil check (if the round boundary is crossed, these may be different if read in the routine).

AdoAdoAdo · 2026-06-15T14:06:13Z

+			continue
+		}
+
+		err := checkGoRoutinesThrottler(sigCtx, sr.signatureThrottler)


this may be blocking here when number of keys in consensus managed by the node is > than throttler allowed routines.

the check will wait for the delta of routines to finish before releasing the access for the validation.

triggered on a goroutine

AdoAdoAdo · 2026-06-15T14:25:05Z

+		// will try to create it
+		log.Debug("sendSignatureForManagedKey.SignatureShare: sig not already created, will try to create it", "error", err)
+
+		signatureShare, err = sr.SigningHandler().CreateSignatureShareForPublicKey(


here we create the sig share if it is missing, but do we still have time to create it?

AdoAdoAdo · 2026-06-15T14:35:24Z

 	}

-	sh.data.sigShares[index] = sigShareBytes
+	// check again before setting signatures shares data


here we already have the signature, bypassing its storage will not save a lot of time, maybe store it.

AdoAdoAdo · 2026-06-16T08:43:36Z

@@ -360,12 +360,21 @@ func (sr *subroundBlock) sendBlockHeader(
 }

 func (sr *subroundBlock) triggerCreateSignaturesForManagedKeys(ctx context.Context) {


since we now trigger this on a goroutine, maybe give the headerHash and headerHandler as argument, so that it is not read inside the goroutine.

AdoAdoAdo · 2026-06-16T08:47:18Z

+	currentHash := sr.GetData()
+	currentEpoch := sr.GetHeader().GetEpoch()
+
 	sigSubroundEndTime := time.Duration(float64(sr.RoundHandler().TimeDuration()) * srSignatureEndTime)


also if triggered on a goroutine, maybe check that the round on the header is still the round in the RoundHandler, otherwise exit without triggering signing.

add context for managed signatures broadcast

sstanculeanu · 2026-06-17T09:02:30Z

-				log.Debug("triggerCreateSignaturesForManagedKeys: context done", "timeLeft", timeLeft)
+	go func() {
+		for _, pk := range keys {
+			log.Info("aaaa")


remove comment

sstanculeanu · 2026-06-17T09:04:11Z

-			select {
-			case <-sigCtx.Done():
-				log.Debug("triggerCreateSignaturesForManagedKeys: context done", "timeLeft", timeLeft)
+	go func() {


is this needed?

yes, that was the intention, to trigger asynchronously, due to goroutines throttler which might block on limit reached

sstanculeanu · 2026-06-17T09:04:17Z

 				return
-			default:
 			}
+			log.Info("bbb")


sstanculeanu · 2026-06-17T09:04:29Z

+				defer sr.signatureThrottler.EndProcessing()
+				defer wg.Done()
+
+				log.Info("ccc")


sstanculeanu · 2026-06-17T09:05:08Z


-			pkBytes := []byte(pk)
-			currentHash := sr.GetData()
+	log.Debug("step 1: multi keys signatures creation has been triggered", "num", len(keys))


perhaps call cancel()?

or call it on defer after creation

the context was set to be cancelled on signature subround, after waiting with timeout, here we are just triggering the creation

raduchistest · 2026-06-17T13:00:02Z

+		default:
+		}
+
+		err := checkGoRoutinesThrottler(ctx, sr.signatureThrottler)


should be sigCtx here?

optimistic sig share creation for managed keys

573aef0

ssd04 self-assigned this Apr 15, 2026

ssd04 commented Apr 15, 2026

View reviewed changes

sstanculeanu reviewed Apr 15, 2026

View reviewed changes

ssd04 added 13 commits April 15, 2026 17:10

fixes after review

faebd8f

trigger sigs creation from block subround

4800fee

fix race in tests

170d42a

update context timeout

7b76320

trigger sigs creation from block subround - without timeout ctx

4bbc8ea

add context in singing handler for create sig

ab81017

fix test

f88f1e5

extra logging

fb7b9b7

adjust time left

40875b5

add context for managed signatures broadcast

197b42d

update tests

d20fca5

log for aggregated sig

7faae14

update logging for triggered optimistic sigs

099ce93

sstanculeanu previously approved these changes May 5, 2026

View reviewed changes

Merge branch 'feat/testnet-fixes' into optimistic-sig-share-creation

1ee6f23

Merge branch 'feat/testnet-fixes' into optimistic-sig-share-creation

735f94d

AdoAdoAdo requested review from AdoAdoAdo and Copilot May 27, 2026 08:56

Copilot started reviewing on behalf of AdoAdoAdo May 27, 2026 08:57 View session

Copilot AI reviewed May 27, 2026

View reviewed changes

fixes after review - signing handler

cd91661

ssd04 dismissed sstanculeanu’s stale review via cd91661 May 27, 2026 10:01

ssd04 added 2 commits May 27, 2026 13:31

fixes after review - sigs trigger

5de6697

fixes after review

d195344

Merge branch 'feat/testnet-fixes' into optimistic-sig-share-creation

3b23668

AdoAdoAdo reviewed Jun 15, 2026

View reviewed changes

fixes after review

832a01c

AdoAdoAdo reviewed Jun 15, 2026

View reviewed changes

Merge branch 'optimistic-sig-share-creation' into managed-sigs-context

e4d6eb1

AdoAdoAdo reviewed Jun 16, 2026

View reviewed changes

ssd04 added 6 commits June 16, 2026 15:20

Merge pull request #7839 from multiversx/managed-sigs-context

da0c4b2

add context for managed signatures broadcast

Merge branch 'feat/testnet-fixes' into optimistic-sig-share-creation

56ee618

fixes after review

f20cfd2

refactor sigs trigger

7628f43

fix unit test

0f74004

fix context in test

490ad26

sstanculeanu reviewed Jun 17, 2026

View reviewed changes

cleanup logs

2cea8d5

raduchistest reviewed Jun 17, 2026

View reviewed changes

fix goroutines throttler ctx

6563f97

sstanculeanu previously approved these changes Jun 17, 2026

View reviewed changes

AdoAdoAdo reviewed Jun 17, 2026

View reviewed changes

Comment thread consensus/spos/bls/v2/subroundBlock.go

drain not triggered goroutines

4467501

ssd04 dismissed sstanculeanu’s stale review via 4467501 June 18, 2026 07:47

AdoAdoAdo approved these changes Jun 18, 2026

View reviewed changes

sstanculeanu approved these changes Jun 18, 2026

View reviewed changes

AdoAdoAdo and others added 2 commits June 18, 2026 16:55

Merge branch 'feat/testnet-fixes' into optimistic-sig-share-creation

829d267

Merge branch 'feat/testnet-fixes' into optimistic-sig-share-creation

58fa573

AdoAdoAdo merged commit 850ffe1 into feat/testnet-fixes Jun 18, 2026
10 of 11 checks passed

AdoAdoAdo deleted the optimistic-sig-share-creation branch June 18, 2026 14:30

		@@ -360,12 +360,21 @@ func (sr *subroundBlock) sendBlockHeader(
		}

		func (sr *subroundBlock) triggerCreateSignaturesForManagedKeys(ctx context.Context) {

Conversation

ssd04 commented Apr 15, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Reasoning behind the pull request

Testing procedure

Pre-requisites

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

ssd04 Apr 15, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

codecov Bot commented May 19, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Codecov Report

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

ssd04 commented Apr 15, 2026 •

edited

Loading

ssd04 Apr 15, 2026 •

edited

Loading

codecov Bot commented May 19, 2026 •

edited

Loading