diff --git a/pkg/morph/client/balance/balanceOf.go b/pkg/morph/client/balance/balanceOf.go
index 12a499ffb..a5fb8e82a 100644
--- a/pkg/morph/client/balance/balanceOf.go
+++ b/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
 }
diff --git a/pkg/morph/client/balance/decimals.go b/pkg/morph/client/balance/decimals.go
index 28329ee6e..c2a66dded 100644
--- a/pkg/morph/client/balance/decimals.go
+++ b/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
 }
diff --git a/pkg/morph/client/balance/transfer.go b/pkg/morph/client/balance/transfer.go
index 16c8f3982..52d69dccb 100644
--- a/pkg/morph/client/balance/transfer.go
+++ b/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
 }
diff --git a/pkg/morph/client/client.go b/pkg/morph/client/client.go
index a0c29141b..5a5d24900 100644
--- a/pkg/morph/client/client.go
+++ b/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)
diff --git a/pkg/morph/client/container/containers_of.go b/pkg/morph/client/container/containers_of.go
index c4db0fe6e..5fe15be0d 100644
--- a/pkg/morph/client/container/containers_of.go
+++ b/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
diff --git a/pkg/morph/client/container/delete.go b/pkg/morph/client/container/delete.go
index ef5cc8c38..09912efa5 100644
--- a/pkg/morph/client/container/delete.go
+++ b/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
 }
diff --git a/pkg/morph/client/container/deletion_info.go b/pkg/morph/client/container/deletion_info.go
index 436ca3c01..b86e0ce9c 100644
--- a/pkg/morph/client/container/deletion_info.go
+++ b/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{
diff --git a/pkg/morph/client/container/get.go b/pkg/morph/client/container/get.go
index 1d84e9109..2ab58bf01 100644
--- a/pkg/morph/client/container/get.go
+++ b/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)
 		}
 	}
 
diff --git a/pkg/morph/client/container/list.go b/pkg/morph/client/container/list.go
index 55317375a..d9719aedd 100644
--- a/pkg/morph/client/container/list.go
+++ b/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
diff --git a/pkg/morph/client/container/put.go b/pkg/morph/client/container/put.go
index 1eb03694f..3bb84eb87 100644
--- a/pkg/morph/client/container/put.go
+++ b/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
 }
diff --git a/pkg/morph/client/frostfsid/subject.go b/pkg/morph/client/frostfsid/subject.go
index 7c93f4922..305f3ce09 100644
--- a/pkg/morph/client/frostfsid/subject.go
+++ b/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
 }
diff --git a/pkg/morph/client/netmap/epoch.go b/pkg/morph/client/netmap/epoch.go
index 6d909a7a1..6d7394998 100644
--- a/pkg/morph/client/netmap/epoch.go
+++ b/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
diff --git a/pkg/morph/client/netmap/innerring.go b/pkg/morph/client/netmap/innerring.go
index 824827d6f..0cfad4c82 100644
--- a/pkg/morph/client/netmap/innerring.go
+++ b/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())
diff --git a/pkg/morph/client/netmap/new_epoch.go b/pkg/morph/client/netmap/new_epoch.go
index efcdfd7b6..341b20935 100644
--- a/pkg/morph/client/netmap/new_epoch.go
+++ b/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
 }
diff --git a/pkg/morph/client/netmap/peer.go b/pkg/morph/client/netmap/peer.go
index 949e8cb63..e83acde39 100644
--- a/pkg/morph/client/netmap/peer.go
+++ b/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
 }
diff --git a/pkg/morph/client/nns.go b/pkg/morph/client/nns.go
index 218f7ad8e..f292dccf1 100644
--- a/pkg/morph/client/nns.go
+++ b/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 {
diff --git a/pkg/morph/client/notary.go b/pkg/morph/client/notary.go
index 8516c89a9..dbd58a53a 100644
--- a/pkg/morph/client/notary.go
+++ b/pkg/morph/client/notary.go
@@ -58,16 +58,11 @@ const (
 	defaultNotaryValidTime = 50
 	defaultNotaryRoundTime = 100
 
-	notaryBalanceOfMethod    = "balanceOf"
-	notaryExpirationOfMethod = "expirationOf"
-	setDesignateMethod       = "designateAsRole"
+	setDesignateMethod = "designateAsRole"
 
-	notaryBalanceErrMsg      = "can't fetch notary balance"
 	notaryNotEnabledPanicMsg = "notary support was not enabled on this client"
 )
 
-var errUnexpectedItems = errors.New("invalid number of NEO VM arguments on stack")
-
 func defaultNotaryConfig(c *Client) *notaryCfg {
 	return &notaryCfg{
 		txValidTime:    defaultNotaryValidTime,
@@ -155,15 +150,16 @@ 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()
+	r := notary.NewReader(c.rpcActor)
+	currentTill, err := r.ExpirationOf(c.acc.PrivateKey().GetScriptHash())
 	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)
+	till := max(int64(bc+delta), int64(currentTill))
 	res, _, err := c.depositNotary(ctx, amount, till)
 	return res, err
 }
@@ -197,7 +193,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.
@@ -237,18 +233,10 @@ func (c *Client) GetNotaryDeposit() (res int64, err error) {
 
 	sh := c.acc.PrivateKey().PublicKey().GetScriptHash()
 
-	items, err := c.TestInvoke(c.notary.notary, notaryBalanceOfMethod, sh)
+	r := notary.NewReader(c.rpcActor)
+	bigIntDeposit, err := r.BalanceOf(sh)
 	if err != nil {
-		return 0, fmt.Errorf("test invoke (%s): %w", notaryBalanceOfMethod, err)
-	}
-
-	if len(items) != 1 {
-		return 0, wrapFrostFSError(fmt.Errorf("%v: %w", notaryBalanceErrMsg, errUnexpectedItems))
-	}
-
-	bigIntDeposit, err := items[0].TryInteger()
-	if err != nil {
-		return 0, wrapFrostFSError(fmt.Errorf("%v: %w", notaryBalanceErrMsg, err))
+		return 0, fmt.Errorf("get notary deposit: %w", err)
 	}
 
 	return bigIntDeposit.Int64(), nil
@@ -289,7 +277,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 +326,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 +395,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 +517,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 +611,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 +620,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 +630,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
@@ -651,24 +639,6 @@ func (c *Client) notaryTxValidationLimit() (uint32, error) {
 	return rounded, nil
 }
 
-func (c *Client) depositExpirationOf() (int64, error) {
-	expirationRes, err := c.TestInvoke(c.notary.notary, notaryExpirationOfMethod, c.acc.PrivateKey().GetScriptHash())
-	if err != nil {
-		return 0, fmt.Errorf("test invoke (%s): %w", notaryExpirationOfMethod, err)
-	}
-
-	if len(expirationRes) != 1 {
-		return 0, fmt.Errorf("method returned unexpected item count: %d", len(expirationRes))
-	}
-
-	currentTillBig, err := expirationRes[0].TryInteger()
-	if err != nil {
-		return 0, fmt.Errorf("can't parse deposit till value: %w", err)
-	}
-
-	return currentTillBig.Int64(), nil
-}
-
 // sigCount returns the number of required signature.
 // For FrostFS Alphabet M is a 2/3+1 of it (like in dBFT).
 // If committee is true, returns M as N/2+1.
@@ -742,12 +712,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 +766,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)
 		}
 	}
 
diff --git a/pkg/morph/client/static.go b/pkg/morph/client/static.go
index be4c09182..21adebd9e 100644
--- a/pkg/morph/client/static.go
+++ b/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
diff --git a/pkg/morph/client/util.go b/pkg/morph/client/util.go
index cd55d6bd2..f68d39beb 100644
--- a/pkg/morph/client/util.go
+++ b/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
diff --git a/pkg/morph/event/listener.go b/pkg/morph/event/listener.go
index 7a16eb991..ed77352ec 100644
--- a/pkg/morph/event/listener.go
+++ b/pkg/morph/event/listener.go
@@ -111,7 +111,7 @@ type listener struct {
 	pool *ants.Pool
 }
 
-const newListenerFailMsg = "could not instantiate Listener"
+const newListenerFailMsg = "instantiate Listener"
 
 var (
 	errNilLogger = errors.New("nil logger")
@@ -195,20 +195,20 @@ func (l *listener) subscribe(errCh chan error) {
 
 	err := l.subscriber.SubscribeForNotification(hashes...)
 	if err != nil {
-		errCh <- fmt.Errorf("could not subscribe for notifications: %w", err)
+		errCh <- fmt.Errorf("subscribe for notifications: %w", err)
 		return
 	}
 
 	if len(l.blockHandlers) > 0 {
 		if err = l.subscriber.BlockNotifications(); err != nil {
-			errCh <- fmt.Errorf("could not subscribe for blocks: %w", err)
+			errCh <- fmt.Errorf("subscribe for blocks: %w", err)
 			return
 		}
 	}
 
 	if l.listenNotary {
 		if err = l.subscriber.SubscribeForNotaryRequests(l.notaryMainTXSigner); err != nil {
-			errCh <- fmt.Errorf("could not subscribe for notary requests: %w", err)
+			errCh <- fmt.Errorf("subscribe for notary requests: %w", err)
 			return
 		}
 	}
@@ -566,7 +566,7 @@ func NewListener(p ListenerParams) (Listener, error) {
 	// The default capacity is 0, which means "infinite".
 	pool, err := ants.NewPool(p.WorkerPoolCapacity)
 	if err != nil {
-		return nil, fmt.Errorf("could not init worker pool: %w", err)
+		return nil, fmt.Errorf("init worker pool: %w", err)
 	}
 
 	return &listener{
diff --git a/pkg/morph/event/netmap/update_peer_notary.go b/pkg/morph/event/netmap/update_peer_notary.go
index 0260810b8..993182ab4 100644
--- a/pkg/morph/event/netmap/update_peer_notary.go
+++ b/pkg/morph/event/netmap/update_peer_notary.go
@@ -10,7 +10,7 @@ import (
 	"github.com/nspcc-dev/neo-go/pkg/vm/opcode"
 )
 
-var errNilPubKey = errors.New("could not parse public key: public key is nil")
+var errNilPubKey = errors.New("public key is nil")
 
 func (s *UpdatePeer) setPublicKey(v []byte) (err error) {
 	if v == nil {
@@ -19,7 +19,7 @@ func (s *UpdatePeer) setPublicKey(v []byte) (err error) {
 
 	s.PubKey, err = keys.NewPublicKeyFromBytes(v, elliptic.P256())
 	if err != nil {
-		return fmt.Errorf("could not parse public key: %w", err)
+		return fmt.Errorf("parse public key: %w", err)
 	}
 
 	return
diff --git a/pkg/morph/event/notary_preparator.go b/pkg/morph/event/notary_preparator.go
index 37091f768..40f5984a9 100644
--- a/pkg/morph/event/notary_preparator.go
+++ b/pkg/morph/event/notary_preparator.go
@@ -127,7 +127,7 @@ func (p Preparator) Prepare(nr *payload.P2PNotaryRequest) (NotaryEvent, error) {
 	for {
 		opCode, param, err = ctx.Next()
 		if err != nil {
-			return nil, fmt.Errorf("could not get next opcode in script: %w", err)
+			return nil, fmt.Errorf("get next opcode in script: %w", err)
 		}
 
 		if opCode == opcode.RET {
@@ -147,7 +147,7 @@ func (p Preparator) Prepare(nr *payload.P2PNotaryRequest) (NotaryEvent, error) {
 	// retrieve contract's script hash
 	contractHash, err := util.Uint160DecodeBytesBE(ops[opsLen-2].param)
 	if err != nil {
-		return nil, fmt.Errorf("could not decode contract hash: %w", err)
+		return nil, fmt.Errorf("decode contract hash: %w", err)
 	}
 
 	// retrieve contract's method
@@ -164,7 +164,7 @@ func (p Preparator) Prepare(nr *payload.P2PNotaryRequest) (NotaryEvent, error) {
 	if len(args) != 0 {
 		err = p.validateParameterOpcodes(args)
 		if err != nil {
-			return nil, fmt.Errorf("could not validate arguments: %w", err)
+			return nil, fmt.Errorf("validate arguments: %w", err)
 		}
 
 		// without args packing opcodes
@@ -206,7 +206,7 @@ func (p Preparator) validateNotaryRequest(nr *payload.P2PNotaryRequest) error {
 
 	currentAlphabet, err := p.alphaKeys()
 	if err != nil {
-		return fmt.Errorf("could not fetch Alphabet public keys: %w", err)
+		return fmt.Errorf("fetch Alphabet public keys: %w", err)
 	}
 
 	err = p.validateCosigners(ln, nr.MainTransaction.Signers, currentAlphabet)
@@ -239,7 +239,7 @@ func (p Preparator) validateParameterOpcodes(ops []Op) error {
 
 	argsLen, err := IntFromOpcode(ops[l-2])
 	if err != nil {
-		return fmt.Errorf("could not parse argument len: %w", err)
+		return fmt.Errorf("parse argument len: %w", err)
 	}
 
 	err = validateNestedArgs(argsLen, ops[:l-2])
@@ -273,7 +273,7 @@ func validateNestedArgs(expArgLen int64, ops []Op) error {
 
 			argsLen, err := IntFromOpcode(ops[i-1])
 			if err != nil {
-				return fmt.Errorf("could not parse argument len: %w", err)
+				return fmt.Errorf("parse argument len: %w", err)
 			}
 
 			expArgLen += argsLen + 1
@@ -307,7 +307,7 @@ func (p Preparator) validateExpiration(fbTX *transaction.Transaction) error {
 
 	currBlock, err := p.blockCounter.BlockCount()
 	if err != nil {
-		return fmt.Errorf("could not fetch current chain height: %w", err)
+		return fmt.Errorf("fetch current chain height: %w", err)
 	}
 
 	if currBlock >= nvb.Height {
@@ -327,7 +327,7 @@ func (p Preparator) validateCosigners(expected int, s []transaction.Signer, alph
 
 	alphaVerificationScript, err := smartcontract.CreateMultiSigRedeemScript(len(alphaKeys)*2/3+1, alphaKeys)
 	if err != nil {
-		return fmt.Errorf("could not get Alphabet verification script: %w", err)
+		return fmt.Errorf("get Alphabet verification script: %w", err)
 	}
 
 	if !s[1].Account.Equals(hash.Hash160(alphaVerificationScript)) {
@@ -346,7 +346,7 @@ func (p Preparator) validateWitnesses(w []transaction.Witness, alphaKeys keys.Pu
 
 	alphaVerificationScript, err := smartcontract.CreateMultiSigRedeemScript(len(alphaKeys)*2/3+1, alphaKeys)
 	if err != nil {
-		return fmt.Errorf("could not get Alphabet verification script: %w", err)
+		return fmt.Errorf("get Alphabet verification script: %w", err)
 	}
 
 	// the second one must be witness of the current
diff --git a/pkg/morph/event/rolemanagement/designate.go b/pkg/morph/event/rolemanagement/designate.go
index 28c968046..b384e436b 100644
--- a/pkg/morph/event/rolemanagement/designate.go
+++ b/pkg/morph/event/rolemanagement/designate.go
@@ -26,7 +26,7 @@ func (Designate) MorphEvent() {}
 func ParseDesignate(e *state.ContainedNotificationEvent) (event.Event, error) {
 	params, err := event.ParseStackArray(e)
 	if err != nil {
-		return nil, fmt.Errorf("could not parse stack items from notify event: %w", err)
+		return nil, fmt.Errorf("parse stack items from notify event: %w", err)
 	}
 
 	if len(params) != 2 {