fix(conway): tolerate duplicate redeemer key

Signed-off-by: Chris Gianelloni <wolf31o2@blinklabs.io>

Author: wolf31o2

ledger/conway/conway.go

@@ -290,8 +290,25 @@ func (r *ConwayRedeemers) UnmarshalCBOR(cborData []byte) error {
 		// Modern map form — clear any stale legacy state
 		r.legacy = false
 		r.legacyRedeemers = alonzo.AlonzoRedeemers{}
-		_, err := cbor.Decode(cborData, &(r.Redeemers))
-		return err
+		if _, err := cbor.Decode(cborData, &(r.Redeemers)); err != nil {
+			if !cbor.IsDuplicateMapKeyError(err) {
+				return err
+			}
+			// A Redeemers map with a duplicate (tag, index) key. cardano-ledger
+			// decodes this map last-wins and cardano-node accepts such blocks,
+			// so they appear on canonical chains (gouroboros #1860: a preview
+			// block carries a duplicate (Spend, 0) redeemer that cardano-node
+			// accepts). Reject-on-duplicate poisons every peer serving the block
+			// and stalls sync, so decode leniently (last-wins) to match
+			// consensus. Hash-safe: redeemer/tx/block hashes are computed over
+			// the stored raw CBOR (SetCbor above), so lenient struct decoding
+			// never changes them.
+			r.Redeemers = nil
+			if _, err := cbor.DecodeLenient(cborData, &(r.Redeemers)); err != nil {
+				return err
+			}
+		}
+		return nil
 	}
 	// Legacy array form — clear any stale map state
 	r.Redeemers = nil

ledger/conway/conway_test.go

@@ -599,3 +599,45 @@ func TestConwayTx_WithReferenceScripts_CborRoundTrip(t *testing.T) {
 		"CBOR round-trip should be byte-identical",
 	)
 }
+
+// TestConwayRedeemersDuplicateKeyLenient verifies that a Redeemers map carrying
+// a duplicate (tag, index) key — which cardano-node accepts and strict decoding
+// rejects — is decoded leniently (last-wins) instead of failing the block.
+// See gouroboros #1860.
+func TestConwayRedeemersDuplicateKeyLenient(t *testing.T) {
+	// Redeemers map with two entries under the same key [Spend(0), index 0]:
+	//   { [0,0]: [0,[1,2]], [0,0]: [0,[3,4]] }
+	// Plutus data is the bare integer 0; the value's second element is
+	// ExUnits [mem, steps].
+	dupCbor := []byte{
+		0xA2,             // map(2)
+		0x82, 0x00, 0x00, // key [Spend, 0]
+		0x82, 0x00, 0x82, 0x01, 0x02, // value [datum=0, exUnits=[1,2]]
+		0x82, 0x00, 0x00, // key [Spend, 0] (duplicate)
+		0x82, 0x00, 0x82, 0x03, 0x04, // value [datum=0, exUnits=[3,4]]
+	}
+	// Strict decode rejects the duplicate key (the pre-fix behavior that
+	// wedged preview sync).
+	var strict map[common.RedeemerKey]common.RedeemerValue
+	_, strictErr := cbor.Decode(dupCbor, &strict)
+	assert.Error(t, strictErr)
+	assert.True(
+		t,
+		cbor.IsDuplicateMapKeyError(strictErr),
+		"expected a duplicate-map-key error, got %v",
+		strictErr,
+	)
+	// ConwayRedeemers decodes it, keeping the last value for the duplicate key.
+	var r ConwayRedeemers
+	if err := r.UnmarshalCBOR(dupCbor); err != nil {
+		t.Fatalf("lenient decode of duplicate-key redeemers failed: %v", err)
+	}
+	key := common.RedeemerKey{Tag: common.RedeemerTagSpend, Index: 0}
+	assert.Len(t, r.Redeemers, 1)
+	assert.Equal(
+		t,
+		common.ExUnits{Memory: 3, Steps: 4},
+		r.Redeemers[key].ExUnits,
+		"duplicate key should resolve last-wins",
+	)
+}