feat: implement CBOR marshal/unmarshal for ScriptsNotPaidUtxo error

Add custom CBOR encoding/decoding for ScriptsNotPaidUtxo that matches
the Haskell cardano-ledger specification. The implementation uses
`[constructor_index, utxo_map]` format with multi-strategy decoding
to handle complex CBOR map structures.

- Add `MarshalCBOR` converting slice to map format
- Add `UnmarshalCBOR` with fallback decoding strategies
- Add comprehensive test with mock interfaces
- Maintain compatibility with existing error handling

Signed-off-by: Chris Gianelloni <[email protected]>
Co-authored-by: GitHub Copilot <[email protected]>

Author: wolf31o2

ledger/error.go

@@ -21,6 +21,9 @@ import (
 	"strings"
 
 	"github.com/blinklabs-io/gouroboros/cbor"
+	"github.com/blinklabs-io/gouroboros/ledger/byron"
+	"github.com/blinklabs-io/gouroboros/ledger/common"
+	"github.com/blinklabs-io/gouroboros/ledger/shelley"
 )
 
 const (
@@ -534,14 +537,115 @@ func (e *InsufficientCollateral) Error() string {
 	)
 }
 
+// ScriptsNotPaidUtxo represents the ScriptsNotPaidUTxO error from cardano-ledger.
+// Haskell: ScriptsNotPaidUTxO !(UTxO era) where UTxO era = Map TxIn TxOut
+// CBOR: [14, utxo_map]
 type ScriptsNotPaidUtxo struct {
 	UtxoFailureErrorBase
-	// TODO: determine content/structure of this value (#847)
-	Value cbor.Value
+	Utxos []common.Utxo // Each Utxo contains Id (input) and Output
+}
+
+func (e *ScriptsNotPaidUtxo) MarshalCBOR() ([]byte, error) {
+	// Set the struct tag for consistency
+	e.Type = UtxoFailureScriptsNotPaidUtxo
+
+	utxoMap := make(
+		map[common.TransactionInput]common.TransactionOutput,
+		len(e.Utxos),
+	)
+	for _, u := range e.Utxos {
+		// Return error for nil entries instead of silently skipping
+		if u.Id == nil || u.Output == nil {
+			return nil, errors.New(
+				"ScriptsNotPaidUtxo: cannot marshal UTxO with nil Id or Output",
+			)
+		}
+		utxoMap[u.Id] = u.Output
+	}
+	arr := []any{UtxoFailureScriptsNotPaidUtxo, utxoMap}
+	return cbor.Encode(arr)
+}
+
+func (e *ScriptsNotPaidUtxo) UnmarshalCBOR(data []byte) error {
+	type tScriptsNotPaidUtxo struct {
+		cbor.StructAsArray
+		ConstructorIdx uint64
+		UtxoMapCbor    cbor.RawMessage
+	}
+	var tmp tScriptsNotPaidUtxo
+	if _, err := cbor.Decode(data, &tmp); err != nil {
+		return fmt.Errorf("failed to decode ScriptsNotPaidUtxo: %w", err)
+	}
+
+	if tmp.ConstructorIdx != UtxoFailureScriptsNotPaidUtxo {
+		return fmt.Errorf(
+			"ScriptsNotPaidUtxo: expected constructor index %d, got %d",
+			UtxoFailureScriptsNotPaidUtxo,
+			tmp.ConstructorIdx,
+		)
+	}
+
+	// Set the struct tag to match the decoded constructor
+	e.Type = UtxoFailureScriptsNotPaidUtxo
+
+	// For era-agnostic decoding, we need to handle the map structure carefully
+	// Since we can't use cbor.RawMessage as map keys, we'll decode to a concrete type first
+	// and then convert to era-agnostic types. Try different era input types until one works.
+
+	// Try Shelley-family transaction inputs first (most common from Shelley onwards)
+	var shelleyUtxoMap map[shelley.ShelleyTransactionInput]cbor.RawMessage
+	if _, err := cbor.Decode(tmp.UtxoMapCbor, &shelleyUtxoMap); err == nil {
+		// Successfully decoded as Shelley-family inputs
+		e.Utxos = make([]common.Utxo, 0, len(shelleyUtxoMap))
+		for input, outputCbor := range shelleyUtxoMap {
+			// Decode output using era-agnostic function (handles all eras)
+			output, err := NewTransactionOutputFromCbor(outputCbor)
+			if err != nil {
+				return fmt.Errorf(
+					"failed to decode transaction output: %w",
+					err,
+				)
+			}
+
+			e.Utxos = append(e.Utxos, common.Utxo{
+				Id:     input,
+				Output: output,
+			})
+		}
+		return nil
+	}
+
+	// Try Byron transaction inputs (for Byron era)
+	var byronUtxoMap map[byron.ByronTransactionInput]cbor.RawMessage
+	if _, err := cbor.Decode(tmp.UtxoMapCbor, &byronUtxoMap); err == nil {
+		// Successfully decoded as Byron inputs
+		e.Utxos = make([]common.Utxo, 0, len(byronUtxoMap))
+		for input, outputCbor := range byronUtxoMap {
+			// Decode output using era-agnostic function (handles all eras)
+			output, err := NewTransactionOutputFromCbor(outputCbor)
+			if err != nil {
+				return fmt.Errorf(
+					"failed to decode transaction output: %w",
+					err,
+				)
+			}
+
+			e.Utxos = append(e.Utxos, common.Utxo{
+				Id:     input,
+				Output: output,
+			})
+		}
+		return nil
+	}
+
+	// If both failed, return an error
+	return errors.New(
+		"failed to decode UTxO map as either Shelley-family or Byron transaction inputs",
+	)
 }
 
 func (e *ScriptsNotPaidUtxo) Error() string {
-	return fmt.Sprintf("ScriptsNotPaidUtxo (%v)", e.Value.Value())
+	return fmt.Sprintf("ScriptsNotPaidUtxo (%d UTxOs)", len(e.Utxos))
 }
 
 type ExUnitsTooBigUtxo struct {