fix(storer/reserve): enforce deterministic equal-timestamp stamp-hash tie-break

Author: martinconic

pkg/storer/internal/reserve/convergence_test.go

@@ -364,8 +364,7 @@ func TestPutOrderConvergence(t *testing.T) {
 			// Three-way conflict across batches: the batch B entry must end
 			// serving whatever payload the batch A conflict settles on, with
 			// its sum refreshed accordingly.
-			name:       "divergent socs with a sibling entry under another batch",
-			unresolved: true,
+			name: "divergent socs with a sibling entry under another batch",
 			chunks: func(t *testing.T) []swarm.Chunk {
 				t.Helper()
 				stamp := postagetesting.MustNewFields(batchA.ID, 0, 7)
@@ -463,17 +462,17 @@ func TestSOCMultiStampDivergenceCornerCase(t *testing.T) {
 		t.Fatal("expected payload P2 after putting stampB")
 	}
 
-	// Re-offer stamp A with lower-wrapped P1: same-stamp resolveDivergence
-	// accepts it, so the store settles on P1.
-	if err := r.Put(ctx, soc1.WithStamp(stampA)); err != nil {
-		t.Fatalf("re-offer soc1 stampA: %v", err)
+	// Re-offering weaker stamp A must be rejected by tie-break against stronger stamp B.
+	err = r.Put(ctx, soc1.WithStamp(stampA))
+	if !errors.Is(err, storage.ErrDivergentChunkRejected) {
+		t.Fatalf("expected ErrDivergentChunkRejected on weaker re-offer, got: %v", err)
 	}
 
 	finalCh, err := ts.ChunkStore().Get(ctx, soc1.Address())
 	if err != nil {
 		t.Fatalf("get final chunk: %v", err)
 	}
-	if !bytes.Equal(finalCh.Data(), soc1.Data()) {
-		t.Fatal("expected payload P1 after re-offering lower-wrapped stampA variant")
+	if !bytes.Equal(finalCh.Data(), soc2.Data()) {
+		t.Fatal("expected payload P2 to be retained after rejecting weaker stampA re-offer")
 	}
 }

pkg/storer/internal/reserve/reserve.go

@@ -284,6 +284,12 @@ func (r *Reserve) evaluateSOCDivergence(
 		if bestStoredStamp == nil || ts > highestPrevTimestamp {
 			highestPrevTimestamp = ts
 			bestStoredStamp = st
+		} else if ts == highestPrevTimestamp {
+			bestHash, err1 := bestStoredStamp.Hash()
+			currHash, err2 := st.Hash()
+			if err1 == nil && err2 == nil && bytes.Compare(currHash, bestHash) < 0 {
+				bestStoredStamp = st
+			}
 		}
 		return false, nil
 	})
@@ -638,6 +644,12 @@ func (r *Reserve) resolveDivergence(
 			if bestStoredStamp == nil || ts > highestPrevTimestamp {
 				highestPrevTimestamp = ts
 				bestStoredStamp = st
+			} else if ts == highestPrevTimestamp {
+				bestHash, err1 := bestStoredStamp.Hash()
+				currHash, err2 := st.Hash()
+				if err1 == nil && err2 == nil && bytes.Compare(currHash, bestHash) < 0 {
+					bestStoredStamp = st
+				}
 			}
 			return false, nil
 		})
@@ -656,7 +668,7 @@ func (r *Reserve) resolveDivergence(
 			return fmt.Errorf("overwrite same chunk. prev %d cur %d batch %s: %w", highestPrevTimestamp, currTimestamp, hex.EncodeToString(chunk.Stamp().BatchID()), storage.ErrOverwriteNewerChunk)
 		}
 
-		if highestPrevTimestamp == currTimestamp && chunkType != swarm.ChunkTypeSingleOwner {
+		if highestPrevTimestamp == currTimestamp {
 			storedStampHash, err := stored.Stamp().Hash()
 			if err != nil {
 				return err