refactor(ledger): put error at end of return

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

Author: wolf31o2

ledger/verify_block.go

@@ -28,7 +28,7 @@ import (
 )
 
 //nolint:staticcheck
-func VerifyBlock(block BlockHexCbor) (error, bool, string, uint64, uint64) {
+func VerifyBlock(block BlockHexCbor) (bool, string, uint64, uint64, error) {
 	headerCborHex := block.HeaderCbor
 	epochNonceHex := block.Eta0
 	bodyHex := block.BlockBodyCbor
@@ -37,70 +37,109 @@ func VerifyBlock(block BlockHexCbor) (error, bool, string, uint64, uint64) {
 	isValid := false
 	vrfHex := ""
 
-	// check is KES valid
+	// Check if this is a Leios block, which is not supported for verification
+	if block.Flag < 0 {
+		return false, "", 0, 0, fmt.Errorf(
+			"VerifyBlock: invalid block flag %d, must be non-negative",
+			block.Flag,
+		)
+	}
+	blockType := uint(block.Flag) // #nosec G115
+	if blockType == BlockTypeLeiosRanking ||
+		blockType == BlockTypeLeiosEndorser {
+		return false, "", 0, 0, errors.New(
+			"VerifyBlock: Leios blocks are not supported for verification",
+		)
+	}
+
+	// For backward compatibility, try to decode as Babbage header first
+	// This allows the function to work with different eras that have compatible structures
 	headerCborByte, headerDecodeError := hex.DecodeString(headerCborHex)
 	if headerDecodeError != nil {
-		return fmt.Errorf(
+		return false, "", 0, 0, fmt.Errorf(
 			"VerifyBlock: headerCborByte decode error, %v",
 			headerDecodeError.Error(),
-		), false, "", 0, 0
+		)
 	}
-	header, headerUnmarshalError := NewBabbageBlockHeaderFromCbor(
-		headerCborByte,
-	)
+	var header BlockHeader
+	var headerUnmarshalError error
+	header, headerUnmarshalError = NewBabbageBlockHeaderFromCbor(headerCborByte)
 	if headerUnmarshalError != nil {
-		return fmt.Errorf(
-			"VerifyBlock: header unmarshal error, %v",
-			headerUnmarshalError.Error(),
-		), false, "", 0, 0
+		// If Babbage decoding fails, try the era-specific decoder
+		header, headerUnmarshalError = NewBlockHeaderFromCbor(
+			blockType,
+			headerCborByte,
+		)
+		if headerUnmarshalError != nil {
+			return false, "", 0, 0, fmt.Errorf(
+				"VerifyBlock: header unmarshal error, %v",
+				headerUnmarshalError.Error(),
+			)
+		}
 	}
 	if header == nil {
-		return errors.New("VerifyBlock: header returned empty"), false, "", 0, 0
+		return false, "", 0, 0, errors.New("VerifyBlock: header returned empty")
 	}
-	isKesValid, errKes := VerifyKes(header, slotPerKesPeriod)
+
+	// For verification, we need to work with Babbage-compatible headers
+	// Try to cast to BabbageBlockHeader
+	babbageHeader, ok := header.(*BabbageBlockHeader)
+	if !ok {
+		// If it's not a Babbage header, check if it's Conway (which embeds Babbage)
+		if conwayHeader, ok := header.(*ConwayBlockHeader); ok {
+			babbageHeader = &conwayHeader.BabbageBlockHeader
+		} else {
+			return false, "", 0, 0, fmt.Errorf("VerifyBlock: block verification only supported for Babbage-compatible headers, got type: %T", header)
+		}
+	}
+
+	isKesValid, errKes := VerifyKes(babbageHeader, slotPerKesPeriod)
 	if errKes != nil {
-		return fmt.Errorf(
+		return false, "", 0, 0, fmt.Errorf(
 			"VerifyBlock: KES invalid, %v",
 			errKes.Error(),
-		), false, "", 0, 0
+		)
 	}
 
 	// check is VRF valid
 	// Ref: https://github.com/IntersectMBO/ouroboros-consensus/blob/de74882102236fdc4dd25aaa2552e8b3e208448c/ouroboros-consensus-protocol/src/ouroboros-consensus-protocol/Ouroboros/Consensus/Protocol/Praos.hs#L541
 	epochNonceByte, epochNonceDecodeError := hex.DecodeString(epochNonceHex)
 	if epochNonceDecodeError != nil {
-		return fmt.Errorf(
+		return false, "", 0, 0, fmt.Errorf(
 			"VerifyBlock: epochNonceByte decode error, %v",
 			epochNonceDecodeError.Error(),
-		), false, "", 0, 0
+		)
 	}
-	vrfBytes := header.Body.VrfKey[:]
-	vrfResult := header.Body.VrfResult
-	seed := MkInputVrf(int64(header.Body.Slot), epochNonceByte) // #nosec G115
+	vrfBytes := babbageHeader.Body.VrfKey[:]
+	vrfResult := babbageHeader.Body.VrfResult
+	seed := MkInputVrf(
+		int64(babbageHeader.Body.Slot),
+		epochNonceByte,
+	) // #nosec G115
 	output, errVrf := VrfVerifyAndHash(vrfBytes, vrfResult.Proof, seed)
 	if errVrf != nil {
-		return fmt.Errorf(
+		return false, "", 0, 0, fmt.Errorf(
 			"VerifyBlock: vrf invalid, %v",
 			errVrf.Error(),
-		), false, "", 0, 0
+		)
 	}
 	isVrfValid := bytes.Equal(output, vrfResult.Output)
 
 	// check if block data valid
-	blockBodyHash := header.Body.BlockBodyHash
+	blockBodyHash := babbageHeader.Body.BlockBodyHash
 	blockBodyHashHex := hex.EncodeToString(blockBodyHash[:])
 	isBodyValid, isBodyValidError := VerifyBlockBody(bodyHex, blockBodyHashHex)
 	if isBodyValidError != nil {
-		return fmt.Errorf(
+		return false, "", 0, 0, fmt.Errorf(
 			"VerifyBlock: VerifyBlockBody error, %v",
 			isBodyValidError.Error(),
-		), false, "", 0, 0
+		)
 	}
 	isValid = isKesValid && isVrfValid && isBodyValid
 	vrfHex = hex.EncodeToString(vrfBytes)
-	blockNo := header.Body.BlockNumber
-	slotNo := header.Body.Slot
-	return nil, isValid, vrfHex, blockNo, slotNo
+	blockNo := babbageHeader.Body.BlockNumber
+	slotNo := babbageHeader.Body.Slot
+	return isValid, vrfHex, blockNo, slotNo, nil
 }
 
 func ExtractBlockData(

ledger/verify_block_test.go

@@ -50,7 +50,7 @@ func TestVerifyBlockBody(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			err, isValid, _, _, _ := VerifyBlock(tc.blockHexCbor)
+			isValid, _, _, _, err := VerifyBlock(tc.blockHexCbor)
 			if tc.expectedValid != isValid {
 				t.Errorf("unexpected error: %v", err)
 			}