Merge pull request #215 from cloudstruct/fix/ntc-chainsync-decode-error

agaffney · web-flow · commit ad654fe7ef21 · 2023-03-15T08:10:32.000-05:00
fix: store block type/CBOR in MsgRollForwardNtC
diff --git a/cbor/cbor.go b/cbor/cbor.go
@@ -1,11 +1,7 @@
 package cbor
 
 import (
-	"fmt"
-	"reflect"
-
 	_cbor "github.com/fxamacker/cbor/v2"
-	"github.com/jinzhu/copier"
 )
 
 const (
@@ -46,32 +42,9 @@ func (d *DecodeStoreCbor) Cbor() []byte {
 	return d.cborData
 }
 
-// UnmarshalCborGeneric decodes the specified CBOR into the destination object without using the
-// destination object's UnmarshalCBOR() function
-func (d *DecodeStoreCbor) UnmarshalCborGeneric(cborData []byte, dest DecodeStoreCborInterface) error {
-	// Create a duplicate(-ish) struct from the destination
-	// We do this so that we can bypass any custom UnmarshalCBOR() function on the
-	// destination object
-	valueDest := reflect.ValueOf(dest)
-	if valueDest.Kind() != reflect.Pointer || valueDest.Elem().Kind() != reflect.Struct {
-		return fmt.Errorf("destination must be a pointer to a struct")
-	}
-	typeDestElem := valueDest.Elem().Type()
-	destTypeFields := []reflect.StructField{}
-	for i := 0; i < typeDestElem.NumField(); i++ {
-		tmpField := typeDestElem.Field(i)
-		if tmpField.IsExported() && tmpField.Name != "DecodeStoreCbor" {
-			destTypeFields = append(destTypeFields, tmpField)
-		}
-	}
-	// Create temporary object with the type created above
-	tmpDest := reflect.New(reflect.StructOf(destTypeFields))
-	// Decode CBOR into temporary object
-	if _, err := Decode(cborData, tmpDest.Interface()); err != nil {
-		return err
-	}
-	// Copy values from temporary object into destination object
-	if err := copier.Copy(dest, tmpDest.Interface()); err != nil {
+// UnmarshalCbor decodes the specified CBOR into the destination object and saves the original CBOR
+func (d *DecodeStoreCbor) UnmarshalCbor(cborData []byte, dest DecodeStoreCborInterface) error {
+	if err := DecodeGeneric(cborData, dest); err != nil {
 		return err
 	}
 	// Store a copy of the original CBOR data
diff --git a/cbor/decode.go b/cbor/decode.go
@@ -3,8 +3,10 @@ package cbor
 import (
 	"bytes"
 	"fmt"
+	"reflect"
 
 	_cbor "github.com/fxamacker/cbor/v2"
+	"github.com/jinzhu/copier"
 )
 
 func Decode(dataBytes []byte, dest interface{}) (int, error) {
@@ -78,3 +80,34 @@ func DecodeById(cborData []byte, idMap map[int]interface{}) (interface{}, error)
 	}
 	return ret, nil
 }
+
+// DecodeGeneric decodes the specified CBOR into the destination object without using the
+// destination object's UnmarshalCBOR() function
+func DecodeGeneric(cborData []byte, dest interface{}) error {
+	// Create a duplicate(-ish) struct from the destination
+	// We do this so that we can bypass any custom UnmarshalCBOR() function on the
+	// destination object
+	valueDest := reflect.ValueOf(dest)
+	if valueDest.Kind() != reflect.Pointer || valueDest.Elem().Kind() != reflect.Struct {
+		return fmt.Errorf("destination must be a pointer to a struct")
+	}
+	typeDestElem := valueDest.Elem().Type()
+	destTypeFields := []reflect.StructField{}
+	for i := 0; i < typeDestElem.NumField(); i++ {
+		tmpField := typeDestElem.Field(i)
+		if tmpField.IsExported() && tmpField.Name != "DecodeStoreCbor" {
+			destTypeFields = append(destTypeFields, tmpField)
+		}
+	}
+	// Create temporary object with the type created above
+	tmpDest := reflect.New(reflect.StructOf(destTypeFields))
+	// Decode CBOR into temporary object
+	if _, err := Decode(cborData, tmpDest.Interface()); err != nil {
+		return err
+	}
+	// Copy values from temporary object into destination object
+	if err := copier.Copy(dest, tmpDest.Interface()); err != nil {
+		return err
+	}
+	return nil
+}
diff --git a/ledger/allegra.go b/ledger/allegra.go
@@ -26,7 +26,7 @@ type AllegraBlock struct {
 }
 
 func (b *AllegraBlock) UnmarshalCBOR(cborData []byte) error {
-	return b.UnmarshalCborGeneric(cborData, b)
+	return b.UnmarshalCbor(cborData, b)
 }
 
 func (b *AllegraBlock) Hash() string {
@@ -69,7 +69,7 @@ type AllegraTransactionBody struct {
 }
 
 func (b *AllegraTransactionBody) UnmarshalCBOR(cborData []byte) error {
-	return b.UnmarshalCborGeneric(cborData, b)
+	return b.UnmarshalCbor(cborData, b)
 }
 
 type AllegraTransaction struct {
@@ -82,23 +82,23 @@ type AllegraTransaction struct {
 func NewAllegraBlockFromCbor(data []byte) (*AllegraBlock, error) {
 	var allegraBlock AllegraBlock
 	if _, err := cbor.Decode(data, &allegraBlock); err != nil {
-		return nil, fmt.Errorf("decode error: %s", err)
+		return nil, fmt.Errorf("Allegra block decode error: %s", err)
 	}
 	return &allegraBlock, nil
 }
 
 func NewAllegraTransactionBodyFromCbor(data []byte) (*AllegraTransactionBody, error) {
 	var allegraTx AllegraTransactionBody
 	if _, err := cbor.Decode(data, &allegraTx); err != nil {
-		return nil, fmt.Errorf("decode error: %s", err)
+		return nil, fmt.Errorf("Allegra transaction body decode error: %s", err)
 	}
 	return &allegraTx, nil
 }
 
 func NewAllegraTransactionFromCbor(data []byte) (*AllegraTransaction, error) {
 	var allegraTx AllegraTransaction
 	if _, err := cbor.Decode(data, &allegraTx); err != nil {
-		return nil, fmt.Errorf("decode error: %s", err)
+		return nil, fmt.Errorf("Allegra transaction decode error: %s", err)
 	}
 	return &allegraTx, nil
 }
diff --git a/ledger/alonzo.go b/ledger/alonzo.go
@@ -27,7 +27,7 @@ type AlonzoBlock struct {
 }
 
 func (b *AlonzoBlock) UnmarshalCBOR(cborData []byte) error {
-	return b.UnmarshalCborGeneric(cborData, b)
+	return b.UnmarshalCbor(cborData, b)
 }
 
 func (b *AlonzoBlock) Hash() string {
@@ -74,7 +74,7 @@ type AlonzoTransactionBody struct {
 }
 
 func (b *AlonzoTransactionBody) UnmarshalCBOR(cborData []byte) error {
-	return b.UnmarshalCborGeneric(cborData, b)
+	return b.UnmarshalCbor(cborData, b)
 }
 
 type AlonzoTransactionOutput struct {
@@ -93,7 +93,7 @@ func (o *AlonzoTransactionOutput) UnmarshalCBOR(cborData []byte) error {
 		o.Address = tmpOutput.Address
 		o.Amount = tmpOutput.Amount
 	} else {
-		return o.UnmarshalCborGeneric(cborData, o)
+		return o.UnmarshalCbor(cborData, o)
 	}
 	return nil
 }
@@ -116,23 +116,23 @@ type AlonzoTransaction struct {
 func NewAlonzoBlockFromCbor(data []byte) (*AlonzoBlock, error) {
 	var alonzoBlock AlonzoBlock
 	if _, err := cbor.Decode(data, &alonzoBlock); err != nil {
-		return nil, fmt.Errorf("decode error: %s", err)
+		return nil, fmt.Errorf("Alonzo block decode error: %s", err)
 	}
 	return &alonzoBlock, nil
 }
 
 func NewAlonzoTransactionBodyFromCbor(data []byte) (*AlonzoTransactionBody, error) {
 	var alonzoTx AlonzoTransactionBody
 	if _, err := cbor.Decode(data, &alonzoTx); err != nil {
-		return nil, fmt.Errorf("decode error: %s", err)
+		return nil, fmt.Errorf("Alonzo transaction body decode error: %s", err)
 	}
 	return &alonzoTx, nil
 }
 
 func NewAlonzoTransactionFromCbor(data []byte) (*AlonzoTransaction, error) {
 	var alonzoTx AlonzoTransaction
 	if _, err := cbor.Decode(data, &alonzoTx); err != nil {
-		return nil, fmt.Errorf("decode error: %s", err)
+		return nil, fmt.Errorf("Alonzo transaction decode error: %s", err)
 	}
 	return &alonzoTx, nil
 }
diff --git a/ledger/babbage.go b/ledger/babbage.go
@@ -27,7 +27,7 @@ type BabbageBlock struct {
 }
 
 func (b *BabbageBlock) UnmarshalCBOR(cborData []byte) error {
-	return b.UnmarshalCborGeneric(cborData, b)
+	return b.UnmarshalCbor(cborData, b)
 }
 
 func (b *BabbageBlock) Hash() string {
@@ -87,7 +87,7 @@ type BabbageBlockHeader struct {
 }
 
 func (h *BabbageBlockHeader) UnmarshalCBOR(cborData []byte) error {
-	return h.UnmarshalCborGeneric(cborData, h)
+	return h.UnmarshalCbor(cborData, h)
 }
 
 func (h *BabbageBlockHeader) Hash() string {
@@ -118,11 +118,10 @@ type BabbageTransactionBody struct {
 }
 
 func (b *BabbageTransactionBody) UnmarshalCBOR(cborData []byte) error {
-	return b.UnmarshalCborGeneric(cborData, b)
+	return b.UnmarshalCbor(cborData, b)
 }
 
 type BabbageTransactionOutput struct {
-	cbor.DecodeStoreCbor
 	Address      Blake2b256        `cbor:"0,keyasint,omitempty"`
 	Amount       cbor.Value        `cbor:"1,keyasint,omitempty"`
 	DatumOption  []cbor.RawMessage `cbor:"2,keyasint,omitempty"`
@@ -139,7 +138,7 @@ func (o *BabbageTransactionOutput) UnmarshalCBOR(cborData []byte) error {
 		o.Amount = tmpOutput.Amount
 		o.legacyOutput = true
 	} else {
-		return o.UnmarshalCborGeneric(cborData, o)
+		return cbor.DecodeGeneric(cborData, o)
 	}
 	return nil
 }
@@ -160,31 +159,31 @@ type BabbageTransaction struct {
 func NewBabbageBlockFromCbor(data []byte) (*BabbageBlock, error) {
 	var babbageBlock BabbageBlock
 	if _, err := cbor.Decode(data, &babbageBlock); err != nil {
-		return nil, fmt.Errorf("decode error: %s", err)
+		return nil, fmt.Errorf("Babbage block decode error: %s", err)
 	}
 	return &babbageBlock, nil
 }
 
 func NewBabbageBlockHeaderFromCbor(data []byte) (*BabbageBlockHeader, error) {
 	var babbageBlockHeader BabbageBlockHeader
 	if _, err := cbor.Decode(data, &babbageBlockHeader); err != nil {
-		return nil, fmt.Errorf("decode error: %s", err)
+		return nil, fmt.Errorf("Babbage block header decode error: %s", err)
 	}
 	return &babbageBlockHeader, nil
 }
 
 func NewBabbageTransactionBodyFromCbor(data []byte) (*BabbageTransactionBody, error) {
 	var babbageTx BabbageTransactionBody
 	if _, err := cbor.Decode(data, &babbageTx); err != nil {
-		return nil, fmt.Errorf("decode error: %s", err)
+		return nil, fmt.Errorf("Babbage transaction body decode error: %s", err)
 	}
 	return &babbageTx, nil
 }
 
 func NewBabbageTransactionFromCbor(data []byte) (*BabbageTransaction, error) {
 	var babbageTx BabbageTransaction
 	if _, err := cbor.Decode(data, &babbageTx); err != nil {
-		return nil, fmt.Errorf("decode error: %s", err)
+		return nil, fmt.Errorf("Babbage transaction decode error: %s", err)
 	}
 	return &babbageTx, nil
 }
diff --git a/ledger/byron.go b/ledger/byron.go
@@ -58,7 +58,7 @@ type ByronMainBlockHeader struct {
 }
 
 func (h *ByronMainBlockHeader) UnmarshalCBOR(cborData []byte) error {
-	return h.UnmarshalCborGeneric(cborData, h)
+	return h.UnmarshalCbor(cborData, h)
 }
 
 func (h *ByronMainBlockHeader) Hash() string {
@@ -117,7 +117,7 @@ type ByronEpochBoundaryBlockHeader struct {
 }
 
 func (h *ByronEpochBoundaryBlockHeader) UnmarshalCBOR(cborData []byte) error {
-	return h.UnmarshalCborGeneric(cborData, h)
+	return h.UnmarshalCbor(cborData, h)
 }
 
 func (h *ByronEpochBoundaryBlockHeader) Hash() string {
@@ -153,7 +153,7 @@ type ByronMainBlock struct {
 }
 
 func (b *ByronMainBlock) UnmarshalCBOR(cborData []byte) error {
-	return b.UnmarshalCborGeneric(cborData, b)
+	return b.UnmarshalCbor(cborData, b)
 }
 
 func (b *ByronMainBlock) Hash() string {
@@ -186,7 +186,7 @@ type ByronEpochBoundaryBlock struct {
 }
 
 func (b *ByronEpochBoundaryBlock) UnmarshalCBOR(cborData []byte) error {
-	return b.UnmarshalCborGeneric(cborData, b)
+	return b.UnmarshalCbor(cborData, b)
 }
 
 func (b *ByronEpochBoundaryBlock) Hash() string {
@@ -213,47 +213,47 @@ func (b *ByronEpochBoundaryBlock) Transactions() []TransactionBody {
 func NewByronEpochBoundaryBlockFromCbor(data []byte) (*ByronEpochBoundaryBlock, error) {
 	var byronEbbBlock ByronEpochBoundaryBlock
 	if _, err := cbor.Decode(data, &byronEbbBlock); err != nil {
-		return nil, fmt.Errorf("decode error: %s", err)
+		return nil, fmt.Errorf("Byron EBB block decode error: %s", err)
 	}
 	return &byronEbbBlock, nil
 }
 
 func NewByronEpochBoundaryBlockHeaderFromCbor(data []byte) (*ByronEpochBoundaryBlockHeader, error) {
 	var byronEbbBlockHeader ByronEpochBoundaryBlockHeader
 	if _, err := cbor.Decode(data, &byronEbbBlockHeader); err != nil {
-		return nil, fmt.Errorf("decode error: %s", err)
+		return nil, fmt.Errorf("Byron EBB block header decode error: %s", err)
 	}
 	return &byronEbbBlockHeader, nil
 }
 
 func NewByronMainBlockFromCbor(data []byte) (*ByronMainBlock, error) {
 	var byronMainBlock ByronMainBlock
 	if _, err := cbor.Decode(data, &byronMainBlock); err != nil {
-		return nil, fmt.Errorf("decode error: %s", err)
+		return nil, fmt.Errorf("Byron main block decode error: %s", err)
 	}
 	return &byronMainBlock, nil
 }
 
 func NewByronMainBlockHeaderFromCbor(data []byte) (*ByronMainBlockHeader, error) {
 	var byronMainBlockHeader ByronMainBlockHeader
 	if _, err := cbor.Decode(data, &byronMainBlockHeader); err != nil {
-		return nil, fmt.Errorf("decode error: %s", err)
+		return nil, fmt.Errorf("Byron main block header decode error: %s", err)
 	}
 	return &byronMainBlockHeader, nil
 }
 
 func NewByronTransactionBodyFromCbor(data []byte) (*ByronTransactionBody, error) {
 	var byronTx ByronTransactionBody
 	if _, err := cbor.Decode(data, &byronTx); err != nil {
-		return nil, fmt.Errorf("decode error: %s", err)
+		return nil, fmt.Errorf("Byron transaction body decode error: %s", err)
 	}
 	return &byronTx, nil
 }
 
 func NewByronTransactionFromCbor(data []byte) (*ByronTransaction, error) {
 	var byronTx ByronTransaction
 	if _, err := cbor.Decode(data, &byronTx); err != nil {
-		return nil, fmt.Errorf("decode error: %s", err)
+		return nil, fmt.Errorf("Byron transaction decode error: %s", err)
 	}
 	return &byronTx, nil
 }
diff --git a/ledger/mary.go b/ledger/mary.go
diff --git a/ledger/shelley.go b/ledger/shelley.go
diff --git a/protocol/chainsync/messages.go b/protocol/chainsync/messages.go

Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ type AllegraBlock struct {`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`func (b *AllegraBlock) UnmarshalCBOR(cborData []byte) error {`
`29`		`- return b.UnmarshalCborGeneric(cborData, b)`
	`29`	`+ return b.UnmarshalCbor(cborData, b)`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`func (b *AllegraBlock) Hash() string {`
`@@ -69,7 +69,7 @@ type AllegraTransactionBody struct {`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`func (b *AllegraTransactionBody) UnmarshalCBOR(cborData []byte) error {`
`72`		`- return b.UnmarshalCborGeneric(cborData, b)`
	`72`	`+ return b.UnmarshalCbor(cborData, b)`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`type AllegraTransaction struct {`
`@@ -82,23 +82,23 @@ type AllegraTransaction struct {`
`82`	`82`	`func NewAllegraBlockFromCbor(data []byte) (*AllegraBlock, error) {`
`83`	`83`	`var allegraBlock AllegraBlock`
`84`	`84`	`if _, err := cbor.Decode(data, &allegraBlock); err != nil {`
`85`		`- return nil, fmt.Errorf("decode error: %s", err)`
	`85`	`+ return nil, fmt.Errorf("Allegra block decode error: %s", err)`
`86`	`86`	`}`
`87`	`87`	`return &allegraBlock, nil`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`func NewAllegraTransactionBodyFromCbor(data []byte) (*AllegraTransactionBody, error) {`
`91`	`91`	`var allegraTx AllegraTransactionBody`
`92`	`92`	`if _, err := cbor.Decode(data, &allegraTx); err != nil {`
`93`		`- return nil, fmt.Errorf("decode error: %s", err)`
	`93`	`+ return nil, fmt.Errorf("Allegra transaction body decode error: %s", err)`
`94`	`94`	`}`
`95`	`95`	`return &allegraTx, nil`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`func NewAllegraTransactionFromCbor(data []byte) (*AllegraTransaction, error) {`
`99`	`99`	`var allegraTx AllegraTransaction`
`100`	`100`	`if _, err := cbor.Decode(data, &allegraTx); err != nil {`
`101`		`- return nil, fmt.Errorf("decode error: %s", err)`
	`101`	`+ return nil, fmt.Errorf("Allegra transaction decode error: %s", err)`
`102`	`102`	`}`
`103`	`103`	`return &allegraTx, nil`
`104`	`104`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ type AlonzoBlock struct {`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`func (b *AlonzoBlock) UnmarshalCBOR(cborData []byte) error {`
`30`		`- return b.UnmarshalCborGeneric(cborData, b)`
	`30`	`+ return b.UnmarshalCbor(cborData, b)`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`func (b *AlonzoBlock) Hash() string {`
`@@ -74,7 +74,7 @@ type AlonzoTransactionBody struct {`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`func (b *AlonzoTransactionBody) UnmarshalCBOR(cborData []byte) error {`
`77`		`- return b.UnmarshalCborGeneric(cborData, b)`
	`77`	`+ return b.UnmarshalCbor(cborData, b)`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`type AlonzoTransactionOutput struct {`
`@@ -93,7 +93,7 @@ func (o *AlonzoTransactionOutput) UnmarshalCBOR(cborData []byte) error {`
`93`	`93`	`o.Address = tmpOutput.Address`
`94`	`94`	`o.Amount = tmpOutput.Amount`
`95`	`95`	`} else {`
`96`		`- return o.UnmarshalCborGeneric(cborData, o)`
	`96`	`+ return o.UnmarshalCbor(cborData, o)`
`97`	`97`	`}`
`98`	`98`	`return nil`
`99`	`99`	`}`
`@@ -116,23 +116,23 @@ type AlonzoTransaction struct {`
`116`	`116`	`func NewAlonzoBlockFromCbor(data []byte) (*AlonzoBlock, error) {`
`117`	`117`	`var alonzoBlock AlonzoBlock`
`118`	`118`	`if _, err := cbor.Decode(data, &alonzoBlock); err != nil {`
`119`		`- return nil, fmt.Errorf("decode error: %s", err)`
	`119`	`+ return nil, fmt.Errorf("Alonzo block decode error: %s", err)`
`120`	`120`	`}`
`121`	`121`	`return &alonzoBlock, nil`
`122`	`122`	`}`
`123`	`123`
`124`	`124`	`func NewAlonzoTransactionBodyFromCbor(data []byte) (*AlonzoTransactionBody, error) {`
`125`	`125`	`var alonzoTx AlonzoTransactionBody`
`126`	`126`	`if _, err := cbor.Decode(data, &alonzoTx); err != nil {`
`127`		`- return nil, fmt.Errorf("decode error: %s", err)`
	`127`	`+ return nil, fmt.Errorf("Alonzo transaction body decode error: %s", err)`
`128`	`128`	`}`
`129`	`129`	`return &alonzoTx, nil`
`130`	`130`	`}`
`131`	`131`
`132`	`132`	`func NewAlonzoTransactionFromCbor(data []byte) (*AlonzoTransaction, error) {`
`133`	`133`	`var alonzoTx AlonzoTransaction`
`134`	`134`	`if _, err := cbor.Decode(data, &alonzoTx); err != nil {`
`135`		`- return nil, fmt.Errorf("decode error: %s", err)`
	`135`	`+ return nil, fmt.Errorf("Alonzo transaction decode error: %s", err)`
`136`	`136`	`}`
`137`	`137`	`return &alonzoTx, nil`
`138`	`138`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ type BabbageBlock struct {`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`func (b *BabbageBlock) UnmarshalCBOR(cborData []byte) error {`
`30`		`- return b.UnmarshalCborGeneric(cborData, b)`
	`30`	`+ return b.UnmarshalCbor(cborData, b)`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`func (b *BabbageBlock) Hash() string {`
`@@ -87,7 +87,7 @@ type BabbageBlockHeader struct {`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`func (h *BabbageBlockHeader) UnmarshalCBOR(cborData []byte) error {`
`90`		`- return h.UnmarshalCborGeneric(cborData, h)`
	`90`	`+ return h.UnmarshalCbor(cborData, h)`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`func (h *BabbageBlockHeader) Hash() string {`
`@@ -118,11 +118,10 @@ type BabbageTransactionBody struct {`
`118`	`118`	`}`
`119`	`119`
`120`	`120`	`func (b *BabbageTransactionBody) UnmarshalCBOR(cborData []byte) error {`
`121`		`- return b.UnmarshalCborGeneric(cborData, b)`
	`121`	`+ return b.UnmarshalCbor(cborData, b)`
`122`	`122`	`}`
`123`	`123`
`124`	`124`	`type BabbageTransactionOutput struct {`
`125`		`- cbor.DecodeStoreCbor`
`126`	`125`	Address Blake2b256 `cbor:"0,keyasint,omitempty"`
`127`	`126`	Amount cbor.Value `cbor:"1,keyasint,omitempty"`
`128`	`127`	DatumOption []cbor.RawMessage `cbor:"2,keyasint,omitempty"`
`@@ -139,7 +138,7 @@ func (o *BabbageTransactionOutput) UnmarshalCBOR(cborData []byte) error {`
`139`	`138`	`o.Amount = tmpOutput.Amount`
`140`	`139`	`o.legacyOutput = true`
`141`	`140`	`} else {`
`142`		`- return o.UnmarshalCborGeneric(cborData, o)`
	`141`	`+ return cbor.DecodeGeneric(cborData, o)`
`143`	`142`	`}`
`144`	`143`	`return nil`
`145`	`144`	`}`
`@@ -160,31 +159,31 @@ type BabbageTransaction struct {`
`160`	`159`	`func NewBabbageBlockFromCbor(data []byte) (*BabbageBlock, error) {`
`161`	`160`	`var babbageBlock BabbageBlock`
`162`	`161`	`if _, err := cbor.Decode(data, &babbageBlock); err != nil {`
`163`		`- return nil, fmt.Errorf("decode error: %s", err)`
	`162`	`+ return nil, fmt.Errorf("Babbage block decode error: %s", err)`
`164`	`163`	`}`
`165`	`164`	`return &babbageBlock, nil`
`166`	`165`	`}`
`167`	`166`
`168`	`167`	`func NewBabbageBlockHeaderFromCbor(data []byte) (*BabbageBlockHeader, error) {`
`169`	`168`	`var babbageBlockHeader BabbageBlockHeader`
`170`	`169`	`if _, err := cbor.Decode(data, &babbageBlockHeader); err != nil {`
`171`		`- return nil, fmt.Errorf("decode error: %s", err)`
	`170`	`+ return nil, fmt.Errorf("Babbage block header decode error: %s", err)`
`172`	`171`	`}`
`173`	`172`	`return &babbageBlockHeader, nil`
`174`	`173`	`}`
`175`	`174`
`176`	`175`	`func NewBabbageTransactionBodyFromCbor(data []byte) (*BabbageTransactionBody, error) {`
`177`	`176`	`var babbageTx BabbageTransactionBody`
`178`	`177`	`if _, err := cbor.Decode(data, &babbageTx); err != nil {`
`179`		`- return nil, fmt.Errorf("decode error: %s", err)`
	`178`	`+ return nil, fmt.Errorf("Babbage transaction body decode error: %s", err)`
`180`	`179`	`}`
`181`	`180`	`return &babbageTx, nil`
`182`	`181`	`}`
`183`	`182`
`184`	`183`	`func NewBabbageTransactionFromCbor(data []byte) (*BabbageTransaction, error) {`
`185`	`184`	`var babbageTx BabbageTransaction`
`186`	`185`	`if _, err := cbor.Decode(data, &babbageTx); err != nil {`
`187`		`- return nil, fmt.Errorf("decode error: %s", err)`
	`186`	`+ return nil, fmt.Errorf("Babbage transaction decode error: %s", err)`
`188`	`187`	`}`
`189`	`188`	`return &babbageTx, nil`
`190`	`189`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ type ByronMainBlockHeader struct {`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`func (h *ByronMainBlockHeader) UnmarshalCBOR(cborData []byte) error {`
`61`		`- return h.UnmarshalCborGeneric(cborData, h)`
	`61`	`+ return h.UnmarshalCbor(cborData, h)`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`func (h *ByronMainBlockHeader) Hash() string {`
`@@ -117,7 +117,7 @@ type ByronEpochBoundaryBlockHeader struct {`
`117`	`117`	`}`
`118`	`118`
`119`	`119`	`func (h *ByronEpochBoundaryBlockHeader) UnmarshalCBOR(cborData []byte) error {`
`120`		`- return h.UnmarshalCborGeneric(cborData, h)`
	`120`	`+ return h.UnmarshalCbor(cborData, h)`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`func (h *ByronEpochBoundaryBlockHeader) Hash() string {`
`@@ -153,7 +153,7 @@ type ByronMainBlock struct {`
`153`	`153`	`}`
`154`	`154`
`155`	`155`	`func (b *ByronMainBlock) UnmarshalCBOR(cborData []byte) error {`
`156`		`- return b.UnmarshalCborGeneric(cborData, b)`
	`156`	`+ return b.UnmarshalCbor(cborData, b)`
`157`	`157`	`}`
`158`	`158`
`159`	`159`	`func (b *ByronMainBlock) Hash() string {`
`@@ -186,7 +186,7 @@ type ByronEpochBoundaryBlock struct {`
`186`	`186`	`}`
`187`	`187`
`188`	`188`	`func (b *ByronEpochBoundaryBlock) UnmarshalCBOR(cborData []byte) error {`
`189`		`- return b.UnmarshalCborGeneric(cborData, b)`
	`189`	`+ return b.UnmarshalCbor(cborData, b)`
`190`	`190`	`}`
`191`	`191`
`192`	`192`	`func (b *ByronEpochBoundaryBlock) Hash() string {`
`@@ -213,47 +213,47 @@ func (b *ByronEpochBoundaryBlock) Transactions() []TransactionBody {`
`213`	`213`	`func NewByronEpochBoundaryBlockFromCbor(data []byte) (*ByronEpochBoundaryBlock, error) {`
`214`	`214`	`var byronEbbBlock ByronEpochBoundaryBlock`
`215`	`215`	`if _, err := cbor.Decode(data, &byronEbbBlock); err != nil {`
`216`		`- return nil, fmt.Errorf("decode error: %s", err)`
	`216`	`+ return nil, fmt.Errorf("Byron EBB block decode error: %s", err)`
`217`	`217`	`}`
`218`	`218`	`return &byronEbbBlock, nil`
`219`	`219`	`}`
`220`	`220`
`221`	`221`	`func NewByronEpochBoundaryBlockHeaderFromCbor(data []byte) (*ByronEpochBoundaryBlockHeader, error) {`
`222`	`222`	`var byronEbbBlockHeader ByronEpochBoundaryBlockHeader`
`223`	`223`	`if _, err := cbor.Decode(data, &byronEbbBlockHeader); err != nil {`
`224`		`- return nil, fmt.Errorf("decode error: %s", err)`
	`224`	`+ return nil, fmt.Errorf("Byron EBB block header decode error: %s", err)`
`225`	`225`	`}`
`226`	`226`	`return &byronEbbBlockHeader, nil`
`227`	`227`	`}`
`228`	`228`
`229`	`229`	`func NewByronMainBlockFromCbor(data []byte) (*ByronMainBlock, error) {`
`230`	`230`	`var byronMainBlock ByronMainBlock`
`231`	`231`	`if _, err := cbor.Decode(data, &byronMainBlock); err != nil {`
`232`		`- return nil, fmt.Errorf("decode error: %s", err)`
	`232`	`+ return nil, fmt.Errorf("Byron main block decode error: %s", err)`
`233`	`233`	`}`
`234`	`234`	`return &byronMainBlock, nil`
`235`	`235`	`}`
`236`	`236`
`237`	`237`	`func NewByronMainBlockHeaderFromCbor(data []byte) (*ByronMainBlockHeader, error) {`
`238`	`238`	`var byronMainBlockHeader ByronMainBlockHeader`
`239`	`239`	`if _, err := cbor.Decode(data, &byronMainBlockHeader); err != nil {`
`240`		`- return nil, fmt.Errorf("decode error: %s", err)`
	`240`	`+ return nil, fmt.Errorf("Byron main block header decode error: %s", err)`
`241`	`241`	`}`
`242`	`242`	`return &byronMainBlockHeader, nil`
`243`	`243`	`}`
`244`	`244`
`245`	`245`	`func NewByronTransactionBodyFromCbor(data []byte) (*ByronTransactionBody, error) {`
`246`	`246`	`var byronTx ByronTransactionBody`
`247`	`247`	`if _, err := cbor.Decode(data, &byronTx); err != nil {`
`248`		`- return nil, fmt.Errorf("decode error: %s", err)`
	`248`	`+ return nil, fmt.Errorf("Byron transaction body decode error: %s", err)`
`249`	`249`	`}`
`250`	`250`	`return &byronTx, nil`
`251`	`251`	`}`
`252`	`252`
`253`	`253`	`func NewByronTransactionFromCbor(data []byte) (*ByronTransaction, error) {`
`254`	`254`	`var byronTx ByronTransaction`
`255`	`255`	`if _, err := cbor.Decode(data, &byronTx); err != nil {`
`256`		`- return nil, fmt.Errorf("decode error: %s", err)`
	`256`	`+ return nil, fmt.Errorf("Byron transaction decode error: %s", err)`
`257`	`257`	`}`
`258`	`258`	`return &byronTx, nil`
`259`	`259`	`}`