feat: implement CBOR marshal/unmarshal for ScriptsNotPaidUtxo error

wolf31o2 · GitHub Copilot · wolf31o2 · commit 9962db517bec · 2025-11-07T04:07:29.000Z
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 &lt;wolf31o2@blinklabs.io&gt;
Co-authored-by: GitHub Copilot &lt;copilot@github.com&gt;
diff --git a/ledger/error.go b/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,99 @@ 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) {
+	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,
+		)
+	}
+
+	// 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 {
diff --git a/ledger/error_test.go b/ledger/error_test.go
@@ -0,0 +1,195 @@
+package ledger
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/blinklabs-io/gouroboros/ledger/byron"
+	"github.com/blinklabs-io/gouroboros/ledger/common"
+	"github.com/blinklabs-io/gouroboros/ledger/shelley"
+)
+
+func TestScriptsNotPaidUtxo_MarshalUnmarshalCBOR(t *testing.T) {
+	// Create multiple UTxOs with different data to test for corruption
+	addr1, err := common.NewAddress("addr1qytna5k2fq9ler0fuk45j7zfwv7t2zwhp777nvdjqqfr5tz8ztpwnk8zq5ngetcz5k5mckgkajnygtsra9aej2h3ek5seupmvd")
+	if err != nil {
+		t.Fatalf("Failed to create address 1: %v", err)
+	}
+	addr2, err := common.NewAddress("addr1qyln2c2cx5jc4hw768pwz60n5245462dvp4auqcw09rl2xz07huw84puu6cea3qe0ce3apks7hjckqkh5ad4uax0l9ws0q9xty")
+	if err != nil {
+		t.Fatalf("Failed to create address 2: %v", err)
+	}
+	addr3, err := common.NewAddress("addr1z8snz7c4974vzdpxu65ruphl3zjdvtxw8strf2c2tmqnxz2j2c79gy9l76sdg0xwhd7r0c0kna0tycz4y5s6mlenh8pq0xmsha")
+	if err != nil {
+		t.Fatalf("Failed to create address 3: %v", err)
+	}
+
+	utxos := []common.Utxo{
+		{
+			Id: shelley.NewShelleyTransactionInput("deadbeef00000000000000000000000000000000000000000000000000000000", 0),
+			Output: &shelley.ShelleyTransactionOutput{
+				OutputAddress: addr1,
+				OutputAmount:  1000,
+			},
+		},
+		{
+			Id: shelley.NewShelleyTransactionInput("cafebabe11111111111111111111111111111111111111111111111111111111", 1),
+			Output: &shelley.ShelleyTransactionOutput{
+				OutputAddress: addr2,
+				OutputAmount:  2500,
+			},
+		},
+		{
+			Id: shelley.NewShelleyTransactionInput("feedface22222222222222222222222222222222222222222222222222222222", 2),
+			Output: &shelley.ShelleyTransactionOutput{
+				OutputAddress: addr3,
+				OutputAmount:  7500,
+			},
+		},
+	}
+
+	// Marshal to CBOR
+	original := &ScriptsNotPaidUtxo{
+		Utxos: utxos,
+	}
+	originalCborData, err := original.MarshalCBOR()
+	if err != nil {
+		t.Fatalf("MarshalCBOR failed: %v", err)
+	}
+
+	// Unmarshal back
+	var decoded ScriptsNotPaidUtxo
+	if err := decoded.UnmarshalCBOR(originalCborData); err != nil {
+		t.Fatalf("UnmarshalCBOR failed: %v", err)
+	}
+
+	// Validate count
+	if len(decoded.Utxos) != len(utxos) {
+		t.Fatalf("Expected %d UTxOs, got %d", len(utxos), len(decoded.Utxos))
+	}
+
+	// Validate each UTxO's data integrity
+	for i, originalUtxo := range utxos {
+		found := false
+		for _, decodedUtxo := range decoded.Utxos {
+			// Check if this is the matching UTxO by comparing transaction input
+			if decodedUtxo.Id.Id() == originalUtxo.Id.Id() && decodedUtxo.Id.Index() == originalUtxo.Id.Index() {
+				found = true
+
+			// Validate transaction output data using interface methods
+			originalOutput := originalUtxo.Output.(*shelley.ShelleyTransactionOutput)
+			
+			// Check the amount using the interface method
+			if decodedUtxo.Output.Amount() != originalOutput.OutputAmount {
+				t.Errorf("UTxO %d: Amount mismatch - expected %d, got %d",
+					i, originalOutput.OutputAmount, decodedUtxo.Output.Amount())
+			}
+
+			// Check the address using the interface method
+			if decodedUtxo.Output.Address().String() != originalOutput.OutputAddress.String() {
+				t.Errorf("UTxO %d: Address mismatch - expected %s, got %s",
+					i, originalOutput.OutputAddress.String(), decodedUtxo.Output.Address().String())
+			}
+				break
+			}
+		}
+		if !found {
+			t.Errorf("UTxO %d not found in decoded data: %s#%d",
+				i, originalUtxo.Id.Id().String(), originalUtxo.Id.Index())
+		}
+	}
+
+	// Test round-trip CBOR fidelity by re-marshaling and comparing bytes
+	remarshaled, err := decoded.MarshalCBOR()
+	if err != nil {
+		t.Fatalf("Re-marshaling failed: %v", err)
+	}
+
+	if !bytes.Equal(originalCborData, remarshaled) {
+		t.Errorf("Round-trip CBOR fidelity failed - bytes don't match")
+		t.Logf("Original:     %x", originalCborData)
+		t.Logf("Remarshaled:  %x", remarshaled)
+	}
+
+	t.Logf("Successfully validated %d UTxOs with full data integrity and round-trip fidelity", len(utxos))
+}
+
+func TestScriptsNotPaidUtxo_MarshalUnmarshalCBOR_AllEras(t *testing.T) {
+	// Create test addresses
+	addr1, err := common.NewAddress("addr1qytna5k2fq9ler0fuk45j7zfwv7t2zwhp777nvdjqqfr5tz8ztpwnk8zq5ngetcz5k5mckgkajnygtsra9aej2h3ek5seupmvd")
+	if err != nil {
+		t.Fatalf("Failed to create address 1: %v", err)
+	}
+	addr2, err := common.NewAddress("addr1qyln2c2cx5jc4hw768pwz60n5245462dvp4auqcw09rl2xz07huw84puu6cea3qe0ce3apks7hjckqkh5ad4uax0l9ws0q9xty")
+	if err != nil {
+		t.Fatalf("Failed to create address 2: %v", err)
+	}
+
+	// Test with Byron transaction inputs
+	byronInput1 := byron.NewByronTransactionInput("abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789ab", 0)
+	byronInput2 := byron.NewByronTransactionInput("fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210fe", 1)
+
+	// Create test UTxOs with Byron inputs
+	byronUtxos := []common.Utxo{
+		{
+			Id:     byronInput1,
+			Output: &shelley.ShelleyTransactionOutput{OutputAddress: addr1, OutputAmount: 1000000},
+		},
+		{
+			Id:     byronInput2,  
+			Output: &shelley.ShelleyTransactionOutput{OutputAddress: addr2, OutputAmount: 2500000},
+		},
+	}
+
+	// Test Byron inputs
+	byronError := &ScriptsNotPaidUtxo{Utxos: byronUtxos}
+	byronCborData, err := byronError.MarshalCBOR()
+	if err != nil {
+		t.Fatalf("Byron marshal failed: %v", err)
+	}
+
+	var decodedByron ScriptsNotPaidUtxo
+	if err := decodedByron.UnmarshalCBOR(byronCborData); err != nil {
+		t.Fatalf("Byron unmarshal failed: %v", err)
+	}
+
+	// Validate Byron decoding
+	if len(decodedByron.Utxos) != 2 {
+		t.Errorf("Expected 2 Byron UTxOs, got %d", len(decodedByron.Utxos))
+	}
+
+	// Test Shelley inputs
+	shelleyInput1 := shelley.NewShelleyTransactionInput("1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef", 0)
+	shelleyInput2 := shelley.NewShelleyTransactionInput("fedcba0987654321fedcba0987654321fedcba0987654321fedcba0987654321", 1)
+
+	shelleyUtxos := []common.Utxo{
+		{
+			Id:     shelleyInput1,
+			Output: &shelley.ShelleyTransactionOutput{OutputAddress: addr1, OutputAmount: 1500000},
+		},
+		{
+			Id:     shelleyInput2,
+			Output: &shelley.ShelleyTransactionOutput{OutputAddress: addr2, OutputAmount: 3000000},
+		},
+	}
+
+	// Test Shelley inputs
+	shelleyError := &ScriptsNotPaidUtxo{Utxos: shelleyUtxos}
+	shelleyCborData, err := shelleyError.MarshalCBOR()
+	if err != nil {
+		t.Fatalf("Shelley marshal failed: %v", err)
+	}
+
+	var decodedShelley ScriptsNotPaidUtxo
+	if err := decodedShelley.UnmarshalCBOR(shelleyCborData); err != nil {
+		t.Fatalf("Shelley unmarshal failed: %v", err)
+	}
+
+	// Validate Shelley decoding
+	if len(decodedShelley.Utxos) != 2 {
+		t.Errorf("Expected 2 Shelley UTxOs, got %d", len(decodedShelley.Utxos))
+	}
+
+	t.Logf("Successfully validated era-agnostic CBOR handling: Byron (%d UTxOs) and Shelley (%d UTxOs)", 
+		len(decodedByron.Utxos), len(decodedShelley.Utxos))
+}
