[#1558] morph/client: Remove "could not"/"can't"/"failed to" from error messages

Signed-off-by: Evgenii Stratonikov <e.stratonikov@yadro.com>

pkg/morph/client/balance/balanceOf.go

@@ -29,7 +29,7 @@ func (c *Client) BalanceOf(id user.ID) (*big.Int, error) {
 
 	amount, err := client.BigIntFromStackItem(prms[0])
 	if err != nil {
-		return nil, fmt.Errorf("could not get integer stack item from stack item (%s): %w", balanceOfMethod, err)
+		return nil, fmt.Errorf("get integer stack item from stack item (%s): %w", balanceOfMethod, err)
 	}
 	return amount, nil
 }

pkg/morph/client/balance/decimals.go

@@ -21,7 +21,7 @@ func (c *Client) Decimals() (uint32, error) {
 
 	decimals, err := client.IntFromStackItem(prms[0])
 	if err != nil {
-		return 0, fmt.Errorf("could not get integer stack item from stack item (%s): %w", decimalsMethod, err)
+		return 0, fmt.Errorf("get integer stack item from stack item (%s): %w", decimalsMethod, err)
 	}
 	return uint32(decimals), nil
 }

pkg/morph/client/balance/transfer.go

@@ -39,7 +39,7 @@ func (c *Client) TransferX(ctx context.Context, p TransferPrm) error {
 
 	_, err = c.client.Invoke(ctx, prm)
 	if err != nil {
-		return fmt.Errorf("could not invoke method (%s): %w", transferXMethod, err)
+		return fmt.Errorf("invoke method (%s): %w", transferXMethod, err)
 	}
 	return nil
 }

pkg/morph/client/client.go

@@ -196,7 +196,7 @@ func (c *Client) Invoke(ctx context.Context, contract util.Uint160, fee fixedn.F
 
 	txHash, vub, err := c.rpcActor.SendTunedCall(contract, method, nil, addFeeCheckerModifier(int64(fee)), args...)
 	if err != nil {
-		return InvokeRes{}, fmt.Errorf("could not invoke %s: %w", method, err)
+		return InvokeRes{}, fmt.Errorf("invoke %s: %w", method, err)
 	}
 
 	c.logger.Debug(ctx, logs.ClientNeoClientInvoke,
@@ -509,7 +509,7 @@ func (c *Client) NeoFSAlphabetList() (res keys.PublicKeys, err error) {
 
 	list, err := c.roleList(noderoles.NeoFSAlphabet)
 	if err != nil {
-		return nil, fmt.Errorf("can't get alphabet nodes role list: %w", err)
+		return nil, fmt.Errorf("get alphabet nodes role list: %w", err)
 	}
 
 	return list, nil
@@ -523,7 +523,7 @@ func (c *Client) GetDesignateHash() util.Uint160 {
 func (c *Client) roleList(r noderoles.Role) (keys.PublicKeys, error) {
 	height, err := c.rpcActor.GetBlockCount()
 	if err != nil {
-		return nil, fmt.Errorf("can't get chain height: %w", err)
+		return nil, fmt.Errorf("get chain height: %w", err)
 	}
 
 	return c.rolemgmt.GetDesignatedByRole(r, height)

pkg/morph/client/container/containers_of.go

@@ -26,7 +26,7 @@ func (c *Client) ContainersOf(idUser *user.ID) ([]cid.ID, error) {
 	cb := func(item stackitem.Item) error {
 		rawID, err := client.BytesFromStackItem(item)
 		if err != nil {
-			return fmt.Errorf("could not get byte array from stack item (%s): %w", containersOfMethod, err)
+			return fmt.Errorf("get byte array from stack item (%s): %w", containersOfMethod, err)
 		}
 
 		var id cid.ID

pkg/morph/client/container/delete.go

@@ -78,7 +78,7 @@ func (c *Client) Delete(ctx context.Context, p DeletePrm) (uint32, error) {
 
 	res, err := c.client.Invoke(ctx, prm)
 	if err != nil {
-		return 0, fmt.Errorf("could not invoke method (%s): %w", deleteMethod, err)
+		return 0, fmt.Errorf("invoke method (%s): %w", deleteMethod, err)
 	}
 	return res.VUB, nil
 }

pkg/morph/client/container/deletion_info.go

@@ -46,7 +46,7 @@ func (c *Client) DeletionInfo(cid []byte) (*containercore.DelInfo, error) {
 
 	arr, err := client.ArrayFromStackItem(res[0])
 	if err != nil {
-		return nil, fmt.Errorf("could not get item array of container (%s): %w", deletionInfoMethod, err)
+		return nil, fmt.Errorf("get item array of container (%s): %w", deletionInfoMethod, err)
 	}
 
 	if len(arr) != 2 {
@@ -55,17 +55,17 @@ func (c *Client) DeletionInfo(cid []byte) (*containercore.DelInfo, error) {
 
 	rawOwner, err := client.BytesFromStackItem(arr[0])
 	if err != nil {
-		return nil, fmt.Errorf("could not get byte array of container (%s): %w", deletionInfoMethod, err)
+		return nil, fmt.Errorf("get byte array of container (%s): %w", deletionInfoMethod, err)
 	}
 
 	var owner user.ID
 	if err := owner.DecodeString(base58.Encode(rawOwner)); err != nil {
-		return nil, fmt.Errorf("could not decode container owner id (%s): %w", deletionInfoMethod, err)
+		return nil, fmt.Errorf("decode container owner id (%s): %w", deletionInfoMethod, err)
 	}
 
 	epoch, err := client.BigIntFromStackItem(arr[1])
 	if err != nil {
-		return nil, fmt.Errorf("could not get byte array of container signature (%s): %w", deletionInfoMethod, err)
+		return nil, fmt.Errorf("get byte array of container signature (%s): %w", deletionInfoMethod, err)
 	}
 
 	return &containercore.DelInfo{

pkg/morph/client/container/get.go

@@ -60,7 +60,7 @@ func (c *Client) Get(cid []byte) (*containercore.Container, error) {
 
 	arr, err := client.ArrayFromStackItem(res[0])
 	if err != nil {
-		return nil, fmt.Errorf("could not get item array of container (%s): %w", getMethod, err)
+		return nil, fmt.Errorf("get item array of container (%s): %w", getMethod, err)
 	}
 
 	if len(arr) != 4 {
@@ -69,29 +69,29 @@ func (c *Client) Get(cid []byte) (*containercore.Container, error) {
 
 	cnrBytes, err := client.BytesFromStackItem(arr[0])
 	if err != nil {
-		return nil, fmt.Errorf("could not get byte array of container (%s): %w", getMethod, err)
+		return nil, fmt.Errorf("get byte array of container (%s): %w", getMethod, err)
 	}
 
 	sigBytes, err := client.BytesFromStackItem(arr[1])
 	if err != nil {
-		return nil, fmt.Errorf("could not get byte array of container signature (%s): %w", getMethod, err)
+		return nil, fmt.Errorf("get byte array of container signature (%s): %w", getMethod, err)
 	}
 
 	pub, err := client.BytesFromStackItem(arr[2])
 	if err != nil {
-		return nil, fmt.Errorf("could not get byte array of public key (%s): %w", getMethod, err)
+		return nil, fmt.Errorf("get byte array of public key (%s): %w", getMethod, err)
 	}
 
 	tokBytes, err := client.BytesFromStackItem(arr[3])
 	if err != nil {
-		return nil, fmt.Errorf("could not get byte array of session token (%s): %w", getMethod, err)
+		return nil, fmt.Errorf("get byte array of session token (%s): %w", getMethod, err)
 	}
 
 	var cnr containercore.Container
 
 	if err := cnr.Value.Unmarshal(cnrBytes); err != nil {
 		// use other major version if there any
-		return nil, fmt.Errorf("can't unmarshal container: %w", err)
+		return nil, fmt.Errorf("unmarshal container: %w", err)
 	}
 
 	if len(tokBytes) > 0 {
@@ -99,7 +99,7 @@ func (c *Client) Get(cid []byte) (*containercore.Container, error) {
 
 		err = cnr.Session.Unmarshal(tokBytes)
 		if err != nil {
-			return nil, fmt.Errorf("could not unmarshal session token: %w", err)
+			return nil, fmt.Errorf("unmarshal session token: %w", err)
 		}
 	}
 

pkg/morph/client/container/list.go

@@ -34,14 +34,14 @@ func (c *Client) list(idUser *user.ID) ([]cid.ID, error) {
 
 	res, err = client.ArrayFromStackItem(res[0])
 	if err != nil {
-		return nil, fmt.Errorf("could not get stack item array from stack item (%s): %w", listMethod, err)
+		return nil, fmt.Errorf("get stack item array from stack item (%s): %w", listMethod, err)
 	}
 
 	cidList := make([]cid.ID, 0, len(res))
 	for i := range res {
 		rawID, err := client.BytesFromStackItem(res[i])
 		if err != nil {
-			return nil, fmt.Errorf("could not get byte array from stack item (%s): %w", listMethod, err)
+			return nil, fmt.Errorf("get byte array from stack item (%s): %w", listMethod, err)
 		}
 
 		var id cid.ID

pkg/morph/client/container/put.go

@@ -117,7 +117,7 @@ func (c *Client) Put(ctx context.Context, p PutPrm) error {
 
 	_, err := c.client.Invoke(ctx, prm)
 	if err != nil {
-		return fmt.Errorf("could not invoke method (%s): %w", method, err)
+		return fmt.Errorf("invoke method (%s): %w", method, err)
 	}
 	return nil
 }

pkg/morph/client/frostfsid/subject.go

@@ -31,7 +31,7 @@ func (c *Client) GetSubject(addr util.Uint160) (*frostfsidclient.Subject, error)
 
 	subj, err := frostfsidclient.ParseSubject(structArr)
 	if err != nil {
-		return nil, fmt.Errorf("could not parse test invocation result (%s): %w", methodGetSubject, err)
+		return nil, fmt.Errorf("parse test invocation result (%s): %w", methodGetSubject, err)
 	}
 
 	return subj, nil
@@ -54,7 +54,7 @@ func (c *Client) GetSubjectExtended(addr util.Uint160) (*frostfsidclient.Subject
 
 	subj, err := frostfsidclient.ParseSubjectExtended(structArr)
 	if err != nil {
-		return nil, fmt.Errorf("could not parse test invocation result (%s): %w", methodGetSubject, err)
+		return nil, fmt.Errorf("parse test invocation result (%s): %w", methodGetSubject, err)
 	}
 
 	return subj, nil
@@ -67,7 +67,7 @@ func checkStackItem(res []stackitem.Item) (structArr []stackitem.Item, err error
 
 	structArr, err = client.ArrayFromStackItem(res[0])
 	if err != nil {
-		return nil, fmt.Errorf("could not get item array of container (%s): %w", methodGetSubject, err)
+		return nil, fmt.Errorf("get item array of container (%s): %w", methodGetSubject, err)
 	}
 	return
 }

pkg/morph/client/netmap/epoch.go

@@ -25,7 +25,7 @@ func (c *Client) Epoch() (uint64, error) {
 
 	num, err := client.IntFromStackItem(items[0])
 	if err != nil {
-		return 0, fmt.Errorf("could not get number from stack item (%s): %w", epochMethod, err)
+		return 0, fmt.Errorf("get number from stack item (%s): %w", epochMethod, err)
 	}
 	return uint64(num), nil
 }
@@ -49,7 +49,7 @@ func (c *Client) LastEpochBlock() (uint32, error) {
 
 	block, err := client.IntFromStackItem(items[0])
 	if err != nil {
-		return 0, fmt.Errorf("could not get number from stack item (%s): %w",
+		return 0, fmt.Errorf("get number from stack item (%s): %w",
 			lastEpochBlockMethod, err)
 	}
 	return uint32(block), nil

pkg/morph/client/netmap/innerring.go

@@ -59,7 +59,7 @@ func irKeysFromStackItem(stack []stackitem.Item, method string) (keys.PublicKeys
 
 	irs, err := client.ArrayFromStackItem(stack[0])
 	if err != nil {
-		return nil, fmt.Errorf("could not get stack item array from stack item (%s): %w", method, err)
+		return nil, fmt.Errorf("get stack item array from stack item (%s): %w", method, err)
 	}
 
 	irKeys := make(keys.PublicKeys, len(irs))
@@ -79,7 +79,7 @@ const irNodeFixedPrmNumber = 1
 func irKeyFromStackItem(prm stackitem.Item) (*keys.PublicKey, error) {
 	prms, err := client.ArrayFromStackItem(prm)
 	if err != nil {
-		return nil, fmt.Errorf("could not get stack item array (IRNode): %w", err)
+		return nil, fmt.Errorf("get stack item array (IRNode): %w", err)
 	} else if ln := len(prms); ln != irNodeFixedPrmNumber {
 		return nil, fmt.Errorf(
 			"unexpected stack item count (IRNode): expected %d, has %d",
@@ -90,7 +90,7 @@ func irKeyFromStackItem(prm stackitem.Item) (*keys.PublicKey, error) {
 
 	byteKey, err := client.BytesFromStackItem(prms[0])
 	if err != nil {
-		return nil, fmt.Errorf("could not parse bytes from stack item (IRNode): %w", err)
+		return nil, fmt.Errorf("parse bytes from stack item (IRNode): %w", err)
 	}
 
 	return keys.NewPublicKeyFromBytes(byteKey, elliptic.P256())

pkg/morph/client/netmap/new_epoch.go

@@ -16,7 +16,7 @@ func (c *Client) NewEpoch(ctx context.Context, epoch uint64) error {
 
 	_, err := c.client.Invoke(ctx, prm)
 	if err != nil {
-		return fmt.Errorf("could not invoke method (%s): %w", newEpochMethod, err)
+		return fmt.Errorf("invoke method (%s): %w", newEpochMethod, err)
 	}
 	return nil
 }
@@ -34,7 +34,7 @@ func (c *Client) NewEpochControl(ctx context.Context, epoch uint64, vub uint32)
 
 	res, err := c.client.Invoke(ctx, prm)
 	if err != nil {
-		return 0, fmt.Errorf("could not invoke method (%s): %w", newEpochMethod, err)
+		return 0, fmt.Errorf("invoke method (%s): %w", newEpochMethod, err)
 	}
 	return res.VUB, nil
 }

pkg/morph/client/netmap/peer.go

@@ -41,7 +41,7 @@ func (c *Client) AddPeer(ctx context.Context, p AddPeerPrm) error {
 	prm.InvokePrmOptional = p.InvokePrmOptional
 
 	if _, err := c.client.Invoke(ctx, prm); err != nil {
-		return fmt.Errorf("could not invoke method (%s): %w", method, err)
+		return fmt.Errorf("invoke method (%s): %w", method, err)
 	}
 	return nil
 }

pkg/morph/client/nns.go

@@ -107,7 +107,7 @@ func (c *Client) NNSHash() (util.Uint160, error) {
 func nnsResolveItem(c *rpcclient.WSClient, nnsHash util.Uint160, domain string) (stackitem.Item, error) {
 	found, err := exists(c, nnsHash, domain)
 	if err != nil {
-		return nil, fmt.Errorf("could not check presence in NNS contract for %s: %w", domain, err)
+		return nil, fmt.Errorf("check presence in NNS contract for %s: %w", domain, err)
 	}
 
 	if !found {

pkg/morph/client/notary.go

@@ -62,7 +62,7 @@ const (
 	notaryExpirationOfMethod = "expirationOf"
 	setDesignateMethod       = "designateAsRole"
 
-	notaryBalanceErrMsg      = "can't fetch notary balance"
+	notaryBalanceErrMsg      = "fetch notary balance"
 	notaryNotEnabledPanicMsg = "notary support was not enabled on this client"
 )
 
@@ -155,12 +155,12 @@ func (c *Client) DepositNotary(ctx context.Context, amount fixedn.Fixed8, delta
 
 	bc, err := c.rpcActor.GetBlockCount()
 	if err != nil {
-		return util.Uint256{}, fmt.Errorf("can't get blockchain height: %w", err)
+		return util.Uint256{}, fmt.Errorf("get blockchain height: %w", err)
 	}
 
 	currentTill, err := c.depositExpirationOf()
 	if err != nil {
-		return util.Uint256{}, fmt.Errorf("can't get previous expiration value: %w", err)
+		return util.Uint256{}, fmt.Errorf("get previous expiration value: %w", err)
 	}
 
 	till := max(int64(bc+delta), currentTill)
@@ -197,7 +197,7 @@ func (c *Client) depositNotary(ctx context.Context, amount fixedn.Fixed8, till i
 		[]any{c.acc.PrivateKey().GetScriptHash(), till})
 	if err != nil {
 		if !errors.Is(err, neorpc.ErrAlreadyExists) {
-			return util.Uint256{}, 0, fmt.Errorf("can't make notary deposit: %w", err)
+			return util.Uint256{}, 0, fmt.Errorf("make notary deposit: %w", err)
 		}
 
 		// Transaction is already in mempool waiting to be processed.
@@ -289,7 +289,7 @@ func (c *Client) UpdateNotaryList(ctx context.Context, prm UpdateNotaryListPrm)
 
 	nonce, vub, err := c.CalculateNonceAndVUB(&prm.hash)
 	if err != nil {
-		return fmt.Errorf("could not calculate nonce and `valicUntilBlock` values: %w", err)
+		return fmt.Errorf("calculate nonce and `valicUntilBlock` values: %w", err)
 	}
 
 	return c.notaryInvokeAsCommittee(
@@ -338,7 +338,7 @@ func (c *Client) UpdateNeoFSAlphabetList(ctx context.Context, prm UpdateAlphabet
 
 	nonce, vub, err := c.CalculateNonceAndVUB(&prm.hash)
 	if err != nil {
-		return fmt.Errorf("could not calculate nonce and `valicUntilBlock` values: %w", err)
+		return fmt.Errorf("calculate nonce and `valicUntilBlock` values: %w", err)
 	}
 
 	return c.notaryInvokeAsCommittee(
@@ -407,7 +407,7 @@ func (c *Client) NotarySignAndInvokeTX(mainTx *transaction.Transaction) error {
 
 	alphabetList, err := c.notary.alphabetSource()
 	if err != nil {
-		return fmt.Errorf("could not fetch current alphabet keys: %w", err)
+		return fmt.Errorf("fetch current alphabet keys: %w", err)
 	}
 
 	cosigners, err := c.notaryCosignersFromTx(mainTx, alphabetList)
@@ -529,24 +529,24 @@ func (c *Client) notaryCosignersFromTx(mainTx *transaction.Transaction, alphabet
 			if ok {
 				pub, err := keys.NewPublicKeyFromBytes(pubBytes, elliptic.P256())
 				if err != nil {
-					return nil, fmt.Errorf("failed to parse verification script of signer #2: invalid public key: %w", err)
+					return nil, fmt.Errorf("parse verification script of signer #2: invalid public key: %w", err)
 				}
 				acc = notary.FakeSimpleAccount(pub)
 			} else {
 				m, pubsBytes, ok := vm.ParseMultiSigContract(script)
 				if !ok {
-					return nil, errors.New("failed to parse verification script of signer #2: unknown witness type")
+					return nil, errors.New("parse verification script of signer #2: unknown witness type")
 				}
 				pubs := make(keys.PublicKeys, len(pubsBytes))
 				for i := range pubs {
 					pubs[i], err = keys.NewPublicKeyFromBytes(pubsBytes[i], elliptic.P256())
 					if err != nil {
-						return nil, fmt.Errorf("failed to parse verification script of signer #2: invalid public key #%d: %w", i, err)
+						return nil, fmt.Errorf("parse verification script of signer #2: invalid public key #%d: %w", i, err)
 					}
 				}
 				acc, err = notary.FakeMultisigAccount(m, pubs)
 				if err != nil {
-					return nil, fmt.Errorf("failed to create fake account for signer #2: %w", err)
+					return nil, fmt.Errorf("create fake account for signer #2: %w", err)
 				}
 			}
 		}
@@ -623,7 +623,7 @@ func (c *Client) notaryMultisigAccount(ir []*keys.PublicKey, committee, invokedB
 		err := multisigAccount.ConvertMultisig(m, ir)
 		if err != nil {
 			// wrap error as FrostFS-specific since the call is not related to any client
-			return nil, wrapFrostFSError(fmt.Errorf("can't convert account to inner ring multisig wallet: %w", err))
+			return nil, wrapFrostFSError(fmt.Errorf("convert account to inner ring multisig wallet: %w", err))
 		}
 	} else {
 		// alphabet multisig redeem script is
@@ -632,7 +632,7 @@ func (c *Client) notaryMultisigAccount(ir []*keys.PublicKey, committee, invokedB
 		multisigAccount, err = notary.FakeMultisigAccount(m, ir)
 		if err != nil {
 			// wrap error as FrostFS-specific since the call is not related to any client
-			return nil, wrapFrostFSError(fmt.Errorf("can't make inner ring multisig wallet: %w", err))
+			return nil, wrapFrostFSError(fmt.Errorf("make inner ring multisig wallet: %w", err))
 		}
 	}
 
@@ -642,7 +642,7 @@ func (c *Client) notaryMultisigAccount(ir []*keys.PublicKey, committee, invokedB
 func (c *Client) notaryTxValidationLimit() (uint32, error) {
 	bc, err := c.rpcActor.GetBlockCount()
 	if err != nil {
-		return 0, fmt.Errorf("can't get current blockchain height: %w", err)
+		return 0, fmt.Errorf("get current blockchain height: %w", err)
 	}
 
 	minTime := bc + c.notary.txValidTime
@@ -663,7 +663,7 @@ func (c *Client) depositExpirationOf() (int64, error) {
 
 	currentTillBig, err := expirationRes[0].TryInteger()
 	if err != nil {
-		return 0, fmt.Errorf("can't parse deposit till value: %w", err)
+		return 0, fmt.Errorf("parse deposit till value: %w", err)
 	}
 
 	return currentTillBig.Int64(), nil
@@ -742,12 +742,12 @@ func alreadyOnChainError(err error) bool {
 func CalculateNotaryDepositAmount(c *Client, gasMul, gasDiv int64) (fixedn.Fixed8, error) {
 	notaryBalance, err := c.GetNotaryDeposit()
 	if err != nil {
-		return 0, fmt.Errorf("could not get notary balance: %w", err)
+		return 0, fmt.Errorf("get notary balance: %w", err)
 	}
 
 	gasBalance, err := c.GasBalance()
 	if err != nil {
-		return 0, fmt.Errorf("could not get GAS balance: %w", err)
+		return 0, fmt.Errorf("get GAS balance: %w", err)
 	}
 
 	if gasBalance == 0 {
@@ -796,12 +796,12 @@ func (c *Client) calculateNonceAndVUB(hash *util.Uint256, roundBlockHeight bool)
 	if hash != nil {
 		height, err = c.getTransactionHeight(*hash)
 		if err != nil {
-			return 0, 0, fmt.Errorf("could not get transaction height: %w", err)
+			return 0, 0, fmt.Errorf("get transaction height: %w", err)
 		}
 	} else {
 		height, err = c.rpcActor.GetBlockCount()
 		if err != nil {
-			return 0, 0, fmt.Errorf("could not get chain height: %w", err)
+			return 0, 0, fmt.Errorf("get chain height: %w", err)
 		}
 	}
 

pkg/morph/client/static.go

@@ -159,7 +159,7 @@ func (s StaticClient) Invoke(ctx context.Context, prm InvokePrm) (InvokeRes, err
 					nonce, vub, err = s.client.CalculateNonceAndVUB(prm.hash)
 				}
 				if err != nil {
-					return InvokeRes{}, fmt.Errorf("could not calculate nonce and VUB for notary alphabet invoke: %w", err)
+					return InvokeRes{}, fmt.Errorf("calculate nonce and VUB for notary alphabet invoke: %w", err)
 				}
 
 				vubP = &vub

pkg/morph/client/util.go

@@ -53,7 +53,7 @@ func BytesFromStackItem(param stackitem.Item) ([]byte, error) {
 	case stackitem.IntegerT:
 		n, err := param.TryInteger()
 		if err != nil {
-			return nil, fmt.Errorf("can't parse integer bytes: %w", err)
+			return nil, fmt.Errorf("parse integer bytes: %w", err)
 		}
 
 		return n.Bytes(), nil