fix: address nilaway issues (#1189)

verbotenj · web-flow · commit 6c14c8033920 · 2025-09-15T16:28:58.000-04:00
diff --git a/ledger/allegra/allegra.go b/ledger/allegra/allegra.go
@@ -230,7 +230,7 @@ func (b *AllegraTransactionBody) AuxDataHash() *common.Blake2b256 {
 }
 
 func (b *AllegraTransactionBody) Utxorpc() (*utxorpc.Tx, error) {
-	return common.TransactionBodyToUtxorpc(b), nil
+	return common.TransactionBodyToUtxorpc(b)
 }
 
 type AllegraTransaction struct {
diff --git a/ledger/allegra/pparams_test.go b/ledger/allegra/pparams_test.go
@@ -164,7 +164,7 @@ func TestAllegraTransactionBody_Utxorpc(t *testing.T) {
 	// Run Utxorpc conversion
 	actual, err := txBody.Utxorpc()
 	if err != nil {
-		t.Errorf("Failed to convert the transaction")
+		t.Fatalf("Could not convert transaction body to utxorpc format: %v", err)
 	}
 
 	// Check that the fee matches
@@ -227,7 +227,7 @@ func TestAllegraTransaction_Utxorpc(t *testing.T) {
 	// Run Utxorpc conversion
 	actual, err := tx.Utxorpc()
 	if err != nil {
-		t.Errorf("Failed to convert the transaction")
+		t.Fatalf("Could not convert transaction to utxorpc format: %v", err)
 	}
 	// Assertion checks
 	if actual.Fee != tx.Fee() {
diff --git a/ledger/alonzo/alonzo.go b/ledger/alonzo/alonzo.go
@@ -268,7 +268,7 @@ func (b *AlonzoTransactionBody) ScriptDataHash() *common.Blake2b256 {
 }
 
 func (b *AlonzoTransactionBody) Utxorpc() (*utxorpc.Tx, error) {
-	return common.TransactionBodyToUtxorpc(b), nil
+	return common.TransactionBodyToUtxorpc(b)
 }
 
 type AlonzoTransactionOutput struct {
diff --git a/ledger/alonzo/pparams_test.go b/ledger/alonzo/pparams_test.go
@@ -261,6 +261,9 @@ func TestScientificNotationInCostModels(t *testing.T) {
 	}
 
 	expected := []int64{2477736, 1500000, 1000000}
+	if params.CostModels == nil || params.CostModels[alonzo.PlutusV1Key] == nil {
+		t.Fatal("CostModels not properly initialized")
+	}
 	for i := range 3 {
 		if params.CostModels[alonzo.PlutusV1Key][i] != expected[i] {
 			t.Errorf("parameter %d conversion failed: got %d, want %d",
@@ -517,7 +520,7 @@ func TestAlonzoTransactionBody_Utxorpc(t *testing.T) {
 	// Run Utxorpc conversion
 	got, err := body.Utxorpc()
 	if err != nil {
-		t.Errorf("Failed to convert the transaction")
+		t.Fatalf("Could not convert transaction body to utxorpc format: %v", err)
 	}
 
 	// Assertion checks
@@ -580,7 +583,7 @@ func TestAlonzoTransaction_Utxorpc(t *testing.T) {
 	// Run Utxorpc conversion
 	got, err := tx.Utxorpc()
 	if err != nil {
-		t.Errorf("Failed to convert the transaction")
+		t.Fatalf("Could not convert transaction to utxorpc format: %v", err)
 	}
 
 	// Assertion checks
diff --git a/ledger/babbage/babbage.go b/ledger/babbage/babbage.go
@@ -364,7 +364,7 @@ func (b *BabbageTransactionBody) TotalCollateral() uint64 {
 }
 
 func (b *BabbageTransactionBody) Utxorpc() (*utxorpc.Tx, error) {
-	return common.TransactionBodyToUtxorpc(b), nil
+	return common.TransactionBodyToUtxorpc(b)
 }
 
 const (
diff --git a/ledger/babbage/pparams_test.go b/ledger/babbage/pparams_test.go
@@ -637,7 +637,7 @@ func TestBabbageTransactionBody_Utxorpc(t *testing.T) {
 
 	got, err := body.Utxorpc()
 	if err != nil {
-		t.Fatalf("Utxorpc() conversion failed: %v", err)
+		t.Fatalf("Could not convert transaction body to utxorpc format: %v", err)
 	}
 	if got.Fee != 100 {
 		t.Errorf("Fee mismatch: got %d, want 100", got.Fee)
@@ -682,7 +682,7 @@ func TestBabbageTransaction_Utxorpc(t *testing.T) {
 
 	got, err := tx.Utxorpc()
 	if err != nil {
-		t.Fatalf("Utxorpc() failed: %v", err)
+		t.Fatalf("Could not convert transaction to utxorpc format: %v", err)
 	}
 	if got.Fee != 150 {
 		t.Errorf("Fee mismatch: got %d, want 150", got.Fee)
diff --git a/ledger/common/script_test.go b/ledger/common/script_test.go
@@ -54,9 +54,13 @@ func TestScriptRefDecodeEncode(t *testing.T) {
 }
 
 func TestNativeScriptHash(t *testing.T) {
-	testScriptBytes, _ := hex.DecodeString(
+	testScriptBytes, err := hex.DecodeString(
 		"820181830301838200581c058a5ab0c66647dcce82d7244f80bfea41ba76c7c9ccaf86a41b00fe8200581c45cbc234959cb619ef54e36c16e7719318592e627cdf1a39bd3d64398200581c85fd53e110449649b709ef0fa93e86d99535bdce5db306ce0e7418fc",
 	)
+	// Make nilaway happy
+	if err != nil {
+		t.Fatalf("failed to decode hex string: %v", err)
+	}
 	expectedScriptHash := "1c0053ec18e2c0f7bd4d007fe14243ca220563f9c124381f75c43704"
 	var testScript common.NativeScript
 	if err := testScript.UnmarshalCBOR(testScriptBytes); err != nil {
diff --git a/ledger/common/tx.go b/ledger/common/tx.go
@@ -195,25 +195,25 @@ func (b *TransactionBodyBase) Donation() uint64 {
 	return 0
 }
 
-func (b *TransactionBodyBase) Utxorpc() *utxorpc.Tx {
-	return nil
+func (b *TransactionBodyBase) Utxorpc() (*utxorpc.Tx, error) {
+	return nil, nil
 }
 
 // TransactionBodyToUtxorpc is a common helper for converting TransactionBody to utxorpc.Tx
-func TransactionBodyToUtxorpc(tx TransactionBody) *utxorpc.Tx {
+func TransactionBodyToUtxorpc(tx TransactionBody) (*utxorpc.Tx, error) {
 	txi := []*utxorpc.TxInput{}
 	txo := []*utxorpc.TxOutput{}
 	for _, i := range tx.Inputs() {
 		input, err := i.Utxorpc()
 		if err != nil {
-			return nil
+			return nil, err
 		}
 		txi = append(txi, input)
 	}
 	for _, o := range tx.Outputs() {
 		output, err := o.Utxorpc()
 		if err != nil {
-			return nil
+			return nil, err
 		}
 		txo = append(txo, output)
 	}
@@ -236,17 +236,17 @@ func TransactionBodyToUtxorpc(tx TransactionBody) *utxorpc.Tx {
 	for _, ri := range tx.ReferenceInputs() {
 		input, err := ri.Utxorpc()
 		if err != nil {
-			return nil
+			return nil, err
 		}
 		ret.ReferenceInputs = append(ret.ReferenceInputs, input)
 	}
 	for _, c := range tx.Certificates() {
 		cert, err := c.Utxorpc()
 		if err != nil {
-			return nil
+			return nil, err
 		}
 		ret.Certificates = append(ret.Certificates, cert)
 	}
 
-	return ret
+	return ret, nil
 }
diff --git a/ledger/conway/conway.go b/ledger/conway/conway.go
@@ -508,7 +508,7 @@ func (b *ConwayTransactionBody) Donation() uint64 {
 }
 
 func (b *ConwayTransactionBody) Utxorpc() (*utxorpc.Tx, error) {
-	return common.TransactionBodyToUtxorpc(b), nil
+	return common.TransactionBodyToUtxorpc(b)
 }
 
 type ConwayTransaction struct {
diff --git a/ledger/conway/pparams_test.go b/ledger/conway/pparams_test.go
@@ -656,7 +656,7 @@ func TestConwayTransactionBody_Utxorpc(t *testing.T) {
 
 	got, err := body.Utxorpc()
 	if err != nil {
-		t.Errorf("Could not get the transaction input")
+		t.Fatalf("Could not convert the transaction body to utxorpc format %v", err)
 	}
 
 	if got.Fee != 1000 {
@@ -733,7 +733,7 @@ func TestConwayTransaction_Utxorpc(t *testing.T) {
 
 	got, err := tx.Utxorpc()
 	if err != nil {
-		t.Errorf("Could not get the transaction input")
+		t.Fatalf("Could not convert transaction to utxorpc format: %v", err)
 	}
 
 	if got.Fee != 1000 {
diff --git a/ledger/mary/mary.go b/ledger/mary/mary.go
@@ -238,7 +238,7 @@ func (b *MaryTransactionBody) AssetMint() *common.MultiAsset[common.MultiAssetTy
 }
 
 func (b *MaryTransactionBody) Utxorpc() (*utxorpc.Tx, error) {
-	return common.TransactionBodyToUtxorpc(b), nil
+	return common.TransactionBodyToUtxorpc(b)
 }
 
 type MaryTransaction struct {
diff --git a/ledger/mary/pparams_test.go b/ledger/mary/pparams_test.go
@@ -214,7 +214,7 @@ func TestMaryTransactionBody_Utxorpc(t *testing.T) {
 
 	got, err := body.Utxorpc()
 	if err != nil {
-		t.Errorf("Could not get correct UTxorpc input")
+		t.Fatalf("Could not convert the transaction body to utxorpc format %v", err)
 	}
 
 	if got.Fee != 100 {
@@ -262,7 +262,7 @@ func TestMaryTransaction_Utxorpc(t *testing.T) {
 
 	got, err := tx.Utxorpc()
 	if err != nil {
-		t.Errorf("Could not get correct UTxorpc input")
+		t.Fatalf("Could not convert transaction to utxorpc format: %v", err)
 	}
 
 	if got.Fee != 25 {
diff --git a/ledger/shelley/pparams_test.go b/ledger/shelley/pparams_test.go
@@ -271,7 +271,7 @@ func TestShelleyTransactionBody_Utxorpc(t *testing.T) {
 	// Convert the transaction body to utxorpc format
 	actual, err := txBody.Utxorpc()
 	if err != nil {
-		t.Errorf("Could not convert the transaction body to utxorpc format")
+		t.Fatalf("Could not convert the transaction body to utxorpc format %v", err)
 	}
 
 	// Check that the fee matches
@@ -339,7 +339,7 @@ func TestShelleyTransaction_Utxorpc(t *testing.T) {
 	// Invoke Utxorpc conversion
 	got, err := tx.Utxorpc()
 	if err != nil {
-		t.Errorf("Could not Invoke Utxorpc conversion")
+		t.Fatalf("Could not convert transaction to utxorpc format: %v", err)
 	}
 
 	// Verify the fee
diff --git a/ledger/shelley/shelley.go b/ledger/shelley/shelley.go
@@ -290,7 +290,7 @@ func (b *ShelleyTransactionBody) AuxDataHash() *common.Blake2b256 {
 }
 
 func (b *ShelleyTransactionBody) Utxorpc() (*utxorpc.Tx, error) {
-	return common.TransactionBodyToUtxorpc(b), nil
+	return common.TransactionBodyToUtxorpc(b)
 }
 
 type ShelleyTransactionInputSet struct {

Original file line number	Diff line number	Diff line change
`@@ -230,7 +230,7 @@ func (b AllegraTransactionBody) AuxDataHash() common.Blake2b256 {`
`230`	`230`	`}`
`231`	`231`
`232`	`232`	`func (b AllegraTransactionBody) Utxorpc() (utxorpc.Tx, error) {`
`233`		`- return common.TransactionBodyToUtxorpc(b), nil`
	`233`	`+ return common.TransactionBodyToUtxorpc(b)`
`234`	`234`	`}`
`235`	`235`
`236`	`236`	`type AllegraTransaction struct {`
Original file line number	Diff line number	Diff line change
`@@ -268,7 +268,7 @@ func (b AlonzoTransactionBody) ScriptDataHash() common.Blake2b256 {`
`268`	`268`	`}`
`269`	`269`
`270`	`270`	`func (b AlonzoTransactionBody) Utxorpc() (utxorpc.Tx, error) {`
`271`		`- return common.TransactionBodyToUtxorpc(b), nil`
	`271`	`+ return common.TransactionBodyToUtxorpc(b)`
`272`	`272`	`}`
`273`	`273`
`274`	`274`	`type AlonzoTransactionOutput struct {`
Original file line number	Diff line number	Diff line change
`@@ -364,7 +364,7 @@ func (b *BabbageTransactionBody) TotalCollateral() uint64 {`
`364`	`364`	`}`
`365`	`365`
`366`	`366`	`func (b BabbageTransactionBody) Utxorpc() (utxorpc.Tx, error) {`
`367`		`- return common.TransactionBodyToUtxorpc(b), nil`
	`367`	`+ return common.TransactionBodyToUtxorpc(b)`
`368`	`368`	`}`
`369`	`369`
`370`	`370`	`const (`
Original file line number	Diff line number	Diff line change
`@@ -54,9 +54,13 @@ func TestScriptRefDecodeEncode(t *testing.T) {`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`func TestNativeScriptHash(t *testing.T) {`
`57`		`- testScriptBytes, _ := hex.DecodeString(`
	`57`	`+ testScriptBytes, err := hex.DecodeString(`
`58`	`58`	`"820181830301838200581c058a5ab0c66647dcce82d7244f80bfea41ba76c7c9ccaf86a41b00fe8200581c45cbc234959cb619ef54e36c16e7719318592e627cdf1a39bd3d64398200581c85fd53e110449649b709ef0fa93e86d99535bdce5db306ce0e7418fc",`
`59`	`59`	`)`
	`60`	`+ // Make nilaway happy`
	`61`	`+ if err != nil {`
	`62`	`+ t.Fatalf("failed to decode hex string: %v", err)`
	`63`	`+ }`
`60`	`64`	`expectedScriptHash := "1c0053ec18e2c0f7bd4d007fe14243ca220563f9c124381f75c43704"`
`61`	`65`	`var testScript common.NativeScript`
`62`	`66`	`if err := testScript.UnmarshalCBOR(testScriptBytes); err != nil {`
Original file line number	Diff line number	Diff line change
`@@ -195,25 +195,25 @@ func (b *TransactionBodyBase) Donation() uint64 {`
`195`	`195`	`return 0`
`196`	`196`	`}`
`197`	`197`
`198`		`-func (b TransactionBodyBase) Utxorpc() utxorpc.Tx {`
`199`		`- return nil`
	`198`	`+func (b TransactionBodyBase) Utxorpc() (utxorpc.Tx, error) {`
	`199`	`+ return nil, nil`
`200`	`200`	`}`
`201`	`201`
`202`	`202`	`// TransactionBodyToUtxorpc is a common helper for converting TransactionBody to utxorpc.Tx`
`203`		`-func TransactionBodyToUtxorpc(tx TransactionBody) *utxorpc.Tx {`
	`203`	`+func TransactionBodyToUtxorpc(tx TransactionBody) (*utxorpc.Tx, error) {`
`204`	`204`	`txi := []*utxorpc.TxInput{}`
`205`	`205`	`txo := []*utxorpc.TxOutput{}`
`206`	`206`	`for _, i := range tx.Inputs() {`
`207`	`207`	`input, err := i.Utxorpc()`
`208`	`208`	`if err != nil {`
`209`		`- return nil`
	`209`	`+ return nil, err`
`210`	`210`	`}`
`211`	`211`	`txi = append(txi, input)`
`212`	`212`	`}`
`213`	`213`	`for _, o := range tx.Outputs() {`
`214`	`214`	`output, err := o.Utxorpc()`
`215`	`215`	`if err != nil {`
`216`		`- return nil`
	`216`	`+ return nil, err`
`217`	`217`	`}`
`218`	`218`	`txo = append(txo, output)`
`219`	`219`	`}`
`@@ -236,17 +236,17 @@ func TransactionBodyToUtxorpc(tx TransactionBody) *utxorpc.Tx {`
`236`	`236`	`for _, ri := range tx.ReferenceInputs() {`
`237`	`237`	`input, err := ri.Utxorpc()`
`238`	`238`	`if err != nil {`
`239`		`- return nil`
	`239`	`+ return nil, err`
`240`	`240`	`}`
`241`	`241`	`ret.ReferenceInputs = append(ret.ReferenceInputs, input)`
`242`	`242`	`}`
`243`	`243`	`for _, c := range tx.Certificates() {`
`244`	`244`	`cert, err := c.Utxorpc()`
`245`	`245`	`if err != nil {`
`246`		`- return nil`
	`246`	`+ return nil, err`
`247`	`247`	`}`
`248`	`248`	`ret.Certificates = append(ret.Certificates, cert)`
`249`	`249`	`}`
`250`	`250`
`251`		`- return ret`
	`251`	`+ return ret, nil`
`252`	`252`	`}`
Original file line number	Diff line number	Diff line change
`@@ -508,7 +508,7 @@ func (b *ConwayTransactionBody) Donation() uint64 {`
`508`	`508`	`}`
`509`	`509`
`510`	`510`	`func (b ConwayTransactionBody) Utxorpc() (utxorpc.Tx, error) {`
`511`		`- return common.TransactionBodyToUtxorpc(b), nil`
	`511`	`+ return common.TransactionBodyToUtxorpc(b)`
`512`	`512`	`}`
`513`	`513`
`514`	`514`	`type ConwayTransaction struct {`
Original file line number	Diff line number	Diff line change
`@@ -656,7 +656,7 @@ func TestConwayTransactionBody_Utxorpc(t *testing.T) {`
`656`	`656`
`657`	`657`	`got, err := body.Utxorpc()`
`658`	`658`	`if err != nil {`
`659`		`- t.Errorf("Could not get the transaction input")`
	`659`	`+ t.Fatalf("Could not convert the transaction body to utxorpc format %v", err)`
`660`	`660`	`}`
`661`	`661`
`662`	`662`	`if got.Fee != 1000 {`
`@@ -733,7 +733,7 @@ func TestConwayTransaction_Utxorpc(t *testing.T) {`
`733`	`733`
`734`	`734`	`got, err := tx.Utxorpc()`
`735`	`735`	`if err != nil {`
`736`		`- t.Errorf("Could not get the transaction input")`
	`736`	`+ t.Fatalf("Could not convert transaction to utxorpc format: %v", err)`
`737`	`737`	`}`
`738`	`738`
`739`	`739`	`if got.Fee != 1000 {`