refactor(fabricx): consistent use of errors package

Signed-off-by: Marcus Brandenburger <bur@zurich.ibm.com>

Author: mbrandenburger

platform/fabricx/core/committer/txhandler.go

@@ -8,7 +8,6 @@ package committer
 
 import (
 	"context"
-	"fmt"
 
 	"github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors"
 	"github.com/hyperledger-labs/fabric-smart-client/platform/common/services/logging"
@@ -37,7 +36,7 @@ type handler struct {
 
 func (h *handler) HandleFabricxTransaction(ctx context.Context, blkMetadata *cb.BlockMetadata, tx committer.CommitTx) (*committer.FinalityEvent, error) {
 	if len(blkMetadata.Metadata) < statusIdx {
-		return nil, fmt.Errorf("block metadata lacks transaction filter")
+		return nil, errors.New("block metadata lacks transaction filter")
 	}
 
 	statusCode := protoblocktx.Status(blkMetadata.Metadata[statusIdx][tx.TxNum])
@@ -61,7 +60,7 @@ func (h *handler) HandleFabricxTransaction(ctx context.Context, blkMetadata *cb.
 				// escaping the switch and discard
 				break
 			}
-			return nil, fmt.Errorf("failed committing transaction [txID=%s]: %w", event.TxID, err)
+			return nil, errors.Wrapf(err, "committing endorser transaction [txID=%s]", event.TxID)
 		}
 		if !processed {
 			logger.Debugf("TODO: Should we try to get chaincode events?")
@@ -74,7 +73,7 @@ func (h *handler) HandleFabricxTransaction(ctx context.Context, blkMetadata *cb.
 
 	logger.Warnf("discarding transaction [txID=%s] [reason=%v]", tx.TxID, statusCode.String())
 	if err := h.committer.DiscardEndorserTransaction(ctx, event.TxID, tx.BlkNum, tx.Raw, event); err != nil {
-		return nil, fmt.Errorf("failed discarding transaction [txID=%s]: %w", event.TxID, err)
+		return nil, errors.Wrapf(err, "discarding endorser transaction [txID=%s]", event.TxID)
 	}
 
 	return event, nil

platform/fabricx/core/finality/config.go

@@ -7,8 +7,9 @@ SPDX-License-Identifier: Apache-2.0
 package finality
 
 import (
-	"fmt"
 	"time"
+
+	"github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors"
 )
 
 const DefaultRequestTimeout = 30 * time.Second
@@ -37,7 +38,7 @@ func NewConfig(configService ConfigService) (*Config, error) {
 
 	err := configService.UnmarshalKey("notificationService", &config)
 	if err != nil {
-		return config, fmt.Errorf("cannot get notify service config: %w", err)
+		return config, errors.Wrap(err, "unmarshal notificationService")
 	}
 
 	return config, nil

platform/fabricx/core/finality/grpc.go

@@ -8,7 +8,6 @@ package finality
 
 import (
 	"errors"
-	"fmt"
 	"os"
 	"time"
 
@@ -18,12 +17,12 @@ import (
 	"google.golang.org/grpc/credentials/insecure"
 )
 
-var ErrInvalidAddress = fmt.Errorf("empty address")
+var ErrInvalidAddress = errors.New("empty address")
 
 func GrpcClient(c *Config) (*grpc.ClientConn, error) {
 	// no endpoints in config
 	if len(c.Endpoints) != 1 {
-		return nil, fmt.Errorf("we need a single endpoint")
+		return nil, errors.New("we need a single endpoint")
 	}
 
 	// currently we only support connections to a single query service

platform/fabricx/core/ledger/ledger.go

@@ -8,7 +8,6 @@ package ledger
 
 import (
 	"context"
-	"fmt"
 	"sync"
 	"time"
 
@@ -53,7 +52,7 @@ func (c *ledger) OnBlock(_ context.Context, block *cb.Block) (bool, error) {
 	for i, tx := range block.Data.Data {
 		_, _, chdr, err := fabricutils.UnmarshalTx(tx)
 		if err != nil {
-			return false, err
+			return false, errors.Wrapf(err, "unmarshal transaction channel header")
 		}
 
 		statusCode := protoblocktx.Status(block.Metadata.Metadata[cb.BlockMetadataIndex_TRANSACTIONS_FILTER][i])
@@ -89,10 +88,10 @@ func (c *ledger) GetTransactionByID(txID string) (driver.ProcessedTransaction, e
 		status, ok := c.statuses[txID]
 		c.mu.RUnlock()
 		if ok {
-			logger.Debugf("Transaction [%s] found with status [%d]", txID, int32(status))
+			logger.Debugf("Transaction [txID=%s] found with status [%d]", txID, int32(status))
 			return &liteTx{txID: txID, validationCode: status}, nil
 		}
-		logger.Warnf("transaction [%s] not found. retrying...", txID)
+		logger.Warnf("Transaction [txID=%s] not found. retrying...", txID)
 		time.Sleep(1 * time.Second)
 	}
 
@@ -107,13 +106,13 @@ func (c *ledger) GetBlockNumberByTxID(txID string) (uint64, error) {
 		blockNum, ok := c.blockNums[txID]
 		c.mu.RUnlock()
 		if ok {
-			logger.Debugf("Transaction [%s] found with blockNum [%v]", txID, blockNum)
+			logger.Debugf("Transaction [txID=%s] found with blockNum [%v]", txID, blockNum)
 			return blockNum, nil
 		}
-		logger.Warnf("transaction [%s] not found. retrying...")
+		logger.Warnf("Transaction [txID=%s] not found. retrying...", txID)
 		time.Sleep(1 * time.Second)
 	}
-	return 0, fmt.Errorf("transaction [%s] not found", txID)
+	return 0, errors.Errorf("transaction [txID=%s] not found", txID)
 }
 
 func (c *ledger) GetBlockByNumber(number uint64) (driver.Block, error) {

platform/fabricx/core/membership/endpoint.go

@@ -7,9 +7,10 @@ SPDX-License-Identifier: Apache-2.0
 package membership
 
 import (
-	"fmt"
 	"regexp"
 	"strconv"
+
+	"github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors"
 )
 
 const (
@@ -19,7 +20,7 @@ const (
 
 var (
 	myExp                    = regexp.MustCompile(`id=(\d+),(` + OrdererBroadcastType + `|` + OrdererDeliverType + `),(.*)`)
-	ErrInvalidEndpointFormat = fmt.Errorf("invalid endpoint format")
+	ErrInvalidEndpointFormat = errors.New("invalid endpoint format")
 )
 
 type endpoint struct {
@@ -37,7 +38,7 @@ func parseEndpoint(str string) (*endpoint, error) {
 
 	id, err := strconv.Atoi(match[1])
 	if err != nil {
-		return nil, fmt.Errorf("invalid endpoint id: %w", err)
+		return nil, errors.Wrap(err, "invalid endpoint id")
 	}
 
 	return &endpoint{

platform/fabricx/core/membership/membership.go

@@ -7,7 +7,6 @@ SPDX-License-Identifier: Apache-2.0
 package membership
 
 import (
-	"fmt"
 	"sync"
 
 	"github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors"
@@ -72,30 +71,30 @@ func (c *Service) DryUpdate(env *cb.Envelope) error {
 func (c *Service) validateConfig(env *cb.Envelope) (*channelconfig.Bundle, error) {
 	payload, err := protoutil.UnmarshalPayload(env.Payload)
 	if err != nil {
-		return nil, errors.Wrapf(err, "cannot get payload from config transaction")
+		return nil, errors.Wrapf(err, "unmarshal common payload")
 	}
 
 	cenv, err := configtx.UnmarshalConfigEnvelope(payload.Data)
 	if err != nil {
-		return nil, errors.Wrapf(err, "error unmarshalling config which passed initial validity checks")
+		return nil, errors.Wrapf(err, "unmarshal config envelope")
 	}
 
 	// check if config tx is valid
 	if c.channelResources != nil {
 		v := c.channelResources.ConfigtxValidator()
 		if err := v.Validate(cenv); err != nil {
-			return nil, errors.Wrap(err, "failed to validate config transaction")
+			return nil, errors.Wrap(err, "validate config transaction")
 		}
 	}
 
 	bundle, err := channelconfig.NewBundle(c.channelID, cenv.Config, factory.GetDefault())
 	if err != nil {
-		return nil, errors.Wrapf(err, "failed to build a new bundle")
+		return nil, errors.Wrapf(err, "build a new bundle")
 	}
 
 	channelconfig.LogSanityChecks(bundle)
 	if err := capabilitiesSupported(bundle); err != nil {
-		return nil, err
+		return nil, errors.Wrapf(err, "check bundle capabilities")
 	}
 
 	return bundle, nil
@@ -108,11 +107,11 @@ func capabilitiesSupported(res channelconfig.Resources) error {
 	}
 
 	if err := ac.Capabilities().Supported(); err != nil {
-		return errors.Wrapf(err, "[Channel %s] incompatible", res.ConfigtxValidator().ChannelID())
+		return errors.Wrapf(err, "[Channel %s] application config capabilities incompatible", res.ConfigtxValidator().ChannelID())
 	}
 
 	if err := res.ChannelConfig().Capabilities().Supported(); err != nil {
-		return errors.Wrapf(err, "[Channel %s] incompatible", res.ConfigtxValidator().ChannelID())
+		return errors.Wrapf(err, "[Channel %s] channel config capabilities incompatible", res.ConfigtxValidator().ChannelID())
 	}
 
 	return nil
@@ -121,7 +120,7 @@ func capabilitiesSupported(res channelconfig.Resources) error {
 func (c *Service) IsValid(identity view.Identity) error {
 	id, err := c.resources().MSPManager().DeserializeIdentity(identity)
 	if err != nil {
-		return errors.Wrapf(err, "failed deserializing identity [%s]", identity.String())
+		return errors.Wrapf(err, "deserializing identity [%s]", identity.String())
 	}
 
 	return id.Validate()
@@ -130,7 +129,7 @@ func (c *Service) IsValid(identity view.Identity) error {
 func (c *Service) GetVerifier(identity view.Identity) (driver.Verifier, error) {
 	id, err := c.resources().MSPManager().DeserializeIdentity(identity)
 	if err != nil {
-		return nil, errors.Wrapf(err, "failed deserializing identity [%s]", identity.String())
+		return nil, errors.Wrapf(err, "deserializing identity [%s]", identity.String())
 	}
 	return id, nil
 }
@@ -154,7 +153,7 @@ func (c *Service) GetMSPIDs() []string {
 func (c *Service) OrdererConfig(cs driver.ConfigService) (string, []*grpc.ConnectionConfig, error) {
 	oc, ok := c.resources().OrdererConfig()
 	if !ok || oc.Organizations() == nil {
-		return "", nil, fmt.Errorf("orderer config does not exist")
+		return "", nil, errors.New("orderer config does not exist")
 	}
 
 	tlsEnabled, isSet := cs.OrderingTLSEnabled()
@@ -182,7 +181,7 @@ func (c *Service) OrdererConfig(cs driver.ConfigService) (string, []*grpc.Connec
 
 			ep, err := parseEndpoint(epStr)
 			if err != nil {
-				return "", nil, fmt.Errorf("cannot parse orderer endpoint [%s]: %w", epStr, err)
+				return "", nil, errors.Wrapf(err, "parse orderer endpoint [%s]", epStr)
 			}
 			logger.Debugf("new OS endpoint: %s", epStr)
 

platform/fabricx/core/transaction/manager.go

@@ -8,7 +8,6 @@ package transaction
 
 import (
 	"context"
-	"fmt"
 	"sync"
 
 	"github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors"
@@ -46,7 +45,7 @@ func (m *Manager) transactionFactory(transactionType driver.TransactionType) (dr
 	logger.Debugf("transactionFactory called with transactionType [%v]", transactionType)
 	f, ok := m.transactionFactories.Load(transactionType)
 	if !ok {
-		return nil, fmt.Errorf("no transaction factory found for transaction type %v", transactionType)
+		return nil, errors.Errorf("no transaction factory found for transaction type %v", transactionType)
 	}
 
 	txFactory, ok := f.(driver.TransactionFactory)

platform/fabricx/core/transaction/rwset/loader.go

@@ -8,7 +8,6 @@ package rwset
 
 import (
 	"context"
-	"fmt"
 	"strings"
 
 	"github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors"
@@ -54,7 +53,7 @@ func NewLoader(
 
 func (c *Loader) AddHandlerProvider(headerType cb.HeaderType, handlerProvider driver.RWSetPayloadHandlerProvider) error {
 	if handler, ok := c.handlers[headerType]; ok {
-		return fmt.Errorf("handler %T already defined for header type %v", handler, headerType)
+		return errors.Errorf("handler %T already defined for header type %v", handler, headerType)
 	}
 
 	c.handlers[headerType] = handlerProvider(c.Network, c.Channel, c.Vault)
@@ -67,30 +66,34 @@ func (c *Loader) GetRWSetFromEvn(ctx context.Context, txID driver2.TxID) (driver
 	defer span.AddEvent("end_get_rwset_from_evn")
 
 	if !c.EnvelopeService.Exists(ctx, txID) {
-		return nil, nil, fmt.Errorf("envelope does not exists for [%s]", txID)
+		return nil, nil, errors.Errorf("envelope does not exists for [txID=%s]", txID)
 	}
 
 	rawEnv, err := c.EnvelopeService.LoadEnvelope(ctx, txID)
 	if err != nil {
-		return nil, nil, fmt.Errorf("cannot load envelope [%s]: %w", txID, err)
+		return nil, nil, errors.Errorf("load envelope [txID=%s]", txID)
 	}
 
 	_, payl, chdr, err := fabricutils.UnmarshalTx(rawEnv)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, errors.Wrap(err, "unmarshal payload and channel header")
+	}
+
+	if txID != chdr.TxId {
+		return nil, nil, errors.Errorf("txID mismatch in channel header, expected=%s, actual=%s", txID, chdr.TxId)
 	}
 
 	rws, err := c.Vault.NewRWSetFromBytes(ctx, chdr.TxId, payl.Data)
 	if err != nil {
-		return nil, nil, fmt.Errorf("failed to create new rws for [%s]: %w", chdr.TxId, err)
+		return nil, nil, errors.Wrapf(err, "create new rws for [txID=%s]", chdr.TxId)
 	}
 
 	var function string
 	if anyKeyContains(rws, "initialized") {
 		function = "init"
 	}
 
-	logger.Debugf("retrieved processed transaction from env [%s,%s]", txID, function)
+	logger.Debugf("retrieved processed transaction from envelope [txID=%s] [function=%s]", txID, function)
 	pt := &processedTransaction{
 		network:  c.Network,
 		channel:  chdr.ChannelId,
@@ -107,22 +110,22 @@ func (c *Loader) GetRWSetFromETx(ctx context.Context, txID driver2.TxID) (driver
 	defer span.AddEvent("end_get_rwset_from_etx")
 
 	if !c.TransactionService.Exists(ctx, txID) {
-		return nil, nil, fmt.Errorf("transaction does not exists for [%s]", txID)
+		return nil, nil, errors.Errorf("transaction does not exists for [txID=%s]", txID)
 	}
 
 	raw, err := c.TransactionService.LoadTransaction(ctx, txID)
 	if err != nil {
-		return nil, nil, fmt.Errorf("cannot load etx [%s]: %w", txID, err)
+		return nil, nil, errors.Wrapf(err, "cannot load etx [txID=%s]", txID)
 	}
 
 	tx, err := c.TransactionManager.NewTransactionFromBytes(ctx, c.Channel, raw)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, errors.Wrap(err, "new transaction from bytes")
 	}
 
 	rws, err := tx.GetRWSet()
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, errors.Wrap(err, "get rwset")
 	}
 
 	return rws, tx, nil
@@ -133,24 +136,24 @@ func (c *Loader) GetInspectingRWSetFromEvn(ctx context.Context, txID driver2.TxI
 	span.AddEvent("start_get_inspecting_rwset_from_evn")
 	defer span.AddEvent("end_get_inspecting_rwset_from_evn")
 
-	logger.Debugf("retrieve rwset from envelope [%s,%s]", c.Channel, txID)
+	logger.Debugf("retrieve rwset from envelope [channel=%s] [txID=%s]", c.Channel, txID)
 
 	_, payl, chdr, err := fabricutils.UnmarshalTx(envelopeRaw)
 	if err != nil {
-		return nil, nil, errors.Wrapf(err, "cannot unmarshal envelope [%s]", txID)
+		return nil, nil, errors.Wrapf(err, "cannot unmarshal envelope [txID=%s]", txID)
 	}
 
 	rws, err := c.Vault.InspectRWSet(ctx, payl.Data)
 	if err != nil {
-		return nil, nil, errors.Wrapf(err, "cannot inspect rwset for [%s]", txID)
+		return nil, nil, errors.Wrapf(err, "cannot inspect rwset for [txID=%s]", txID)
 	}
 
 	var function string
 	if anyKeyContains(rws, "initialized") {
 		function = "init"
 	}
 
-	logger.Debugf("retrieved inspecting processed transaction from env [%s,%s]", txID, function)
+	logger.Debugf("retrieved inspecting processed transaction from env [txID=%s] [function=%s]", txID, function)
 	pt := &processedTransaction{
 		network:  c.Network,
 		channel:  chdr.ChannelId,