Pull request overview

This PR updates the HTTP /txs batch ingestion path in services/propagation to actually process transactions concurrently (using the existing server-wide batch semaphore) while preserving deterministic, submission-ordered error reporting. It also adjusts tests to reflect the documented “no parent+child in the same batch” contract and fixes a race in the HTTP test mock tx store exposed by parallelism.

Changes:

• Make handleMultipleTx fan out per-tx processing across goroutines gated by batchWorkerPool, and aggregate errors in submission order via preallocated slots.
• Replace the prior chain-based batch test with a sibling-based batch test and add an error-order-preservation test.
• Add mutex protection to MockTxStore’s internal txIDs slice to make the mock concurrency-safe.

Reviewed changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated no comments.

			if err != nil {
				// End of stream is expected and not an error
				if err == io.EOF {
					break
				}

				// Record the parse error in submission order.
				errSlots[nextSlot] = err
				nextSlot++

				// if the error came from panic recovery, the stream is likely corrupted
				if terr, ok := err.(*errors.Error); ok && terr.Code() == errors.ERR_PROCESSING {
					ps.logger.Errorf("Stream corrupted after panic, stopping transaction processing")
					break
				}

				// skip counters and reading this tx if a non-EOF error occurred
				continue
			}

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

Verified the concurrency aspects. claude[bot]'s CRITICAL semaphore-leak claim does not hold — the select has two mutually exclusive arms (pool-acquire + spawn-goroutine with defer release, vs ctx.Done + break). A slot cannot be acquired and then abandoned. The bot appears to have misread it as sequential.

• errSlots index aliasing: each goroutine writes to its own index; wg.Wait establishes happens-before for the assembly walk
• MockTxStore mutex covers txIDs append, Exists, Size — race-clean
• wg.Wait ordering: slots indexed by submission position; assembly walks in order after Wait
• maxSubmissions = maxTransactionsPerRequest + 1: the +1 is correct — ctx-cancel error is written at slot nextSlot == maxTransactionsPerRequest; without +1 that's OOB
• Parent+child caller contract: acceptable to let the violation surface as missing-parent errors; enforcing in-batch ordering would require a dependency graph pass

go test -race -count=10 on order-preserved + parallel tests: 90 pass, race-clean. vet / golangci-lint clean.

Test coverage gaps worth following up (non-blocking)

1. No HTTP-path ctx-cancellation mid-batch test. The exact test that would have refuted (or confirmed) the bot's claim is missing — adding one pins the no-leak guarantee in a regression test.
2. No HTTP-path test with non-nil batchWorkerPool (only the gRPC path has TestProcessTransactionBatch_BatchConcurrencyLimit).
3. No worker-panic mid-batch test — the panic recovery path in the worker goroutine is untested.

None of these are blockers; they'd close the coverage story.