diff --git a/connection_test.go b/connection_test.go
index f904b6ad..412b72d2 100644
--- a/connection_test.go
+++ b/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"
 )
 
diff --git a/ledger/allegra/allegra.go b/ledger/allegra/allegra.go
index b22b2233..14490989 100644
--- a/ledger/allegra/allegra.go
+++ b/ledger/allegra/allegra.go
@@ -136,6 +136,10 @@ func (b *AllegraBlock) Utxorpc() (*utxorpc.Block, error) {
 	return block, nil
 }
 
+func (b *AllegraBlock) BlockBodyHash() common.Blake2b256 {
+	return b.Header().BlockBodyHash()
+}
+
 type AllegraBlockHeader struct {
 	shelley.ShelleyBlockHeader
 }
diff --git a/ledger/alonzo/alonzo.go b/ledger/alonzo/alonzo.go
index 0c3e8b88..28b7671d 100644
--- a/ledger/alonzo/alonzo.go
+++ b/ledger/alonzo/alonzo.go
@@ -189,6 +189,10 @@ func (b *AlonzoBlock) Utxorpc() (*utxorpc.Block, error) {
 	return block, nil
 }
 
+func (b *AlonzoBlock) BlockBodyHash() common.Blake2b256 {
+	return b.Header().BlockBodyHash()
+}
+
 type AlonzoBlockHeader struct {
 	shelley.ShelleyBlockHeader
 }
diff --git a/ledger/babbage/babbage.go b/ledger/babbage/babbage.go
index 8b666787..1c7bf25b 100644
--- a/ledger/babbage/babbage.go
+++ b/ledger/babbage/babbage.go
@@ -149,6 +149,10 @@ func (b *BabbageBlock) Utxorpc() (*utxorpc.Block, error) {
 	return block, nil
 }
 
+func (b *BabbageBlock) BlockBodyHash() common.Blake2b256 {
+	return b.Header().BlockBodyHash()
+}
+
 type BabbageBlockHeader struct {
 	cbor.StructAsArray
 	cbor.DecodeStoreCbor
@@ -228,6 +232,10 @@ func (h *BabbageBlockHeader) Era() common.Era {
 	return EraBabbage
 }
 
+func (h *BabbageBlockHeader) BlockBodyHash() common.Blake2b256 {
+	return h.Body.BlockBodyHash
+}
+
 type BabbageTransactionPparamUpdate struct {
 	cbor.StructAsArray
 	ProtocolParamUpdates map[common.Blake2b224]BabbageProtocolParameterUpdate
diff --git a/ledger/byron/byron.go b/ledger/byron/byron.go
index c07a558b..795312e5 100644
--- a/ledger/byron/byron.go
+++ b/ledger/byron/byron.go
@@ -136,6 +136,19 @@ func (h *ByronMainBlockHeader) Era() common.Era {
 	return EraByron
 }
 
+func (h *ByronMainBlockHeader) BlockBodyHash() common.Blake2b256 {
+	// BodyProof is the hash of the block body, encoded as bytes in CBOR
+	if bodyProofBytes, ok := h.BodyProof.([]byte); ok &&
+		len(bodyProofBytes) == common.Blake2b256Size {
+		var hash common.Blake2b256
+		copy(hash[:], bodyProofBytes)
+		return hash
+	}
+	// Return zero hash instead of panicking to prevent DoS in verification path
+	// This will cause validation to fail gracefully rather than crash
+	return common.Blake2b256{}
+}
+
 type ByronTransaction struct {
 	cbor.StructAsArray
 	cbor.DecodeStoreCbor
@@ -731,6 +744,19 @@ func (h *ByronEpochBoundaryBlockHeader) Era() common.Era {
 	return EraByron
 }
 
+func (h *ByronEpochBoundaryBlockHeader) BlockBodyHash() common.Blake2b256 {
+	// BodyProof is the hash of the block body, encoded as bytes in CBOR
+	if bodyProofBytes, ok := h.BodyProof.([]byte); ok &&
+		len(bodyProofBytes) == common.Blake2b256Size {
+		var hash common.Blake2b256
+		copy(hash[:], bodyProofBytes)
+		return hash
+	}
+	// Return zero hash instead of panicking to prevent DoS in verification path
+	// This will cause validation to fail gracefully rather than crash
+	return common.Blake2b256{}
+}
+
 type ByronMainBlock struct {
 	cbor.StructAsArray
 	cbor.DecodeStoreCbor
@@ -798,6 +824,10 @@ func (b *ByronMainBlock) Utxorpc() (*utxorpc.Block, error) {
 	return &utxorpc.Block{}, nil
 }
 
+func (b *ByronMainBlock) BlockBodyHash() common.Blake2b256 {
+	return b.Header().BlockBodyHash()
+}
+
 type ByronEpochBoundaryBlock struct {
 	cbor.StructAsArray
 	cbor.DecodeStoreCbor
@@ -863,6 +893,10 @@ func (b *ByronEpochBoundaryBlock) Utxorpc() (*utxorpc.Block, error) {
 	return &utxorpc.Block{}, nil
 }
 
+func (b *ByronEpochBoundaryBlock) BlockBodyHash() common.Blake2b256 {
+	return b.Header().BlockBodyHash()
+}
+
 func NewByronEpochBoundaryBlockFromCbor(
 	data []byte,
 ) (*ByronEpochBoundaryBlock, error) {
diff --git a/ledger/common/block.go b/ledger/common/block.go
index 65c3c36e..63c39f7c 100644
--- a/ledger/common/block.go
+++ b/ledger/common/block.go
@@ -19,4 +19,5 @@ type BlockHeader interface {
 	BlockBodySize() uint64
 	Era() Era
 	Cbor() []byte
+	BlockBodyHash() Blake2b256
 }
diff --git a/ledger/common/rewards.go b/ledger/common/rewards.go
index 2d6da6ff..a856b22d 100644
--- a/ledger/common/rewards.go
+++ b/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)
diff --git a/ledger/conway/conway.go b/ledger/conway/conway.go
index 55662be2..8a438b1b 100644
--- a/ledger/conway/conway.go
+++ b/ledger/conway/conway.go
@@ -149,6 +149,10 @@ func (b *ConwayBlock) Utxorpc() (*utxorpc.Block, error) {
 	return block, nil
 }
 
+func (b *ConwayBlock) BlockBodyHash() common.Blake2b256 {
+	return b.Header().BlockBodyHash()
+}
+
 type ConwayBlockHeader struct {
 	babbage.BabbageBlockHeader
 }
diff --git a/ledger/leios/leios.go b/ledger/leios/leios.go
index 0ce8a297..6cabec65 100644
--- a/ledger/leios/leios.go
+++ b/ledger/leios/leios.go
@@ -14,6 +14,10 @@
 
 package leios
 
+// NOTE: Leios is still in development and experimental.
+// Block structures and validation logic may change as the protocol evolves.
+// It is acceptable to skip validation on Leios blocks, but tests must be maintained.
+
 import (
 	"fmt"
 
@@ -67,11 +71,14 @@ type LeiosEndorserBlockBody struct {
 }
 
 func (b *LeiosEndorserBlockBody) BlockBodyHash() common.Blake2b256 {
+	// NOTE: Leios is still in development and experimental.
+	// This implementation may change as the protocol evolves.
 	// Compute hash of the block body content
 	bodyCbor, err := cbor.Encode(b)
 	if err != nil {
-		// Return zero hash on encoding error
-		return common.Blake2b256{}
+		// CBOR encoding failure indicates a serious structural issue
+		// Panic loudly during development to catch problems early
+		panic(fmt.Sprintf("Leios block body CBOR encoding failed: %v", err))
 	}
 	return common.Blake2b256Hash(bodyCbor)
 }
@@ -126,6 +133,10 @@ func (h *LeiosBlockHeader) Era() common.Era {
 	return EraLeios
 }
 
+func (h *LeiosBlockHeader) BlockBodyHash() common.Blake2b256 {
+	return h.Body.BlockBodyHash
+}
+
 func (LeiosEndorserBlock) Type() int {
 	return BlockTypeLeiosEndorser
 }
@@ -182,7 +193,8 @@ func (b *LeiosEndorserBlock) Utxorpc() (*utxorpc.Block, error) {
 
 func (b *LeiosEndorserBlock) BlockBodyHash() common.Blake2b256 {
 	if b.Body == nil {
-		return common.Blake2b256{}
+		// Panic on nil body to distinguish from empty body
+		panic("LeiosEndorserBlock has nil body")
 	}
 	return b.Body.BlockBodyHash()
 }
@@ -273,6 +285,13 @@ func (b *LeiosRankingBlock) Utxorpc() (*utxorpc.Block, error) {
 	return block, nil
 }
 
+func (b *LeiosRankingBlock) BlockBodyHash() common.Blake2b256 {
+	if b.BlockHeader == nil {
+		panic("LeiosRankingBlock has nil BlockHeader")
+	}
+	return b.Header().BlockBodyHash()
+}
+
 func NewLeiosEndorserBlockFromCbor(data []byte) (*LeiosEndorserBlock, error) {
 	var leiosEndorserBlock LeiosEndorserBlock
 	if _, err := cbor.Decode(data, &leiosEndorserBlock); err != nil {
diff --git a/ledger/mary/mary.go b/ledger/mary/mary.go
index e36a582d..df546123 100644
--- a/ledger/mary/mary.go
+++ b/ledger/mary/mary.go
@@ -150,6 +150,10 @@ func (b *MaryBlock) Utxorpc() (*utxorpc.Block, error) {
 	return block, nil
 }
 
+func (b *MaryBlock) BlockBodyHash() common.Blake2b256 {
+	return b.Header().BlockBodyHash()
+}
+
 type MaryBlockHeader struct {
 	shelley.ShelleyBlockHeader
 }
diff --git a/ledger/shelley/shelley.go b/ledger/shelley/shelley.go
index 355ae2f5..365d6c36 100644
--- a/ledger/shelley/shelley.go
+++ b/ledger/shelley/shelley.go
@@ -140,6 +140,10 @@ func (b *ShelleyBlock) Utxorpc() (*utxorpc.Block, error) {
 	return block, nil
 }
 
+func (b *ShelleyBlock) BlockBodyHash() common.Blake2b256 {
+	return b.Header().BlockBodyHash()
+}
+
 type ShelleyBlockHeader struct {
 	cbor.StructAsArray
 	cbor.DecodeStoreCbor
@@ -209,6 +213,10 @@ func (h *ShelleyBlockHeader) Era() common.Era {
 	return EraShelley
 }
 
+func (h *ShelleyBlockHeader) BlockBodyHash() common.Blake2b256 {
+	return h.Body.BlockBodyHash
+}
+
 type ShelleyTransactionPparamUpdate struct {
 	cbor.StructAsArray
 	ProtocolParamUpdates map[common.Blake2b224]ShelleyProtocolParameterUpdate
diff --git a/ledger/verify_block.go b/ledger/verify_block.go
index 7b967fe9..601eb8fc 100644
--- a/ledger/verify_block.go
+++ b/ledger/verify_block.go
@@ -23,124 +23,335 @@ import (
 	"encoding/hex"
 	"errors"
 	"fmt"
+	"math"
+	"os"
 
 	"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/byron"
+	"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"
+	"golang.org/x/crypto/blake2b"
 )
 
-//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
+const (
+	HeaderBodyLengthShelleyLike = 15
+	HeaderBodyLengthBabbageLike = 10
+	ProtoMajorShelley           = 2
+	ProtoMajorAllegra           = 3
+	ProtoMajorMary              = 4
+	ProtoMajorAlonzo            = 5
+	ProtoMajorBabbage           = 7
+	ProtoMajorConway            = 9
+)
+
+var allowMissingCbor = false
 
+// 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 HeaderBodyLengthShelleyLike:
+		// Shelley era
+		protoMajor, ok := body[13].(uint64)
+		if !ok {
+			return 0, errors.New("invalid proto major")
+		}
+		switch protoMajor {
+		case ProtoMajorShelley:
+			return BlockTypeShelley, nil
+		case ProtoMajorAllegra:
+			return BlockTypeAllegra, nil
+		case ProtoMajorMary:
+			return BlockTypeMary, nil
+		case ProtoMajorAlonzo:
+			return BlockTypeAlonzo, nil
+		default:
+			return 0, fmt.Errorf(
+				"unknown proto major %d for Shelley-like",
+				protoMajor,
+			)
+		}
+	case HeaderBodyLengthBabbageLike:
+		// Babbage era
+		if len(body) <= 9 {
+			return 0, errors.New(
+				"header body too short for proto version field",
+			)
+		}
+		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 ProtoMajorBabbage:
+			return BlockTypeBabbage, nil
+		case ProtoMajorConway:
+			return BlockTypeConway, nil
+		case ProtoMajorAlonzo:
+			return BlockTypeAlonzo, nil
+		case ProtoMajorMary:
+			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 {
-		return false, "", 0, 0, fmt.Errorf(
-			"VerifyBlock: headerCborByte decode error, %v",
-			headerDecodeError.Error(),
-		)
-	}
-	header, headerUnmarshalError := NewBabbageBlockHeaderFromCbor(
-		headerCborByte,
-	)
-	if headerUnmarshalError != nil {
+	// Decode eta0
+	eta0, err := hex.DecodeString(eta0Hex)
+	if err != nil {
 		return false, "", 0, 0, fmt.Errorf(
-			"VerifyBlock: header unmarshal error, %v",
-			headerUnmarshalError.Error(),
+			"VerifyBlock: eta0 decode error, %v",
+			err.Error(),
 		)
 	}
-	if header == nil {
-		return false, "", 0, 0, errors.New("VerifyBlock: header returned empty")
-	}
-	isKesValid, errKes := VerifyKes(header, slotPerKesPeriod)
-	if errKes != nil {
+
+	// Get header
+	header := block.Header()
+
+	// Extract slot and block number from header
+	slot := header.SlotNumber()
+	blockNo := header.BlockNumber()
+
+	// VRF verification
+	var vrfValid bool
+	var kesValid bool
+	var vrfResult common.VrfResult
+	var vrfKey []byte
+	switch h := block.Header().(type) {
+	case *shelley.ShelleyBlockHeader:
+		vrfResult = h.Body.LeaderVrf
+		vrfKey = h.Body.VrfKey
+	case *allegra.AllegraBlockHeader:
+		vrfResult = h.Body.LeaderVrf
+		vrfKey = h.Body.VrfKey
+	case *mary.MaryBlockHeader:
+		vrfResult = h.Body.LeaderVrf
+		vrfKey = h.Body.VrfKey
+	case *alonzo.AlonzoBlockHeader:
+		vrfResult = h.Body.LeaderVrf
+		vrfKey = h.Body.VrfKey
+	case *babbage.BabbageBlockHeader:
+		vrfResult = h.Body.VrfResult
+		vrfKey = h.Body.VrfKey
+	case *conway.ConwayBlockHeader:
+		vrfResult = h.Body.VrfResult
+		vrfKey = h.Body.VrfKey
+	default:
 		return false, "", 0, 0, fmt.Errorf(
-			"VerifyBlock: KES invalid, %v",
-			errKes.Error(),
+			"VerifyBlock: unsupported block type for VRF %T",
+			block.Header(),
 		)
 	}
 
-	// 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 {
+	// Verify VRF
+	if slot > math.MaxInt64 {
 		return false, "", 0, 0, fmt.Errorf(
-			"VerifyBlock: epochNonceByte decode error, %v",
-			epochNonceDecodeError.Error(),
+			"VerifyBlock: slot value %d exceeds maximum int64 value",
+			slot,
 		)
 	}
-	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 {
+	vrfMsg := MkInputVrf(int64(slot), eta0)
+	vrfValid, err = VerifyVrf(vrfKey, vrfResult.Proof, vrfResult.Output, vrfMsg)
+	if err != nil {
 		return false, "", 0, 0, fmt.Errorf(
-			"VerifyBlock: vrf invalid, %v",
-			errVrf.Error(),
+			"VerifyBlock: VRF verification error, %v",
+			err.Error(),
 		)
 	}
-	isVrfValid := bytes.Equal(output, vrfResult.Output)
 
-	// check if block data valid
-	blockBodyHash := header.Body.BlockBodyHash
-	blockBodyHashHex := hex.EncodeToString(blockBodyHash[:])
-	isBodyValid, isBodyValidError := VerifyBlockBody(bodyHex, blockBodyHashHex)
-	if isBodyValidError != nil {
+	vrfHex = hex.EncodeToString(vrfResult.Output)
+
+	// KES verification
+	var bodyCbor []byte
+	var signature []byte
+	var hotVkey []byte
+	var kesPeriod uint64
+	switch h := block.Header().(type) {
+	case *shelley.ShelleyBlockHeader:
+		bodyCbor, err = cbor.Encode(h.Body)
+		if err != nil {
+			return false, "", 0, 0, fmt.Errorf(
+				"VerifyBlock: failed to encode Shelley header body for KES, %w",
+				err,
+			)
+		}
+		signature = h.Signature
+		hotVkey = h.Body.OpCertHotVkey
+		kesPeriod = uint64(h.Body.OpCertKesPeriod)
+	case *allegra.AllegraBlockHeader:
+		bodyCbor, err = cbor.Encode(h.Body)
+		if err != nil {
+			return false, "", 0, 0, fmt.Errorf(
+				"VerifyBlock: failed to encode Allegra header body for KES, %w",
+				err,
+			)
+		}
+		signature = h.Signature
+		hotVkey = h.Body.OpCertHotVkey
+		kesPeriod = uint64(h.Body.OpCertKesPeriod)
+	case *mary.MaryBlockHeader:
+		bodyCbor, err = cbor.Encode(h.Body)
+		if err != nil {
+			return false, "", 0, 0, fmt.Errorf(
+				"VerifyBlock: failed to encode Mary header body for KES, %w",
+				err,
+			)
+		}
+		signature = h.Signature
+		hotVkey = h.Body.OpCertHotVkey
+		kesPeriod = uint64(h.Body.OpCertKesPeriod)
+	case *alonzo.AlonzoBlockHeader:
+		bodyCbor, err = cbor.Encode(h.Body)
+		if err != nil {
+			return false, "", 0, 0, fmt.Errorf(
+				"VerifyBlock: failed to encode Alonzo header body for KES, %w",
+				err,
+			)
+		}
+		signature = h.Signature
+		hotVkey = h.Body.OpCertHotVkey
+		kesPeriod = uint64(h.Body.OpCertKesPeriod)
+	case *babbage.BabbageBlockHeader:
+		bodyCbor, err = cbor.Encode(h.Body)
+		if err != nil {
+			return false, "", 0, 0, fmt.Errorf(
+				"VerifyBlock: failed to encode Babbage header body for KES, %w",
+				err,
+			)
+		}
+		signature = h.Signature
+		hotVkey = h.Body.OpCert.HotVkey
+		kesPeriod = uint64(h.Body.OpCert.KesPeriod)
+	case *conway.ConwayBlockHeader:
+		bodyCbor, err = cbor.Encode(h.Body)
+		if err != nil {
+			return false, "", 0, 0, fmt.Errorf(
+				"VerifyBlock: failed to encode Conway header body for KES, %w",
+				err,
+			)
+		}
+		signature = h.Signature
+		hotVkey = h.Body.OpCert.HotVkey
+		kesPeriod = uint64(h.Body.OpCert.KesPeriod)
+	default:
 		return false, "", 0, 0, fmt.Errorf(
-			"VerifyBlock: VerifyBlockBody error, %v",
-			isBodyValidError.Error(),
+			"VerifyBlock: unsupported block type for KES %T",
+			block.Header(),
 		)
 	}
-	isValid = isKesValid && isVrfValid && isBodyValid
-	vrfHex = hex.EncodeToString(vrfBytes)
-	blockNo := header.Body.BlockNumber
-	slotNo := header.Body.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)
+	kesValid, err = VerifyKesComponents(
+		bodyCbor,
+		signature,
+		hotVkey,
+		kesPeriod,
+		slot,
+		slotsPerKesPeriod,
+	)
 	if err != nil {
-		return nil, nil, nil, fmt.Errorf(
-			"ExtractBlockData: txsRaw decode error, %v",
+		return false, "", 0, 0, fmt.Errorf(
+			"VerifyBlock: KES verification 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(),
-		)
+
+	// Verify block body hash
+	expectedBodyHash := block.BlockBodyHash()
+	isBodyValid := true
+	if block.Era() != byron.EraByron {
+		rawCbor := block.Cbor()
+		if len(rawCbor) == 0 {
+			if allowMissingCbor && os.Getenv("GOUROBOROS_TEST_ALLOW_MISSING_CBOR") == "1" {
+				// Allow missing CBOR for tests only
+				isBodyValid = true
+			} else {
+				return false, "", 0, 0, errors.New(
+					"VerifyBlock: block CBOR is required for body hash verification",
+				)
+			}
+		} else {
+			var raw []cbor.RawMessage
+			if _, err := cbor.Decode(rawCbor, &raw); err != nil {
+				return false, "", 0, 0, fmt.Errorf(
+					"VerifyBlock: failed to decode block CBOR for body hash, %w",
+					err,
+				)
+			}
+			if len(raw) < 4 {
+				return false, "", 0, 0, errors.New(
+					"VerifyBlock: invalid block CBOR structure for body hash",
+				)
+			}
+			// Compute body hash as per Cardano spec: blake2b_256(hash_tx || hash_wit || hash_aux || hash_invalid)
+			emptyInvalidCbor, _ := cbor.Encode(cbor.IndefLengthList([]any{}))
+			hashInvalidDefault := blake2b.Sum256(emptyInvalidCbor)
+			var bodyHashes []byte
+			hashTx := blake2b.Sum256(raw[1])
+			bodyHashes = append(bodyHashes, hashTx[:]...)
+			hashWit := blake2b.Sum256(raw[2])
+			bodyHashes = append(bodyHashes, hashWit[:]...)
+			hashAux := blake2b.Sum256(raw[3])
+			bodyHashes = append(bodyHashes, hashAux[:]...)
+			switch block.Header().(type) {
+			case *shelley.ShelleyBlockHeader, *allegra.AllegraBlockHeader, *mary.MaryBlockHeader:
+				bodyHashes = append(bodyHashes, hashInvalidDefault[:]...)
+			case *alonzo.AlonzoBlockHeader, *babbage.BabbageBlockHeader, *conway.ConwayBlockHeader:
+				hashInvalid := blake2b.Sum256(raw[4])
+				bodyHashes = append(bodyHashes, hashInvalid[:]...)
+			default:
+				return false, "", 0, 0, fmt.Errorf(
+					"VerifyBlock: unsupported block type for body hash %T",
+					block.Header(),
+				)
+			}
+			actualBodyHash := blake2b.Sum256(bodyHashes)
+			if !bytes.Equal(actualBodyHash[:], expectedBodyHash.Bytes()) {
+				return false, "", 0, 0, errors.New(
+					"VerifyBlock: block body hash mismatch",
+				)
+			}
+		}
 	}
-	return uTXOOutput, regisCerts, deRegisCerts, nil
-}
 
-// These are copied from types.go
+	isValid = isBodyValid && vrfValid && kesValid
+	slotNo := slot
+	return isValid, vrfHex, blockNo, slotNo, nil
+}
 
 type BlockHexCbor struct {
 	cbor.StructAsArray
diff --git a/ledger/verify_block_body.go b/ledger/verify_block_body.go
index 8dc5d6b3..2a877e0e 100644
--- a/ledger/verify_block_body.go
+++ b/ledger/verify_block_body.go
@@ -20,33 +20,27 @@ package ledger
 
 import (
 	"bytes"
-	"encoding/binary"
 	"encoding/hex"
 	"fmt"
-	"math"
-	"reflect"
 	"strconv"
 
 	"github.com/blinklabs-io/gouroboros/cbor"
-	_cbor "github.com/fxamacker/cbor/v2"
+	"github.com/blinklabs-io/gouroboros/ledger/common"
 	"golang.org/x/crypto/blake2b"
 )
 
-const (
-	maxAdditionalInformationWithoutArgument = 23
-	additionalInformationWith1ByteArgument  = 24
-	additionalInformationWith2ByteArgument  = 25
-	additionalInformationWith4ByteArgument  = 26
-	additionalInformationWith8ByteArgument  = 27
-)
+func convertToAnySlice[T any](slice []T) []any {
+	result := make([]any, len(slice))
+	for i, v := range slice {
+		result[i] = v
+	}
+	return result
+}
 
 const (
 	LOVELACE_TOKEN              = "lovelace"
 	BLOCK_BODY_HASH_ZERO_TX_HEX = "29571d16f081709b3c48651860077bebf9340abb3fc7133443c54f1f5a5edcf1"
 	MAX_LIST_LENGTH_CBOR        = 23
-	CBOR_TYPE_MAP               = 0xa0
-	CBOR_TYPE_MAP_INDEF         = 0xbf
-	CBOR_BREAK_TAG              = 0xff
 )
 
 func VerifyBlockBody(data string, blockBodyHash string) (bool, error) {
@@ -87,89 +81,13 @@ func VerifyBlockBody(data string, blockBodyHash string) (bool, error) {
 		}
 		calculateBlockBodyHashByte = blake2b.Sum256(calculateBlockBodyHash)
 	}
-	return bytes.Equal(calculateBlockBodyHashByte[:32], blockBodyHashByte), nil
-}
-
-func CustomTagSet() _cbor.TagSet {
-	customTagSet := _cbor.NewTagSet()
-	tagOpts := _cbor.TagOptions{
-		EncTag: _cbor.EncTagRequired,
-		DecTag: _cbor.DecTagRequired,
-	}
-	// Wrapped CBOR
-	if err := customTagSet.Add(
-		tagOpts,
-		reflect.TypeOf(cbor.WrappedCbor{}),
-		cbor.CborTagCbor,
-	); err != nil {
-		panic(err)
-	}
-	// Rational numbers
-	if err := customTagSet.Add(
-		tagOpts,
-		reflect.TypeOf(cbor.Rat{}),
-		cbor.CborTagRational,
-	); err != nil {
-		panic(err)
-	}
-	// Sets
-	if err := customTagSet.Add(
-		tagOpts,
-		reflect.TypeOf(cbor.Set{}),
-		cbor.CborTagSet,
-	); err != nil {
-		panic(err)
-	}
-	// Maps
-	if err := customTagSet.Add(
-		tagOpts,
-		reflect.TypeOf(cbor.Map{}),
-		cbor.CborTagMap,
-	); err != nil {
-		panic(err)
-	}
-
-	return customTagSet
-}
-
-func GetEncMode() (_cbor.EncMode, error) {
-	opts := _cbor.EncOptions{
-		Sort: _cbor.SortNone,
-	}
-	customTagSet := CustomTagSet()
-	em, err := opts.EncModeWithTags(customTagSet)
-	if err != nil {
-		return nil, err
-	}
-	return em, nil
-}
-
-func EncodeCborList(data []cbor.RawMessage) ([]byte, error) {
-	// Cardano base consider list more than 23 will be ListLenIndef
-	// https://github.com/IntersectMBO/cardano-base/blob/e86a25c54389ddd0f77fdbc3f3615c57bd91d543/cardano-binary/src/Cardano/Binary/ToCBOR.hs#L708C10-L708C28
-	if len(data) <= MAX_LIST_LENGTH_CBOR {
-		return cbor.Encode(data)
-	}
-	buf := bytes.NewBuffer(nil)
-	em, err := GetEncMode()
-	if err != nil {
-		return nil, err
-	}
-	enc := em.NewEncoder(buf)
-
-	if err := enc.StartIndefiniteArray(); err != nil {
-		return nil, err
-	}
-	for _, item := range data {
-		err = enc.Encode(item)
-		if err != nil {
-			return nil, err
-		}
-	}
-	if err := enc.EndIndefinite(); err != nil {
-		return nil, err
+	if !bytes.Equal(calculateBlockBodyHashByte[:32], blockBodyHashByte) {
+		return false, fmt.Errorf(
+			"body hash mismatch, derived bodyHex: %s",
+			hex.EncodeToString(calculateBlockBodyHashByte[:]),
+		)
 	}
-	return buf.Bytes(), err
+	return true, nil
 }
 
 func EncodeCborTxSeq(data []uint) ([]byte, error) {
@@ -179,26 +97,7 @@ func EncodeCborTxSeq(data []uint) ([]byte, error) {
 	if len(data) <= MAX_LIST_LENGTH_CBOR {
 		return cbor.Encode(data)
 	}
-	buf := bytes.NewBuffer(nil)
-	em, err := GetEncMode()
-	if err != nil {
-		return nil, err
-	}
-	enc := em.NewEncoder(buf)
-
-	if err := enc.StartIndefiniteArray(); err != nil {
-		return nil, err
-	}
-	for _, item := range data {
-		err = enc.Encode(item)
-		if err != nil {
-			return nil, err
-		}
-	}
-	if err := enc.EndIndefinite(); err != nil {
-		return nil, err
-	}
-	return buf.Bytes(), err
+	return cbor.Encode(cbor.IndefLengthList(convertToAnySlice(data)))
 }
 
 type AuxData struct {
@@ -206,91 +105,33 @@ type AuxData struct {
 	data  []byte
 }
 
-// encodeHead writes CBOR head of specified type t and returns number of bytes written.
-// copy from https://github.com/fxamacker/cbor/blob/46c3919161ecd1beff1b80867e08efb37d43f27c/encode.go#L1728
-func encodeHead(e *bytes.Buffer, t byte, n uint64) int {
-	if n <= maxAdditionalInformationWithoutArgument {
-		const headSize = 1
-		e.WriteByte(t | byte(n))
-		return headSize
-	}
-
-	if n <= math.MaxUint8 {
-		const headSize = 2
-		scratch := [headSize]byte{
-			t | byte(additionalInformationWith1ByteArgument),
-			byte(n),
-		}
-		e.Write(scratch[:])
-		return headSize
-	}
-
-	if n <= math.MaxUint16 {
-		const headSize = 3
-		scratch := [headSize]byte{
-			t | byte(additionalInformationWith2ByteArgument),
-		}
-		binary.BigEndian.PutUint16(scratch[1:], uint16(n))
-		e.Write(scratch[:])
-		return headSize
-	}
-
-	if n <= math.MaxUint32 {
-		const headSize = 5
-		scratch := [headSize]byte{
-			t | byte(additionalInformationWith4ByteArgument),
-		}
-		binary.BigEndian.PutUint32(scratch[1:], uint32(n))
-		e.Write(scratch[:])
-		return headSize
-	}
-
-	const headSize = 9
-	scratch := [headSize]byte{
-		t | byte(additionalInformationWith8ByteArgument),
-	}
-	binary.BigEndian.PutUint64(scratch[1:], n)
-	e.Write(scratch[:])
-	return headSize
-}
-
 // EncodeCborMap manual build aux bytes data
-func EncodeCborMap(data []AuxData) ([]byte, error) {
+func encodeAuxData(data []AuxData) ([]byte, error) {
 	dataLen := len(data)
 	if dataLen == 0 {
 		txSeqMetadata := make(map[uint64]any)
 		return cbor.Encode(txSeqMetadata)
 	}
-	var dataBuffer bytes.Buffer
-	var dataBytes []byte
 	if dataLen <= MAX_LIST_LENGTH_CBOR {
-		encodeHead(&dataBuffer, byte(CBOR_TYPE_MAP), uint64(dataLen))
-		dataBytes = dataBuffer.Bytes()
-	} else {
-		dataBytes = []byte{
-			uint8(CBOR_TYPE_MAP_INDEF),
+		// Use definite length map
+		metadataMap := make(map[uint64]any)
+		for _, aux := range data {
+			metadataMap[aux.index] = aux.data
 		}
+		return cbor.Encode(metadataMap)
 	}
-
+	// Use indefinite length map
+	metadataMap := make(map[any]any)
 	for _, aux := range data {
-		dataIndex := aux.index
-		dataValue := aux.data
-		indexBytes, _ := cbor.Encode(dataIndex)
-		dataBytes = append(dataBytes, indexBytes...)
-		dataBytes = append(dataBytes, dataValue...)
+		metadataMap[aux.index] = aux.data
 	}
-	if dataLen > MAX_LIST_LENGTH_CBOR {
-		dataBytes = append(dataBytes, CBOR_BREAK_TAG)
-	}
-
-	return dataBytes, nil
+	return cbor.Encode(cbor.IndefLengthMap(metadataMap))
 }
 
 func CalculateBlockBodyHash(txsRaw [][]string) ([]byte, error) {
 	txSeqBody := make([]cbor.RawMessage, 0)
 	txSeqWit := make([]cbor.RawMessage, 0)
 	auxRawData := make([]AuxData, 0)
-	txSeqNonValid := make([]uint, 0)
 	for index, tx := range txsRaw {
 		if len(tx) != 3 {
 			return nil, fmt.Errorf(
@@ -340,7 +181,9 @@ func CalculateBlockBodyHash(txsRaw [][]string) ([]byte, error) {
 		}
 		// TODO: should form nonValid TX here
 	}
-	txSeqBodyBytes, txSeqBodyBytesError := EncodeCborList(txSeqBody)
+	txSeqBodyBytes, txSeqBodyBytesError := cbor.Encode(
+		cbor.IndefLengthList(convertToAnySlice(txSeqBody)),
+	)
 	if txSeqBodyBytesError != nil {
 		return nil, fmt.Errorf(
 			"CalculateBlockBodyHash: encode txSeqBody error, %v",
@@ -351,7 +194,9 @@ func CalculateBlockBodyHash(txsRaw [][]string) ([]byte, error) {
 	txSeqBodySum32Bytes := blake2b.Sum256(txSeqBodyBytes)
 	txSeqBodySumBytes := txSeqBodySum32Bytes[:]
 
-	txSeqWitsBytes, txSeqWitsBytesError := EncodeCborList(txSeqWit)
+	txSeqWitsBytes, txSeqWitsBytesError := cbor.Encode(
+		cbor.IndefLengthList(convertToAnySlice(txSeqWit)),
+	)
 	if txSeqWitsBytesError != nil {
 		return nil, fmt.Errorf(
 			"CalculateBlockBodyHash: encode txSeqWit error, %v",
@@ -361,7 +206,7 @@ func CalculateBlockBodyHash(txsRaw [][]string) ([]byte, error) {
 	txSeqWitsSum32Bytes := blake2b.Sum256(txSeqWitsBytes)
 	txSeqWitsSumBytes := txSeqWitsSum32Bytes[:]
 
-	txSeqMetadataBytes, txSeqMetadataBytesError := EncodeCborMap(auxRawData)
+	txSeqMetadataBytes, txSeqMetadataBytesError := encodeAuxData(auxRawData)
 	if txSeqMetadataBytesError != nil {
 		return nil, fmt.Errorf(
 			"CalculateBlockBodyHash: encode txSeqMetadata error, %v",
@@ -371,8 +216,9 @@ func CalculateBlockBodyHash(txsRaw [][]string) ([]byte, error) {
 	txSeqMetadataSum32Bytes := blake2b.Sum256(txSeqMetadataBytes)
 	txSeqMetadataSumBytes := txSeqMetadataSum32Bytes[:]
 
-	txSeqNonValidBytes, txSeqNonValidBytesError := EncodeCborTxSeq(
-		txSeqNonValid,
+	// txSeqNonValid is always empty, so we encode an empty list
+	txSeqNonValidBytes, txSeqNonValidBytesError := cbor.Encode(
+		cbor.IndefLengthList([]any{}),
 	)
 	if txSeqNonValidBytesError != nil {
 		return nil, fmt.Errorf(
@@ -421,10 +267,10 @@ func GetTxBodies(txsRaw [][]string) ([]BabbageTransactionBody, error) {
 
 func GetBlockOutput(
 	txBodies []BabbageTransactionBody,
-) ([]UTXOOutput, []RegisCert, []DeRegisCert, error) {
+) ([]UTXOOutput, []common.PoolRegistrationCertificate, []common.PoolRetirementCertificate, error) {
 	var outputs []UTXOOutput
-	var regisCerts []RegisCert
-	var deRegisCerts []DeRegisCert
+	var regisCerts []common.PoolRegistrationCertificate
+	var deRegisCerts []common.PoolRetirementCertificate
 	for txIndex, tx := range txBodies {
 		txId := tx.Id().String()
 		txOutputs := tx.Outputs()
@@ -459,23 +305,11 @@ func GetBlockOutput(
 		for _, cert := range tx.Certificates() {
 			switch v := cert.(type) {
 			case *PoolRegistrationCertificate:
-				poolId := NewBlake2b224(v.Operator[:]).String()
-				vrfKeyHashHex := hex.EncodeToString(v.VrfKeyHash[:])
-				regisCerts = append(regisCerts, RegisCert{
-					RegisPoolId:  poolId,
-					RegisPoolVrf: vrfKeyHashHex,
-					TxIndex:      txIndex,
-				})
+				regisCerts = append(regisCerts, *v)
 
 			case *PoolRetirementCertificate:
 				// pool_retirement
-				poolId := NewBlake2b224(v.PoolKeyHash[:]).String()
-				retireEpoch := v.Epoch
-				deRegisCerts = append(deRegisCerts, DeRegisCert{
-					DeRegisPoolId: poolId,
-					DeRegisEpoch:  strconv.FormatUint(retireEpoch, 10),
-					TxIndex:       txIndex,
-				})
+				deRegisCerts = append(deRegisCerts, *v)
 			}
 		}
 	}
@@ -525,37 +359,25 @@ type UTXOOutput struct {
 	DatumHex    string
 }
 
-type RegisCert struct {
-	_            struct{} `cbor:",toarray"`
-	Flag         int
-	RegisPoolId  string
-	RegisPoolVrf string
-	TxIndex      int
-}
-
-type DeRegisCert struct {
-	_             struct{} `cbor:",toarray"`
-	Flag          int
-	DeRegisPoolId string
-	DeRegisEpoch  string
-	TxIndex       int
-}
-
-func GetListRegisCertPoolId(regisCerts []RegisCert) []string {
+func GetListRegisCertPoolId(
+	regisCerts []common.PoolRegistrationCertificate,
+) []string {
 	poolId := make([]string, 0)
 	if len(regisCerts) > 0 {
 		for _, cert := range regisCerts {
-			poolId = append(poolId, cert.RegisPoolId)
+			poolId = append(poolId, NewBlake2b224(cert.Operator[:]).String())
 		}
 	}
 	return poolId
 }
 
-func GetListUnregisCertPoolId(deRegisCerts []DeRegisCert) []string {
+func GetListUnregisCertPoolId(
+	deRegisCerts []common.PoolRetirementCertificate,
+) []string {
 	poolId := make([]string, 0)
 	if len(deRegisCerts) > 0 {
 		for _, cert := range deRegisCerts {
-			poolId = append(poolId, cert.DeRegisPoolId)
+			poolId = append(poolId, NewBlake2b224(cert.PoolKeyHash[:]).String())
 		}
 	}
 	return poolId
diff --git a/ledger/verify_block_test.go b/ledger/verify_block_test.go
index 83aa8b6e..8c4a5d6e 100644
--- a/ledger/verify_block_test.go
+++ b/ledger/verify_block_test.go
@@ -1,10 +1,64 @@
 package ledger
 
 import (
+	"encoding/hex"
+	"os"
+	"strings"
 	"testing"
+
+	"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/conway"
+	"github.com/blinklabs-io/gouroboros/ledger/mary"
+	"github.com/blinklabs-io/gouroboros/ledger/shelley"
 )
 
+func init() {
+	allowMissingCbor = true
+}
+
+// decodeTxBodyBytes extracts transaction body bytes from either []byte or hex string
+func decodeTxBodyBytes(t *testing.T, v interface{}) []byte {
+	t.Helper()
+	switch b := v.(type) {
+	case []byte:
+		return b
+	case string:
+		txBodyBytes, err := hex.DecodeString(b)
+		if err != nil {
+			t.Fatalf("failed to hex decode transaction body string: %v", err)
+		}
+		return txBodyBytes
+	default:
+		t.Fatalf("unexpected type for tx body: %T", v)
+		return nil
+	}
+}
+
+// decodeTxBodies decodes transaction bodies for a specific era
+func decodeTxBodies[T any](t *testing.T, txs []interface{}, label string) []T {
+	t.Helper()
+	bodies := make([]T, len(txs))
+	for i, tx := range txs {
+		txArray, ok := tx.([]interface{})
+		if !ok {
+			t.Fatalf("unexpected %s tx element type %T", label, tx)
+		}
+		txBodyBytes := decodeTxBodyBytes(t, txArray[0])
+		if _, err := cbor.Decode(txBodyBytes, &bodies[i]); err != nil {
+			t.Fatalf("failed to decode %s transaction body %d: %v", label, i, err)
+		}
+	}
+	return bodies
+}
+
 func TestVerifyBlockBody(t *testing.T) {
+	// Allow missing CBOR for tests
+	os.Setenv("GOUROBOROS_TEST_ALLOW_MISSING_CBOR", "1")
+	defer os.Unsetenv("GOUROBOROS_TEST_ALLOW_MISSING_CBOR")
+
 	testCases := []struct {
 		name          string
 		blockHexCbor  BlockHexCbor
@@ -45,15 +99,158 @@ func TestVerifyBlockBody(t *testing.T) {
 				BlockBodyCbor: "838379047061633030383138323538323033663565366537363039353633646337366461323934333064636131393963343631616634363963373530633130303938613065623962653161623435303761303030643831383235383230633566373064353535663662643730363366353663313532623133323363306566343562666131303764653065636563316431303835623232653036383436623030313238323832353832303130323936633831656235326237386630346430613165353839653831656132306163343835633230626361623064653836343830356166343065326664653830313832353832303639376238643735646332373661383538373465383436343831373862663565353836386264633535646162316132333861313664383434383561376562616530303031383238323538333930313765613939336666613538393664353139663030323833376238393836356262346164313038393534373138396631303762333434633031363332323462623561346266653932353933663364636633623764306562626631613866663262633634613263623366393365643934613138323161303037326561306461313538316338646232363963336563363330653036616532396637346263333965646431663837633831396631303536323036653837396131636436316131346334343661363536343464363936333732366635353533343431613363363766323965383235383339303137656139393366666135383936643531396630303238333762383938363562623461643130383935343731383966313037623334346330313633323234626235613462666539323539336633646366336237643065626266316138666632626336346132636233663933656439346131383231613030313138663332613135383163306466666431643666363764663664303836623733653364396134353736643639376163633335386135376233633338383262316266303561313437373134393731353635313531343130313130383235383339303130623461656261373536366135333131316266613766636636613034643437653762333762666331616135366361323437353434623861306235616639616537633836366539393464653266343136363136363034383964303063636234643833666433316466386433376639363862316133623935613362333131316130303035323634643032316130303033366564653033316130376232346639323038316130376232343838613065383135383163373731643561323861393962396566613431396433323366303536303565376438396364663232393730363137666532303639623363323430623538323039613532376630653137353432343939633232616161373762666663613866303862303962366566613861653332326365626463356237343533653563663861303735383230633561326538666535656163363362313039653733353239353637623430613661653062393461653430666134343630346164303364643965663235353931347901c061323030383238323538323036353366336539623466653434306664666263336237373931386664666563643936663030643236626139303331306631646536383966386135396134653730353834303434663330383235366165363730336437633636313365653236353931336430393463303931666235346332313464313132336362316463623663343734623064363434333731303637396363333037653238323935376232663661396530383734643266616239303535656437313262646262343032643333663035353035383235383230626431656566343761336465613432646164303064646534636466663261333465343438653065633564343666623132303332306566633664353132356533633538343061303266623436316532653937353431393139633931366334343532343766653039336333393766306335373131663332393537333265393635393763383735623565633536393462363332383035313837333739313838366130626334373130643332373632303833353634333565616239643961373338353761376430353035383138343030303064383765383038323161303030356335303731613038356632323665787e6439303130336131303061313139303261326131363336643733363738323737343137383666336132303433366336663733363536343230363237393230353037323666373436663633366636633737353236353631373336663665336132303534373236313634363532303433366636643730366336353734363536348378b461343030383138323538323035333339346564383766393739316633376231383836633236646562646663326536623233653634393762333431663263313934363634643634346338383965303030313831383235383164363164663535613333393765653265373738343538386166616162383635346663313732383630646263636338643630393634663161386537643161303334616464633530323161303030323932333430333161303762323566666178d0613130303831383235383230303463623932343733626434646438653533613864653665626639316331306437633766626636613139666164393935303964666133613963303663643631643538343034396334386337396634323934323134336630313733393735646330663732323263623266373666633166383037663732653766643638613137333831383764326639663738343035626365356663323764366562313062613136313561323164616264623737313037373636623033616265373064646434383338386530666083790ac26137303038333832353832306134666130636166356435663765343564646539356263346361323861386434353430316565663735376336653066373634626166636463383733383835396330313832353832306134666130636166356435663765343564646539356263346361323861386434353430316565663735376336653066373634626166636463383733383835396330323832353832306262393037653439303435303538353262653266663936393532376265643161653731636335626262323662303366653165363535343230623066386336363530303031383338323538333930313232313436346261366261366339303362396339343332633330306433623731323563663139396638366430346233306438353934353037376662636530653232353637363035363165633837626336353434376137666334666139626432346438626337336565663133626265333538323161303031616464363561313538316332396432323263653736333435356533643761303961363635636535353466303061633839643265393961316138336432363731373063366131343334643439346531613031633764333830383235383339303161646231626636613531623230666631623834353037323665663338393162623065313533643562663437373833333735653231333461666264366130393663626261356532353939343637393865393438343033653264326233643965613838613132656538653761653934343937316230303030303031656533663538383830383235383339303161646231626636613531623230666631623834353037323665663338393162623065313533643562663437373833333735653231333461666264366130393663626261356532353939343637393865393438343033653264326233643965613838613132656538653761653934343937383231613030343934333363623435383163313333666163396531353331393434323865623039313962653339383337623432623965393737666337323938663366663162373665663961313435353035353434343735393162303030303134363661633630363234613538316331363061383830643966633435333830373337636237653537666638353937363332333061616232386233656636613834303037626663636131343434643439353234313161323565303266636435383163323964323232636537363334353565336437613039613636356365353534663030616338396432653939613161383364323637313730633661313433346434393465316230303030313431663863616232303933353831633264393261663630656534323962636532333864336664396632353331623435343537333031643734646164316263663366396431646361613134333536346534643162303030303030303139613265353161343538316334363233616233313162376439383264386432366663626531613934333963613536363631616166636463643864386130656633316664366131343634373532343534353465353331623030303030303064346636663763363335383163373234613331643134323137343463616333626231643534376161363932623433353137643635316334366536306130636631663730656361313434343434663434346631613032353139326436353831633961316466653733333434303333653730646561623863356332386330306636326230393238313466623134353831656333613364353136613134383030313464663130343334663434343531623030303330353939623963343261346435383163396162663061666432663233366131396632383432643530326430343530636263643963373966313233613937303866393666643962393661313434343534653433353331623030303030303035363039653735376435383163396634353265323338303464663330343062333532623437383033393335376235303661643362353064326365306437636264356638303661313433343335343536313932626431353831636131636530343134643739623034306639383666336263643138376137353633666432363636323339306465636536623132323632623532613134623436346334353533343832303534346634623435346531623030326362316637376161353538396335383163626633653139313932646137376466616463376339303635393434653530636137653161343339643930383333653361653538623732306161313435343434313465356134663161333831613934633535383163626661393335343836326533346632646434313763393036386139333637623533306431613730346130663564633431343638633430326361313435353035323466343334623161373131363934623835383163636139343263623862623564316566373530373636646564333535663332303838303533393131316631306566613262316134373866663961313433353234313437316130303062623561303538316363633864316230323633353330323261626266636332653165373131353966396533303864396336653930356163316462323463376662366131343735303631373236393632373537333162303030303032383264313064323132313538316363653562396530663861383832353562363566326534643036356336653731366539666139613861383664666238363432336464316163306131343434343439346534373162303030303030613138343961633732353538316365613032633939633036363838393164366237636463343965303735636264646639636435623839343034653561386138653564373031366131343935333463346635303230343336663639366531613030393631396638353831636565303633336537353766646431343233323230663433363838633734363738616264653163656164376365323635626138613234666364613134343433343234633530316230303030303039373630396333366265353831636634643937313931663835373039366234343161343130633033366636336436363937646465306337316432373535646436363465333032613134333464346234313162303030303030366233323139343961663538316366373531366339663762333437656234313261373737663363373131303939623139396363643262653233623536386134613361626636646131343335333530353831623030303033366330336435373235363235383163666235396461393230643032396464653935376235353664393831303436613931303236393865643730373937646135393038653436333461313437343534633435346434353465353431613031396132323535303231613030303337616535303331613037623237326264303735383230646365623631356466346333376362333565646330323265313166616261346639386530343232363161323463623165326263613063633365346463633435373039613135383163643139356361376462323966306631336130306361633766636137303432366666363062616434653165383764333735376661653834383461323435363837363431343434313361303030393465333234353638373634643439346533613031633764333766306538313538316334663634313435356631373931316665326635356164336164363766633265306232393436623539616633333532353734333232653637657901de61323030383238323538323030363231323537626235626431343737633039363062326533393163373062616138613634326164323538343230646161313062616238356431633234626566353834303635643535653635633439623432303465666566623636623032626436663231636436623931393165633835393436356464376266643362613330363137363236323561316434636164343038366235656330326338313662376331326164356334656334663062663833623865333139393266356663656137393562333063383235383230353432346661313062613833633935633333373134633432303437396331393138336137323734653763316434313631643137333834326332343562333430633538343037633264373261363365383339386239616161623166613434353532396637326431336463376430343231636266303137666366303135353733336662623063663533383164643761653163373437623163313264656165666161356532636166346534363362643136383734376464313239366637303963393430623830363031383138323030353831633466363431343535663137393131666532663535616433616436376663326530623239343662353961663333353235373433323265363765783c613131393032613261313633366437333637383137333464363936653733373736313730336132303464363137333734363537323433363836353636",
 			},
 			expectedValid: false,
+			expectedErr:   "unknown proto major 8 for 10-field header",
 		},
 	}
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			isValid, _, _, _, err := VerifyBlock(tc.blockHexCbor)
+			// Parse header to determine block type
+			headerBytes, err := hex.DecodeString(tc.blockHexCbor.HeaderCbor)
+			if err != nil {
+				t.Fatalf("failed to decode header hex: %v", err)
+			}
+			blockType, err := DetermineBlockType(headerBytes)
+			if err != nil {
+				if tc.expectedErr != "" &&
+					strings.Contains(err.Error(), tc.expectedErr) {
+					// Expected error, test passes
+					return
+				}
+				t.Fatalf("failed to determine block type: %v", err)
+			}
+			if tc.expectedErr != "" {
+				t.Errorf("expected error %q but got none", tc.expectedErr)
+			}
+
+			// Decode components
+			headerCborBytes := headerBytes
+			bodyCborBytes, err := hex.DecodeString(
+				tc.blockHexCbor.BlockBodyCbor,
+			)
+			if err != nil {
+				t.Fatalf("failed to decode body hex: %v", err)
+			}
+
+			// Parse header
+			header, err := NewBlockHeaderFromCbor(blockType, headerCborBytes)
+			if err != nil {
+				t.Fatalf("failed to parse header: %v", err)
+			}
+
+			// Parse txs based on block type
+			var block Block
+			var txs []interface{}
+			if _, err := cbor.Decode(bodyCborBytes, &txs); err != nil {
+				t.Fatalf("failed to decode body CBOR: %v", err)
+			}
+			switch blockType {
+			case BlockTypeShelley:
+				transactionBodies := decodeTxBodies[shelley.ShelleyTransactionBody](t, txs, "Shelley")
+				transactionMetadataSet := make(map[uint]*cbor.LazyValue)
+				shelleyHeader := header.(*shelley.ShelleyBlockHeader)
+				block = &shelley.ShelleyBlock{
+					BlockHeader:       shelleyHeader,
+					TransactionBodies: transactionBodies,
+					TransactionWitnessSets: make(
+						[]shelley.ShelleyTransactionWitnessSet,
+						len(txs),
+					),
+					TransactionMetadataSet: transactionMetadataSet,
+				}
+			case BlockTypeAllegra:
+				transactionBodies := decodeTxBodies[allegra.AllegraTransactionBody](t, txs, "Allegra")
+				transactionMetadataSet := make(map[uint]*cbor.LazyValue)
+				allegraHeader := header.(*allegra.AllegraBlockHeader)
+				block = &allegra.AllegraBlock{
+					BlockHeader:       allegraHeader,
+					TransactionBodies: transactionBodies,
+					TransactionWitnessSets: make(
+						[]shelley.ShelleyTransactionWitnessSet,
+						len(txs),
+					),
+					TransactionMetadataSet: transactionMetadataSet,
+				}
+			case BlockTypeMary:
+				transactionBodies := decodeTxBodies[mary.MaryTransactionBody](t, txs, "Mary")
+				transactionMetadataSet := make(map[uint]*cbor.LazyValue)
+				maryHeader := header.(*mary.MaryBlockHeader)
+				block = &mary.MaryBlock{
+					BlockHeader:       maryHeader,
+					TransactionBodies: transactionBodies,
+					TransactionWitnessSets: make(
+						[]shelley.ShelleyTransactionWitnessSet,
+						len(txs),
+					),
+					TransactionMetadataSet: transactionMetadataSet,
+				}
+			case BlockTypeAlonzo:
+				transactionBodies := decodeTxBodies[alonzo.AlonzoTransactionBody](t, txs, "Alonzo")
+				transactionMetadataSet := make(map[uint]*cbor.LazyValue)
+				alonzoHeader := header.(*alonzo.AlonzoBlockHeader)
+				block = &alonzo.AlonzoBlock{
+					BlockHeader:       alonzoHeader,
+					TransactionBodies: transactionBodies,
+					TransactionWitnessSets: make(
+						[]alonzo.AlonzoTransactionWitnessSet,
+						len(txs),
+					),
+					TransactionMetadataSet: transactionMetadataSet,
+					InvalidTransactions:    []uint{},
+				}
+			case BlockTypeBabbage:
+				transactionBodies := decodeTxBodies[babbage.BabbageTransactionBody](t, txs, "Babbage")
+				transactionMetadataSet := make(map[uint]*cbor.LazyValue)
+				babbageHeader := header.(*babbage.BabbageBlockHeader)
+				block = &babbage.BabbageBlock{
+					BlockHeader:       babbageHeader,
+					TransactionBodies: transactionBodies,
+					TransactionWitnessSets: make(
+						[]babbage.BabbageTransactionWitnessSet,
+						len(txs),
+					),
+					TransactionMetadataSet: transactionMetadataSet,
+					InvalidTransactions:    []uint{},
+				}
+			case BlockTypeConway:
+				transactionBodies := decodeTxBodies[conway.ConwayTransactionBody](t, txs, "Conway")
+				transactionMetadataSet := make(map[uint]*cbor.LazyValue)
+				conwayHeader := header.(*conway.ConwayBlockHeader)
+				block = &conway.ConwayBlock{
+					BlockHeader:       conwayHeader,
+					TransactionBodies: transactionBodies,
+					TransactionWitnessSets: make(
+						[]conway.ConwayTransactionWitnessSet,
+						len(txs),
+					),
+					TransactionMetadataSet: transactionMetadataSet,
+					InvalidTransactions:    []uint{},
+				}
+			default:
+				t.Fatalf("unsupported block type %d", blockType)
+			}
+
+			// No need to re-parse
+
+			isValid, _, _, _, err := VerifyBlock(
+				block,
+				tc.blockHexCbor.Eta0,
+				uint64(tc.blockHexCbor.Spk),
+			)
 			if tc.expectedValid != isValid {
+				t.Errorf(
+					"unexpected validity: got %v, expected %v",
+					isValid,
+					tc.expectedValid,
+				)
+			}
+			if tc.expectedErr != "" &&
+				(err == nil || !strings.Contains(err.Error(), tc.expectedErr)) {
 				t.Errorf("unexpected error: %v", err)
 			}
+			if tc.expectedErr == "" && err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
 		})
 	}
 }
diff --git a/ledger/verify_kes.go b/ledger/verify_kes.go
index 9f424345..e656961b 100644
--- a/ledger/verify_kes.go
+++ b/ledger/verify_kes.go
@@ -21,6 +21,7 @@ package ledger
 import (
 	"bytes"
 	"crypto/ed25519"
+	"errors"
 	"fmt"
 	"math"
 
@@ -35,6 +36,11 @@ const (
 	SIGMA_SIZE      = 64
 	PUBLIC_KEY_SIZE = 32
 	Sum0KesSig_SIZE = 64
+
+	// CardanoKesDepth is the fixed KES tree depth used in Cardano's consensus protocol
+	CardanoKesDepth = 6
+	// CardanoKesSignatureSize is the expected KES signature size: 64 + depth*64
+	CardanoKesSignatureSize = 448
 )
 
 type SumXKesSig struct {
@@ -140,16 +146,46 @@ func VerifyKes(
 	opCertVkHotBytes := header.Body.OpCert.HotVkey
 	startOfKesPeriod := uint64(opCert.KesPeriod)
 	currentSlot := header.Body.Slot
-	currentKesPeriod := currentSlot / slotsPerKesPeriod
-	t := uint64(0)
-	if currentKesPeriod >= startOfKesPeriod {
-		t = currentKesPeriod - startOfKesPeriod
+	return VerifyKesComponents(
+		msgBytes,
+		header.Signature,
+		opCertVkHotBytes,
+		startOfKesPeriod,
+		currentSlot,
+		slotsPerKesPeriod,
+	)
+}
+
+func VerifyKesComponents(
+	bodyCbor []byte,
+	signature []byte,
+	hotVkey []byte,
+	kesPeriod uint64,
+	slot uint64,
+	slotsPerKesPeriod uint64,
+) (bool, error) {
+	if slotsPerKesPeriod == 0 {
+		return false, errors.New("slotsPerKesPeriod must be greater than 0")
+	}
+	// Validate KES signature length (CardanoKesDepth levels: 64 + CardanoKesDepth*64 = CardanoKesSignatureSize bytes)
+	if len(signature) != CardanoKesSignatureSize {
+		return false, fmt.Errorf(
+			"invalid KES signature length: expected %d bytes, got %d",
+			CardanoKesSignatureSize,
+			len(signature),
+		)
+	}
+	currentKesPeriod := slot / slotsPerKesPeriod
+	if currentKesPeriod < kesPeriod {
+		// Certificate start period is in the future - invalid operational certificate
+		return false, nil
 	}
-	return verifySignedKES(opCertVkHotBytes, t, msgBytes, header.Signature), nil
+	t := currentKesPeriod - kesPeriod
+	return verifySignedKES(hotVkey, t, bodyCbor, signature), nil
 }
 
 func verifySignedKES(vkey []byte, period uint64, msg []byte, sig []byte) bool {
-	proof := NewSumKesFromByte(6, sig)
+	proof := NewSumKesFromByte(CardanoKesDepth, sig)
 	isValid := proof.Verify(period, vkey, msg)
 	return isValid
 }
diff --git a/ledger/verify_vrf.go b/ledger/verify_vrf.go
index b6c422b0..4953844e 100644
--- a/ledger/verify_vrf.go
+++ b/ledger/verify_vrf.go
@@ -380,3 +380,16 @@ func chi25519(z *field.Element) *field.Element {
 
 	return out
 }
+
+func VerifyVrf(
+	vrfKey []byte,
+	proof []byte,
+	expectedOutput []byte,
+	msg []byte,
+) (bool, error) {
+	output, err := VrfVerifyAndHash(vrfKey, proof, msg)
+	if err != nil {
+		return false, err
+	}
+	return subtle.ConstantTimeCompare(output, expectedOutput) == 1, nil
+}
diff --git a/protocol/localstatequery/client_test.go b/protocol/localstatequery/client_test.go
index 06ad24ed..3f89a922 100644
--- a/protocol/localstatequery/client_test.go
+++ b/protocol/localstatequery/client_test.go
@@ -22,7 +22,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/blinklabs-io/gouroboros"
+	ouroboros "github.com/blinklabs-io/gouroboros"
 	"github.com/blinklabs-io/gouroboros/cbor"
 	"github.com/blinklabs-io/gouroboros/internal/test"
 	"github.com/blinklabs-io/gouroboros/ledger"