diff --git a/cmd/gouroboros/chainsync.go b/cmd/gouroboros/chainsync.go
index ec153e4b..bfd00896 100644
--- a/cmd/gouroboros/chainsync.go
+++ b/cmd/gouroboros/chainsync.go
@@ -219,10 +219,10 @@ func chainSyncRollForwardHandler(blockType uint, blockData interface{}, tip chai
 	}
 	// Display block info
 	switch blockType {
-	case ledger.BLOCK_TYPE_BYRON_EBB:
+	case ledger.BlockTypeByronEbb:
 		byronEbbBlock := block.(*ledger.ByronEpochBoundaryBlock)
 		fmt.Printf("era = Byron (EBB), epoch = %d, slot = %d, id = %s\n", byronEbbBlock.Header.ConsensusData.Epoch, byronEbbBlock.SlotNumber(), byronEbbBlock.Hash())
-	case ledger.BLOCK_TYPE_BYRON_MAIN:
+	case ledger.BlockTypeByronMain:
 		byronBlock := block.(*ledger.ByronMainBlock)
 		fmt.Printf("era = Byron, epoch = %d, slot = %d, id = %s\n", byronBlock.Header.ConsensusData.SlotId.Epoch, byronBlock.SlotNumber(), byronBlock.Hash())
 	default:
diff --git a/cmd/gouroboros/localtxsubmission.go b/cmd/gouroboros/localtxsubmission.go
index 3b9095e2..75dfafdb 100644
--- a/cmd/gouroboros/localtxsubmission.go
+++ b/cmd/gouroboros/localtxsubmission.go
@@ -107,7 +107,7 @@ func testLocalTxSubmission(f *globalFlags) {
 		}
 	}
 
-	if err = o.LocalTxSubmission().Client.SubmitTx(ledger.TX_TYPE_ALONZO, txBytes); err != nil {
+	if err = o.LocalTxSubmission().Client.SubmitTx(ledger.TxTypeAlonzo, txBytes); err != nil {
 		fmt.Printf("Error submitting transaction: %s\n", err)
 		os.Exit(1)
 	}
diff --git a/ledger/allegra.go b/ledger/allegra.go
index d069e9b8..0f1b46fe 100644
--- a/ledger/allegra.go
+++ b/ledger/allegra.go
@@ -21,13 +21,13 @@ import (
 )
 
 const (
-	ERA_ID_ALLEGRA = 2
+	EraIdAllegra = 2
 
-	BLOCK_TYPE_ALLEGRA = 3
+	BlockTypeAllegra = 3
 
-	BLOCK_HEADER_TYPE_ALLEGRA = 2
+	BlockHeaderTypeAllegra = 2
 
-	TX_TYPE_ALLEGRA = 2
+	TxTypeAllegra = 2
 )
 
 type AllegraBlock struct {
@@ -56,7 +56,7 @@ func (b *AllegraBlock) SlotNumber() uint64 {
 }
 
 func (b *AllegraBlock) Era() Era {
-	return eras[ERA_ID_ALLEGRA]
+	return eras[EraIdAllegra]
 }
 
 func (b *AllegraBlock) Transactions() []Transaction {
@@ -77,7 +77,7 @@ type AllegraBlockHeader struct {
 }
 
 func (h *AllegraBlockHeader) Era() Era {
-	return eras[ERA_ID_ALLEGRA]
+	return eras[EraIdAllegra]
 }
 
 type AllegraTransactionBody struct {
diff --git a/ledger/alonzo.go b/ledger/alonzo.go
index 671e2533..58b9ed1c 100644
--- a/ledger/alonzo.go
+++ b/ledger/alonzo.go
@@ -22,13 +22,13 @@ import (
 )
 
 const (
-	ERA_ID_ALONZO = 4
+	EraIdAlonzo = 4
 
-	BLOCK_TYPE_ALONZO = 5
+	BlockTypeAlonzo = 5
 
-	BLOCK_HEADER_TYPE_ALONZO = 4
+	BlockHeaderTypeAlonzo = 4
 
-	TX_TYPE_ALONZO = 4
+	TxTypeAlonzo = 4
 )
 
 type AlonzoBlock struct {
@@ -58,7 +58,7 @@ func (b *AlonzoBlock) SlotNumber() uint64 {
 }
 
 func (b *AlonzoBlock) Era() Era {
-	return eras[ERA_ID_ALONZO]
+	return eras[EraIdAlonzo]
 }
 
 func (b *AlonzoBlock) Transactions() []Transaction {
@@ -87,7 +87,7 @@ type AlonzoBlockHeader struct {
 }
 
 func (h *AlonzoBlockHeader) Era() Era {
-	return eras[ERA_ID_ALONZO]
+	return eras[EraIdAlonzo]
 }
 
 type AlonzoTransactionBody struct {
diff --git a/ledger/babbage.go b/ledger/babbage.go
index fd293dd1..875dad4e 100644
--- a/ledger/babbage.go
+++ b/ledger/babbage.go
@@ -22,13 +22,13 @@ import (
 )
 
 const (
-	ERA_ID_BABBAGE = 5
+	EraIdBabbage = 5
 
-	BLOCK_TYPE_BABBAGE = 6
+	BlockTypeBabbage = 6
 
-	BLOCK_HEADER_TYPE_BABBAGE = 5
+	BlockHeaderTypeBabbage = 5
 
-	TX_TYPE_BABBAGE = 5
+	TxTypeBabbage = 5
 )
 
 type BabbageBlock struct {
@@ -58,7 +58,7 @@ func (b *BabbageBlock) SlotNumber() uint64 {
 }
 
 func (b *BabbageBlock) Era() Era {
-	return eras[ERA_ID_BABBAGE]
+	return eras[EraIdBabbage]
 }
 
 func (b *BabbageBlock) Transactions() []Transaction {
@@ -132,7 +132,7 @@ func (h *BabbageBlockHeader) SlotNumber() uint64 {
 }
 
 func (h *BabbageBlockHeader) Era() Era {
-	return eras[ERA_ID_BABBAGE]
+	return eras[EraIdBabbage]
 }
 
 type BabbageTransactionBody struct {
diff --git a/ledger/block.go b/ledger/block.go
index 2310af98..c1773eda 100644
--- a/ledger/block.go
+++ b/ledger/block.go
@@ -36,19 +36,19 @@ type BlockHeader interface {
 
 func NewBlockFromCbor(blockType uint, data []byte) (Block, error) {
 	switch blockType {
-	case BLOCK_TYPE_BYRON_EBB:
+	case BlockTypeByronEbb:
 		return NewByronEpochBoundaryBlockFromCbor(data)
-	case BLOCK_TYPE_BYRON_MAIN:
+	case BlockTypeByronMain:
 		return NewByronMainBlockFromCbor(data)
-	case BLOCK_TYPE_SHELLEY:
+	case BlockTypeShelley:
 		return NewShelleyBlockFromCbor(data)
-	case BLOCK_TYPE_ALLEGRA:
+	case BlockTypeAllegra:
 		return NewAllegraBlockFromCbor(data)
-	case BLOCK_TYPE_MARY:
+	case BlockTypeMary:
 		return NewMaryBlockFromCbor(data)
-	case BLOCK_TYPE_ALONZO:
+	case BlockTypeAlonzo:
 		return NewAlonzoBlockFromCbor(data)
-	case BLOCK_TYPE_BABBAGE:
+	case BlockTypeBabbage:
 		return NewBabbageBlockFromCbor(data)
 	}
 	return nil, fmt.Errorf("unknown node-to-client block type: %d", blockType)
@@ -57,14 +57,14 @@ func NewBlockFromCbor(blockType uint, data []byte) (Block, error) {
 // XXX: should this take the block header type instead?
 func NewBlockHeaderFromCbor(blockType uint, data []byte) (BlockHeader, error) {
 	switch blockType {
-	case BLOCK_TYPE_BYRON_EBB:
+	case BlockTypeByronEbb:
 		return NewByronEpochBoundaryBlockHeaderFromCbor(data)
-	case BLOCK_TYPE_BYRON_MAIN:
+	case BlockTypeByronMain:
 		return NewByronMainBlockHeaderFromCbor(data)
 	// TODO: break into separate cases and parse as specific block header types
-	case BLOCK_TYPE_SHELLEY, BLOCK_TYPE_ALLEGRA, BLOCK_TYPE_MARY, BLOCK_TYPE_ALONZO:
+	case BlockTypeShelley, BlockTypeAllegra, BlockTypeMary, BlockTypeAlonzo:
 		return NewShelleyBlockHeaderFromCbor(data)
-	case BLOCK_TYPE_BABBAGE:
+	case BlockTypeBabbage:
 		return NewBabbageBlockHeaderFromCbor(data)
 	}
 	return nil, fmt.Errorf("unknown node-to-node block type: %d", blockType)
diff --git a/ledger/byron.go b/ledger/byron.go
index 17aef097..c44d3db7 100644
--- a/ledger/byron.go
+++ b/ledger/byron.go
@@ -21,16 +21,16 @@ import (
 )
 
 const (
-	ERA_ID_BYRON = 0
+	EraIdByron = 0
 
-	BLOCK_TYPE_BYRON_EBB  = 0
-	BLOCK_TYPE_BYRON_MAIN = 1
+	BlockTypeByronEbb  = 0
+	BlockTypeByronMain = 1
 
-	BLOCK_HEADER_TYPE_BYRON = 0
+	BlockHeaderTypeByron = 0
 
-	TX_TYPE_BYRON = 0
+	TxTypeByron = 0
 
-	BYRON_SLOTS_PER_EPOCH = 21600
+	ByronSlotsPerEpoch = 21600
 )
 
 type ByronMainBlockHeader struct {
@@ -82,7 +82,7 @@ func (h *ByronMainBlockHeader) Hash() string {
 		// Prepend bytes for CBOR list wrapper
 		// The block hash is calculated with these extra bytes, so we have to add them to
 		// get the correct value
-		h.hash = generateBlockHeaderHash(h.Cbor(), []byte{0x82, BLOCK_TYPE_BYRON_MAIN})
+		h.hash = generateBlockHeaderHash(h.Cbor(), []byte{0x82, BlockTypeByronMain})
 	}
 	return h.hash
 }
@@ -93,11 +93,11 @@ func (h *ByronMainBlockHeader) BlockNumber() uint64 {
 }
 
 func (h *ByronMainBlockHeader) SlotNumber() uint64 {
-	return uint64((h.ConsensusData.SlotId.Epoch * BYRON_SLOTS_PER_EPOCH) + uint64(h.ConsensusData.SlotId.Slot))
+	return uint64((h.ConsensusData.SlotId.Epoch * ByronSlotsPerEpoch) + uint64(h.ConsensusData.SlotId.Slot))
 }
 
 func (h *ByronMainBlockHeader) Era() Era {
-	return eras[ERA_ID_BYRON]
+	return eras[EraIdByron]
 }
 
 type ByronTransaction struct {
@@ -169,7 +169,7 @@ func (h *ByronEpochBoundaryBlockHeader) Hash() string {
 		// Prepend bytes for CBOR list wrapper
 		// The block hash is calculated with these extra bytes, so we have to add them to
 		// get the correct value
-		h.hash = generateBlockHeaderHash(h.Cbor(), []byte{0x82, BLOCK_TYPE_BYRON_EBB})
+		h.hash = generateBlockHeaderHash(h.Cbor(), []byte{0x82, BlockTypeByronEbb})
 	}
 	return h.hash
 }
@@ -180,11 +180,11 @@ func (h *ByronEpochBoundaryBlockHeader) BlockNumber() uint64 {
 }
 
 func (h *ByronEpochBoundaryBlockHeader) SlotNumber() uint64 {
-	return uint64(h.ConsensusData.Epoch * BYRON_SLOTS_PER_EPOCH)
+	return uint64(h.ConsensusData.Epoch * ByronSlotsPerEpoch)
 }
 
 func (h *ByronEpochBoundaryBlockHeader) Era() Era {
-	return eras[ERA_ID_BYRON]
+	return eras[EraIdByron]
 }
 
 type ByronMainBlock struct {
diff --git a/ledger/era.go b/ledger/era.go
index 3bfa6443..2a255e27 100644
--- a/ledger/era.go
+++ b/ledger/era.go
@@ -20,28 +20,28 @@ type Era struct {
 }
 
 var eras = map[uint8]Era{
-	ERA_ID_BYRON: Era{
-		Id:   ERA_ID_BYRON,
+	EraIdByron: Era{
+		Id:   EraIdByron,
 		Name: "Byron",
 	},
-	ERA_ID_SHELLEY: Era{
-		Id:   ERA_ID_SHELLEY,
+	EraIdShelley: Era{
+		Id:   EraIdShelley,
 		Name: "Shelley",
 	},
-	ERA_ID_ALLEGRA: Era{
-		Id:   ERA_ID_ALLEGRA,
+	EraIdAllegra: Era{
+		Id:   EraIdAllegra,
 		Name: "Allegra",
 	},
-	ERA_ID_MARY: Era{
-		Id:   ERA_ID_MARY,
+	EraIdMary: Era{
+		Id:   EraIdMary,
 		Name: "Mary",
 	},
-	ERA_ID_ALONZO: Era{
-		Id:   ERA_ID_ALONZO,
+	EraIdAlonzo: Era{
+		Id:   EraIdAlonzo,
 		Name: "Alonzo",
 	},
-	ERA_ID_BABBAGE: Era{
-		Id:   ERA_ID_BABBAGE,
+	EraIdBabbage: Era{
+		Id:   EraIdBabbage,
 		Name: "Babbage",
 	},
 }
diff --git a/ledger/error.go b/ledger/error.go
index 26eea59f..f66cbc43 100644
--- a/ledger/error.go
+++ b/ledger/error.go
@@ -21,33 +21,33 @@ import (
 )
 
 const (
-	APPLY_TX_ERROR_UTXOW_FAILURE = 0
-
-	UTXOW_FAILURE_UTXO_FAILURE = 2
-
-	UTXO_FAILURE_FROM_ALONZO = 1
-
-	UTXO_FAILURE_BAD_INPUTS_UTXO                = 0
-	UTXO_FAILURE_OUTSIDE_VALIDITY_INTERVAL_UTXO = 1
-	UTXO_FAILURE_MAX_TX_SIZE_UTXO               = 2
-	UTXO_FAILURE_INPUT_SET_EMPTY                = 3
-	UTXO_FAILURE_FEE_TOO_SMALL_UTXO             = 4
-	UTXO_FAILURE_VALUE_NOT_CONSERVED_UTXO       = 5
-	UTXO_FAILURE_OUTPUT_TOO_SMALL_UTXO          = 6
-	UTXO_FAILURE_UTXOS_FAILURE                  = 7
-	UTXO_FAILURE_WRONG_NETWORK                  = 8
-	UTXO_FAILURE_WRONG_NETWORK_WITHDRAWAL       = 9
-	UTXO_FAILURE_OUTPUT_BOOT_ADDR_ATTRS_TOO_BIG = 10
-	UTXO_FAILURE_TRIES_TO_FORGE_ADA             = 11
-	UTXO_FAILURE_OUTPUT_TOO_BIG_UTXO            = 12
-	UTXO_FAILURE_INSUFFICIENT_COLLATERAL        = 13
-	UTXO_FAILURE_SCRIPTS_NOT_PAID_UTXO          = 14
-	UTXO_FAILURE_EX_UNITS_TOO_BIG_UTXO          = 15
-	UTXO_FAILURE_COLLATERAL_CONTAINS_NON_ADA    = 16
-	UTXO_FAILURE_WRONG_NETWORK_IN_TX_BODY       = 17
-	UTXO_FAILURE_OUTSIDE_FORECAST               = 18
-	UTXO_FAILURE_TOO_MANY_COLLATERAL_INPUTS     = 19
-	UTXO_FAILURE_NO_COLLATERAL_INPUTS           = 20
+	ApplyTxErrorUtxowFailure = 0
+
+	UTXOWFailureUtxoFailure = 2
+
+	UtxoFailureFromAlonzo = 1
+
+	UtxoFailureBadInputsUtxo               = 0
+	UtxoFailureOutsideValidityIntervalUtxo = 1
+	UtxoFailureMaxTxSizeUtxo               = 2
+	UtxoFailureInputSetEmpty               = 3
+	UtxoFailureFeeTooSmallUtxo             = 4
+	UtxoFailureValueNotConservedUtxo       = 5
+	UtxoFailureOutputTooSmallUtxo          = 6
+	UtxoFailureUtxosFailure                = 7
+	UtxoFailureWrongNetwork                = 8
+	UtxoFailureWrongNetworkWithdrawal      = 9
+	UtxoFailureOutputBootAddrAttrsTooBig   = 10
+	UtxoFailureTriesToForgeAda             = 11
+	UtxoFailureOutputTooBigUtxo            = 12
+	UtxoFailureInsufficientCollateral      = 13
+	UtxoFailureScriptsNotPaidUtxo          = 14
+	UtxoFailureExUnitsTooBigUtxo           = 15
+	UtxoFailureCollateralContainsNonAda    = 16
+	UtxoFailureWrongNetworkInTxBody        = 17
+	UtxoFailureOutsideForecast             = 18
+	UtxoFailureTooManyCollateralInputs     = 19
+	UtxoFailureNoCollateralInputs          = 20
 )
 
 // Helper type to make the code a little cleaner
@@ -169,7 +169,7 @@ func (e *ApplyTxError) UnmarshalCBOR(data []byte) error {
 		}
 		var newErr error
 		switch failureType {
-		case APPLY_TX_ERROR_UTXOW_FAILURE:
+		case ApplyTxErrorUtxowFailure:
 			newErr = &UtxowFailure{}
 		default:
 			if tmpErr, err := NewGenericErrorFromCbor(data); err != nil {
@@ -214,7 +214,7 @@ func (e *UtxowFailure) UnmarshalCBOR(data []byte) error {
 	}
 	var newErr error
 	switch failureType {
-	case UTXOW_FAILURE_UTXO_FAILURE:
+	case UTXOWFailureUtxoFailure:
 		newErr = &UtxoFailure{}
 	default:
 		if tmpErr, err := NewGenericErrorFromCbor(data); err != nil {
@@ -253,27 +253,27 @@ func (e *UtxoFailure) UnmarshalCBOR(data []byte) error {
 	newErr, err := cbor.DecodeById(
 		tmpData.Err,
 		map[int]interface{}{
-			UTXO_FAILURE_BAD_INPUTS_UTXO:                &BadInputsUtxo{},
-			UTXO_FAILURE_OUTSIDE_VALIDITY_INTERVAL_UTXO: &OutsideValidityIntervalUtxo{},
-			UTXO_FAILURE_MAX_TX_SIZE_UTXO:               &MaxTxSizeUtxo{},
-			UTXO_FAILURE_INPUT_SET_EMPTY:                &InputSetEmptyUtxo{},
-			UTXO_FAILURE_FEE_TOO_SMALL_UTXO:             &FeeTooSmallUtxo{},
-			UTXO_FAILURE_VALUE_NOT_CONSERVED_UTXO:       &ValueNotConservedUtxo{},
-			UTXO_FAILURE_OUTPUT_TOO_SMALL_UTXO:          &OutputTooSmallUtxo{},
-			UTXO_FAILURE_UTXOS_FAILURE:                  &UtxosFailure{},
-			UTXO_FAILURE_WRONG_NETWORK:                  &WrongNetwork{},
-			UTXO_FAILURE_WRONG_NETWORK_WITHDRAWAL:       &WrongNetworkWithdrawal{},
-			UTXO_FAILURE_OUTPUT_BOOT_ADDR_ATTRS_TOO_BIG: &OutputBootAddrAttrsTooBig{},
-			UTXO_FAILURE_TRIES_TO_FORGE_ADA:             &TriesToForgeADA{},
-			UTXO_FAILURE_OUTPUT_TOO_BIG_UTXO:            &OutputTooBigUtxo{},
-			UTXO_FAILURE_INSUFFICIENT_COLLATERAL:        &InsufficientCollateral{},
-			UTXO_FAILURE_SCRIPTS_NOT_PAID_UTXO:          &ScriptsNotPaidUtxo{},
-			UTXO_FAILURE_EX_UNITS_TOO_BIG_UTXO:          &ExUnitsTooBigUtxo{},
-			UTXO_FAILURE_COLLATERAL_CONTAINS_NON_ADA:    &CollateralContainsNonADA{},
-			UTXO_FAILURE_WRONG_NETWORK_IN_TX_BODY:       &WrongNetworkInTxBody{},
-			UTXO_FAILURE_OUTSIDE_FORECAST:               &OutsideForecast{},
-			UTXO_FAILURE_TOO_MANY_COLLATERAL_INPUTS:     &TooManyCollateralInputs{},
-			UTXO_FAILURE_NO_COLLATERAL_INPUTS:           &NoCollateralInputs{},
+			UtxoFailureBadInputsUtxo:               &BadInputsUtxo{},
+			UtxoFailureOutsideValidityIntervalUtxo: &OutsideValidityIntervalUtxo{},
+			UtxoFailureMaxTxSizeUtxo:               &MaxTxSizeUtxo{},
+			UtxoFailureInputSetEmpty:               &InputSetEmptyUtxo{},
+			UtxoFailureFeeTooSmallUtxo:             &FeeTooSmallUtxo{},
+			UtxoFailureValueNotConservedUtxo:       &ValueNotConservedUtxo{},
+			UtxoFailureOutputTooSmallUtxo:          &OutputTooSmallUtxo{},
+			UtxoFailureUtxosFailure:                &UtxosFailure{},
+			UtxoFailureWrongNetwork:                &WrongNetwork{},
+			UtxoFailureWrongNetworkWithdrawal:      &WrongNetworkWithdrawal{},
+			UtxoFailureOutputBootAddrAttrsTooBig:   &OutputBootAddrAttrsTooBig{},
+			UtxoFailureTriesToForgeAda:             &TriesToForgeADA{},
+			UtxoFailureOutputTooBigUtxo:            &OutputTooBigUtxo{},
+			UtxoFailureInsufficientCollateral:      &InsufficientCollateral{},
+			UtxoFailureScriptsNotPaidUtxo:          &ScriptsNotPaidUtxo{},
+			UtxoFailureExUnitsTooBigUtxo:           &ExUnitsTooBigUtxo{},
+			UtxoFailureCollateralContainsNonAda:    &CollateralContainsNonADA{},
+			UtxoFailureWrongNetworkInTxBody:        &WrongNetworkInTxBody{},
+			UtxoFailureOutsideForecast:             &OutsideForecast{},
+			UtxoFailureTooManyCollateralInputs:     &TooManyCollateralInputs{},
+			UtxoFailureNoCollateralInputs:          &NoCollateralInputs{},
 		},
 	)
 	if err != nil {
diff --git a/ledger/mary.go b/ledger/mary.go
index e92924b5..4c71b452 100644
--- a/ledger/mary.go
+++ b/ledger/mary.go
@@ -22,13 +22,13 @@ import (
 )
 
 const (
-	ERA_ID_MARY = 3
+	EraIdMary = 3
 
-	BLOCK_TYPE_MARY = 4
+	BlockTypeMary = 4
 
-	BLOCK_HEADER_TYPE_MARY = 3
+	BlockHeaderTypeMary = 3
 
-	TX_TYPE_MARY = 3
+	TxTypeMary = 3
 )
 
 type MaryBlock struct {
@@ -57,7 +57,7 @@ func (b *MaryBlock) SlotNumber() uint64 {
 }
 
 func (b *MaryBlock) Era() Era {
-	return eras[ERA_ID_MARY]
+	return eras[EraIdMary]
 }
 
 func (b *MaryBlock) Transactions() []Transaction {
@@ -78,7 +78,7 @@ type MaryBlockHeader struct {
 }
 
 func (h *MaryBlockHeader) Era() Era {
-	return eras[ERA_ID_MARY]
+	return eras[EraIdMary]
 }
 
 type MaryTransactionBody struct {
diff --git a/ledger/shelley.go b/ledger/shelley.go
index a40a77cb..59496c89 100644
--- a/ledger/shelley.go
+++ b/ledger/shelley.go
@@ -21,13 +21,13 @@ import (
 )
 
 const (
-	ERA_ID_SHELLEY = 1
+	EraIdShelley = 1
 
-	BLOCK_TYPE_SHELLEY = 2
+	BlockTypeShelley = 2
 
-	BLOCK_HEADER_TYPE_SHELLEY = 1
+	BlockHeaderTypeShelley = 1
 
-	TX_TYPE_SHELLEY = 1
+	TxTypeShelley = 1
 )
 
 type ShelleyBlock struct {
@@ -56,7 +56,7 @@ func (b *ShelleyBlock) SlotNumber() uint64 {
 }
 
 func (b *ShelleyBlock) Era() Era {
-	return eras[ERA_ID_SHELLEY]
+	return eras[EraIdShelley]
 }
 
 func (b *ShelleyBlock) Transactions() []Transaction {
@@ -117,7 +117,7 @@ func (h *ShelleyBlockHeader) SlotNumber() uint64 {
 }
 
 func (h *ShelleyBlockHeader) Era() Era {
-	return eras[ERA_ID_SHELLEY]
+	return eras[EraIdShelley]
 }
 
 type ShelleyTransactionBody struct {
diff --git a/ledger/tx.go b/ledger/tx.go
index 4f80c477..1bc659f7 100644
--- a/ledger/tx.go
+++ b/ledger/tx.go
@@ -50,17 +50,17 @@ type TransactionOutput interface {
 
 func NewTransactionFromCbor(txType uint, data []byte) (Transaction, error) {
 	switch txType {
-	case TX_TYPE_BYRON:
+	case TxTypeByron:
 		return NewByronTransactionFromCbor(data)
-	case TX_TYPE_SHELLEY:
+	case TxTypeShelley:
 		return NewShelleyTransactionFromCbor(data)
-	case TX_TYPE_ALLEGRA:
+	case TxTypeAllegra:
 		return NewAllegraTransactionFromCbor(data)
-	case TX_TYPE_MARY:
+	case TxTypeMary:
 		return NewMaryTransactionFromCbor(data)
-	case TX_TYPE_ALONZO:
+	case TxTypeAlonzo:
 		return NewAlonzoTransactionFromCbor(data)
-	case TX_TYPE_BABBAGE:
+	case TxTypeBabbage:
 		return NewBabbageTransactionFromCbor(data)
 	}
 	return nil, fmt.Errorf("unknown transaction type: %d", txType)
@@ -68,17 +68,17 @@ func NewTransactionFromCbor(txType uint, data []byte) (Transaction, error) {
 
 func NewTransactionBodyFromCbor(txType uint, data []byte) (TransactionBody, error) {
 	switch txType {
-	case TX_TYPE_BYRON:
+	case TxTypeByron:
 		return nil, fmt.Errorf("Byron transactions do not contain a body")
-	case TX_TYPE_SHELLEY:
+	case TxTypeShelley:
 		return NewShelleyTransactionBodyFromCbor(data)
-	case TX_TYPE_ALLEGRA:
+	case TxTypeAllegra:
 		return NewAllegraTransactionBodyFromCbor(data)
-	case TX_TYPE_MARY:
+	case TxTypeMary:
 		return NewMaryTransactionBodyFromCbor(data)
-	case TX_TYPE_ALONZO:
+	case TxTypeAlonzo:
 		return NewAlonzoTransactionBodyFromCbor(data)
-	case TX_TYPE_BABBAGE:
+	case TxTypeBabbage:
 		return NewBabbageTransactionBodyFromCbor(data)
 	}
 	return nil, fmt.Errorf("unknown transaction type: %d", txType)
diff --git a/protocol/chainsync/client.go b/protocol/chainsync/client.go
index 5fb55bc4..7fd34fa3 100644
--- a/protocol/chainsync/client.go
+++ b/protocol/chainsync/client.go
@@ -256,7 +256,7 @@ func (c *Client) handleRollForward(msgGeneric protocol.Message) error {
 		var blockType uint
 		blockEra := msg.WrappedHeader.Era
 		switch blockEra {
-		case ledger.BLOCK_HEADER_TYPE_BYRON:
+		case ledger.BlockHeaderTypeByron:
 			blockType = msg.WrappedHeader.ByronType()
 			var err error
 			blockHeader, err = ledger.NewBlockHeaderFromCbor(blockType, msg.WrappedHeader.HeaderCbor())
@@ -266,11 +266,11 @@ func (c *Client) handleRollForward(msgGeneric protocol.Message) error {
 		default:
 			// Map block header types to block types
 			blockTypeMap := map[uint]uint{
-				ledger.BLOCK_HEADER_TYPE_SHELLEY: ledger.BLOCK_TYPE_SHELLEY,
-				ledger.BLOCK_HEADER_TYPE_ALLEGRA: ledger.BLOCK_TYPE_ALLEGRA,
-				ledger.BLOCK_HEADER_TYPE_MARY:    ledger.BLOCK_TYPE_MARY,
-				ledger.BLOCK_HEADER_TYPE_ALONZO:  ledger.BLOCK_TYPE_ALONZO,
-				ledger.BLOCK_HEADER_TYPE_BABBAGE: ledger.BLOCK_TYPE_BABBAGE,
+				ledger.BlockHeaderTypeShelley: ledger.BlockTypeShelley,
+				ledger.BlockHeaderTypeAllegra: ledger.BlockTypeAllegra,
+				ledger.BlockHeaderTypeMary:    ledger.BlockTypeMary,
+				ledger.BlockHeaderTypeAlonzo:  ledger.BlockTypeAlonzo,
+				ledger.BlockHeaderTypeBabbage: ledger.BlockTypeBabbage,
 			}
 			blockType = blockTypeMap[blockEra]
 			var err error
diff --git a/protocol/chainsync/messages_test.go b/protocol/chainsync/messages_test.go
index 8a02a7b9..b1adb258 100644
--- a/protocol/chainsync/messages_test.go
+++ b/protocol/chainsync/messages_test.go
@@ -123,7 +123,7 @@ func TestMsgRollForwardNodeToNode(t *testing.T) {
 		{
 			CborHex: string(readFile("testdata/rollforward_ntn_byron_ebb_testnet_8f8602837f7c6f8b8867dd1cbc1842cf51a27eaed2c70ef48325d00f8efb320f.hex")),
 			Message: NewMsgRollForwardNtN(
-				ledger.BLOCK_HEADER_TYPE_BYRON,
+				ledger.BlockHeaderTypeByron,
 				0,
 				hexDecode(string(readFile("testdata/byron_ebb_testnet_8f8602837f7c6f8b8867dd1cbc1842cf51a27eaed2c70ef48325d00f8efb320f.hex"))),
 				Tip{
@@ -143,7 +143,7 @@ func TestMsgRollForwardNodeToNode(t *testing.T) {
 			{
 				CborHex: string(readFile("testdata/rollforward_ntn_byron_main_block_testnet_388a82f053603f3552717d61644a353188f2d5500f4c6354cc1ad27a36a7ea91.hex")),
 				Message: NewMsgRollForwardNtN(
-					ledger.BLOCK_HEADER_TYPE_BYRON,
+					ledger.BlockHeaderTypeByron,
 					1,
 					hexDecode(string(readFile("testdata/byron_main_block_testnet_xxxx.hex"))),
 					Tip{
@@ -162,7 +162,7 @@ func TestMsgRollForwardNodeToNode(t *testing.T) {
 		{
 			CborHex: string(readFile("testdata/rollforward_ntn_shelley_block_testnet_02b1c561715da9e540411123a6135ee319b02f60b9a11a603d3305556c04329f.hex")),
 			Message: NewMsgRollForwardNtN(
-				ledger.BLOCK_HEADER_TYPE_SHELLEY,
+				ledger.BlockHeaderTypeShelley,
 				0,
 				hexDecode(string(readFile("testdata/shelley_block_testnet_02b1c561715da9e540411123a6135ee319b02f60b9a11a603d3305556c04329f.hex"))),
 				Tip{
diff --git a/protocol/chainsync/wrappers.go b/protocol/chainsync/wrappers.go
index 5384f962..ef8a2d6c 100644
--- a/protocol/chainsync/wrappers.go
+++ b/protocol/chainsync/wrappers.go
@@ -53,7 +53,7 @@ func NewWrappedHeader(era uint, byronType uint, blockCbor []byte) *WrappedHeader
 		byronType: byronType,
 	}
 	// Record the original block size for Byron blocks
-	if era == ledger.BLOCK_HEADER_TYPE_BYRON {
+	if era == ledger.BlockHeaderTypeByron {
 		// TODO: figure out why we have to add 2 to the length to match official message CBOR
 		w.byronSize = uint(len(blockCbor)) + 2
 	}
@@ -79,7 +79,7 @@ func (w *WrappedHeader) UnmarshalCBOR(data []byte) error {
 	}
 	w.Era = tmpHeader.Era
 	switch w.Era {
-	case ledger.BLOCK_HEADER_TYPE_BYRON:
+	case ledger.BlockHeaderTypeByron:
 		var wrappedHeaderByron wrappedHeaderByron
 		if _, err := cbor.Decode(tmpHeader.HeaderRaw, &wrappedHeaderByron); err != nil {
 			return err
@@ -102,7 +102,7 @@ func (w *WrappedHeader) MarshalCBOR() ([]byte, error) {
 		w.Era,
 	}
 	switch w.Era {
-	case ledger.BLOCK_HEADER_TYPE_BYRON:
+	case ledger.BlockHeaderTypeByron:
 		tmp := []interface{}{
 			[]interface{}{
 				w.byronType,
diff --git a/protocol/localtxsubmission/messages_test.go b/protocol/localtxsubmission/messages_test.go
index b98d0572..548f25ac 100644
--- a/protocol/localtxsubmission/messages_test.go
+++ b/protocol/localtxsubmission/messages_test.go
@@ -17,12 +17,13 @@ package localtxsubmission
 import (
 	"encoding/hex"
 	"fmt"
-	"github.com/blinklabs-io/gouroboros/cbor"
-	"github.com/blinklabs-io/gouroboros/ledger"
-	"github.com/blinklabs-io/gouroboros/protocol"
 	"reflect"
 	"strings"
 	"testing"
+
+	"github.com/blinklabs-io/gouroboros/cbor"
+	"github.com/blinklabs-io/gouroboros/ledger"
+	"github.com/blinklabs-io/gouroboros/protocol"
 )
 
 type testDefinition struct {
@@ -54,7 +55,7 @@ var tests = []testDefinition{
 	{
 		CborHex:     fmt.Sprintf("82008204d81846%x", placeholderTx),
 		MessageType: MessageTypeSubmitTx,
-		Message:     NewMsgSubmitTx(ledger.TX_TYPE_ALONZO, placeholderTx),
+		Message:     NewMsgSubmitTx(ledger.TxTypeAlonzo, placeholderTx),
 	},
 	{
 		CborHex:     "8101",