fix: use %w for errors (#917)

wolf31o2 · web-flow · commit fcc436495fd5 · 2025-02-28T10:52:10.000-05:00
Signed-off-by: Chris Gianelloni &lt;wolf31o2@blinklabs.io&gt;
diff --git a/cmd/gouroboros/server.go b/cmd/gouroboros/server.go
@@ -43,16 +43,16 @@ func createListenerSocket(f *globalFlags) (net.Listener, error) {
 	switch {
 	case f.socket != "":
 		if err := os.Remove(f.socket); err != nil {
-			return nil, fmt.Errorf("failed to remove existing socket: %s", err)
+			return nil, fmt.Errorf("failed to remove existing socket: %w", err)
 		}
 		listen, err = net.Listen("unix", f.socket)
 		if err != nil {
-			return nil, fmt.Errorf("failed to open listening socket: %s", err)
+			return nil, fmt.Errorf("failed to open listening socket: %w", err)
 		}
 	case f.address != "":
 		listen, err = net.Listen("tcp", f.address)
 		if err != nil {
-			return nil, fmt.Errorf("failed to open listening socket: %s", err)
+			return nil, fmt.Errorf("failed to open listening socket: %w", err)
 		}
 	default:
 		return nil, fmt.Errorf("no listening address or socket specified")
diff --git a/connection.go b/connection.go
@@ -282,7 +282,7 @@ func (c *Connection) setupConnection() error {
 				c.errorChan <- io.EOF
 			} else {
 				// Wrap error message to denote it comes from the muxer
-				c.errorChan <- fmt.Errorf("muxer error: %s", err)
+				c.errorChan <- fmt.Errorf("muxer error: %w", err)
 			}
 			// Close connection on muxer errors
 			c.Close()
@@ -368,7 +368,7 @@ func (c *Connection) setupConnection() error {
 			if !ok {
 				return
 			}
-			c.errorChan <- fmt.Errorf("protocol error: %s", err)
+			c.errorChan <- fmt.Errorf("protocol error: %w", err)
 			// Close connection on mini-protocol errors
 			c.Close()
 		}
diff --git a/ledger/allegra/allegra.go b/ledger/allegra/allegra.go
@@ -324,7 +324,7 @@ func (t *AllegraTransaction) Cbor() []byte {
 func NewAllegraBlockFromCbor(data []byte) (*AllegraBlock, error) {
 	var allegraBlock AllegraBlock
 	if _, err := cbor.Decode(data, &allegraBlock); err != nil {
-		return nil, fmt.Errorf("Allegra block decode error: %s", err)
+		return nil, fmt.Errorf("Allegra block decode error: %w", err)
 	}
 	return &allegraBlock, nil
 }
@@ -334,15 +334,15 @@ func NewAllegraTransactionBodyFromCbor(
 ) (*AllegraTransactionBody, error) {
 	var allegraTx AllegraTransactionBody
 	if _, err := cbor.Decode(data, &allegraTx); err != nil {
-		return nil, fmt.Errorf("Allegra transaction body decode error: %s", err)
+		return nil, fmt.Errorf("Allegra transaction body decode error: %w", 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("Allegra transaction decode error: %s", err)
+		return nil, fmt.Errorf("Allegra transaction decode error: %w", err)
 	}
 	return &allegraTx, nil
 }
diff --git a/ledger/alonzo/alonzo.go b/ledger/alonzo/alonzo.go
@@ -527,7 +527,7 @@ func (t *AlonzoTransaction) Utxorpc() *utxorpc.Tx {
 func NewAlonzoBlockFromCbor(data []byte) (*AlonzoBlock, error) {
 	var alonzoBlock AlonzoBlock
 	if _, err := cbor.Decode(data, &alonzoBlock); err != nil {
-		return nil, fmt.Errorf("Alonzo block decode error: %s", err)
+		return nil, fmt.Errorf("Alonzo block decode error: %w", err)
 	}
 	return &alonzoBlock, nil
 }
@@ -537,15 +537,15 @@ func NewAlonzoTransactionBodyFromCbor(
 ) (*AlonzoTransactionBody, error) {
 	var alonzoTx AlonzoTransactionBody
 	if _, err := cbor.Decode(data, &alonzoTx); err != nil {
-		return nil, fmt.Errorf("Alonzo transaction body decode error: %s", err)
+		return nil, fmt.Errorf("Alonzo transaction body decode error: %w", 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("Alonzo transaction decode error: %s", err)
+		return nil, fmt.Errorf("Alonzo transaction decode error: %w", err)
 	}
 	return &alonzoTx, nil
 }
@@ -556,7 +556,7 @@ func NewAlonzoTransactionOutputFromCbor(
 	var alonzoTxOutput AlonzoTransactionOutput
 	if _, err := cbor.Decode(data, &alonzoTxOutput); err != nil {
 		return nil, fmt.Errorf(
-			"Alonzo transaction output decode error: %s",
+			"Alonzo transaction output decode error: %w",
 			err,
 		)
 	}
diff --git a/ledger/babbage/babbage.go b/ledger/babbage/babbage.go
@@ -681,15 +681,15 @@ func (t *BabbageTransaction) Utxorpc() *utxorpc.Tx {
 func NewBabbageBlockFromCbor(data []byte) (*BabbageBlock, error) {
 	var babbageBlock BabbageBlock
 	if _, err := cbor.Decode(data, &babbageBlock); err != nil {
-		return nil, fmt.Errorf("Babbage block decode error: %s", err)
+		return nil, fmt.Errorf("Babbage block decode error: %w", 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("Babbage block header decode error: %s", err)
+		return nil, fmt.Errorf("Babbage block header decode error: %w", err)
 	}
 	return &babbageBlockHeader, nil
 }
@@ -699,15 +699,15 @@ func NewBabbageTransactionBodyFromCbor(
 ) (*BabbageTransactionBody, error) {
 	var babbageTx BabbageTransactionBody
 	if _, err := cbor.Decode(data, &babbageTx); err != nil {
-		return nil, fmt.Errorf("Babbage transaction body decode error: %s", err)
+		return nil, fmt.Errorf("Babbage transaction body decode error: %w", 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("Babbage transaction decode error: %s", err)
+		return nil, fmt.Errorf("Babbage transaction decode error: %w", err)
 	}
 	return &babbageTx, nil
 }
@@ -718,7 +718,7 @@ func NewBabbageTransactionOutputFromCbor(
 	var babbageTxOutput BabbageTransactionOutput
 	if _, err := cbor.Decode(data, &babbageTxOutput); err != nil {
 		return nil, fmt.Errorf(
-			"Babbage transaction output decode error: %s",
+			"Babbage transaction output decode error: %w",
 			err,
 		)
 	}
diff --git a/ledger/byron/byron.go b/ledger/byron/byron.go
@@ -689,7 +689,7 @@ func NewByronEpochBoundaryBlockFromCbor(
 ) (*ByronEpochBoundaryBlock, error) {
 	var byronEbbBlock ByronEpochBoundaryBlock
 	if _, err := cbor.Decode(data, &byronEbbBlock); err != nil {
-		return nil, fmt.Errorf("Byron EBB block decode error: %s", err)
+		return nil, fmt.Errorf("Byron EBB block decode error: %w", err)
 	}
 	return &byronEbbBlock, nil
 }
@@ -699,15 +699,15 @@ func NewByronEpochBoundaryBlockHeaderFromCbor(
 ) (*ByronEpochBoundaryBlockHeader, error) {
 	var byronEbbBlockHeader ByronEpochBoundaryBlockHeader
 	if _, err := cbor.Decode(data, &byronEbbBlockHeader); err != nil {
-		return nil, fmt.Errorf("Byron EBB block header decode error: %s", err)
+		return nil, fmt.Errorf("Byron EBB block header decode error: %w", 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("Byron main block decode error: %s", err)
+		return nil, fmt.Errorf("Byron main block decode error: %w", err)
 	}
 	return &byronMainBlock, nil
 }
@@ -717,15 +717,15 @@ func NewByronMainBlockHeaderFromCbor(
 ) (*ByronMainBlockHeader, error) {
 	var byronMainBlockHeader ByronMainBlockHeader
 	if _, err := cbor.Decode(data, &byronMainBlockHeader); err != nil {
-		return nil, fmt.Errorf("Byron main block header decode error: %s", err)
+		return nil, fmt.Errorf("Byron main block header decode error: %w", err)
 	}
 	return &byronMainBlockHeader, nil
 }
 
 func NewByronTransactionFromCbor(data []byte) (*ByronTransaction, error) {
 	var byronTx ByronTransaction
 	if _, err := cbor.Decode(data, &byronTx); err != nil {
-		return nil, fmt.Errorf("Byron transaction decode error: %s", err)
+		return nil, fmt.Errorf("Byron transaction decode error: %w", err)
 	}
 	return &byronTx, nil
 }
diff --git a/ledger/conway/conway.go b/ledger/conway/conway.go
@@ -472,15 +472,15 @@ func (t *ConwayTransaction) Utxorpc() *utxorpc.Tx {
 func NewConwayBlockFromCbor(data []byte) (*ConwayBlock, error) {
 	var conwayBlock ConwayBlock
 	if _, err := cbor.Decode(data, &conwayBlock); err != nil {
-		return nil, fmt.Errorf("Conway block decode error: %s", err)
+		return nil, fmt.Errorf("Conway block decode error: %w", err)
 	}
 	return &conwayBlock, nil
 }
 
 func NewConwayBlockHeaderFromCbor(data []byte) (*ConwayBlockHeader, error) {
 	var conwayBlockHeader ConwayBlockHeader
 	if _, err := cbor.Decode(data, &conwayBlockHeader); err != nil {
-		return nil, fmt.Errorf("Conway block header decode error: %s", err)
+		return nil, fmt.Errorf("Conway block header decode error: %w", err)
 	}
 	return &conwayBlockHeader, nil
 }
@@ -490,15 +490,15 @@ func NewConwayTransactionBodyFromCbor(
 ) (*ConwayTransactionBody, error) {
 	var conwayTx ConwayTransactionBody
 	if _, err := cbor.Decode(data, &conwayTx); err != nil {
-		return nil, fmt.Errorf("Conway transaction body decode error: %s", err)
+		return nil, fmt.Errorf("Conway transaction body decode error: %w", err)
 	}
 	return &conwayTx, nil
 }
 
 func NewConwayTransactionFromCbor(data []byte) (*ConwayTransaction, error) {
 	var conwayTx ConwayTransaction
 	if _, err := cbor.Decode(data, &conwayTx); err != nil {
-		return nil, fmt.Errorf("Conway transaction decode error: %s", err)
+		return nil, fmt.Errorf("Conway transaction decode error: %w", err)
 	}
 	return &conwayTx, nil
 }
diff --git a/ledger/error.go b/ledger/error.go
@@ -287,7 +287,7 @@ func (e *UtxoFailure) UnmarshalCBOR(data []byte) error {
 	if err != nil {
 		newErr, err = NewGenericErrorFromCbor(tmpData.Err)
 		if err != nil {
-			return fmt.Errorf("failed to parse UtxoFailure: %s", err)
+			return fmt.Errorf("failed to parse UtxoFailure: %w", err)
 		}
 	}
 	e.Err = newErr.(error)
diff --git a/ledger/mary/mary.go b/ledger/mary/mary.go
@@ -409,23 +409,23 @@ func (v *MaryTransactionOutputValue) MarshalCBOR() ([]byte, error) {
 func NewMaryBlockFromCbor(data []byte) (*MaryBlock, error) {
 	var maryBlock MaryBlock
 	if _, err := cbor.Decode(data, &maryBlock); err != nil {
-		return nil, fmt.Errorf("Mary block decode error: %s", err)
+		return nil, fmt.Errorf("Mary block decode error: %w", err)
 	}
 	return &maryBlock, nil
 }
 
 func NewMaryTransactionBodyFromCbor(data []byte) (*MaryTransactionBody, error) {
 	var maryTx MaryTransactionBody
 	if _, err := cbor.Decode(data, &maryTx); err != nil {
-		return nil, fmt.Errorf("Mary transaction body decode error: %s", err)
+		return nil, fmt.Errorf("Mary transaction body decode error: %w", err)
 	}
 	return &maryTx, nil
 }
 
 func NewMaryTransactionFromCbor(data []byte) (*MaryTransaction, error) {
 	var maryTx MaryTransaction
 	if _, err := cbor.Decode(data, &maryTx); err != nil {
-		return nil, fmt.Errorf("Mary transaction decode error: %s", err)
+		return nil, fmt.Errorf("Mary transaction decode error: %w", err)
 	}
 	return &maryTx, nil
 }
@@ -435,7 +435,7 @@ func NewMaryTransactionOutputFromCbor(
 ) (*MaryTransactionOutput, error) {
 	var maryTxOutput MaryTransactionOutput
 	if _, err := cbor.Decode(data, &maryTxOutput); err != nil {
-		return nil, fmt.Errorf("Mary transaction output decode error: %s", err)
+		return nil, fmt.Errorf("Mary transaction output decode error: %w", err)
 	}
 	return &maryTxOutput, nil
 }
diff --git a/ledger/shelley/shelley.go b/ledger/shelley/shelley.go
@@ -680,15 +680,15 @@ func (t *ShelleyTransaction) Cbor() []byte {
 func NewShelleyBlockFromCbor(data []byte) (*ShelleyBlock, error) {
 	var shelleyBlock ShelleyBlock
 	if _, err := cbor.Decode(data, &shelleyBlock); err != nil {
-		return nil, fmt.Errorf("Shelley block decode error: %s", err)
+		return nil, fmt.Errorf("Shelley block decode error: %w", err)
 	}
 	return &shelleyBlock, nil
 }
 
 func NewShelleyBlockHeaderFromCbor(data []byte) (*ShelleyBlockHeader, error) {
 	var shelleyBlockHeader ShelleyBlockHeader
 	if _, err := cbor.Decode(data, &shelleyBlockHeader); err != nil {
-		return nil, fmt.Errorf("Shelley block header decode error: %s", err)
+		return nil, fmt.Errorf("Shelley block header decode error: %w", err)
 	}
 	return &shelleyBlockHeader, nil
 }
@@ -698,15 +698,15 @@ func NewShelleyTransactionBodyFromCbor(
 ) (*ShelleyTransactionBody, error) {
 	var shelleyTx ShelleyTransactionBody
 	if _, err := cbor.Decode(data, &shelleyTx); err != nil {
-		return nil, fmt.Errorf("Shelley transaction body decode error: %s", err)
+		return nil, fmt.Errorf("Shelley transaction body decode error: %w", err)
 	}
 	return &shelleyTx, nil
 }
 
 func NewShelleyTransactionFromCbor(data []byte) (*ShelleyTransaction, error) {
 	var shelleyTx ShelleyTransaction
 	if _, err := cbor.Decode(data, &shelleyTx); err != nil {
-		return nil, fmt.Errorf("Shelley transaction decode error: %s", err)
+		return nil, fmt.Errorf("Shelley transaction decode error: %w", err)
 	}
 	return &shelleyTx, nil
 }
@@ -717,7 +717,7 @@ func NewShelleyTransactionOutputFromCbor(
 	var shelleyTxOutput ShelleyTransactionOutput
 	if _, err := cbor.Decode(data, &shelleyTxOutput); err != nil {
 		return nil, fmt.Errorf(
-			"Shelley transaction output decode error: %s",
+			"Shelley transaction output decode error: %w",
 			err,
 		)
 	}
diff --git a/protocol/blockfetch/client.go b/protocol/blockfetch/client.go
@@ -252,7 +252,7 @@ func (c *Client) handleBlock(msgGeneric protocol.Message) error {
 	// Decode only enough to get the block type value
 	var wrappedBlock WrappedBlock
 	if _, err := cbor.Decode(msg.WrappedBlock, &wrappedBlock); err != nil {
-		return fmt.Errorf("%s: decode error: %s", ProtocolName, err)
+		return fmt.Errorf("%s: decode error: %w", ProtocolName, err)
 	}
 	var block ledger.Block
 	if !c.blockUseCallback || c.config.BlockFunc != nil {
diff --git a/protocol/blockfetch/messages.go b/protocol/blockfetch/messages.go
@@ -48,7 +48,7 @@ func NewMsgFromCbor(msgType uint, data []byte) (protocol.Message, error) {
 		ret = &MsgBatchDone{}
 	}
 	if _, err := cbor.Decode(data, ret); err != nil {
-		return nil, fmt.Errorf("%s: decode error: %s", ProtocolName, err)
+		return nil, fmt.Errorf("%s: decode error: %w", ProtocolName, err)
 	}
 	if ret != nil {
 		// Store the raw message CBOR
diff --git a/protocol/chainsync/messages.go b/protocol/chainsync/messages.go
@@ -74,7 +74,7 @@ func NewMsgFromCbor(
 		ret = &MsgDone{}
 	}
 	if _, err := cbor.Decode(data, ret); err != nil {
-		return nil, fmt.Errorf("%s: decode error: %s", ProtocolName, err)
+		return nil, fmt.Errorf("%s: decode error: %w", ProtocolName, err)
 	}
 	if ret != nil {
 		// Store the raw message CBOR
diff --git a/protocol/handshake/messages.go b/protocol/handshake/messages.go
@@ -47,7 +47,7 @@ func NewMsgFromCbor(msgType uint, data []byte) (protocol.Message, error) {
 		ret = &MsgRefuse{}
 	}
 	if _, err := cbor.Decode(data, ret); err != nil {
-		return nil, fmt.Errorf("%s: decode error: %s", ProtocolName, err)
+		return nil, fmt.Errorf("%s: decode error: %w", ProtocolName, err)
 	}
 	if ret != nil {
 		// Store the raw message CBOR
diff --git a/protocol/handshake/server.go b/protocol/handshake/server.go
@@ -161,7 +161,7 @@ func (s *Server) handleProposeVersions(msg protocol.Message) error {
 			return err
 		}
 		return fmt.Errorf(
-			"handshake failed: refused due to protocol parameters decode failure: %s",
+			"handshake failed: refused due to protocol parameters decode failure: %w",
 			err,
 		)
 	}
diff --git a/protocol/keepalive/messages.go b/protocol/keepalive/messages.go
@@ -37,7 +37,7 @@ func NewMsgFromCbor(msgType uint, data []byte) (protocol.Message, error) {
 		ret = &MsgDone{}
 	}
 	if _, err := cbor.Decode(data, ret); err != nil {
-		return nil, fmt.Errorf("%s: decode error: %s", ProtocolName, err)
+		return nil, fmt.Errorf("%s: decode error: %w", ProtocolName, err)
 	}
 	if ret != nil {
 		// Store the raw message CBOR
diff --git a/protocol/localstatequery/messages.go b/protocol/localstatequery/messages.go
@@ -74,7 +74,7 @@ func NewMsgFromCbor(msgType uint, data []byte) (protocol.Message, error) {
 		ret = &MsgDone{}
 	}
 	if _, err := cbor.Decode(data, ret); err != nil {
-		return nil, fmt.Errorf("%s: decode error: %s", ProtocolName, err)
+		return nil, fmt.Errorf("%s: decode error: %w", ProtocolName, err)
 	}
 	if ret != nil {
 		// Store the raw message CBOR
diff --git a/protocol/localtxmonitor/messages.go b/protocol/localtxmonitor/messages.go
@@ -62,7 +62,7 @@ func NewMsgFromCbor(msgType uint, data []byte) (protocol.Message, error) {
 		ret = &MsgReplyGetSizes{}
 	}
 	if _, err := cbor.Decode(data, ret); err != nil {
-		return nil, fmt.Errorf("%s: decode error: %s", ProtocolName, err)
+		return nil, fmt.Errorf("%s: decode error: %w", ProtocolName, err)
 	}
 	if ret != nil {
 		// Store the raw message CBOR
diff --git a/protocol/localtxsubmission/messages.go b/protocol/localtxsubmission/messages.go
@@ -43,7 +43,7 @@ func NewMsgFromCbor(msgType uint, data []byte) (protocol.Message, error) {
 		ret = &MsgDone{}
 	}
 	if _, err := cbor.Decode(data, ret); err != nil {
-		return nil, fmt.Errorf("%s: decode error: %s", ProtocolName, err)
+		return nil, fmt.Errorf("%s: decode error: %w", ProtocolName, err)
 	}
 	if ret != nil {
 		// Store the raw message CBOR
diff --git a/protocol/peersharing/messages.go b/protocol/peersharing/messages.go
diff --git a/protocol/protocol.go b/protocol/protocol.go
diff --git a/protocol/txsubmission/messages.go b/protocol/txsubmission/messages.go

Original file line number	Diff line number	Diff line change
`@@ -282,7 +282,7 @@ func (c *Connection) setupConnection() error {`
`282`	`282`	`c.errorChan <- io.EOF`
`283`	`283`	`} else {`
`284`	`284`	`// Wrap error message to denote it comes from the muxer`
`285`		`- c.errorChan <- fmt.Errorf("muxer error: %s", err)`
	`285`	`+ c.errorChan <- fmt.Errorf("muxer error: %w", err)`
`286`	`286`	`}`
`287`	`287`	`// Close connection on muxer errors`
`288`	`288`	`c.Close()`
`@@ -368,7 +368,7 @@ func (c *Connection) setupConnection() error {`
`368`	`368`	`if !ok {`
`369`	`369`	`return`
`370`	`370`	`}`
`371`		`- c.errorChan <- fmt.Errorf("protocol error: %s", err)`
	`371`	`+ c.errorChan <- fmt.Errorf("protocol error: %w", err)`
`372`	`372`	`// Close connection on mini-protocol errors`
`373`	`373`	`c.Close()`
`374`	`374`	`}`
Original file line number	Diff line number	Diff line change
`@@ -324,7 +324,7 @@ func (t *AllegraTransaction) Cbor() []byte {`
`324`	`324`	`func NewAllegraBlockFromCbor(data []byte) (*AllegraBlock, error) {`
`325`	`325`	`var allegraBlock AllegraBlock`
`326`	`326`	`if _, err := cbor.Decode(data, &allegraBlock); err != nil {`
`327`		`- return nil, fmt.Errorf("Allegra block decode error: %s", err)`
	`327`	`+ return nil, fmt.Errorf("Allegra block decode error: %w", err)`
`328`	`328`	`}`
`329`	`329`	`return &allegraBlock, nil`
`330`	`330`	`}`
`@@ -334,15 +334,15 @@ func NewAllegraTransactionBodyFromCbor(`
`334`	`334`	`) (*AllegraTransactionBody, error) {`
`335`	`335`	`var allegraTx AllegraTransactionBody`
`336`	`336`	`if _, err := cbor.Decode(data, &allegraTx); err != nil {`
`337`		`- return nil, fmt.Errorf("Allegra transaction body decode error: %s", err)`
	`337`	`+ return nil, fmt.Errorf("Allegra transaction body decode error: %w", err)`
`338`	`338`	`}`
`339`	`339`	`return &allegraTx, nil`
`340`	`340`	`}`
`341`	`341`
`342`	`342`	`func NewAllegraTransactionFromCbor(data []byte) (*AllegraTransaction, error) {`
`343`	`343`	`var allegraTx AllegraTransaction`
`344`	`344`	`if _, err := cbor.Decode(data, &allegraTx); err != nil {`
`345`		`- return nil, fmt.Errorf("Allegra transaction decode error: %s", err)`
	`345`	`+ return nil, fmt.Errorf("Allegra transaction decode error: %w", err)`
`346`	`346`	`}`
`347`	`347`	`return &allegraTx, nil`
`348`	`348`	`}`
Original file line number	Diff line number	Diff line change
`@@ -527,7 +527,7 @@ func (t AlonzoTransaction) Utxorpc() utxorpc.Tx {`
`527`	`527`	`func NewAlonzoBlockFromCbor(data []byte) (*AlonzoBlock, error) {`
`528`	`528`	`var alonzoBlock AlonzoBlock`
`529`	`529`	`if _, err := cbor.Decode(data, &alonzoBlock); err != nil {`
`530`		`- return nil, fmt.Errorf("Alonzo block decode error: %s", err)`
	`530`	`+ return nil, fmt.Errorf("Alonzo block decode error: %w", err)`
`531`	`531`	`}`
`532`	`532`	`return &alonzoBlock, nil`
`533`	`533`	`}`
`@@ -537,15 +537,15 @@ func NewAlonzoTransactionBodyFromCbor(`
`537`	`537`	`) (*AlonzoTransactionBody, error) {`
`538`	`538`	`var alonzoTx AlonzoTransactionBody`
`539`	`539`	`if _, err := cbor.Decode(data, &alonzoTx); err != nil {`
`540`		`- return nil, fmt.Errorf("Alonzo transaction body decode error: %s", err)`
	`540`	`+ return nil, fmt.Errorf("Alonzo transaction body decode error: %w", err)`
`541`	`541`	`}`
`542`	`542`	`return &alonzoTx, nil`
`543`	`543`	`}`
`544`	`544`
`545`	`545`	`func NewAlonzoTransactionFromCbor(data []byte) (*AlonzoTransaction, error) {`
`546`	`546`	`var alonzoTx AlonzoTransaction`
`547`	`547`	`if _, err := cbor.Decode(data, &alonzoTx); err != nil {`
`548`		`- return nil, fmt.Errorf("Alonzo transaction decode error: %s", err)`
	`548`	`+ return nil, fmt.Errorf("Alonzo transaction decode error: %w", err)`
`549`	`549`	`}`
`550`	`550`	`return &alonzoTx, nil`
`551`	`551`	`}`
`@@ -556,7 +556,7 @@ func NewAlonzoTransactionOutputFromCbor(`
`556`	`556`	`var alonzoTxOutput AlonzoTransactionOutput`
`557`	`557`	`if _, err := cbor.Decode(data, &alonzoTxOutput); err != nil {`
`558`	`558`	`return nil, fmt.Errorf(`
`559`		`- "Alonzo transaction output decode error: %s",`
	`559`	`+ "Alonzo transaction output decode error: %w",`
`560`	`560`	`err,`
`561`	`561`	`)`
`562`	`562`	`}`
Original file line number	Diff line number	Diff line change
`@@ -681,15 +681,15 @@ func (t BabbageTransaction) Utxorpc() utxorpc.Tx {`
`681`	`681`	`func NewBabbageBlockFromCbor(data []byte) (*BabbageBlock, error) {`
`682`	`682`	`var babbageBlock BabbageBlock`
`683`	`683`	`if _, err := cbor.Decode(data, &babbageBlock); err != nil {`
`684`		`- return nil, fmt.Errorf("Babbage block decode error: %s", err)`
	`684`	`+ return nil, fmt.Errorf("Babbage block decode error: %w", err)`
`685`	`685`	`}`
`686`	`686`	`return &babbageBlock, nil`
`687`	`687`	`}`
`688`	`688`
`689`	`689`	`func NewBabbageBlockHeaderFromCbor(data []byte) (*BabbageBlockHeader, error) {`
`690`	`690`	`var babbageBlockHeader BabbageBlockHeader`
`691`	`691`	`if _, err := cbor.Decode(data, &babbageBlockHeader); err != nil {`
`692`		`- return nil, fmt.Errorf("Babbage block header decode error: %s", err)`
	`692`	`+ return nil, fmt.Errorf("Babbage block header decode error: %w", err)`
`693`	`693`	`}`
`694`	`694`	`return &babbageBlockHeader, nil`
`695`	`695`	`}`
`@@ -699,15 +699,15 @@ func NewBabbageTransactionBodyFromCbor(`
`699`	`699`	`) (*BabbageTransactionBody, error) {`
`700`	`700`	`var babbageTx BabbageTransactionBody`
`701`	`701`	`if _, err := cbor.Decode(data, &babbageTx); err != nil {`
`702`		`- return nil, fmt.Errorf("Babbage transaction body decode error: %s", err)`
	`702`	`+ return nil, fmt.Errorf("Babbage transaction body decode error: %w", err)`
`703`	`703`	`}`
`704`	`704`	`return &babbageTx, nil`
`705`	`705`	`}`
`706`	`706`
`707`	`707`	`func NewBabbageTransactionFromCbor(data []byte) (*BabbageTransaction, error) {`
`708`	`708`	`var babbageTx BabbageTransaction`
`709`	`709`	`if _, err := cbor.Decode(data, &babbageTx); err != nil {`
`710`		`- return nil, fmt.Errorf("Babbage transaction decode error: %s", err)`
	`710`	`+ return nil, fmt.Errorf("Babbage transaction decode error: %w", err)`
`711`	`711`	`}`
`712`	`712`	`return &babbageTx, nil`
`713`	`713`	`}`
`@@ -718,7 +718,7 @@ func NewBabbageTransactionOutputFromCbor(`
`718`	`718`	`var babbageTxOutput BabbageTransactionOutput`
`719`	`719`	`if _, err := cbor.Decode(data, &babbageTxOutput); err != nil {`
`720`	`720`	`return nil, fmt.Errorf(`
`721`		`- "Babbage transaction output decode error: %s",`
	`721`	`+ "Babbage transaction output decode error: %w",`
`722`	`722`	`err,`
`723`	`723`	`)`
`724`	`724`	`}`
Original file line number	Diff line number	Diff line change
`@@ -689,7 +689,7 @@ func NewByronEpochBoundaryBlockFromCbor(`
`689`	`689`	`) (*ByronEpochBoundaryBlock, error) {`
`690`	`690`	`var byronEbbBlock ByronEpochBoundaryBlock`
`691`	`691`	`if _, err := cbor.Decode(data, &byronEbbBlock); err != nil {`
`692`		`- return nil, fmt.Errorf("Byron EBB block decode error: %s", err)`
	`692`	`+ return nil, fmt.Errorf("Byron EBB block decode error: %w", err)`
`693`	`693`	`}`
`694`	`694`	`return &byronEbbBlock, nil`
`695`	`695`	`}`
`@@ -699,15 +699,15 @@ func NewByronEpochBoundaryBlockHeaderFromCbor(`
`699`	`699`	`) (*ByronEpochBoundaryBlockHeader, error) {`
`700`	`700`	`var byronEbbBlockHeader ByronEpochBoundaryBlockHeader`
`701`	`701`	`if _, err := cbor.Decode(data, &byronEbbBlockHeader); err != nil {`
`702`		`- return nil, fmt.Errorf("Byron EBB block header decode error: %s", err)`
	`702`	`+ return nil, fmt.Errorf("Byron EBB block header decode error: %w", err)`
`703`	`703`	`}`
`704`	`704`	`return &byronEbbBlockHeader, nil`
`705`	`705`	`}`
`706`	`706`
`707`	`707`	`func NewByronMainBlockFromCbor(data []byte) (*ByronMainBlock, error) {`
`708`	`708`	`var byronMainBlock ByronMainBlock`
`709`	`709`	`if _, err := cbor.Decode(data, &byronMainBlock); err != nil {`
`710`		`- return nil, fmt.Errorf("Byron main block decode error: %s", err)`
	`710`	`+ return nil, fmt.Errorf("Byron main block decode error: %w", err)`
`711`	`711`	`}`
`712`	`712`	`return &byronMainBlock, nil`
`713`	`713`	`}`
`@@ -717,15 +717,15 @@ func NewByronMainBlockHeaderFromCbor(`
`717`	`717`	`) (*ByronMainBlockHeader, error) {`
`718`	`718`	`var byronMainBlockHeader ByronMainBlockHeader`
`719`	`719`	`if _, err := cbor.Decode(data, &byronMainBlockHeader); err != nil {`
`720`		`- return nil, fmt.Errorf("Byron main block header decode error: %s", err)`
	`720`	`+ return nil, fmt.Errorf("Byron main block header decode error: %w", err)`
`721`	`721`	`}`
`722`	`722`	`return &byronMainBlockHeader, nil`
`723`	`723`	`}`
`724`	`724`
`725`	`725`	`func NewByronTransactionFromCbor(data []byte) (*ByronTransaction, error) {`
`726`	`726`	`var byronTx ByronTransaction`
`727`	`727`	`if _, err := cbor.Decode(data, &byronTx); err != nil {`
`728`		`- return nil, fmt.Errorf("Byron transaction decode error: %s", err)`
	`728`	`+ return nil, fmt.Errorf("Byron transaction decode error: %w", err)`
`729`	`729`	`}`
`730`	`730`	`return &byronTx, nil`
`731`	`731`	`}`
Original file line number	Diff line number	Diff line change
`@@ -472,15 +472,15 @@ func (t ConwayTransaction) Utxorpc() utxorpc.Tx {`
`472`	`472`	`func NewConwayBlockFromCbor(data []byte) (*ConwayBlock, error) {`
`473`	`473`	`var conwayBlock ConwayBlock`
`474`	`474`	`if _, err := cbor.Decode(data, &conwayBlock); err != nil {`
`475`		`- return nil, fmt.Errorf("Conway block decode error: %s", err)`
	`475`	`+ return nil, fmt.Errorf("Conway block decode error: %w", err)`
`476`	`476`	`}`
`477`	`477`	`return &conwayBlock, nil`
`478`	`478`	`}`
`479`	`479`
`480`	`480`	`func NewConwayBlockHeaderFromCbor(data []byte) (*ConwayBlockHeader, error) {`
`481`	`481`	`var conwayBlockHeader ConwayBlockHeader`
`482`	`482`	`if _, err := cbor.Decode(data, &conwayBlockHeader); err != nil {`
`483`		`- return nil, fmt.Errorf("Conway block header decode error: %s", err)`
	`483`	`+ return nil, fmt.Errorf("Conway block header decode error: %w", err)`
`484`	`484`	`}`
`485`	`485`	`return &conwayBlockHeader, nil`
`486`	`486`	`}`
`@@ -490,15 +490,15 @@ func NewConwayTransactionBodyFromCbor(`
`490`	`490`	`) (*ConwayTransactionBody, error) {`
`491`	`491`	`var conwayTx ConwayTransactionBody`
`492`	`492`	`if _, err := cbor.Decode(data, &conwayTx); err != nil {`
`493`		`- return nil, fmt.Errorf("Conway transaction body decode error: %s", err)`
	`493`	`+ return nil, fmt.Errorf("Conway transaction body decode error: %w", err)`
`494`	`494`	`}`
`495`	`495`	`return &conwayTx, nil`
`496`	`496`	`}`
`497`	`497`
`498`	`498`	`func NewConwayTransactionFromCbor(data []byte) (*ConwayTransaction, error) {`
`499`	`499`	`var conwayTx ConwayTransaction`
`500`	`500`	`if _, err := cbor.Decode(data, &conwayTx); err != nil {`
`501`		`- return nil, fmt.Errorf("Conway transaction decode error: %s", err)`
	`501`	`+ return nil, fmt.Errorf("Conway transaction decode error: %w", err)`
`502`	`502`	`}`
`503`	`503`	`return &conwayTx, nil`
`504`	`504`	`}`
Original file line number	Diff line number	Diff line change
`@@ -287,7 +287,7 @@ func (e *UtxoFailure) UnmarshalCBOR(data []byte) error {`
`287`	`287`	`if err != nil {`
`288`	`288`	`newErr, err = NewGenericErrorFromCbor(tmpData.Err)`
`289`	`289`	`if err != nil {`
`290`		`- return fmt.Errorf("failed to parse UtxoFailure: %s", err)`
	`290`	`+ return fmt.Errorf("failed to parse UtxoFailure: %w", err)`
`291`	`291`	`}`
`292`	`292`	`}`
`293`	`293`	`e.Err = newErr.(error)`
Original file line number	Diff line number	Diff line change
`@@ -409,23 +409,23 @@ func (v *MaryTransactionOutputValue) MarshalCBOR() ([]byte, error) {`
`409`	`409`	`func NewMaryBlockFromCbor(data []byte) (*MaryBlock, error) {`
`410`	`410`	`var maryBlock MaryBlock`
`411`	`411`	`if _, err := cbor.Decode(data, &maryBlock); err != nil {`
`412`		`- return nil, fmt.Errorf("Mary block decode error: %s", err)`
	`412`	`+ return nil, fmt.Errorf("Mary block decode error: %w", err)`
`413`	`413`	`}`
`414`	`414`	`return &maryBlock, nil`
`415`	`415`	`}`
`416`	`416`
`417`	`417`	`func NewMaryTransactionBodyFromCbor(data []byte) (*MaryTransactionBody, error) {`
`418`	`418`	`var maryTx MaryTransactionBody`
`419`	`419`	`if _, err := cbor.Decode(data, &maryTx); err != nil {`
`420`		`- return nil, fmt.Errorf("Mary transaction body decode error: %s", err)`
	`420`	`+ return nil, fmt.Errorf("Mary transaction body decode error: %w", err)`
`421`	`421`	`}`
`422`	`422`	`return &maryTx, nil`
`423`	`423`	`}`
`424`	`424`
`425`	`425`	`func NewMaryTransactionFromCbor(data []byte) (*MaryTransaction, error) {`
`426`	`426`	`var maryTx MaryTransaction`
`427`	`427`	`if _, err := cbor.Decode(data, &maryTx); err != nil {`
`428`		`- return nil, fmt.Errorf("Mary transaction decode error: %s", err)`
	`428`	`+ return nil, fmt.Errorf("Mary transaction decode error: %w", err)`
`429`	`429`	`}`
`430`	`430`	`return &maryTx, nil`
`431`	`431`	`}`
`@@ -435,7 +435,7 @@ func NewMaryTransactionOutputFromCbor(`
`435`	`435`	`) (*MaryTransactionOutput, error) {`
`436`	`436`	`var maryTxOutput MaryTransactionOutput`
`437`	`437`	`if _, err := cbor.Decode(data, &maryTxOutput); err != nil {`
`438`		`- return nil, fmt.Errorf("Mary transaction output decode error: %s", err)`
	`438`	`+ return nil, fmt.Errorf("Mary transaction output decode error: %w", err)`
`439`	`439`	`}`
`440`	`440`	`return &maryTxOutput, nil`
`441`	`441`	`}`
Original file line number	Diff line number	Diff line change
`@@ -680,15 +680,15 @@ func (t *ShelleyTransaction) Cbor() []byte {`
`680`	`680`	`func NewShelleyBlockFromCbor(data []byte) (*ShelleyBlock, error) {`
`681`	`681`	`var shelleyBlock ShelleyBlock`
`682`	`682`	`if _, err := cbor.Decode(data, &shelleyBlock); err != nil {`
`683`		`- return nil, fmt.Errorf("Shelley block decode error: %s", err)`
	`683`	`+ return nil, fmt.Errorf("Shelley block decode error: %w", err)`
`684`	`684`	`}`
`685`	`685`	`return &shelleyBlock, nil`
`686`	`686`	`}`
`687`	`687`
`688`	`688`	`func NewShelleyBlockHeaderFromCbor(data []byte) (*ShelleyBlockHeader, error) {`
`689`	`689`	`var shelleyBlockHeader ShelleyBlockHeader`
`690`	`690`	`if _, err := cbor.Decode(data, &shelleyBlockHeader); err != nil {`
`691`		`- return nil, fmt.Errorf("Shelley block header decode error: %s", err)`
	`691`	`+ return nil, fmt.Errorf("Shelley block header decode error: %w", err)`
`692`	`692`	`}`
`693`	`693`	`return &shelleyBlockHeader, nil`
`694`	`694`	`}`
`@@ -698,15 +698,15 @@ func NewShelleyTransactionBodyFromCbor(`
`698`	`698`	`) (*ShelleyTransactionBody, error) {`
`699`	`699`	`var shelleyTx ShelleyTransactionBody`
`700`	`700`	`if _, err := cbor.Decode(data, &shelleyTx); err != nil {`
`701`		`- return nil, fmt.Errorf("Shelley transaction body decode error: %s", err)`
	`701`	`+ return nil, fmt.Errorf("Shelley transaction body decode error: %w", err)`
`702`	`702`	`}`
`703`	`703`	`return &shelleyTx, nil`
`704`	`704`	`}`
`705`	`705`
`706`	`706`	`func NewShelleyTransactionFromCbor(data []byte) (*ShelleyTransaction, error) {`
`707`	`707`	`var shelleyTx ShelleyTransaction`
`708`	`708`	`if _, err := cbor.Decode(data, &shelleyTx); err != nil {`
`709`		`- return nil, fmt.Errorf("Shelley transaction decode error: %s", err)`
	`709`	`+ return nil, fmt.Errorf("Shelley transaction decode error: %w", err)`
`710`	`710`	`}`
`711`	`711`	`return &shelleyTx, nil`
`712`	`712`	`}`
`@@ -717,7 +717,7 @@ func NewShelleyTransactionOutputFromCbor(`
`717`	`717`	`var shelleyTxOutput ShelleyTransactionOutput`
`718`	`718`	`if _, err := cbor.Decode(data, &shelleyTxOutput); err != nil {`
`719`	`719`	`return nil, fmt.Errorf(`
`720`		`- "Shelley transaction output decode error: %s",`
	`720`	`+ "Shelley transaction output decode error: %w",`
`721`	`721`	`err,`
`722`	`722`	`)`
`723`	`723`	`}`