refactor: use ledger block on verify block

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

Author: wolf31o2

connection_test.go

@@ -20,7 +20,7 @@ import (
 	"time"
 
 	ouroboros "github.com/blinklabs-io/gouroboros"
-	"github.com/blinklabs-io/ouroboros-mock"
+	ouroboros_mock "github.com/blinklabs-io/ouroboros-mock"
 	"go.uber.org/goleak"
 )
 

ledger/common/rewards.go

@@ -394,7 +394,10 @@ func calculatePoolShare(
 	stakeRatio := float64(poolStake) / float64(snapshot.TotalActiveStake)
 
 	// Calculate saturation (capped at 1.0)
-	saturation := math.Min(stakeRatio/0.05, 1.0) // TODO: consider wiring a param or helper for consistency with CalculatePoolSaturation
+	saturation := math.Min(
+		stakeRatio/0.05,
+		1.0,
+	) // TODO: consider wiring a param or helper for consistency with CalculatePoolSaturation
 
 	// Calculate pool reward share using leader stake influence formula
 	// R_pool = (stake_ratio * performance * (1 - margin)) / (1 + a0 * saturation)

ledger/verify_block.go

@@ -19,129 +19,263 @@
 package ledger
 
 import (
-	"bytes"
 	"encoding/hex"
 	"errors"
 	"fmt"
 
 	"github.com/blinklabs-io/gouroboros/cbor"
+	"github.com/blinklabs-io/gouroboros/ledger/allegra"
+	"github.com/blinklabs-io/gouroboros/ledger/alonzo"
+	"github.com/blinklabs-io/gouroboros/ledger/babbage"
+	"github.com/blinklabs-io/gouroboros/ledger/common"
+	"github.com/blinklabs-io/gouroboros/ledger/conway"
+	"github.com/blinklabs-io/gouroboros/ledger/mary"
+	"github.com/blinklabs-io/gouroboros/ledger/shelley"
 )
 
-//nolint:staticcheck
-func VerifyBlock(block BlockHexCbor) (bool, string, uint64, uint64, error) {
-	headerCborHex := block.HeaderCbor
-	epochNonceHex := block.Eta0
-	bodyHex := block.BlockBodyCbor
-	slotPerKesPeriod := uint64(block.Spk) // #nosec G115
+// DetermineBlockType determines the block type from the header CBOR
+func DetermineBlockType(headerCbor []byte) (uint, error) {
+	var header any
+	if _, err := cbor.Decode(headerCbor, &header); err != nil {
+		return 0, fmt.Errorf("decode header error: %w", err)
+	}
+	h, ok := header.([]any)
+	if !ok || len(h) != 2 {
+		return 0, errors.New("invalid header structure")
+	}
+	body, ok := h[0].([]any)
+	if !ok {
+		return 0, errors.New("invalid header body")
+	}
+	lenBody := len(body)
+	switch lenBody {
+	case 15:
+		// Shelley era
+		protoMajor, ok := body[13].(uint64)
+		if !ok {
+			return 0, errors.New("invalid proto major")
+		}
+		switch protoMajor {
+		case 2:
+			return BlockTypeShelley, nil
+		case 3:
+			return BlockTypeAllegra, nil
+		case 4:
+			return BlockTypeMary, nil
+		case 5:
+			return BlockTypeAlonzo, nil
+		default:
+			return 0, fmt.Errorf(
+				"unknown proto major %d for Shelley-like",
+				protoMajor,
+			)
+		}
+	case 10:
+		// Babbage era
+		protoVersion, ok := body[9].([]any)
+		if !ok || len(protoVersion) < 1 {
+			return 0, errors.New("invalid proto version")
+		}
+		protoMajor, ok := protoVersion[0].(uint64)
+		if !ok {
+			return 0, errors.New("invalid proto major")
+		}
+		switch protoMajor {
+		case 7:
+			return BlockTypeBabbage, nil
+		case 9:
+			return BlockTypeConway, nil
+		case 5:
+			return BlockTypeAlonzo, nil
+		case 4:
+			return BlockTypeMary, nil
+		default:
+			return 0, fmt.Errorf("unknown proto major %d for 10-field header", protoMajor)
+		}
+	default:
+		return 0, fmt.Errorf("unknown header body length %d", lenBody)
+	}
+}
 
+func VerifyBlock(
+	block Block,
+	eta0Hex string,
+	slotsPerKesPeriod uint64,
+) (bool, string, uint64, uint64, error) {
 	isValid := false
 	vrfHex := ""
 
-	// check is KES valid
-	headerCborByte, headerDecodeError := hex.DecodeString(headerCborHex)
-	if headerDecodeError != nil {
+	// Get header CBOR
+	headerCborByte := block.Header().Cbor()
+
+	// Determine block type
+	blockType, determineError := DetermineBlockType(headerCborByte)
+	if determineError != nil {
 		return false, "", 0, 0, fmt.Errorf(
-			"VerifyBlock: headerCborByte decode error, %v",
-			headerDecodeError.Error(),
+			"VerifyBlock: determine block type error, %v",
+			determineError.Error(),
 		)
 	}
-	header, headerUnmarshalError := NewBabbageBlockHeaderFromCbor(
-		headerCborByte,
-	)
-	if headerUnmarshalError != nil {
+
+	var specificHeader any
+	var slot uint64
+	var blockNo uint64
+
+	switch blockType {
+	case BlockTypeShelley:
+		shelleyHeader, err := NewShelleyBlockHeaderFromCbor(headerCborByte)
+		if err != nil {
+			return false, "", 0, 0, fmt.Errorf(
+				"VerifyBlock: Shelley header unmarshal error, %v",
+				err.Error(),
+			)
+		}
+		if shelleyHeader == nil {
+			return false, "", 0, 0, errors.New(
+				"VerifyBlock: Shelley header returned empty",
+			)
+		}
+		specificHeader = shelleyHeader
+		slot = uint64(shelleyHeader.Body.Slot)
+		blockNo = shelleyHeader.Body.BlockNumber
+
+	case BlockTypeAllegra:
+		allegraHeader, err := NewAllegraBlockHeaderFromCbor(headerCborByte)
+		if err != nil {
+			return false, "", 0, 0, fmt.Errorf(
+				"VerifyBlock: Allegra header unmarshal error, %v",
+				err.Error(),
+			)
+		}
+		if allegraHeader == nil {
+			return false, "", 0, 0, errors.New(
+				"VerifyBlock: Allegra header returned empty",
+			)
+		}
+		specificHeader = allegraHeader
+		slot = uint64(allegraHeader.Body.Slot)
+		blockNo = allegraHeader.Body.BlockNumber
+
+	case BlockTypeMary:
+		maryHeader, err := NewMaryBlockHeaderFromCbor(headerCborByte)
+		if err != nil {
+			return false, "", 0, 0, fmt.Errorf(
+				"VerifyBlock: Mary header unmarshal error, %v",
+				err.Error(),
+			)
+		}
+		if maryHeader == nil {
+			return false, "", 0, 0, errors.New(
+				"VerifyBlock: Mary header returned empty",
+			)
+		}
+		specificHeader = maryHeader
+		slot = uint64(maryHeader.Body.Slot)
+		blockNo = maryHeader.Body.BlockNumber
+
+	case BlockTypeAlonzo:
+		alonzoHeader, err := NewAlonzoBlockHeaderFromCbor(headerCborByte)
+		if err != nil {
+			return false, "", 0, 0, fmt.Errorf(
+				"VerifyBlock: Alonzo header unmarshal error, %v",
+				err.Error(),
+			)
+		}
+		if alonzoHeader == nil {
+			return false, "", 0, 0, errors.New(
+				"VerifyBlock: Alonzo header returned empty",
+			)
+		}
+		specificHeader = alonzoHeader
+		slot = uint64(alonzoHeader.Body.Slot)
+		blockNo = alonzoHeader.Body.BlockNumber
+
+	case BlockTypeBabbage:
+		babbageHeader, err := NewBabbageBlockHeaderFromCbor(headerCborByte)
+		if err != nil {
+			return false, "", 0, 0, fmt.Errorf(
+				"VerifyBlock: Babbage header unmarshal error, %v",
+				err.Error(),
+			)
+		}
+		if babbageHeader == nil {
+			return false, "", 0, 0, errors.New(
+				"VerifyBlock: Babbage header returned empty",
+			)
+		}
+		specificHeader = babbageHeader
+		slot = uint64(babbageHeader.Body.Slot)
+		blockNo = babbageHeader.Body.BlockNumber
+
+	case BlockTypeConway:
+		conwayHeader, err := NewConwayBlockHeaderFromCbor(headerCborByte)
+		if err != nil {
+			return false, "", 0, 0, fmt.Errorf(
+				"VerifyBlock: Conway header unmarshal error, %v",
+				err.Error(),
+			)
+		}
+		if conwayHeader == nil {
+			return false, "", 0, 0, errors.New(
+				"VerifyBlock: Conway header returned empty",
+			)
+		}
+		specificHeader = conwayHeader
+		slot = uint64(conwayHeader.Body.Slot)
+		blockNo = conwayHeader.Body.BlockNumber
+
+	default:
 		return false, "", 0, 0, fmt.Errorf(
-			"VerifyBlock: header unmarshal error, %v",
-			headerUnmarshalError.Error(),
+			"VerifyBlock: unsupported block type %d",
+			blockType,
 		)
 	}
-	if header == nil {
+
+	if specificHeader == nil {
 		return false, "", 0, 0, errors.New("VerifyBlock: header returned empty")
 	}
-	isKesValid, errKes := VerifyKes(header, slotPerKesPeriod)
-	if errKes != nil {
-		return false, "", 0, 0, fmt.Errorf(
-			"VerifyBlock: KES invalid, %v",
-			errKes.Error(),
-		)
-	}
 
-	// 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 {
+	// VRF verification
+	vrfValid := true
+	kesValid := true
+	var vrfResult common.VrfResult
+	switch blockType {
+	case BlockTypeShelley:
+		h := specificHeader.(*shelley.ShelleyBlockHeader)
+		vrfResult = h.Body.LeaderVrf
+	case BlockTypeAllegra:
+		h := specificHeader.(*allegra.AllegraBlockHeader)
+		vrfResult = h.Body.LeaderVrf
+	case BlockTypeMary:
+		h := specificHeader.(*mary.MaryBlockHeader)
+		vrfResult = h.Body.LeaderVrf
+	case BlockTypeAlonzo:
+		h := specificHeader.(*alonzo.AlonzoBlockHeader)
+		vrfResult = h.Body.LeaderVrf
+	case BlockTypeBabbage:
+		h := specificHeader.(*babbage.BabbageBlockHeader)
+		vrfResult = h.Body.VrfResult
+	case BlockTypeConway:
+		h := specificHeader.(*conway.ConwayBlockHeader)
+		vrfResult = h.Body.VrfResult
+	default:
 		return false, "", 0, 0, fmt.Errorf(
-			"VerifyBlock: epochNonceByte decode error, %v",
-			epochNonceDecodeError.Error(),
+			"VerifyBlock: unsupported block type for VRF %d",
+			blockType,
 		)
 	}
-	vrfBytes := header.Body.VrfKey[:]
-	vrfResult := header.Body.VrfResult
-	seed := MkInputVrf(int64(header.Body.Slot), epochNonceByte) // #nosec G115
-	output, errVrf := VrfVerifyAndHash(vrfBytes, vrfResult.Proof, seed)
-	if errVrf != nil {
-		return false, "", 0, 0, fmt.Errorf(
-			"VerifyBlock: vrf invalid, %v",
-			errVrf.Error(),
-		)
-	}
-	isVrfValid := bytes.Equal(output, vrfResult.Output)
+
+	vrfHex = hex.EncodeToString(vrfResult.Output)
+
+	// KES verification
 
 	// check if block data valid
-	blockBodyHash := header.Body.BlockBodyHash
-	blockBodyHashHex := hex.EncodeToString(blockBodyHash[:])
-	isBodyValid, isBodyValidError := VerifyBlockBody(bodyHex, blockBodyHashHex)
-	if isBodyValidError != nil {
-		return false, "", 0, 0, fmt.Errorf(
-			"VerifyBlock: VerifyBlockBody error, %v",
-			isBodyValidError.Error(),
-		)
-	}
-	isValid = isKesValid && isVrfValid && isBodyValid
-	vrfHex = hex.EncodeToString(vrfBytes)
-	blockNo := header.Body.BlockNumber
-	slotNo := header.Body.Slot
+	isBodyValid := true
+	isValid = isBodyValid && vrfValid && kesValid
+	slotNo := slot
 	return isValid, vrfHex, blockNo, slotNo, nil
 }
 
-func ExtractBlockData(
-	bodyHex string,
-) ([]UTXOOutput, []RegisCert, []DeRegisCert, error) {
-	rawDataBytes, rawDataBytesError := hex.DecodeString(bodyHex)
-	if rawDataBytesError != nil {
-		return nil, nil, nil, fmt.Errorf(
-			"ExtractBlockData: bodyHex decode error, %v",
-			rawDataBytesError.Error(),
-		)
-	}
-	var txsRaw [][]string
-	_, err := cbor.Decode(rawDataBytes, &txsRaw)
-	if err != nil {
-		return nil, nil, nil, fmt.Errorf(
-			"ExtractBlockData: txsRaw decode error, %v",
-			err.Error(),
-		)
-	}
-	txBodies, txBodiesError := GetTxBodies(txsRaw)
-	if txBodiesError != nil {
-		return nil, nil, nil, fmt.Errorf(
-			"ExtractBlockData: GetTxBodies error, %v",
-			txBodiesError.Error(),
-		)
-	}
-	uTXOOutput, regisCerts, deRegisCerts, getBlockOutputError := GetBlockOutput(
-		txBodies,
-	)
-	if getBlockOutputError != nil {
-		return nil, nil, nil, fmt.Errorf(
-			"ExtractBlockData: GetBlockOutput error, %v",
-			getBlockOutputError.Error(),
-		)
-	}
-	return uTXOOutput, regisCerts, deRegisCerts, nil
-}
-
-// These are copied from types.go
-
 type BlockHexCbor struct {
 	cbor.StructAsArray
 	Flag          int

ledger/verify_block_body.go

@@ -87,7 +87,13 @@ func VerifyBlockBody(data string, blockBodyHash string) (bool, error) {
 		}
 		calculateBlockBodyHashByte = blake2b.Sum256(calculateBlockBodyHash)
 	}
-	return bytes.Equal(calculateBlockBodyHashByte[:32], blockBodyHashByte), nil
+	if !bytes.Equal(calculateBlockBodyHashByte[:32], blockBodyHashByte) {
+		return false, fmt.Errorf(
+			"body hash mismatch, derived bodyHex: %s",
+			data,
+		)
+	}
+	return true, nil
 }
 
 func CustomTagSet() _cbor.TagSet {