feat: block function to get header

wolf31o2 · wolf31o2 · commit b9654b1f5ea5 · 2024-11-22T07:43:48.000-05:00
Signed-off-by: Chris Gianelloni &lt;wolf31o2@blinklabs.io&gt;
diff --git a/cmd/gouroboros/chainsync.go b/cmd/gouroboros/chainsync.go
@@ -279,15 +279,15 @@ func chainSyncRollForwardHandler(
 		byronEbbBlock := block.(*ledger.ByronEpochBoundaryBlock)
 		fmt.Printf(
 			"era = Byron (EBB), epoch = %d, slot = %d, id = %s\n",
-			byronEbbBlock.Header.ConsensusData.Epoch,
+			byronEbbBlock.BlockHeader.ConsensusData.Epoch,
 			byronEbbBlock.SlotNumber(),
 			byronEbbBlock.Hash(),
 		)
 	case ledger.BlockTypeByronMain:
 		byronBlock := block.(*ledger.ByronMainBlock)
 		fmt.Printf(
 			"era = Byron, epoch = %d, slot = %d, id = %s\n",
-			byronBlock.Header.ConsensusData.SlotId.Epoch,
+			byronBlock.BlockHeader.ConsensusData.SlotId.Epoch,
 			byronBlock.SlotNumber(),
 			byronBlock.Hash(),
 		)
@@ -313,9 +313,9 @@ func blockFetchBlockHandler(
 ) error {
 	switch block := blockData.(type) {
 	case *ledger.ByronEpochBoundaryBlock:
-		fmt.Printf("era = Byron (EBB), epoch = %d, slot = %d, id = %s\n", block.Header.ConsensusData.Epoch, block.SlotNumber(), block.Hash())
+		fmt.Printf("era = Byron (EBB), epoch = %d, slot = %d, id = %s\n", block.BlockHeader.ConsensusData.Epoch, block.SlotNumber(), block.Hash())
 	case *ledger.ByronMainBlock:
-		fmt.Printf("era = Byron, epoch = %d, slot = %d, id = %s\n", block.Header.ConsensusData.SlotId.Epoch, block.SlotNumber(), block.Hash())
+		fmt.Printf("era = Byron, epoch = %d, slot = %d, id = %s\n", block.BlockHeader.ConsensusData.SlotId.Epoch, block.SlotNumber(), block.Hash())
 	case ledger.Block:
 		fmt.Printf("era = %s, slot = %d, block_no = %d, id = %s\n", block.Era().Name, block.SlotNumber(), block.BlockNumber(), block.Hash())
 	}
diff --git a/ledger/allegra/allegra.go b/ledger/allegra/allegra.go
@@ -50,7 +50,7 @@ func init() {
 type AllegraBlock struct {
 	cbor.StructAsArray
 	cbor.DecodeStoreCbor
-	Header                 *AllegraBlockHeader
+	BlockHeader            *AllegraBlockHeader
 	TransactionBodies      []AllegraTransactionBody
 	TransactionWitnessSets []shelley.ShelleyTransactionWitnessSet
 	TransactionMetadataSet map[uint]*cbor.LazyValue
@@ -65,27 +65,31 @@ func (AllegraBlock) Type() int {
 }
 
 func (b *AllegraBlock) Hash() string {
-	return b.Header.Hash()
+	return b.BlockHeader.Hash()
+}
+
+func (b *AllegraBlock) Header() common.BlockHeader {
+	return b.BlockHeader
 }
 
 func (b *AllegraBlock) PrevHash() string {
-	return b.Header.PrevHash()
+	return b.BlockHeader.PrevHash()
 }
 
 func (b *AllegraBlock) BlockNumber() uint64 {
-	return b.Header.BlockNumber()
+	return b.BlockHeader.BlockNumber()
 }
 
 func (b *AllegraBlock) SlotNumber() uint64 {
-	return b.Header.SlotNumber()
+	return b.BlockHeader.SlotNumber()
 }
 
 func (b *AllegraBlock) IssuerVkey() common.IssuerVkey {
-	return b.Header.IssuerVkey()
+	return b.BlockHeader.IssuerVkey()
 }
 
 func (b *AllegraBlock) BlockBodySize() uint64 {
-	return b.Header.BlockBodySize()
+	return b.BlockHeader.BlockBodySize()
 }
 
 func (b *AllegraBlock) Era() common.Era {
diff --git a/ledger/alonzo/alonzo.go b/ledger/alonzo/alonzo.go
@@ -52,7 +52,7 @@ func init() {
 type AlonzoBlock struct {
 	cbor.StructAsArray
 	cbor.DecodeStoreCbor
-	Header                 *AlonzoBlockHeader
+	BlockHeader            *AlonzoBlockHeader
 	TransactionBodies      []AlonzoTransactionBody
 	TransactionWitnessSets []AlonzoTransactionWitnessSet
 	TransactionMetadataSet map[uint]*cbor.LazyValue
@@ -68,27 +68,31 @@ func (AlonzoBlock) Type() int {
 }
 
 func (b *AlonzoBlock) Hash() string {
-	return b.Header.Hash()
+	return b.BlockHeader.Hash()
+}
+
+func (b *AlonzoBlock) Header() common.BlockHeader {
+	return b.BlockHeader
 }
 
 func (b *AlonzoBlock) PrevHash() string {
-	return b.Header.PrevHash()
+	return b.BlockHeader.PrevHash()
 }
 
 func (b *AlonzoBlock) BlockNumber() uint64 {
-	return b.Header.BlockNumber()
+	return b.BlockHeader.BlockNumber()
 }
 
 func (b *AlonzoBlock) SlotNumber() uint64 {
-	return b.Header.SlotNumber()
+	return b.BlockHeader.SlotNumber()
 }
 
 func (b *AlonzoBlock) IssuerVkey() common.IssuerVkey {
-	return b.Header.IssuerVkey()
+	return b.BlockHeader.IssuerVkey()
 }
 
 func (b *AlonzoBlock) BlockBodySize() uint64 {
-	return b.Header.BlockBodySize()
+	return b.BlockHeader.BlockBodySize()
 }
 
 func (b *AlonzoBlock) Era() common.Era {
diff --git a/ledger/babbage/babbage.go b/ledger/babbage/babbage.go
@@ -53,7 +53,7 @@ func init() {
 type BabbageBlock struct {
 	cbor.StructAsArray
 	cbor.DecodeStoreCbor
-	Header                 *BabbageBlockHeader
+	BlockHeader            *BabbageBlockHeader
 	TransactionBodies      []BabbageTransactionBody
 	TransactionWitnessSets []BabbageTransactionWitnessSet
 	TransactionMetadataSet map[uint]*cbor.LazyValue
@@ -69,27 +69,31 @@ func (BabbageBlock) Type() int {
 }
 
 func (b *BabbageBlock) Hash() string {
-	return b.Header.Hash()
+	return b.BlockHeader.Hash()
+}
+
+func (b *BabbageBlock) Header() common.BlockHeader {
+	return b.BlockHeader
 }
 
 func (b *BabbageBlock) PrevHash() string {
-	return b.Header.PrevHash()
+	return b.BlockHeader.PrevHash()
 }
 
 func (b *BabbageBlock) BlockNumber() uint64 {
-	return b.Header.BlockNumber()
+	return b.BlockHeader.BlockNumber()
 }
 
 func (b *BabbageBlock) SlotNumber() uint64 {
-	return b.Header.SlotNumber()
+	return b.BlockHeader.SlotNumber()
 }
 
 func (b *BabbageBlock) IssuerVkey() common.IssuerVkey {
-	return b.Header.IssuerVkey()
+	return b.BlockHeader.IssuerVkey()
 }
 
 func (b *BabbageBlock) BlockBodySize() uint64 {
-	return b.Header.BlockBodySize()
+	return b.BlockHeader.BlockBodySize()
 }
 
 func (b *BabbageBlock) Era() common.Era {
diff --git a/ledger/byron/byron.go b/ledger/byron/byron.go
@@ -559,9 +559,9 @@ func (h *ByronEpochBoundaryBlockHeader) Era() common.Era {
 type ByronMainBlock struct {
 	cbor.StructAsArray
 	cbor.DecodeStoreCbor
-	Header *ByronMainBlockHeader
-	Body   ByronMainBlockBody
-	Extra  []interface{}
+	BlockHeader *ByronMainBlockHeader
+	Body        ByronMainBlockBody
+	Extra       []interface{}
 }
 
 func (b *ByronMainBlock) UnmarshalCBOR(cborData []byte) error {
@@ -574,31 +574,35 @@ func (ByronMainBlock) Type() int {
 }
 
 func (b *ByronMainBlock) Hash() string {
-	return b.Header.Hash()
+	return b.BlockHeader.Hash()
+}
+
+func (b *ByronMainBlock) Header() common.BlockHeader {
+	return b.BlockHeader
 }
 
 func (b *ByronMainBlock) PrevHash() string {
-	return b.Header.PrevHash()
+	return b.BlockHeader.PrevHash()
 }
 
 func (b *ByronMainBlock) BlockNumber() uint64 {
-	return b.Header.BlockNumber()
+	return b.BlockHeader.BlockNumber()
 }
 
 func (b *ByronMainBlock) SlotNumber() uint64 {
-	return b.Header.SlotNumber()
+	return b.BlockHeader.SlotNumber()
 }
 
 func (b *ByronMainBlock) IssuerVkey() common.IssuerVkey {
-	return b.Header.IssuerVkey()
+	return b.BlockHeader.IssuerVkey()
 }
 
 func (b *ByronMainBlock) BlockBodySize() uint64 {
 	return uint64(len(b.Body.Cbor()))
 }
 
 func (b *ByronMainBlock) Era() common.Era {
-	return b.Header.Era()
+	return b.BlockHeader.Era()
 }
 
 func (b *ByronMainBlock) Transactions() []common.Transaction {
@@ -617,9 +621,9 @@ func (b *ByronMainBlock) Utxorpc() *utxorpc.Block {
 type ByronEpochBoundaryBlock struct {
 	cbor.StructAsArray
 	cbor.DecodeStoreCbor
-	Header *ByronEpochBoundaryBlockHeader
-	Body   []common.Blake2b224
-	Extra  []interface{}
+	BlockHeader *ByronEpochBoundaryBlockHeader
+	Body        []common.Blake2b224
+	Extra       []interface{}
 }
 
 func (b *ByronEpochBoundaryBlock) UnmarshalCBOR(cborData []byte) error {
@@ -632,23 +636,27 @@ func (ByronEpochBoundaryBlock) Type() int {
 }
 
 func (b *ByronEpochBoundaryBlock) Hash() string {
-	return b.Header.Hash()
+	return b.BlockHeader.Hash()
+}
+
+func (b *ByronEpochBoundaryBlock) Header() common.BlockHeader {
+	return b.BlockHeader
 }
 
 func (b *ByronEpochBoundaryBlock) PrevHash() string {
-	return b.Header.PrevHash()
+	return b.BlockHeader.PrevHash()
 }
 
 func (b *ByronEpochBoundaryBlock) BlockNumber() uint64 {
-	return b.Header.BlockNumber()
+	return b.BlockHeader.BlockNumber()
 }
 
 func (b *ByronEpochBoundaryBlock) SlotNumber() uint64 {
-	return b.Header.SlotNumber()
+	return b.BlockHeader.SlotNumber()
 }
 
 func (b *ByronEpochBoundaryBlock) IssuerVkey() common.IssuerVkey {
-	return b.Header.IssuerVkey()
+	return b.BlockHeader.IssuerVkey()
 }
 
 func (b *ByronEpochBoundaryBlock) BlockBodySize() uint64 {
@@ -657,7 +665,7 @@ func (b *ByronEpochBoundaryBlock) BlockBodySize() uint64 {
 }
 
 func (b *ByronEpochBoundaryBlock) Era() common.Era {
-	return b.Header.Era()
+	return b.BlockHeader.Era()
 }
 
 func (b *ByronEpochBoundaryBlock) Transactions() []common.Transaction {
diff --git a/ledger/common/block.go b/ledger/common/block.go
@@ -4,6 +4,7 @@ import utxorpc "github.com/utxorpc/go-codegen/utxorpc/v1alpha/cardano"
 
 type Block interface {
 	BlockHeader
+	Header() BlockHeader
 	Type() int
 	Transactions() []Transaction
 	Utxorpc() *utxorpc.Block
diff --git a/ledger/conway/conway.go b/ledger/conway/conway.go
@@ -52,7 +52,7 @@ func init() {
 type ConwayBlock struct {
 	cbor.StructAsArray
 	cbor.DecodeStoreCbor
-	Header                 *ConwayBlockHeader
+	BlockHeader            *ConwayBlockHeader
 	TransactionBodies      []ConwayTransactionBody
 	TransactionWitnessSets []ConwayTransactionWitnessSet
 	TransactionMetadataSet map[uint]*cbor.LazyValue
@@ -68,27 +68,31 @@ func (ConwayBlock) Type() int {
 }
 
 func (b *ConwayBlock) Hash() string {
-	return b.Header.Hash()
+	return b.BlockHeader.Hash()
+}
+
+func (b *ConwayBlock) Header() common.BlockHeader {
+	return b.BlockHeader
 }
 
 func (b *ConwayBlock) PrevHash() string {
-	return b.Header.PrevHash()
+	return b.BlockHeader.PrevHash()
 }
 
 func (b *ConwayBlock) BlockNumber() uint64 {
-	return b.Header.BlockNumber()
+	return b.BlockHeader.BlockNumber()
 }
 
 func (b *ConwayBlock) SlotNumber() uint64 {
-	return b.Header.SlotNumber()
+	return b.BlockHeader.SlotNumber()
 }
 
 func (b *ConwayBlock) IssuerVkey() common.IssuerVkey {
-	return b.Header.IssuerVkey()
+	return b.BlockHeader.IssuerVkey()
 }
 
 func (b *ConwayBlock) BlockBodySize() uint64 {
-	return b.Header.BlockBodySize()
+	return b.BlockHeader.BlockBodySize()
 }
 
 func (b *ConwayBlock) Era() common.Era {
diff --git a/ledger/mary/mary.go b/ledger/mary/mary.go
@@ -52,7 +52,7 @@ func init() {
 type MaryBlock struct {
 	cbor.StructAsArray
 	cbor.DecodeStoreCbor
-	Header                 *MaryBlockHeader
+	BlockHeader            *MaryBlockHeader
 	TransactionBodies      []MaryTransactionBody
 	TransactionWitnessSets []MaryTransactionWitnessSet
 	TransactionMetadataSet map[uint]*cbor.LazyValue
@@ -67,27 +67,31 @@ func (MaryBlock) Type() int {
 }
 
 func (b *MaryBlock) Hash() string {
-	return b.Header.Hash()
+	return b.BlockHeader.Hash()
+}
+
+func (b *MaryBlock) Header() common.BlockHeader {
+	return b.BlockHeader
 }
 
 func (b *MaryBlock) PrevHash() string {
-	return b.Header.PrevHash()
+	return b.BlockHeader.PrevHash()
 }
 
 func (b *MaryBlock) BlockNumber() uint64 {
-	return b.Header.BlockNumber()
+	return b.BlockHeader.BlockNumber()
 }
 
 func (b *MaryBlock) SlotNumber() uint64 {
-	return b.Header.SlotNumber()
+	return b.BlockHeader.SlotNumber()
 }
 
 func (b *MaryBlock) IssuerVkey() common.IssuerVkey {
-	return b.Header.IssuerVkey()
+	return b.BlockHeader.IssuerVkey()
 }
 
 func (b *MaryBlock) BlockBodySize() uint64 {
-	return b.Header.BlockBodySize()
+	return b.BlockHeader.BlockBodySize()
 }
 
 func (b *MaryBlock) Era() common.Era {
diff --git a/ledger/shelley/shelley.go b/ledger/shelley/shelley.go
diff --git a/ledger/verify_block_test.go b/ledger/verify_block_test.go

Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ func init() {`
`50`	`50`	`type AllegraBlock struct {`
`51`	`51`	`cbor.StructAsArray`
`52`	`52`	`cbor.DecodeStoreCbor`
`53`		`- Header *AllegraBlockHeader`
	`53`	`+ BlockHeader *AllegraBlockHeader`
`54`	`54`	`TransactionBodies []AllegraTransactionBody`
`55`	`55`	`TransactionWitnessSets []shelley.ShelleyTransactionWitnessSet`
`56`	`56`	`TransactionMetadataSet map[uint]*cbor.LazyValue`
`@@ -65,27 +65,31 @@ func (AllegraBlock) Type() int {`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`func (b *AllegraBlock) Hash() string {`
`68`		`- return b.Header.Hash()`
	`68`	`+ return b.BlockHeader.Hash()`
	`69`	`+}`
	`70`	`+`
	`71`	`+func (b *AllegraBlock) Header() common.BlockHeader {`
	`72`	`+ return b.BlockHeader`
`69`	`73`	`}`
`70`	`74`
`71`	`75`	`func (b *AllegraBlock) PrevHash() string {`
`72`		`- return b.Header.PrevHash()`
	`76`	`+ return b.BlockHeader.PrevHash()`
`73`	`77`	`}`
`74`	`78`
`75`	`79`	`func (b *AllegraBlock) BlockNumber() uint64 {`
`76`		`- return b.Header.BlockNumber()`
	`80`	`+ return b.BlockHeader.BlockNumber()`
`77`	`81`	`}`
`78`	`82`
`79`	`83`	`func (b *AllegraBlock) SlotNumber() uint64 {`
`80`		`- return b.Header.SlotNumber()`
	`84`	`+ return b.BlockHeader.SlotNumber()`
`81`	`85`	`}`
`82`	`86`
`83`	`87`	`func (b *AllegraBlock) IssuerVkey() common.IssuerVkey {`
`84`		`- return b.Header.IssuerVkey()`
	`88`	`+ return b.BlockHeader.IssuerVkey()`
`85`	`89`	`}`
`86`	`90`
`87`	`91`	`func (b *AllegraBlock) BlockBodySize() uint64 {`
`88`		`- return b.Header.BlockBodySize()`
	`92`	`+ return b.BlockHeader.BlockBodySize()`
`89`	`93`	`}`
`90`	`94`
`91`	`95`	`func (b *AllegraBlock) Era() common.Era {`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ func init() {`
`52`	`52`	`type AlonzoBlock struct {`
`53`	`53`	`cbor.StructAsArray`
`54`	`54`	`cbor.DecodeStoreCbor`
`55`		`- Header *AlonzoBlockHeader`
	`55`	`+ BlockHeader *AlonzoBlockHeader`
`56`	`56`	`TransactionBodies []AlonzoTransactionBody`
`57`	`57`	`TransactionWitnessSets []AlonzoTransactionWitnessSet`
`58`	`58`	`TransactionMetadataSet map[uint]*cbor.LazyValue`
`@@ -68,27 +68,31 @@ func (AlonzoBlock) Type() int {`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`func (b *AlonzoBlock) Hash() string {`
`71`		`- return b.Header.Hash()`
	`71`	`+ return b.BlockHeader.Hash()`
	`72`	`+}`
	`73`	`+`
	`74`	`+func (b *AlonzoBlock) Header() common.BlockHeader {`
	`75`	`+ return b.BlockHeader`
`72`	`76`	`}`
`73`	`77`
`74`	`78`	`func (b *AlonzoBlock) PrevHash() string {`
`75`		`- return b.Header.PrevHash()`
	`79`	`+ return b.BlockHeader.PrevHash()`
`76`	`80`	`}`
`77`	`81`
`78`	`82`	`func (b *AlonzoBlock) BlockNumber() uint64 {`
`79`		`- return b.Header.BlockNumber()`
	`83`	`+ return b.BlockHeader.BlockNumber()`
`80`	`84`	`}`
`81`	`85`
`82`	`86`	`func (b *AlonzoBlock) SlotNumber() uint64 {`
`83`		`- return b.Header.SlotNumber()`
	`87`	`+ return b.BlockHeader.SlotNumber()`
`84`	`88`	`}`
`85`	`89`
`86`	`90`	`func (b *AlonzoBlock) IssuerVkey() common.IssuerVkey {`
`87`		`- return b.Header.IssuerVkey()`
	`91`	`+ return b.BlockHeader.IssuerVkey()`
`88`	`92`	`}`
`89`	`93`
`90`	`94`	`func (b *AlonzoBlock) BlockBodySize() uint64 {`
`91`		`- return b.Header.BlockBodySize()`
	`95`	`+ return b.BlockHeader.BlockBodySize()`
`92`	`96`	`}`
`93`	`97`
`94`	`98`	`func (b *AlonzoBlock) Era() common.Era {`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ func init() {`
`53`	`53`	`type BabbageBlock struct {`
`54`	`54`	`cbor.StructAsArray`
`55`	`55`	`cbor.DecodeStoreCbor`
`56`		`- Header *BabbageBlockHeader`
	`56`	`+ BlockHeader *BabbageBlockHeader`
`57`	`57`	`TransactionBodies []BabbageTransactionBody`
`58`	`58`	`TransactionWitnessSets []BabbageTransactionWitnessSet`
`59`	`59`	`TransactionMetadataSet map[uint]*cbor.LazyValue`
`@@ -69,27 +69,31 @@ func (BabbageBlock) Type() int {`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`func (b *BabbageBlock) Hash() string {`
`72`		`- return b.Header.Hash()`
	`72`	`+ return b.BlockHeader.Hash()`
	`73`	`+}`
	`74`	`+`
	`75`	`+func (b *BabbageBlock) Header() common.BlockHeader {`
	`76`	`+ return b.BlockHeader`
`73`	`77`	`}`
`74`	`78`
`75`	`79`	`func (b *BabbageBlock) PrevHash() string {`
`76`		`- return b.Header.PrevHash()`
	`80`	`+ return b.BlockHeader.PrevHash()`
`77`	`81`	`}`
`78`	`82`
`79`	`83`	`func (b *BabbageBlock) BlockNumber() uint64 {`
`80`		`- return b.Header.BlockNumber()`
	`84`	`+ return b.BlockHeader.BlockNumber()`
`81`	`85`	`}`
`82`	`86`
`83`	`87`	`func (b *BabbageBlock) SlotNumber() uint64 {`
`84`		`- return b.Header.SlotNumber()`
	`88`	`+ return b.BlockHeader.SlotNumber()`
`85`	`89`	`}`
`86`	`90`
`87`	`91`	`func (b *BabbageBlock) IssuerVkey() common.IssuerVkey {`
`88`		`- return b.Header.IssuerVkey()`
	`92`	`+ return b.BlockHeader.IssuerVkey()`
`89`	`93`	`}`
`90`	`94`
`91`	`95`	`func (b *BabbageBlock) BlockBodySize() uint64 {`
`92`		`- return b.Header.BlockBodySize()`
	`96`	`+ return b.BlockHeader.BlockBodySize()`
`93`	`97`	`}`
`94`	`98`
`95`	`99`	`func (b *BabbageBlock) Era() common.Era {`
Original file line number	Diff line number	Diff line change
`@@ -559,9 +559,9 @@ func (h *ByronEpochBoundaryBlockHeader) Era() common.Era {`
`559`	`559`	`type ByronMainBlock struct {`
`560`	`560`	`cbor.StructAsArray`
`561`	`561`	`cbor.DecodeStoreCbor`
`562`		`- Header *ByronMainBlockHeader`
`563`		`- Body ByronMainBlockBody`
`564`		`- Extra []interface{}`
	`562`	`+ BlockHeader *ByronMainBlockHeader`
	`563`	`+ Body ByronMainBlockBody`
	`564`	`+ Extra []interface{}`
`565`	`565`	`}`
`566`	`566`
`567`	`567`	`func (b *ByronMainBlock) UnmarshalCBOR(cborData []byte) error {`
`@@ -574,31 +574,35 @@ func (ByronMainBlock) Type() int {`
`574`	`574`	`}`
`575`	`575`
`576`	`576`	`func (b *ByronMainBlock) Hash() string {`
`577`		`- return b.Header.Hash()`
	`577`	`+ return b.BlockHeader.Hash()`
	`578`	`+}`
	`579`	`+`
	`580`	`+func (b *ByronMainBlock) Header() common.BlockHeader {`
	`581`	`+ return b.BlockHeader`
`578`	`582`	`}`
`579`	`583`
`580`	`584`	`func (b *ByronMainBlock) PrevHash() string {`
`581`		`- return b.Header.PrevHash()`
	`585`	`+ return b.BlockHeader.PrevHash()`
`582`	`586`	`}`
`583`	`587`
`584`	`588`	`func (b *ByronMainBlock) BlockNumber() uint64 {`
`585`		`- return b.Header.BlockNumber()`
	`589`	`+ return b.BlockHeader.BlockNumber()`
`586`	`590`	`}`
`587`	`591`
`588`	`592`	`func (b *ByronMainBlock) SlotNumber() uint64 {`
`589`		`- return b.Header.SlotNumber()`
	`593`	`+ return b.BlockHeader.SlotNumber()`
`590`	`594`	`}`
`591`	`595`
`592`	`596`	`func (b *ByronMainBlock) IssuerVkey() common.IssuerVkey {`
`593`		`- return b.Header.IssuerVkey()`
	`597`	`+ return b.BlockHeader.IssuerVkey()`
`594`	`598`	`}`
`595`	`599`
`596`	`600`	`func (b *ByronMainBlock) BlockBodySize() uint64 {`
`597`	`601`	`return uint64(len(b.Body.Cbor()))`
`598`	`602`	`}`
`599`	`603`
`600`	`604`	`func (b *ByronMainBlock) Era() common.Era {`
`601`		`- return b.Header.Era()`
	`605`	`+ return b.BlockHeader.Era()`
`602`	`606`	`}`
`603`	`607`
`604`	`608`	`func (b *ByronMainBlock) Transactions() []common.Transaction {`
`@@ -617,9 +621,9 @@ func (b ByronMainBlock) Utxorpc() utxorpc.Block {`
`617`	`621`	`type ByronEpochBoundaryBlock struct {`
`618`	`622`	`cbor.StructAsArray`
`619`	`623`	`cbor.DecodeStoreCbor`
`620`		`- Header *ByronEpochBoundaryBlockHeader`
`621`		`- Body []common.Blake2b224`
`622`		`- Extra []interface{}`
	`624`	`+ BlockHeader *ByronEpochBoundaryBlockHeader`
	`625`	`+ Body []common.Blake2b224`
	`626`	`+ Extra []interface{}`
`623`	`627`	`}`
`624`	`628`
`625`	`629`	`func (b *ByronEpochBoundaryBlock) UnmarshalCBOR(cborData []byte) error {`
`@@ -632,23 +636,27 @@ func (ByronEpochBoundaryBlock) Type() int {`
`632`	`636`	`}`
`633`	`637`
`634`	`638`	`func (b *ByronEpochBoundaryBlock) Hash() string {`
`635`		`- return b.Header.Hash()`
	`639`	`+ return b.BlockHeader.Hash()`
	`640`	`+}`
	`641`	`+`
	`642`	`+func (b *ByronEpochBoundaryBlock) Header() common.BlockHeader {`
	`643`	`+ return b.BlockHeader`
`636`	`644`	`}`
`637`	`645`
`638`	`646`	`func (b *ByronEpochBoundaryBlock) PrevHash() string {`
`639`		`- return b.Header.PrevHash()`
	`647`	`+ return b.BlockHeader.PrevHash()`
`640`	`648`	`}`
`641`	`649`
`642`	`650`	`func (b *ByronEpochBoundaryBlock) BlockNumber() uint64 {`
`643`		`- return b.Header.BlockNumber()`
	`651`	`+ return b.BlockHeader.BlockNumber()`
`644`	`652`	`}`
`645`	`653`
`646`	`654`	`func (b *ByronEpochBoundaryBlock) SlotNumber() uint64 {`
`647`		`- return b.Header.SlotNumber()`
	`655`	`+ return b.BlockHeader.SlotNumber()`
`648`	`656`	`}`
`649`	`657`
`650`	`658`	`func (b *ByronEpochBoundaryBlock) IssuerVkey() common.IssuerVkey {`
`651`		`- return b.Header.IssuerVkey()`
	`659`	`+ return b.BlockHeader.IssuerVkey()`
`652`	`660`	`}`
`653`	`661`
`654`	`662`	`func (b *ByronEpochBoundaryBlock) BlockBodySize() uint64 {`
`@@ -657,7 +665,7 @@ func (b *ByronEpochBoundaryBlock) BlockBodySize() uint64 {`
`657`	`665`	`}`
`658`	`666`
`659`	`667`	`func (b *ByronEpochBoundaryBlock) Era() common.Era {`
`660`		`- return b.Header.Era()`
	`668`	`+ return b.BlockHeader.Era()`
`661`	`669`	`}`
`662`	`670`
`663`	`671`	`func (b *ByronEpochBoundaryBlock) Transactions() []common.Transaction {`