update

TODO.md

@@ -6,3 +6,4 @@
 4. Write linters (names with prefixes 'p', 'f', 's', 'i', 'c', 'g'), (objects with name=p)
 5. Create HLC (Hidden Lake Connector)
 6. HLM to service
+7. Errors wrapper

cmd/hidden_lake/messenger/cmd/hlm/init_app.go

@@ -4,13 +4,14 @@ import (
 	"github.com/number571/go-peer/cmd/hidden_lake/messenger/internal/app"
 	"github.com/number571/go-peer/cmd/hidden_lake/messenger/internal/config"
 	"github.com/number571/go-peer/cmd/hidden_lake/messenger/internal/settings"
+	"github.com/number571/go-peer/pkg/errors"
 	"github.com/number571/go-peer/pkg/types"
 )
 
 func initApp() (types.ICommand, error) {
 	cfg, err := config.InitConfig(settings.CPathCFG, nil)
 	if err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "init config")
 	}
 
 	return app.NewApp(cfg, "."), nil

cmd/hidden_lake/messenger/cmd/m_hlm/init_app.go

@@ -7,6 +7,7 @@ import (
 	"github.com/number571/go-peer/cmd/hidden_lake/messenger/internal/config"
 	"github.com/number571/go-peer/cmd/hidden_lake/messenger/internal/settings"
 	"github.com/number571/go-peer/pkg/crypto/asymmetric"
+	"github.com/number571/go-peer/pkg/errors"
 	"github.com/number571/go-peer/pkg/types"
 
 	hls_app "github.com/number571/go-peer/cmd/hidden_lake/service/pkg/app"
@@ -21,7 +22,7 @@ const (
 func initApp(pPathTo string) (types.ICommand, types.ICommand, error) {
 	privKey := asymmetric.NewRSAPrivKey(hls_settings.CAKeySize)
 	if privKey == nil {
-		return nil, nil, fmt.Errorf("private key is invalid")
+		return nil, nil, errors.NewError("private key is invalid")
 	}
 
 	cfgHLS, err := hls_config.InitConfig(
@@ -38,7 +39,7 @@ func initApp(pPathTo string) (types.ICommand, types.ICommand, error) {
 		},
 	)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, errors.WrapError(err, "init config HLS")
 	}
 
 	cfgHLM, err := config.InitConfig(
@@ -55,7 +56,7 @@ func initApp(pPathTo string) (types.ICommand, types.ICommand, error) {
 		},
 	)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, errors.WrapError(err, "init config HLM")
 	}
 
 	return hls_app.NewApp(cfgHLS, privKey, pPathTo), app.NewApp(cfgHLM, pPathTo), nil

cmd/hidden_lake/messenger/internal/app/app.go

@@ -19,6 +19,7 @@ import (
 	hls_settings "github.com/number571/go-peer/cmd/hidden_lake/service/pkg/settings"
 	hlt_client "github.com/number571/go-peer/cmd/hidden_lake/traffic/pkg/client"
 	internal_logger "github.com/number571/go-peer/internal/logger"
+	pkg_errors "github.com/number571/go-peer/pkg/errors"
 )
 
 const (
@@ -85,7 +86,7 @@ func (p *sApp) Run() error {
 	defer p.fMutex.Unlock()
 
 	if p.fIsRun {
-		return errors.New("application already running")
+		return pkg_errors.NewError("application already running")
 	}
 	p.fIsRun = true
 
@@ -112,8 +113,7 @@ func (p *sApp) Run() error {
 
 	select {
 	case err := <-res:
-		p.Stop()
-		return err
+		return pkg_errors.AppendError(err, p.Stop())
 	case <-time.After(cInitStart):
 		p.fLogger.PushInfo(fmt.Sprintf("%s is running...", settings.CServiceName))
 		return nil
@@ -125,7 +125,7 @@ func (p *sApp) Stop() error {
 	defer p.fMutex.Unlock()
 
 	if !p.fIsRun {
-		return errors.New("application already stopped or not started")
+		return pkg_errors.NewError("application already stopped or not started")
 	}
 	p.fIsRun = false
 	p.fLogger.PushInfo(fmt.Sprintf("%s is shutting down...", settings.CServiceName))
@@ -133,9 +133,13 @@ func (p *sApp) Stop() error {
 	// state may be already closed
 	_ = p.fState.ClearActiveState()
 
-	return types.CloseAll([]types.ICloser{
+	err := types.CloseAll([]types.ICloser{
 		p.fIntServiceHTTP,
 		p.fIncServiceHTTP,
 		p.fState.GetWrapperDB(),
 	})
+	if err != nil {
+		return pkg_errors.WrapError(err, "close/stop all")
+	}
+	return nil
 }

cmd/hidden_lake/messenger/internal/app/init_storage.go

@@ -5,13 +5,18 @@ import (
 
 	"github.com/number571/go-peer/cmd/hidden_lake/messenger/internal/config"
 	hlm_settings "github.com/number571/go-peer/cmd/hidden_lake/messenger/internal/settings"
+	"github.com/number571/go-peer/pkg/errors"
 	"github.com/number571/go-peer/pkg/storage"
 )
 
 func initCryptoStorage(pCfg config.IConfig, pPathTo string) (storage.IKeyValueStorage, error) {
-	return storage.NewCryptoStorage(storage.NewSettings(&storage.SSettings{
+	stg, err := storage.NewCryptoStorage(storage.NewSettings(&storage.SSettings{
 		FPath:      fmt.Sprintf("%s/%s", pPathTo, hlm_settings.CPathSTG),
 		FWorkSize:  hlm_settings.CWorkForKeys,
 		FCipherKey: []byte(pCfg.GetStorageKey()),
 	}))
+	if err != nil {
+		return nil, errors.WrapError(err, "new crypto storage")
+	}
+	return stg, nil
 }

cmd/hidden_lake/messenger/internal/app/state/clear.go

@@ -3,25 +3,33 @@ package state
 import (
 	pkg_settings "github.com/number571/go-peer/cmd/hidden_lake/service/pkg/settings"
 	"github.com/number571/go-peer/pkg/crypto/asymmetric"
+	"github.com/number571/go-peer/pkg/errors"
 )
 
 func (p *sState) clearClientState() error {
 	if err := p.clearClientPrivKey(); err != nil {
-		return err
+		return errors.WrapError(err, "clear client private key")
 	}
 
 	if err := p.clearClientFriends(); err != nil {
-		return err
+		return errors.WrapError(err, "clear client friends")
 	}
 
-	return p.clearClientConnections()
+	if err := p.clearClientConnections(); err != nil {
+		return errors.WrapError(err, "clear client connections")
+	}
+
+	return nil
 }
 
 func (p *sState) clearClientPrivKey() error {
 	client := p.GetClient().Service()
 
 	pseudoPrivKey := asymmetric.NewRSAPrivKey(pkg_settings.CAKeySize)
-	return client.SetPrivKey(pseudoPrivKey)
+	if err := client.SetPrivKey(pseudoPrivKey); err != nil {
+		return errors.WrapError(err, "set pseudo private key")
+	}
+	return nil
 }
 
 func (p *sState) clearClientFriends() error {
@@ -29,12 +37,12 @@ func (p *sState) clearClientFriends() error {
 
 	friends, err := client.GetFriends()
 	if err != nil {
-		return err
+		return errors.WrapError(err, "get friends")
 	}
 
 	for aliasName := range friends {
 		if err := client.DelFriend(aliasName); err != nil {
-			return err
+			return errors.WrapError(err, "del friend")
 		}
 	}
 
@@ -46,11 +54,11 @@ func (p *sState) clearClientConnections() error {
 
 	connects, err := client.GetConnections()
 	if err != nil {
-		return err
+		return errors.WrapError(err, "get connections")
 	}
 	for _, conn := range connects {
 		if err := client.DelConnection(conn); err != nil {
-			return err
+			return errors.WrapError(err, "del connection")
 		}
 	}
 

cmd/hidden_lake/messenger/internal/app/state/state.go

@@ -8,6 +8,7 @@ import (
 	"github.com/number571/go-peer/pkg/crypto/asymmetric"
 	"github.com/number571/go-peer/pkg/crypto/entropy"
 	"github.com/number571/go-peer/pkg/encoding"
+	"github.com/number571/go-peer/pkg/errors"
 	"github.com/number571/go-peer/pkg/storage"
 
 	hlm_settings "github.com/number571/go-peer/cmd/hidden_lake/messenger/internal/settings"
@@ -80,9 +81,12 @@ func (p *sState) GetTemplate() *STemplateState {
 
 func (p *sState) CreateState(pHashLP []byte, pPrivKey asymmetric.IPrivKey) error {
 	if _, err := p.GetStorage().Get(pHashLP); err == nil {
-		return fmt.Errorf("state already exists")
+		return errors.NewError("state already exists")
 	}
-	return p.newStorageState(pHashLP, pPrivKey)
+	if err := p.newStorageState(pHashLP, pPrivKey); err != nil {
+		return errors.WrapError(err, "new storage state")
+	}
+	return nil
 }
 
 func (p *sState) UpdateState(pHashLP []byte) error {
@@ -90,22 +94,26 @@ func (p *sState) UpdateState(pHashLP []byte) error {
 	defer p.fMutex.Unlock()
 
 	if p.IsActive() {
-		return fmt.Errorf("state already exists")
+		return errors.NewError("state already exists")
 	}
 
 	stateValue, err := p.getStorageState(pHashLP)
 	if err != nil {
-		return err
+		return errors.WrapError(err, "get storage state")
 	}
 
 	entropyBooster := entropy.NewEntropyBooster(hlm_settings.CWorkForKeys, []byte{5, 7, 1})
-	p.GetWrapperDB().Set(database.NewKeyValueDB(
+	db, err := database.NewKeyValueDB(
 		fmt.Sprintf("%s/%s", p.fPathTo, hlm_settings.CPathDB),
 		entropyBooster.BoostEntropy(pHashLP),
-	))
+	)
+	if err != nil {
+		return errors.WrapError(err, "open KV database")
+	}
 
+	p.GetWrapperDB().Set(db)
 	if err := p.updateClientState(stateValue); err != nil {
-		return err
+		return errors.WrapError(err, "update client state")
 	}
 	p.fHashLP = pHashLP
 
@@ -118,42 +126,50 @@ func (p *sState) ClearActiveState() error {
 	defer p.fMutex.Unlock()
 
 	if !p.IsActive() {
-		return fmt.Errorf("state does not exist")
+		return errors.NewError("state does not exist")
 	}
 
 	p.fHashLP = nil
 
 	if err := p.GetWrapperDB().Close(); err != nil {
-		return err
+		return errors.WrapError(err, "close database")
 	}
 
 	if err := p.clearClientState(); err != nil {
-		return err
+		return errors.WrapError(err, "clear client state")
 	}
 
 	return nil
 }
 
 func (p *sState) AddFriend(pAliasName string, pPubKey asymmetric.IPubKey) error {
-	return p.stateUpdater(
+	err := p.stateUpdater(
 		p.updateClientFriends,
 		func(storageValue *SStorageState) {
 			storageValue.FFriends[pAliasName] = pPubKey.ToString()
 		},
 	)
+	if err != nil {
+		return errors.WrapError(err, "add friend (state updater)")
+	}
+	return nil
 }
 
 func (p *sState) DelFriend(pAliasName string) error {
-	return p.stateUpdater(
+	err := p.stateUpdater(
 		p.updateClientFriends,
 		func(storageValue *SStorageState) {
 			delete(storageValue.FFriends, pAliasName)
 		},
 	)
+	if err != nil {
+		return errors.WrapError(err, "del friend (state updater)")
+	}
+	return nil
 }
 
 func (p *sState) AddConnection(pConnect string) error {
-	return p.stateUpdater(
+	err := p.stateUpdater(
 		p.updateClientConnections,
 		func(storageValue *SStorageState) {
 			storageValue.FConnections = append(
@@ -162,10 +178,14 @@ func (p *sState) AddConnection(pConnect string) error {
 			)
 		},
 	)
+	if err != nil {
+		return errors.WrapError(err, "add connection (state updater)")
+	}
+	return nil
 }
 
 func (p *sState) DelConnection(pConnect string) error {
-	return p.stateUpdater(
+	err := p.stateUpdater(
 		p.updateClientConnections,
 		func(storageValue *SStorageState) {
 			storageValue.FConnections = remove(
@@ -174,6 +194,10 @@ func (p *sState) DelConnection(pConnect string) error {
 			)
 		},
 	)
+	if err != nil {
+		return errors.WrapError(err, "del connection (state updater)")
+	}
+	return nil
 }
 
 func (p *sState) IsActive() bool {
@@ -184,26 +208,32 @@ func (p *sState) newStorageState(pHashLP []byte, pPrivKey asymmetric.IPrivKey) e
 	stateValueBytes := encoding.Serialize(&SStorageState{
 		FPrivKey: pPrivKey.ToString(),
 	})
-	return p.GetStorage().Set(pHashLP, stateValueBytes)
+	if err := p.GetStorage().Set(pHashLP, stateValueBytes); err != nil {
+		return errors.WrapError(err, "new storage state")
+	}
+	return nil
 }
 
 func (p *sState) setStorageState(pStateValue *SStorageState) error {
 	stateValueBytes := encoding.Serialize(pStateValue)
-	return p.GetStorage().Set(p.fHashLP, stateValueBytes)
+	if err := p.GetStorage().Set(p.fHashLP, stateValueBytes); err != nil {
+		return errors.WrapError(err, "update storage state")
+	}
+	return nil
 }
 
 func (p *sState) getStorageState(pHashLP []byte) (*SStorageState, error) {
 	stateValueBytes, err := p.GetStorage().Get(pHashLP)
 	if err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "get storage state")
 	}
 
 	var stateValue = new(SStorageState)
 	if err := encoding.Deserialize(stateValueBytes, stateValue); err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "deserialize state")
 	}
 
-	return stateValue, err
+	return stateValue, nil
 }
 
 func remove(pSlice []string, pElem string) []string {

cmd/hidden_lake/messenger/internal/app/state/update.go

@@ -1,22 +1,21 @@
 package state
 
 import (
-	"fmt"
-
 	"github.com/number571/go-peer/pkg/crypto/asymmetric"
+	"github.com/number571/go-peer/pkg/errors"
 )
 
 func (p *sState) updateClientState(pStateValue *SStorageState) error {
 	if err := p.updateClientPrivKey(pStateValue); err != nil {
-		return err
+		return errors.WrapError(err, "update client private key")
 	}
 
 	if err := p.updateClientFriends(pStateValue); err != nil {
-		return err
+		return errors.WrapError(err, "update client friends")
 	}
 
 	if err := p.updateClientConnections(pStateValue); err != nil {
-		return err
+		return errors.WrapError(err, "update client connections")
 	}
 
 	return nil
@@ -26,28 +25,31 @@ func (p *sState) updateClientPrivKey(pStateValue *SStorageState) error {
 	hlsClient := p.GetClient().Service()
 
 	if err := p.clearClientPrivKey(); err != nil {
-		return err
+		return errors.WrapError(err, "clear client private key")
 	}
 
 	privKey := asymmetric.LoadRSAPrivKey(pStateValue.FPrivKey)
 	if privKey == nil {
-		return fmt.Errorf("private key is null")
+		return errors.NewError("private key is null")
 	}
 
-	return hlsClient.SetPrivKey(privKey)
+	if err := hlsClient.SetPrivKey(privKey); err != nil {
+		return errors.WrapError(err, "set private key")
+	}
+	return nil
 }
 
 func (p *sState) updateClientFriends(pStateValue *SStorageState) error {
 	client := p.GetClient().Service()
 
 	if err := p.clearClientFriends(); err != nil {
-		return err
+		return errors.WrapError(err, "clear client friends")
 	}
 
 	for aliasName, pubKeyString := range pStateValue.FFriends {
 		pubKey := asymmetric.LoadRSAPubKey(pubKeyString)
 		if err := client.AddFriend(aliasName, pubKey); err != nil {
-			return err
+			return errors.WrapError(err, "add friend")
 		}
 	}
 
@@ -58,12 +60,12 @@ func (p *sState) updateClientConnections(pStateValue *SStorageState) error {
 	client := p.GetClient().Service()
 
 	if err := p.clearClientConnections(); err != nil {
-		return err
+		return errors.WrapError(err, "clear client connections")
 	}
 
 	for _, conn := range pStateValue.FConnections {
 		if err := client.AddConnection(conn); err != nil {
-			return err
+			return errors.WrapError(err, "add connections")
 		}
 	}
 
@@ -76,7 +78,7 @@ func (p *sState) updateClientTraffic(pStateValue *SStorageState) error {
 
 	hashes, err := hltClient.GetHashes()
 	if err != nil {
-		return err
+		return errors.WrapError(err, "get hashes")
 	}
 
 	for _, hash := range hashes {

cmd/hidden_lake/messenger/internal/app/state/updater.go

@@ -1,6 +1,6 @@
 package state
 
-import "fmt"
+import "github.com/number571/go-peer/pkg/errors"
 
 func (p *sState) stateUpdater(
 	clientUpdater func(storageValue *SStorageState) error,
@@ -10,22 +10,28 @@ func (p *sState) stateUpdater(
 	defer p.fMutex.Unlock()
 
 	if !p.IsActive() {
-		return fmt.Errorf("state does not exist")
+		return errors.NewError("state does not exist")
 	}
 
 	oldStorageValue, err := p.getStorageState(p.fHashLP)
 	if err != nil {
-		return err
+		return errors.WrapError(err, "get old storage state")
 	}
 
 	newStorageValue := copyStorageState(oldStorageValue)
 	middleWare(newStorageValue)
 
 	if err := clientUpdater(newStorageValue); err == nil {
-		return p.setStorageState(newStorageValue)
+		if err := p.setStorageState(newStorageValue); err != nil {
+			return errors.WrapError(err, "get new storage state")
+		}
+		return nil
 	}
 
-	return p.setStorageState(oldStorageValue)
+	if err := p.setStorageState(oldStorageValue); err != nil {
+		return errors.WrapError(err, "update state (old -> new)")
+	}
+	return nil
 }
 
 func copyStorageState(pStorageValue *SStorageState) *SStorageState {

cmd/hidden_lake/messenger/internal/config/config.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/number571/go-peer/pkg/encoding"
+	"github.com/number571/go-peer/pkg/errors"
 	"github.com/number571/go-peer/pkg/filesystem"
 	"github.com/number571/go-peer/pkg/logger"
 )
@@ -39,15 +40,15 @@ func BuildConfig(pFilepath string, pCfg *SConfig) (IConfig, error) {
 	configFile := filesystem.OpenFile(pFilepath)
 
 	if configFile.IsExist() {
-		return nil, fmt.Errorf("config file '%s' already exist", pFilepath)
+		return nil, errors.NewError(fmt.Sprintf("config file '%s' already exist", pFilepath))
 	}
 
 	if err := configFile.Write(encoding.Serialize(pCfg)); err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "write config")
 	}
 
 	if err := pCfg.loadLogging(); err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "load logging")
 	}
 	return pCfg, nil
 }
@@ -56,21 +57,21 @@ func LoadConfig(pFilepath string) (IConfig, error) {
 	configFile := filesystem.OpenFile(pFilepath)
 
 	if !configFile.IsExist() {
-		return nil, fmt.Errorf("config file '%s' does not exist", pFilepath)
+		return nil, errors.NewError(fmt.Sprintf("config file '%s' does not exist", pFilepath))
 	}
 
 	bytes, err := configFile.Read()
 	if err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "read config")
 	}
 
 	cfg := new(SConfig)
 	if err := encoding.Deserialize(bytes, cfg); err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "deserialize config")
 	}
 
 	if err := cfg.loadLogging(); err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "load logging")
 	}
 	return cfg, nil
 }
@@ -88,7 +89,7 @@ func (p *SConfig) loadLogging() error {
 	for _, v := range p.FLogging {
 		logType, ok := mapping[v]
 		if !ok {
-			return fmt.Errorf("undefined log type '%s'", v)
+			return errors.NewError(fmt.Sprintf("undefined log type '%s'", v))
 		}
 		logging[logType] = true
 	}

cmd/hidden_lake/messenger/internal/database/database.go

@@ -1,10 +1,10 @@
 package database
 
 import (
-	"fmt"
 	"sync"
 
 	"github.com/number571/go-peer/pkg/encoding"
+	"github.com/number571/go-peer/pkg/errors"
 	gp_database "github.com/number571/go-peer/pkg/storage/database"
 )
 
@@ -13,7 +13,7 @@ type sKeyValueDB struct {
 	fDB    *gp_database.IKeyValueDB
 }
 
-func NewKeyValueDB(pPath string, pKey []byte) IKeyValueDB {
+func NewKeyValueDB(pPath string, pKey []byte) (IKeyValueDB, error) {
 	db, err := gp_database.NewSQLiteDB(
 		gp_database.NewSettings(&gp_database.SSettings{
 			FPath:      pPath,
@@ -22,11 +22,11 @@ func NewKeyValueDB(pPath string, pKey []byte) IKeyValueDB {
 		}),
 	)
 	if err != nil {
-		return nil
+		return nil, errors.WrapError(err, "new sqlite")
 	}
 	return &sKeyValueDB{
 		fDB: &db,
-	}
+	}, nil
 }
 
 func (p *sKeyValueDB) Size(pR IRelation) uint64 {
@@ -41,23 +41,23 @@ func (p *sKeyValueDB) Load(pR IRelation, pStart, pEnd uint64) ([]IMessage, error
 	defer p.fMutex.Unlock()
 
 	if pStart > pEnd {
-		return nil, fmt.Errorf("start > end")
+		return nil, errors.NewError("start > end")
 	}
 
 	size := p.getSize(pR)
 	if pEnd > size {
-		return nil, fmt.Errorf("end > size")
+		return nil, errors.NewError("end > size")
 	}
 
 	res := make([]IMessage, 0, pEnd-pStart)
 	for i := pStart; i < pEnd; i++ {
 		data, err := (*p.fDB).Get(getKeyMessageByEnum(pR, i))
 		if err != nil {
-			return nil, fmt.Errorf("message undefined")
+			return nil, errors.WrapError(err, "message undefined")
 		}
 		msg := LoadMessage(data)
 		if msg == nil {
-			return nil, fmt.Errorf("message is null")
+			return nil, errors.NewError("message is null")
 		}
 		res = append(res, msg)
 	}
@@ -69,31 +69,35 @@ func (p *sKeyValueDB) Push(pR IRelation, pMsg IMessage) error {
 	p.fMutex.Lock()
 	defer p.fMutex.Unlock()
 
-	_, err := (*p.fDB).Get(getKeyMessageByHash(pR, pMsg.GetSHA256UID()))
-	if err == nil {
-		return fmt.Errorf("message is already exist")
+	if _, err := (*p.fDB).Get(getKeyMessageByHash(pR, pMsg.GetSHA256UID())); err == nil {
+		return errors.WrapError(err, "message is already exist")
 	}
 
-	err = (*p.fDB).Set(getKeyMessageByHash(pR, pMsg.GetSHA256UID()), []byte{1})
-	if err != nil {
-		return err
+	if err := (*p.fDB).Set(getKeyMessageByHash(pR, pMsg.GetSHA256UID()), []byte{1}); err != nil {
+		return errors.WrapError(err, "set uid to database")
 	}
 
 	size := p.getSize(pR)
-	err = (*p.fDB).Set(getKeyMessageByEnum(pR, size), pMsg.ToBytes())
-	if err != nil {
-		return err
+	numBytes := encoding.Uint64ToBytes(size + 1)
+	if err := (*p.fDB).Set(getKeySize(pR), numBytes[:]); err != nil {
+		return errors.WrapError(err, "set size of message to database")
 	}
 
-	numBytes := encoding.Uint64ToBytes(size + 1)
-	return (*p.fDB).Set(getKeySize(pR), numBytes[:])
+	if err := (*p.fDB).Set(getKeyMessageByEnum(pR, size), pMsg.ToBytes()); err != nil {
+		return errors.WrapError(err, "set message to database")
+	}
+
+	return nil
 }
 
 func (p *sKeyValueDB) Close() error {
 	p.fMutex.Lock()
 	defer p.fMutex.Unlock()
 
-	return (*p.fDB).Close()
+	if err := (*p.fDB).Close(); err != nil {
+		return errors.WrapError(err, "close KV database")
+	}
+	return nil
 }
 
 func (p *sKeyValueDB) getSize(pR IRelation) uint64 {

cmd/hidden_lake/messenger/internal/database/wrapper.go

@@ -3,6 +3,7 @@ package database
 import (
 	"sync"
 
+	"github.com/number571/go-peer/pkg/errors"
 	"github.com/number571/go-peer/pkg/wrapper"
 )
 
@@ -49,5 +50,8 @@ func (p *sWrapperDB) Close() error {
 	}
 
 	p.fWrapper.Set(nil)
-	return db.Close()
+	if err := db.Close(); err != nil {
+		return errors.WrapError(err, "close database wrapper")
+	}
+	return nil
 }

cmd/hidden_lake/service/cmd/hls/init_app.go

@@ -2,10 +2,10 @@ package main
 
 import (
 	"flag"
-	"fmt"
 
 	"github.com/number571/go-peer/cmd/hidden_lake/service/pkg/app"
 	"github.com/number571/go-peer/pkg/crypto/asymmetric"
+	"github.com/number571/go-peer/pkg/errors"
 	"github.com/number571/go-peer/pkg/filesystem"
 	"github.com/number571/go-peer/pkg/types"
 
@@ -29,18 +29,18 @@ func initApp() (types.ICommand, error) {
 	default:
 		privKeyStr, err := filesystem.OpenFile(inputKey).Read()
 		if err != nil {
-			return nil, err
+			return nil, errors.WrapError(err, "read public key")
 		}
 		privKey = asymmetric.LoadRSAPrivKey(string(privKeyStr))
 	}
 
 	if privKey == nil {
-		return nil, fmt.Errorf("private key is invalid")
+		return nil, errors.NewError("private key is invalid")
 	}
 
 	cfg, err := pkg_config.InitConfig(pkg_settings.CPathCFG, nil)
 	if err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "init config")
 	}
 
 	return app.NewApp(cfg, privKey, "."), nil

cmd/hidden_lake/service/cmd/m_hls/init_app.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/number571/go-peer/cmd/hidden_lake/service/pkg/app"
 	"github.com/number571/go-peer/pkg/crypto/asymmetric"
+	"github.com/number571/go-peer/pkg/errors"
 	"github.com/number571/go-peer/pkg/types"
 
 	pkg_config "github.com/number571/go-peer/cmd/hidden_lake/service/pkg/config"
@@ -19,7 +20,7 @@ const (
 func initApp(pPathTo string) (types.ICommand, error) {
 	privKey := asymmetric.NewRSAPrivKey(pkg_settings.CAKeySize)
 	if privKey == nil {
-		return nil, fmt.Errorf("private key is invalid")
+		return nil, errors.NewError("private key is invalid")
 	}
 
 	cfg, err := pkg_config.InitConfig(
@@ -33,7 +34,7 @@ func initApp(pPathTo string) (types.ICommand, error) {
 		},
 	)
 	if err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "init config")
 	}
 
 	return app.NewApp(cfg, privKey, pPathTo), nil

cmd/hidden_lake/service/pkg/app/app.go

@@ -18,6 +18,7 @@ import (
 	"github.com/number571/go-peer/cmd/hidden_lake/service/internal/handler"
 	pkg_settings "github.com/number571/go-peer/cmd/hidden_lake/service/pkg/settings"
 	internal_logger "github.com/number571/go-peer/internal/logger"
+	pkg_errors "github.com/number571/go-peer/pkg/errors"
 )
 
 const (
@@ -61,13 +62,13 @@ func (p *sApp) Run() error {
 	defer p.fMutex.Unlock()
 
 	if p.fIsRun {
-		return errors.New("application already running")
+		return pkg_errors.NewError("application already running")
 	}
 	p.fIsRun = true
 
 	p.initServiceHTTP()
 	if err := p.initDatabase(); err != nil {
-		return err
+		return pkg_errors.WrapError(err, "init database")
 	}
 
 	res := make(chan error)
@@ -112,7 +113,7 @@ func (p *sApp) Run() error {
 
 		// run node in server mode
 		err := p.fNode.GetNetworkNode().Run()
-		if err != nil && !errors.Is(err, net.ErrClosed) {
+		if err != nil && !pkg_errors.HasError(err, net.ErrClosed) {
 			res <- err
 			return
 		}
@@ -120,8 +121,7 @@ func (p *sApp) Run() error {
 
 	select {
 	case err := <-res:
-		p.Stop()
-		return err
+		return pkg_errors.AppendError(pkg_errors.WrapError(err, "got run error"), p.Stop())
 	case <-time.After(cInitStart):
 		p.fLogger.PushInfo(fmt.Sprintf("%s is running...", pkg_settings.CServiceName))
 		return nil
@@ -133,25 +133,25 @@ func (p *sApp) Stop() error {
 	defer p.fMutex.Unlock()
 
 	if !p.fIsRun {
-		return errors.New("application already stopped or not started")
+		return pkg_errors.NewError("application already stopped or not started")
 	}
 	p.fIsRun = false
 	p.fLogger.PushInfo(fmt.Sprintf("%s is shutting down...", pkg_settings.CServiceName))
 
 	p.fNode.HandleFunc(pkg_settings.CServiceMask, nil)
-	lastErr := types.StopAll([]types.ICommand{
-		p.fNode,
-		p.fConnKeeper,
-		p.fNode.GetNetworkNode(),
-	})
-
-	err := types.CloseAll([]types.ICloser{
-		p.fServiceHTTP,
-		p.fNode.GetWrapperDB(),
-	})
+	err := pkg_errors.AppendError(
+		types.StopAll([]types.ICommand{
+			p.fNode,
+			p.fConnKeeper,
+			p.fNode.GetNetworkNode(),
+		}),
+		types.CloseAll([]types.ICloser{
+			p.fServiceHTTP,
+			p.fNode.GetWrapperDB(),
+		}),
+	)
 	if err != nil {
-		lastErr = err
+		return pkg_errors.WrapError(err, "close/stop all")
 	}
-
-	return lastErr
+	return nil
 }

cmd/hidden_lake/service/pkg/app/init_database.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	pkg_settings "github.com/number571/go-peer/cmd/hidden_lake/service/pkg/settings"
+	"github.com/number571/go-peer/pkg/errors"
 	"github.com/number571/go-peer/pkg/storage/database"
 )
 
@@ -16,7 +17,7 @@ func (p *sApp) initDatabase() error {
 		}),
 	)
 	if err != nil {
-		return err
+		return errors.WrapError(err, "new sqlitedb")
 	}
 	p.fNode.GetWrapperDB().Set(db)
 	return nil

cmd/hidden_lake/service/pkg/client/client.go

@@ -5,6 +5,7 @@ import (
 	"github.com/number571/go-peer/cmd/hidden_lake/service/pkg/response"
 	"github.com/number571/go-peer/pkg/client/message"
 	"github.com/number571/go-peer/pkg/crypto/asymmetric"
+	"github.com/number571/go-peer/pkg/errors"
 )
 
 var (
@@ -24,57 +25,105 @@ func NewClient(pBuilder IBuilder, pRequester IRequester) IClient {
 }
 
 func (p *sClient) GetIndex() (string, error) {
-	return p.fRequester.GetIndex()
+	res, err := p.fRequester.GetIndex()
+	if err != nil {
+		return "", errors.WrapError(err, "get index (client)")
+	}
+	return res, nil
 }
 
 func (p *sClient) HandleMessage(pMsg message.IMessage) error {
-	return p.fRequester.HandleMessage(p.fBuilder.Message(pMsg))
+	if err := p.fRequester.HandleMessage(p.fBuilder.Message(pMsg)); err != nil {
+		return errors.WrapError(err, "handle message (client)")
+	}
+	return nil
 }
 
 func (p *sClient) BroadcastRequest(pRecv asymmetric.IPubKey, pData request.IRequest) error {
-	return p.fRequester.BroadcastRequest(p.fBuilder.Request(pRecv, pData))
+	if err := p.fRequester.BroadcastRequest(p.fBuilder.Request(pRecv, pData)); err != nil {
+		return errors.WrapError(err, "broadcast request (client)")
+	}
+	return nil
 }
 
 func (p *sClient) FetchRequest(pRecv asymmetric.IPubKey, pData request.IRequest) (response.IResponse, error) {
-	return p.fRequester.FetchRequest(p.fBuilder.Request(pRecv, pData))
+	res, err := p.fRequester.FetchRequest(p.fBuilder.Request(pRecv, pData))
+	if err != nil {
+		return nil, errors.WrapError(err, "fetch request (client)")
+	}
+	return res, nil
 }
 
 func (p *sClient) GetFriends() (map[string]asymmetric.IPubKey, error) {
-	return p.fRequester.GetFriends()
+	res, err := p.fRequester.GetFriends()
+	if err != nil {
+		return nil, errors.WrapError(err, "get friends (client)")
+	}
+	return res, nil
 }
 
 func (p *sClient) AddFriend(pAliasName string, pPubKey asymmetric.IPubKey) error {
-	return p.fRequester.AddFriend(p.fBuilder.Friend(pAliasName, pPubKey))
+	if err := p.fRequester.AddFriend(p.fBuilder.Friend(pAliasName, pPubKey)); err != nil {
+		return errors.WrapError(err, "add friend (client)")
+	}
+	return nil
 }
 
 func (p *sClient) DelFriend(pAliasName string) error {
-	return p.fRequester.DelFriend(p.fBuilder.Friend(pAliasName, nil))
+	if err := p.fRequester.DelFriend(p.fBuilder.Friend(pAliasName, nil)); err != nil {
+		return errors.WrapError(err, "del friend (client)")
+	}
+	return nil
 }
 
 func (p *sClient) GetOnlines() ([]string, error) {
-	return p.fRequester.GetOnlines()
+	res, err := p.fRequester.GetOnlines()
+	if err != nil {
+		return nil, errors.WrapError(err, "get onlines (client)")
+	}
+	return res, nil
 }
 
 func (p *sClient) DelOnline(pConnect string) error {
-	return p.fRequester.DelOnline(p.fBuilder.Connect(pConnect))
+	if err := p.fRequester.DelOnline(p.fBuilder.Connect(pConnect)); err != nil {
+		return errors.WrapError(err, "del online (client)")
+	}
+	return nil
 }
 
 func (p *sClient) GetConnections() ([]string, error) {
-	return p.fRequester.GetConnections()
+	res, err := p.fRequester.GetConnections()
+	if err != nil {
+		return nil, errors.WrapError(err, "get connections (client)")
+	}
+	return res, nil
 }
 
 func (p *sClient) AddConnection(pConnect string) error {
-	return p.fRequester.AddConnection(p.fBuilder.Connect(pConnect))
+	if err := p.fRequester.AddConnection(p.fBuilder.Connect(pConnect)); err != nil {
+		return errors.WrapError(err, "add connection (client)")
+	}
+	return nil
 }
 
 func (p *sClient) DelConnection(pConnect string) error {
-	return p.fRequester.DelConnection(p.fBuilder.Connect(pConnect))
+	if err := p.fRequester.DelConnection(p.fBuilder.Connect(pConnect)); err != nil {
+		return errors.WrapError(err, "del connection (client)")
+	}
+	return nil
 }
 
 func (p *sClient) SetPrivKey(pPrivKey asymmetric.IPrivKey) error {
-	return p.fRequester.SetPrivKey(p.fBuilder.SetPrivKey(pPrivKey))
+	if err := p.fRequester.SetPrivKey(p.fBuilder.SetPrivKey(pPrivKey)); err != nil {
+		return errors.WrapError(err, "set private key (client)")
+	}
+	return nil
 }
 
 func (p *sClient) GetPubKey() (asymmetric.IPubKey, error) {
-	return p.fRequester.GetPubKey()
+	res, err := p.fRequester.GetPubKey()
+	if err != nil {
+		return nil, errors.WrapError(err, "get public key (client)")
+	}
+	return res, nil
 }

cmd/hidden_lake/service/pkg/client/requester.go

@@ -9,6 +9,7 @@ import (
 	pkg_settings "github.com/number571/go-peer/cmd/hidden_lake/service/pkg/settings"
 	"github.com/number571/go-peer/internal/api"
 	"github.com/number571/go-peer/pkg/crypto/asymmetric"
+	"github.com/number571/go-peer/pkg/errors"
 )
 
 var (
@@ -35,11 +36,11 @@ func (p *sRequester) GetIndex() (string, error) {
 		nil,
 	)
 	if err != nil {
-		return "", err
+		return "", errors.WrapError(err, "get index (requester)")
 	}
 
 	if res != pkg_settings.CTitlePattern {
-		return "", fmt.Errorf("incorrect title pattern")
+		return "", errors.NewError("incorrect title pattern")
 	}
 	return res, nil
 }
@@ -51,7 +52,10 @@ func (p *sRequester) HandleMessage(pMsg pkg_settings.SMessage) error {
 		fmt.Sprintf(pkg_settings.CHandleNetworkMessageTemplate, p.fHost),
 		pMsg,
 	)
-	return err
+	if err != nil {
+		return errors.WrapError(err, "handle message (requester)")
+	}
+	return nil
 }
 
 func (p *sRequester) FetchRequest(pRequest *pkg_settings.SRequest) (response.IResponse, error) {
@@ -62,9 +66,14 @@ func (p *sRequester) FetchRequest(pRequest *pkg_settings.SRequest) (response.IRe
 		pRequest,
 	)
 	if err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "fetch request (requester)")
 	}
-	return response.LoadResponse([]byte(res))
+
+	resp, err := response.LoadResponse([]byte(res))
+	if err != nil {
+		return nil, errors.WrapError(err, "load fetch response (requester)")
+	}
+	return resp, nil
 }
 
 func (p *sRequester) BroadcastRequest(pRequest *pkg_settings.SRequest) error {
@@ -74,7 +83,10 @@ func (p *sRequester) BroadcastRequest(pRequest *pkg_settings.SRequest) error {
 		fmt.Sprintf(pkg_settings.CHandleNetworkRequestTemplate, p.fHost),
 		pRequest,
 	)
-	return err
+	if err != nil {
+		return errors.WrapError(err, "broadcast request (requester)")
+	}
+	return nil
 }
 
 func (p *sRequester) GetFriends() (map[string]asymmetric.IPubKey, error) {
@@ -85,7 +97,7 @@ func (p *sRequester) GetFriends() (map[string]asymmetric.IPubKey, error) {
 		nil,
 	)
 	if err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "get friends (requester)")
 	}
 
 	listFriends := deleteVoidStrings(strings.Split(res, ","))
@@ -93,7 +105,7 @@ func (p *sRequester) GetFriends() (map[string]asymmetric.IPubKey, error) {
 	for _, friend := range listFriends {
 		splited := strings.Split(friend, ":")
 		if len(splited) != 2 {
-			return nil, fmt.Errorf("length of splited != 2")
+			return nil, errors.NewError("length of splited != 2")
 		}
 		aliasName := splited[0]
 		pubKeyStr := splited[1]
@@ -109,7 +121,10 @@ func (p *sRequester) AddFriend(pFriend *pkg_settings.SFriend) error {
 		fmt.Sprintf(pkg_settings.CHandleConfigFriendsTemplate, p.fHost),
 		pFriend,
 	)
-	return err
+	if err != nil {
+		return errors.WrapError(err, "add friend (requester)")
+	}
+	return nil
 }
 
 func (p *sRequester) DelFriend(pFriend *pkg_settings.SFriend) error {
@@ -119,7 +134,10 @@ func (p *sRequester) DelFriend(pFriend *pkg_settings.SFriend) error {
 		fmt.Sprintf(pkg_settings.CHandleConfigFriendsTemplate, p.fHost),
 		pFriend,
 	)
-	return err
+	if err != nil {
+		return errors.WrapError(err, "del friend (requester)")
+	}
+	return nil
 }
 
 func (p *sRequester) GetOnlines() ([]string, error) {
@@ -130,7 +148,7 @@ func (p *sRequester) GetOnlines() ([]string, error) {
 		nil,
 	)
 	if err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "get onlines (requester)")
 	}
 	return deleteVoidStrings(strings.Split(res, ",")), nil
 }
@@ -142,7 +160,10 @@ func (p *sRequester) DelOnline(pConnect pkg_settings.SConnect) error {
 		fmt.Sprintf(pkg_settings.CHandleNetworkOnlineTemplate, p.fHost),
 		pConnect,
 	)
-	return err
+	if err != nil {
+		return errors.WrapError(err, "del online (requester)")
+	}
+	return nil
 }
 
 func (p *sRequester) GetConnections() ([]string, error) {
@@ -153,7 +174,7 @@ func (p *sRequester) GetConnections() ([]string, error) {
 		nil,
 	)
 	if err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "get connections (requester)")
 	}
 	return deleteVoidStrings(strings.Split(res, ",")), nil
 }
@@ -165,7 +186,10 @@ func (p *sRequester) AddConnection(pConnect pkg_settings.SConnect) error {
 		fmt.Sprintf(pkg_settings.CHandleConfigConnectsTemplate, p.fHost),
 		pConnect,
 	)
-	return err
+	if err != nil {
+		return errors.WrapError(err, "add connection (requester)")
+	}
+	return nil
 }
 
 func (p *sRequester) DelConnection(pConnect pkg_settings.SConnect) error {
@@ -175,7 +199,10 @@ func (p *sRequester) DelConnection(pConnect pkg_settings.SConnect) error {
 		fmt.Sprintf(pkg_settings.CHandleConfigConnectsTemplate, p.fHost),
 		pConnect,
 	)
-	return err
+	if err != nil {
+		return errors.WrapError(err, "del connection (requester)")
+	}
+	return nil
 }
 
 func (p *sRequester) SetPrivKey(pPrivKey pkg_settings.SPrivKey) error {
@@ -185,7 +212,10 @@ func (p *sRequester) SetPrivKey(pPrivKey pkg_settings.SPrivKey) error {
 		fmt.Sprintf(pkg_settings.CHandleNodeKeyTemplate, p.fHost),
 		pPrivKey,
 	)
-	return err
+	if err != nil {
+		return errors.WrapError(err, "set private key (requester)")
+	}
+	return nil
 }
 
 func (p *sRequester) GetPubKey() (asymmetric.IPubKey, error) {
@@ -196,9 +226,13 @@ func (p *sRequester) GetPubKey() (asymmetric.IPubKey, error) {
 		nil,
 	)
 	if err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "get public key (requester)")
 	}
-	return asymmetric.LoadRSAPubKey(res), nil
+	pubKey := asymmetric.LoadRSAPubKey(res)
+	if pubKey == nil {
+		return nil, errors.NewError("got invalid public key")
+	}
+	return pubKey, nil
 }
 
 func deleteVoidStrings(pS []string) []string {

cmd/hidden_lake/service/pkg/config/config.go

@@ -7,6 +7,7 @@ import (
 	pkg_settings "github.com/number571/go-peer/cmd/hidden_lake/service/pkg/settings"
 	"github.com/number571/go-peer/pkg/crypto/asymmetric"
 	"github.com/number571/go-peer/pkg/encoding"
+	"github.com/number571/go-peer/pkg/errors"
 	"github.com/number571/go-peer/pkg/filesystem"
 	"github.com/number571/go-peer/pkg/logger"
 )
@@ -48,15 +49,15 @@ type SAddress struct {
 func BuildConfig(pFilepath string, pCfg *SConfig) (IConfig, error) {
 	configFile := filesystem.OpenFile(pFilepath)
 	if configFile.IsExist() {
-		return nil, fmt.Errorf("config file '%s' already exist", pFilepath)
+		return nil, errors.NewError(fmt.Sprintf("config file '%s' already exist", pFilepath))
 	}
 
 	if err := configFile.Write(encoding.Serialize(pCfg)); err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "write config")
 	}
 
 	if err := pCfg.initConfig(pFilepath); err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "init config")
 	}
 	return pCfg, nil
 }
@@ -65,21 +66,21 @@ func LoadConfig(pFilepath string) (IConfig, error) {
 	configFile := filesystem.OpenFile(pFilepath)
 
 	if !configFile.IsExist() {
-		return nil, fmt.Errorf("config file '%s' does not exist", pFilepath)
+		return nil, errors.NewError(fmt.Sprintf("config file '%s' does not exist", pFilepath))
 	}
 
 	bytes, err := configFile.Read()
 	if err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "read config")
 	}
 
 	cfg := new(SConfig)
 	if err := encoding.Deserialize(bytes, cfg); err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "deserialize config")
 	}
 
 	if err := cfg.initConfig(pFilepath); err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "init config")
 	}
 	return cfg, nil
 }
@@ -88,11 +89,11 @@ func (p *SConfig) initConfig(filepath string) error {
 	p.fFilepath = filepath
 
 	if err := p.loadPubKeys(); err != nil {
-		return err
+		return errors.WrapError(err, "load public keys")
 	}
 
 	if err := p.loadLogging(); err != nil {
-		return err
+		return errors.WrapError(err, "load logging")
 	}
 
 	return nil
@@ -111,7 +112,7 @@ func (p *SConfig) loadLogging() error {
 	for _, v := range p.FLogging {
 		logType, ok := mapping[v]
 		if !ok {
-			return fmt.Errorf("undefined log type '%s'", v)
+			return errors.NewError(fmt.Sprintf("undefined log type '%s'", v))
 		}
 		logging[logType] = true
 	}
@@ -130,11 +131,11 @@ func (p *SConfig) loadPubKeys() error {
 		}
 		pubKey := asymmetric.LoadRSAPubKey(val)
 		if pubKey == nil {
-			return fmt.Errorf("public key is nil for '%s'", name)
+			return errors.NewError(fmt.Sprintf("public key is nil for '%s'", name))
 		}
 		p.fFriends[name] = pubKey
 		if pubKey.GetSize() != pkg_settings.CAKeySize {
-			return fmt.Errorf("not supported key size for '%s'", name)
+			return errors.NewError(fmt.Sprintf("not supported key size for '%s'", name))
 		}
 	}
 

cmd/hidden_lake/service/pkg/config/editor.go

@@ -7,6 +7,7 @@ import (
 	pkg_settings "github.com/number571/go-peer/cmd/hidden_lake/service/pkg/settings"
 	"github.com/number571/go-peer/pkg/crypto/asymmetric"
 	"github.com/number571/go-peer/pkg/encoding"
+	"github.com/number571/go-peer/pkg/errors"
 	"github.com/number571/go-peer/pkg/filesystem"
 )
 
@@ -39,14 +40,14 @@ func (p *sEditor) UpdateConnections(pConns []string) error {
 	filepath := p.fConfig.fFilepath
 	icfg, err := LoadConfig(filepath)
 	if err != nil {
-		return err
+		return errors.WrapError(err, "load config (update connections)")
 	}
 
 	cfg := icfg.(*SConfig)
 	cfg.FConnections = deleteDuplicateStrings(pConns)
 	err = filesystem.OpenFile(filepath).Write(encoding.Serialize(cfg))
 	if err != nil {
-		return err
+		return errors.WrapError(err, "write config (update connections)")
 	}
 
 	p.fConfig.fMutex.Lock()
@@ -64,13 +65,13 @@ func (p *sEditor) UpdateFriends(pFriends map[string]asymmetric.IPubKey) error {
 		if pubKey.GetSize() == pkg_settings.CAKeySize {
 			continue
 		}
-		return fmt.Errorf("not supported key size for '%s'", name)
+		return errors.NewError(fmt.Sprintf("not supported key size for '%s'", name))
 	}
 
 	filepath := p.fConfig.fFilepath
 	icfg, err := LoadConfig(filepath)
 	if err != nil {
-		return err
+		return errors.WrapError(err, "load config (update friends)")
 	}
 
 	cfg := icfg.(*SConfig)
@@ -78,7 +79,7 @@ func (p *sEditor) UpdateFriends(pFriends map[string]asymmetric.IPubKey) error {
 	cfg.FFriends = pubKeysToStrings(pFriends)
 	err = filesystem.OpenFile(filepath).Write(encoding.Serialize(cfg))
 	if err != nil {
-		return err
+		return errors.WrapError(err, "write config (update friends)")
 	}
 
 	p.fConfig.fMutex.Lock()

cmd/hidden_lake/service/pkg/config/init.go

@@ -2,12 +2,17 @@ package config
 
 import (
 	"github.com/number571/go-peer/internal/logger"
+	"github.com/number571/go-peer/pkg/errors"
 	"github.com/number571/go-peer/pkg/filesystem"
 )
 
 func InitConfig(cfgPath string, initCfg *SConfig) (IConfig, error) {
 	if filesystem.OpenFile(cfgPath).IsExist() {
-		return LoadConfig(cfgPath)
+		cfg, err := LoadConfig(cfgPath)
+		if err != nil {
+			return nil, errors.WrapError(err, "load config by cfgPath")
+		}
+		return cfg, nil
 	}
 	if initCfg == nil {
 		initCfg = &SConfig{
@@ -18,5 +23,9 @@ func InitConfig(cfgPath string, initCfg *SConfig) (IConfig, error) {
 			},
 		}
 	}
-	return BuildConfig(cfgPath, initCfg)
+	cfg, err := BuildConfig(cfgPath, initCfg)
+	if err != nil {
+		return nil, errors.WrapError(err, "build config by cfgPath")
+	}
+	return cfg, nil
 }

cmd/hidden_lake/service/pkg/request/request.go

@@ -2,6 +2,7 @@ package request
 
 import (
 	"github.com/number571/go-peer/pkg/encoding"
+	"github.com/number571/go-peer/pkg/errors"
 )
 
 var (
@@ -26,8 +27,10 @@ func NewRequest(pMethod, pHost, pPath string) IRequest {
 
 func LoadRequest(pData []byte) (IRequest, error) {
 	request := new(sRequest)
-	err := encoding.Deserialize(pData, request)
-	return request, err
+	if err := encoding.Deserialize(pData, request); err != nil {
+		return nil, errors.WrapError(err, "load request")
+	}
+	return request, nil
 }
 
 func (p *sRequest) ToBytes() []byte {

cmd/hidden_lake/service/pkg/response/response.go

@@ -1,6 +1,9 @@
 package response
 
-import "github.com/number571/go-peer/pkg/encoding"
+import (
+	"github.com/number571/go-peer/pkg/encoding"
+	"github.com/number571/go-peer/pkg/errors"
+)
 
 var (
 	_ IResponse = &sResponse{}
@@ -20,8 +23,10 @@ func NewResponse(pCode int) IResponse {
 
 func LoadResponse(pBytes []byte) (IResponse, error) {
 	response := new(sResponse)
-	err := encoding.Deserialize(pBytes, response)
-	return response, err
+	if err := encoding.Deserialize(pBytes, response); err != nil {
+		return nil, errors.WrapError(err, "load response")
+	}
+	return response, nil
 }
 
 func (p *sResponse) ToBytes() []byte {

cmd/hidden_lake/traffic/cmd/hlt/init_app.go

@@ -5,13 +5,14 @@ import (
 	"github.com/number571/go-peer/cmd/hidden_lake/traffic/internal/config"
 	"github.com/number571/go-peer/cmd/hidden_lake/traffic/pkg/settings"
 
+	"github.com/number571/go-peer/pkg/errors"
 	"github.com/number571/go-peer/pkg/types"
 )
 
 func initApp() (types.ICommand, error) {
 	cfg, err := config.InitConfig(settings.CPathCFG, nil)
 	if err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "init config")
 	}
 
 	return app.NewApp(cfg, "."), nil

cmd/hidden_lake/traffic/cmd/m_hlt/init_app.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/number571/go-peer/cmd/hidden_lake/traffic/internal/app"
+	"github.com/number571/go-peer/pkg/errors"
 	"github.com/number571/go-peer/pkg/types"
 
 	pkg_config "github.com/number571/go-peer/cmd/hidden_lake/traffic/internal/config"
@@ -24,7 +25,7 @@ func initApp(pPathTo string) (types.ICommand, error) {
 		},
 	)
 	if err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "init config")
 	}
 	return app.NewApp(cfg, pPathTo), nil
 }

cmd/hidden_lake/traffic/internal/app/app.go

@@ -15,6 +15,7 @@ import (
 
 	pkg_settings "github.com/number571/go-peer/cmd/hidden_lake/traffic/pkg/settings"
 	internal_logger "github.com/number571/go-peer/internal/logger"
+	pkg_errors "github.com/number571/go-peer/pkg/errors"
 )
 
 const (
@@ -58,7 +59,7 @@ func (p *sApp) Run() error {
 	defer p.fMutex.Unlock()
 
 	if p.fIsRun {
-		return errors.New("application already running")
+		return pkg_errors.NewError("application already running")
 	}
 	p.fIsRun = true
 
@@ -90,8 +91,7 @@ func (p *sApp) Run() error {
 
 	select {
 	case err := <-res:
-		p.Stop()
-		return err
+		return pkg_errors.AppendError(pkg_errors.WrapError(err, "got run error"), p.Stop())
 	case <-time.After(cInitStart):
 		p.fLogger.PushInfo(fmt.Sprintf("%s is running...", pkg_settings.CServiceName))
 		return nil
@@ -103,23 +103,23 @@ func (p *sApp) Stop() error {
 	defer p.fMutex.Unlock()
 
 	if !p.fIsRun {
-		return errors.New("application already stopped or not started")
+		return pkg_errors.NewError("application already stopped or not started")
 	}
 	p.fIsRun = false
 	p.fLogger.PushInfo(fmt.Sprintf("%s is shutting down...", pkg_settings.CServiceName))
 
-	lastErr := types.StopAll([]types.ICommand{
-		p.fConnKeeper,
-		p.fConnKeeper.GetNetworkNode(),
-	})
-
-	err := types.CloseAll([]types.ICloser{
-		p.fServiceHTTP,
-		p.fWrapperDB,
-	})
+	err := pkg_errors.AppendError(
+		types.StopAll([]types.ICommand{
+			p.fConnKeeper,
+			p.fConnKeeper.GetNetworkNode(),
+		}),
+		types.CloseAll([]types.ICloser{
+			p.fServiceHTTP,
+			p.fWrapperDB,
+		}),
+	)
 	if err != nil {
-		lastErr = err
+		return pkg_errors.WrapError(err, "close/stop all")
 	}
-
-	return lastErr
+	return nil
 }

cmd/hidden_lake/traffic/internal/app/init_database.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/number571/go-peer/cmd/hidden_lake/traffic/internal/database"
+	"github.com/number571/go-peer/pkg/errors"
 
 	hls_settings "github.com/number571/go-peer/cmd/hidden_lake/service/pkg/settings"
 	hlt_settings "github.com/number571/go-peer/cmd/hidden_lake/traffic/pkg/settings"
@@ -19,7 +20,7 @@ func (p *sApp) initDatabase() error {
 		}),
 	)
 	if err != nil {
-		return err
+		return errors.WrapError(err, "init database")
 	}
 	p.fWrapperDB.Set(db)
 	return nil

cmd/hidden_lake/traffic/internal/config/config.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/number571/go-peer/pkg/encoding"
+	"github.com/number571/go-peer/pkg/errors"
 	"github.com/number571/go-peer/pkg/filesystem"
 	"github.com/number571/go-peer/pkg/logger"
 )
@@ -29,15 +30,15 @@ func BuildConfig(pFilepath string, pCfg *SConfig) (IConfig, error) {
 	configFile := filesystem.OpenFile(pFilepath)
 
 	if configFile.IsExist() {
-		return nil, fmt.Errorf("config file '%s' already exist", pFilepath)
+		return nil, errors.NewError(fmt.Sprintf("config file '%s' already exist", pFilepath))
 	}
 
 	if err := configFile.Write(encoding.Serialize(pCfg)); err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "write config")
 	}
 
 	if err := pCfg.loadLogging(); err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "load logging")
 	}
 	return pCfg, nil
 }
@@ -46,21 +47,21 @@ func LoadConfig(pFilepath string) (IConfig, error) {
 	configFile := filesystem.OpenFile(pFilepath)
 
 	if !configFile.IsExist() {
-		return nil, fmt.Errorf("config file '%s' does not exist", pFilepath)
+		return nil, errors.NewError(fmt.Sprintf("config file '%s' does not exist", pFilepath))
 	}
 
 	bytes, err := configFile.Read()
 	if err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "read config")
 	}
 
 	cfg := new(SConfig)
 	if err := encoding.Deserialize(bytes, cfg); err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "deserialize config")
 	}
 
 	if err := cfg.loadLogging(); err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "load logging")
 	}
 	return cfg, nil
 }
@@ -78,7 +79,7 @@ func (p *SConfig) loadLogging() error {
 	for _, v := range p.FLogging {
 		logType, ok := mapping[v]
 		if !ok {
-			return fmt.Errorf("undefined log type '%s'", v)
+			return errors.NewError(fmt.Sprintf("undefined log type '%s'", v))
 		}
 		logging[logType] = true
 	}

cmd/hidden_lake/traffic/internal/config/init.go

@@ -2,12 +2,17 @@ package config
 
 import (
 	"github.com/number571/go-peer/internal/logger"
+	"github.com/number571/go-peer/pkg/errors"
 	"github.com/number571/go-peer/pkg/filesystem"
 )
 
 func InitConfig(cfgPath string, initCfg *SConfig) (IConfig, error) {
 	if filesystem.OpenFile(cfgPath).IsExist() {
-		return LoadConfig(cfgPath)
+		cfg, err := LoadConfig(cfgPath)
+		if err != nil {
+			return nil, errors.WrapError(err, "load config")
+		}
+		return cfg, nil
 	}
 	if initCfg == nil {
 		initCfg = &SConfig{
@@ -16,5 +21,9 @@ func InitConfig(cfgPath string, initCfg *SConfig) (IConfig, error) {
 			FConnection: "localhost:9571",
 		}
 	}
-	return BuildConfig(cfgPath, initCfg)
+	cfg, err := BuildConfig(cfgPath, initCfg)
+	if err != nil {
+		return nil, errors.WrapError(err, "build config")
+	}
+	return cfg, nil
 }

cmd/hidden_lake/traffic/internal/database/database.go

@@ -1,12 +1,12 @@
 package database
 
 import (
-	"fmt"
 	"sync"
 
 	"github.com/number571/go-peer/pkg/client/message"
 	"github.com/number571/go-peer/pkg/crypto/hashing"
 	"github.com/number571/go-peer/pkg/encoding"
+	"github.com/number571/go-peer/pkg/errors"
 	gp_database "github.com/number571/go-peer/pkg/storage/database"
 )
 
@@ -27,17 +27,17 @@ func NewKeyValueDB(pSett ISettings) (IKeyValueDB, error) {
 		}),
 	)
 	if err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "new sqlite")
 	}
 	if sqlDB == nil {
-		return nil, fmt.Errorf("storage (hashes) is nil")
+		return nil, errors.NewError("storage (hashes) is nil")
 	}
 	db := &sKeyValueDB{
 		fSettings: pSett,
 		fDB:       sqlDB,
 	}
 	db.fPointer = db.getPointer()
-	return db, err
+	return db, nil
 }
 
 func (p *sKeyValueDB) Settings() ISettings {
@@ -56,7 +56,7 @@ func (p *sKeyValueDB) Hashes() ([]string, error) {
 			break
 		}
 		if len(hash) != hashing.CSHA256Size {
-			return nil, fmt.Errorf("incorrect hash size")
+			return nil, errors.NewError("incorrect hash size")
 		}
 		res = append(res, encoding.HexEncode(hash))
 	}
@@ -78,7 +78,7 @@ func (p *sKeyValueDB) Push(pMsg message.IMessage) error {
 		FMessageSize: p.Settings().GetMessageSize(),
 	})
 	if !pMsg.IsValid(params) {
-		return fmt.Errorf("invalid push message")
+		return errors.NewError("invalid push message")
 	}
 
 	// delete old message
@@ -86,25 +86,25 @@ func (p *sKeyValueDB) Push(pMsg message.IMessage) error {
 	if hash, err := p.fDB.Get(keyHash); err == nil {
 		keyMsg := getKeyMessage(hash)
 		if err := p.fDB.Del(keyMsg); err != nil {
-			return err
+			return errors.WrapError(err, "delete old key")
 		}
 	}
 
 	// rewrite hash's field
 	newHash := pMsg.GetBody().GetHash()
 	if err := p.fDB.Set(keyHash, newHash); err != nil {
-		return err
+		return errors.WrapError(err, "rewrite key hash")
 	}
 
 	// write message
 	keyMsg := getKeyMessage(newHash)
 	if err := p.fDB.Set(keyMsg, pMsg.ToBytes()); err != nil {
-		return err
+		return errors.WrapError(err, "write message")
 	}
 
 	// update pointer
 	if err := p.incPointer(); err != nil {
-		return err
+		return errors.WrapError(err, "increment pointer")
 	}
 
 	return nil
@@ -116,12 +116,12 @@ func (p *sKeyValueDB) Load(pStrHash string) (message.IMessage, error) {
 
 	hash := encoding.HexDecode(pStrHash)
 	if len(hash) != hashing.CSHA256Size {
-		return nil, fmt.Errorf("key size invalid")
+		return nil, errors.NewError("key size invalid")
 	}
 
 	data, err := p.fDB.Get(getKeyMessage(hash))
 	if err != nil {
-		return nil, fmt.Errorf("message undefined")
+		return nil, errors.NewError("message undefined")
 	}
 
 	msg := message.LoadMessage(
@@ -142,7 +142,10 @@ func (p *sKeyValueDB) Close() error {
 	p.fMutex.Lock()
 	defer p.fMutex.Unlock()
 
-	return p.fDB.Close()
+	if err := p.fDB.Close(); err != nil {
+		return errors.WrapError(err, "close KV database")
+	}
+	return nil
 }
 
 func (p *sKeyValueDB) getPointer() uint64 {
@@ -159,5 +162,8 @@ func (p *sKeyValueDB) getPointer() uint64 {
 func (p *sKeyValueDB) incPointer() error {
 	msgsLimit := p.Settings().GetCapacity()
 	res := encoding.Uint64ToBytes((p.getPointer() + 1) % msgsLimit)
-	return p.fDB.Set(getKeyPointer(), res[:])
+	if err := p.fDB.Set(getKeyPointer(), res[:]); err != nil {
+		return errors.WrapError(err, "set pointer into KV database")
+	}
+	return nil
 }

cmd/hidden_lake/traffic/internal/database/wrapper.go

@@ -3,6 +3,7 @@ package database
 import (
 	"sync"
 
+	"github.com/number571/go-peer/pkg/errors"
 	"github.com/number571/go-peer/pkg/wrapper"
 )
 
@@ -49,5 +50,8 @@ func (p *sWrapperDB) Close() error {
 	}
 
 	p.fWrapper.Set(nil)
-	return db.Close()
+	if err := db.Close(); err != nil {
+		return errors.WrapError(err, "close wrapped database")
+	}
+	return nil
 }

cmd/hidden_lake/traffic/pkg/client/client.go

@@ -2,6 +2,7 @@ package client
 
 import (
 	"github.com/number571/go-peer/pkg/client/message"
+	"github.com/number571/go-peer/pkg/errors"
 )
 
 var (
@@ -21,21 +22,32 @@ func NewClient(pBuilder IBuilder, pRequester IRequester) IClient {
 }
 
 func (p *sClient) GetIndex() (string, error) {
-	return p.fRequester.GetIndex()
+	res, err := p.fRequester.GetIndex()
+	if err != nil {
+		return "", errors.WrapError(err, "get index (client)")
+	}
+	return res, nil
 }
 
 func (p *sClient) GetHashes() ([]string, error) {
-	return p.fRequester.GetHashes()
+	res, err := p.fRequester.GetHashes()
+	if err != nil {
+		return nil, errors.WrapError(err, "get hashes (client)")
+	}
+	return res, nil
 }
 
 func (p *sClient) GetMessage(pHash string) (message.IMessage, error) {
 	msg, err := p.fRequester.GetMessage(p.fBuilder.GetMessage(pHash))
 	if err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "get message (client)")
 	}
 	return msg, nil
 }
 
 func (p *sClient) PutMessage(pMsg message.IMessage) error {
-	return p.fRequester.PutMessage(p.fBuilder.PutMessage(pMsg))
+	if err := p.fRequester.PutMessage(p.fBuilder.PutMessage(pMsg)); err != nil {
+		return errors.WrapError(err, "put message (client)")
+	}
+	return nil
 }

cmd/hidden_lake/traffic/pkg/client/requester.go

@@ -9,6 +9,7 @@ import (
 	"github.com/number571/go-peer/internal/api"
 	"github.com/number571/go-peer/pkg/client/message"
 	"github.com/number571/go-peer/pkg/encoding"
+	"github.com/number571/go-peer/pkg/errors"
 )
 
 var (
@@ -37,11 +38,10 @@ func (p *sRequester) GetIndex() (string, error) {
 		nil,
 	)
 	if err != nil {
-		return "", err
+		return "", errors.WrapError(err, "get index (requester)")
 	}
-
 	if resp != pkg_settings.CTitlePattern {
-		return "", fmt.Errorf("incorrect title pattern")
+		return "", errors.NewError("incorrect title pattern")
 	}
 	return resp, nil
 }
@@ -54,7 +54,7 @@ func (p *sRequester) GetHashes() ([]string, error) {
 		nil,
 	)
 	if err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "get hashes (requester)")
 	}
 	return strings.Split(resp, ";"), nil
 }
@@ -67,7 +67,7 @@ func (p *sRequester) GetMessage(pRequest string) (message.IMessage, error) {
 		nil,
 	)
 	if err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "get message (requester)")
 	}
 
 	msg := message.LoadMessage(
@@ -78,7 +78,7 @@ func (p *sRequester) GetMessage(pRequest string) (message.IMessage, error) {
 		encoding.HexDecode(resp),
 	)
 	if msg == nil {
-		return nil, fmt.Errorf("message is nil")
+		return nil, errors.NewError("load message")
 	}
 
 	return msg, nil
@@ -91,5 +91,8 @@ func (p *sRequester) PutMessage(pRequest string) error {
 		fmt.Sprintf(pkg_settings.CHandleMessageTemplate, p.fHost),
 		pRequest,
 	)
-	return err
+	if err != nil {
+		return errors.WrapError(err, "put message (requester)")
+	}
+	return nil
 }

internal/api/request.go

@@ -6,6 +6,8 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+
+	"github.com/number571/go-peer/pkg/errors"
 )
 
 func Request(pClient *http.Client, pMethod, pURL string, pData interface{}) (string, error) {
@@ -19,7 +21,7 @@ func Request(pClient *http.Client, pMethod, pURL string, pData interface{}) (str
 	default:
 		jsonValue, err := json.Marshal(pData)
 		if err != nil {
-			return "", err
+			return "", errors.WrapError(err, "marshal request")
 		}
 		requestBytes = jsonValue
 	}
@@ -30,28 +32,32 @@ func Request(pClient *http.Client, pMethod, pURL string, pData interface{}) (str
 		bytes.NewBuffer(requestBytes),
 	)
 	if err != nil {
-		return "", err
+		return "", errors.WrapError(err, "new request")
 	}
 
 	req.Header.Set("Content-Type", CContentType)
 	resp, err := pClient.Do(req)
 	if err != nil {
-		return "", err
+		return "", errors.WrapError(err, "do request")
 	}
 	defer resp.Body.Close()
 
-	return loadResponse(resp.StatusCode, resp.Body)
+	result, err := loadResponse(resp.StatusCode, resp.Body)
+	if err != nil {
+		return "", errors.WrapError(err, "load response")
+	}
+	return result, nil
 }
 
 func loadResponse(pStatusCode int, pReader io.ReadCloser) (string, error) {
 	resp, err := io.ReadAll(pReader)
 	if err != nil {
-		return "", err
+		return "", errors.WrapError(err, "read response")
 	}
 
 	result := string(resp)
 	if pStatusCode != http.StatusOK {
-		return "", fmt.Errorf("error code = %d (%s)", pStatusCode, result)
+		return "", errors.NewError(fmt.Sprintf("error code = %d (%s)", pStatusCode, result))
 	}
 
 	return result, nil

internal/mobile/mobile.go

@@ -2,6 +2,7 @@ package mobile
 
 import (
 	"fyne.io/fyne/v2"
+	"github.com/number571/go-peer/pkg/errors"
 )
 
 var (
@@ -70,13 +71,13 @@ func (p *sMobileState) doDefault() error {
 	case true:
 		if p.fConstructApp != nil {
 			if err := p.fConstructApp(); err != nil {
-				return err
+				return errors.WrapError(err, "construct app")
 			}
 		}
 	case false:
 		if p.fDestructApp != nil {
 			if err := p.fDestructApp(); err != nil {
-				return err
+				return errors.WrapError(err, "destruct app")
 			}
 		}
 	}

internal/mobile/openurl.go

@@ -4,12 +4,16 @@ import (
 	"net/url"
 
 	"fyne.io/fyne/v2"
+	"github.com/number571/go-peer/pkg/errors"
 )
 
 func OpenURL(pApp fyne.App, pPageURL string) error {
 	u, err := url.Parse(pPageURL)
 	if err != nil {
-		return err
+		return errors.WrapError(err, "parse url")
 	}
-	return pApp.OpenURL(u)
+	if err := pApp.OpenURL(u); err != nil {
+		return errors.WrapError(err, "open url")
+	}
+	return nil
 }

pkg/client/client.go

@@ -11,6 +11,7 @@ import (
 	"github.com/number571/go-peer/pkg/crypto/random"
 	"github.com/number571/go-peer/pkg/crypto/symmetric"
 	"github.com/number571/go-peer/pkg/encoding"
+	"github.com/number571/go-peer/pkg/errors"
 	"github.com/number571/go-peer/pkg/payload"
 )
 
@@ -64,7 +65,7 @@ func (p *sClient) GetSettings() message.ISettings {
 // The message can be decrypted only if private key is known.
 func (p *sClient) EncryptPayload(pRecv asymmetric.IPubKey, pPld payload.IPayload) (message.IMessage, error) {
 	if pRecv.GetSize() != p.GetPubKey().GetSize() {
-		return nil, fmt.Errorf("size of public keys sender and receiver not equal")
+		return nil, errors.NewError("size of public keys sender and receiver not equal")
 	}
 
 	var (
@@ -73,11 +74,11 @@ func (p *sClient) EncryptPayload(pRecv asymmetric.IPubKey, pPld payload.IPayload
 	)
 
 	if resultSize > maxMsgSize {
-		return nil, fmt.Errorf(
+		return nil, errors.NewError(fmt.Sprintf(
 			"limit of message size without hex encoding = %d bytes < current payload size with additional padding = %d bytes",
 			maxMsgSize,
 			resultSize,
-		)
+		))
 	}
 
 	return p.encryptWithParams(
@@ -137,57 +138,57 @@ func (p *sClient) encryptWithParams(pRecv asymmetric.IPubKey, pPld payload.IPayl
 // No one else except the sender will be able to decrypt the message.
 func (p *sClient) DecryptMessage(pMsg message.IMessage) (asymmetric.IPubKey, payload.IPayload, error) {
 	if pMsg == nil {
-		return nil, nil, fmt.Errorf("msg is nil")
+		return nil, nil, errors.NewError("msg is nil")
 	}
 
 	// Initial check.
 	if len(pMsg.GetBody().GetHash()) != hashing.CSHA256Size {
-		return nil, nil, fmt.Errorf("msg hash != sha256 size")
+		return nil, nil, errors.NewError("msg hash != sha256 size")
 	}
 
 	// Proof of work. Prevent spam.
 	diff := p.GetSettings().GetWorkSize()
 	puzzle := puzzle.NewPoWPuzzle(diff)
 	if !puzzle.VerifyBytes(pMsg.GetBody().GetHash(), pMsg.GetBody().GetProof()) {
-		return nil, nil, fmt.Errorf("invalid proof of msg")
+		return nil, nil, errors.NewError("invalid proof of msg")
 	}
 
 	// Decrypt session key by private key of receiver.
 	session := p.GetPrivKey().DecryptBytes(pMsg.GetHead().GetSession())
 	if session == nil {
-		return nil, nil, fmt.Errorf("failed decrypt session key")
+		return nil, nil, errors.NewError("failed decrypt session key")
 	}
 
 	// Decrypt public key of sender by decrypted session key.
 	cipher := symmetric.NewAESCipher(session)
 	publicBytes := cipher.DecryptBytes(pMsg.GetHead().GetSender())
 	if publicBytes == nil {
-		return nil, nil, fmt.Errorf("failed decrypt public key")
+		return nil, nil, errors.NewError("failed decrypt public key")
 	}
 
 	// Load public key and check standart size.
 	pubKey := asymmetric.LoadRSAPubKey(publicBytes)
 	if pubKey == nil {
-		return nil, nil, fmt.Errorf("failed load public key")
+		return nil, nil, errors.NewError("failed load public key")
 	}
 	if pubKey.GetSize() != p.GetPubKey().GetSize() {
-		return nil, nil, fmt.Errorf("invalid public key size")
+		return nil, nil, errors.NewError("invalid public key size")
 	}
 
 	// Decrypt main data of message by session key.
 	doublePayloadBytes := cipher.DecryptBytes(pMsg.GetBody().GetPayload().ToBytes())
 	if doublePayloadBytes == nil {
-		return nil, nil, fmt.Errorf("failed decrypt double payload")
+		return nil, nil, errors.NewError("failed decrypt double payload")
 	}
 	doublePayload := payload.LoadPayload(doublePayloadBytes)
 	if doublePayload == nil {
-		return nil, nil, fmt.Errorf("failed load double payload")
+		return nil, nil, errors.NewError("failed load double payload")
 	}
 
 	// Decrypt salt.
 	salt := cipher.DecryptBytes(pMsg.GetHead().GetSalt())
 	if salt == nil {
-		return nil, nil, fmt.Errorf("failed decrypt salt")
+		return nil, nil, errors.NewError("failed decrypt salt")
 	}
 
 	// Check received hash and generated hash.
@@ -200,27 +201,27 @@ func (p *sClient) DecryptMessage(pMsg message.IMessage) (asymmetric.IPubKey, pay
 		[]byte{},
 	)).ToBytes()
 	if !bytes.Equal(check, pMsg.GetBody().GetHash()) {
-		return nil, nil, fmt.Errorf("invalid msg hash")
+		return nil, nil, errors.NewError("invalid msg hash")
 	}
 
 	// Decrypt sign of message and verify this
 	// by public key of sender and hash of message.
 	sign := cipher.DecryptBytes(pMsg.GetBody().GetSign())
 	if sign == nil {
-		return nil, nil, fmt.Errorf("failed decrypt sign")
+		return nil, nil, errors.NewError("failed decrypt sign")
 	}
 	if !pubKey.VerifyBytes(pMsg.GetBody().GetHash(), sign) {
-		return nil, nil, fmt.Errorf("invalid msg sign")
+		return nil, nil, errors.NewError("invalid msg sign")
 	}
 
 	// Remove random bytes and get main data
 	mustLen := doublePayload.GetHead()
 	if mustLen > uint64(len(doublePayload.GetBody())) {
-		return nil, nil, fmt.Errorf("invalid size of payload")
+		return nil, nil, errors.NewError("invalid size of payload")
 	}
 	pld := payload.LoadPayload(doublePayload.GetBody()[:mustLen])
 	if pld == nil {
-		return nil, nil, fmt.Errorf("invalid load payload")
+		return nil, nil, errors.NewError("invalid load payload")
 	}
 
 	// Return decrypted message with title

pkg/client/queue/queue.go

@@ -1,12 +1,12 @@
 package queue
 
 import (
-	"errors"
 	"sync"
 	"time"
 
 	"github.com/number571/go-peer/pkg/client"
 	"github.com/number571/go-peer/pkg/client/message"
+	"github.com/number571/go-peer/pkg/errors"
 	"github.com/number571/go-peer/pkg/payload"
 )
 
@@ -63,7 +63,7 @@ func (p *sMessageQueue) Run() error {
 	defer p.fMutex.Unlock()
 
 	if p.fIsRun {
-		return errors.New("queue already running")
+		return errors.NewError("queue already running")
 	}
 	p.fIsRun = true
 
@@ -91,7 +91,7 @@ func (p *sMessageQueue) Stop() error {
 	defer p.fMutex.Unlock()
 
 	if !p.fIsRun {
-		return errors.New("queue already closed or not started")
+		return errors.NewError("queue already closed or not started")
 	}
 	p.fIsRun = false
 
@@ -104,7 +104,7 @@ func (p *sMessageQueue) EnqueueMessage(pMsg message.IMessage) error {
 	defer p.fMutex.Unlock()
 
 	if uint64(len(p.fQueue)) >= p.GetSettings().GetMainCapacity() {
-		return errors.New("queue already full, need wait and retry")
+		return errors.NewError("queue already full, need wait and retry")
 	}
 
 	p.fQueue <- pMsg

pkg/encoding/serialize.go

@@ -1,6 +1,10 @@
 package encoding
 
-import "encoding/json"
+import (
+	"encoding/json"
+
+	"github.com/number571/go-peer/pkg/errors"
+)
 
 func Serialize(pData interface{}) []byte {
 	res, err := json.Marshal(pData)
@@ -11,5 +15,8 @@ func Serialize(pData interface{}) []byte {
 }
 
 func Deserialize(pData []byte, pRes interface{}) error {
-	return json.Unmarshal(pData, pRes)
+	if err := json.Unmarshal(pData, pRes); err != nil {
+		return errors.WrapError(err, "unmarshal data")
+	}
+	return nil
 }

pkg/errors/errors.go

@@ -0,0 +1,83 @@
+package errors
+
+import (
+	std_errors "errors"
+	"fmt"
+	"strings"
+)
+
+var (
+	_ error = &sError{}
+)
+
+type sError struct {
+	fErrStack []error
+}
+
+func (p *sError) Error() string {
+	s := ""
+	for i := len(p.fErrStack) - 1; i >= 0; i-- {
+		s += fmt.Sprintf("%s; ", p.fErrStack[i].Error())
+	}
+	return strings.TrimSpace(s)
+}
+
+func NewError(pMsg string) error {
+	return WrapError(nil, pMsg)
+}
+
+func WrapError(pErr error, pMsg string) error {
+	return AppendError(pErr, std_errors.New(pMsg))
+}
+
+func AppendError(pErr, pErr2 error) error {
+	if pErr == nil && pErr2 == nil {
+		return nil
+	}
+	if pErr == nil {
+		if _, ok := pErr2.(*sError); ok {
+			return pErr2
+		}
+		return &sError{[]error{pErr2}}
+	}
+	if pErr2 == nil {
+		if _, ok := pErr.(*sError); ok {
+			return pErr
+		}
+		return &sError{[]error{pErr}}
+	}
+	v, ok := pErr.(*sError)
+	if ok {
+		return &sError{copyAndAppend(v.fErrStack, pErr2)}
+	}
+	return &sError{[]error{pErr, pErr2}}
+}
+
+func HasError(pErr, pErrType error) bool {
+	if pErr == nil {
+		return false
+	}
+	v, ok := pErr.(*sError)
+	if !ok {
+		return std_errors.Is(pErr, pErrType)
+	}
+	for i := len(v.fErrStack) - 1; i >= 0; i-- {
+		vErr, ok := v.fErrStack[i].(*sError)
+		if ok {
+			if exist := HasError(vErr, pErrType); exist {
+				return true
+			}
+			continue
+		}
+		if std_errors.Is(v.fErrStack[i], pErrType) {
+			return true
+		}
+	}
+	return false
+}
+
+func copyAndAppend(slice []error, val error) []error {
+	newSlice := make([]error, len(slice))
+	copy(newSlice[:], slice)
+	return append(newSlice, val)
+}

pkg/errors/errors_test.go

@@ -0,0 +1,70 @@
+package errors
+
+import (
+	"fmt"
+	"testing"
+)
+
+const (
+	tcErrorResult = "test_3; test_2; test_1;"
+)
+
+type tsErrType1 struct{}
+type tsErrType2 struct{}
+type tsErrType3 struct{}
+type tsErrType4 struct{}
+
+func (p *tsErrType1) Error() string {
+	return "1"
+}
+
+func (p *tsErrType2) Error() string {
+	return "2"
+}
+
+func (p *tsErrType3) Error() string {
+	return "3"
+}
+
+func (p *tsErrType4) Error() string {
+	return "4"
+}
+
+func TestWrapError(t *testing.T) {
+	err := WrapError(WrapError(NewError("test_1"), "test_2"), "test_3")
+	if err.Error() != tcErrorResult {
+		t.Error("result .Error() is invalid")
+	}
+
+	if WrapError(nil, "test_1").Error() != NewError("test_1").Error() {
+		fmt.Println(WrapError(nil, "test_1").Error())
+		fmt.Println(NewError("test_1").Error())
+		t.Error("wrap error not equal new error")
+	}
+}
+
+func TestAppendError(t *testing.T) {
+	err1 := AppendError(AppendError(&tsErrType1{}, &tsErrType2{}), &tsErrType3{})
+	if !HasError(err1, &tsErrType1{}) || !HasError(err1, &tsErrType2{}) || !HasError(err1, &tsErrType3{}) {
+		t.Error("has not error (1, 2 or 3)")
+	}
+	if HasError(err1, &tsErrType4{}) {
+		t.Error("has error (4)")
+	}
+
+	if err := AppendError(nil, nil); err != nil {
+		t.Error("err2 is not nil")
+	}
+	if err := AppendError(&tsErrType1{}, nil); !HasError(err, &tsErrType1{}) {
+		t.Error("invalid error type")
+	}
+	if err := AppendError(nil, &tsErrType1{}); !HasError(err, &tsErrType1{}) {
+		t.Error("invalid error type")
+	}
+
+	err2 := AppendError(nil, &tsErrType1{})
+	err3 := AppendError(nil, &tsErrType2{})
+	if err := AppendError(&tsErrType3{}, AppendError(err2, err3)); !HasError(err, &tsErrType2{}) {
+		t.Error("not found error in error stack")
+	}
+}

pkg/filesystem/file.go

@@ -2,6 +2,8 @@ package filesystem
 
 import (
 	"os"
+
+	"github.com/number571/go-peer/pkg/errors"
 )
 
 var (
@@ -21,13 +23,16 @@ func OpenFile(pPath string) IFile {
 func (p *sFile) Read() ([]byte, error) {
 	data, err := os.ReadFile(p.fPath)
 	if err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "read file")
 	}
 	return data, nil
 }
 
 func (p *sFile) Write(pData []byte) error {
-	return os.WriteFile(p.fPath, pData, 0644)
+	if err := os.WriteFile(p.fPath, pData, 0644); err != nil {
+		return errors.WrapError(err, "write file")
+	}
+	return nil
 }
 
 func (p *sFile) IsExist() bool {

pkg/network/anonymity/anonymity.go

@@ -1,7 +1,6 @@
 package anonymity
 
 import (
-	"errors"
 	"fmt"
 	"strings"
 	"sync"
@@ -11,6 +10,7 @@ import (
 	"github.com/number571/go-peer/pkg/client/queue"
 	"github.com/number571/go-peer/pkg/crypto/asymmetric"
 	"github.com/number571/go-peer/pkg/crypto/random"
+	"github.com/number571/go-peer/pkg/errors"
 	"github.com/number571/go-peer/pkg/logger"
 	"github.com/number571/go-peer/pkg/network"
 	"github.com/number571/go-peer/pkg/network/conn"
@@ -60,22 +60,24 @@ func NewNode(
 func (p *sNode) Run() error {
 	logger := anon_logger.NewLogger(p.GetSettings().GetServiceName())
 	if err := p.runQueue(logger); err != nil {
-		return err
+		return errors.WrapError(err, "run node")
 	}
-
 	p.GetNetworkNode().HandleFunc(
 		p.GetSettings().GetNetworkMask(),
 		p.handleWrapper(logger),
 	)
-
 	return nil
 }
 
 func (p *sNode) Stop() error {
 	p.GetNetworkNode().HandleFunc(p.GetSettings().GetNetworkMask(), nil)
-	return types.StopAll([]types.ICommand{
+	err := types.StopAll([]types.ICommand{
 		p.GetMessageQueue(),
 	})
+	if err != nil {
+		return errors.WrapError(err, "stop node")
+	}
+	return nil
 }
 
 func (p *sNode) GetLogger() logger.ILogger {
@@ -118,12 +120,15 @@ func (p *sNode) HandleFunc(pHead uint32, pHandle IHandlerF) INode {
 
 // Send message without response waiting.
 func (p *sNode) BroadcastPayload(pRecv asymmetric.IPubKey, pPld adapters.IPayload) error {
-	return p.broadcastPayload(cIsRequest, pRecv, pPld.ToOrigin())
+	if err := p.broadcastPayload(cIsRequest, pRecv, pPld.ToOrigin()); err != nil {
+		return errors.WrapError(err, "broadcast payload")
+	}
+	return nil
 }
 
 func (p *sNode) broadcastPayload(pType iDataType, pRecv asymmetric.IPubKey, pPld payload.IPayload) error {
 	if len(p.GetNetworkNode().GetConnections()) == 0 {
-		return errors.New("length of connections = 0")
+		return errors.NewError("length of connections = 0")
 	}
 
 	var newBody []byte
@@ -133,16 +138,19 @@ func (p *sNode) broadcastPayload(pType iDataType, pRecv asymmetric.IPubKey, pPld
 	case cIsResponse:
 		newBody = wrapResponse(pPld.GetBody())
 	default:
-		return fmt.Errorf("unknown format type")
+		return errors.NewError("unknown format type")
 	}
 
 	newPld := payload.NewPayload(pPld.GetHead(), newBody)
 	msg, err := p.GetMessageQueue().GetClient().EncryptPayload(pRecv, newPld)
 	if err != nil {
-		return err
+		return errors.WrapError(err, "encrypt payload")
 	}
 
-	return p.send(msg)
+	if err := p.send(msg); err != nil {
+		return errors.WrapError(err, "send message")
+	}
+	return nil
 }
 
 // Send message with response waiting.
@@ -160,9 +168,14 @@ func (p *sNode) FetchPayload(pRecv asymmetric.IPubKey, pPld adapters.IPayload) (
 	defer p.delAction(actionKey)
 
 	if err := p.broadcastPayload(cIsRequest, pRecv, newPld); err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "fetch payload")
 	}
-	return p.recv(actionKey)
+
+	resp, err := p.recv(actionKey)
+	if err != nil {
+		return nil, errors.WrapError(err, "receive response from fetch")
+	}
+	return resp, nil
 }
 
 func (p *sNode) send(pMsg message.IMessage) error {
@@ -173,28 +186,28 @@ func (p *sNode) send(pMsg message.IMessage) error {
 		}
 		return nil
 	}
-	return fmt.Errorf("failed: enqueue message")
+	return errors.NewError("enqueue message as send")
 }
 
 func (p *sNode) recv(pActionKey string) ([]byte, error) {
 	action, ok := p.getAction(pActionKey)
 	if !ok {
-		return nil, errors.New("action undefined")
+		return nil, errors.NewError("action undefined")
 	}
 	select {
 	case result, opened := <-action:
 		if !opened {
-			return nil, errors.New("chan is closed")
+			return nil, errors.NewError("chan is closed")
 		}
 		return result, nil
 	case <-time.After(p.GetSettings().GetFetchTimeWait()):
-		return nil, errors.New("time is over")
+		return nil, errors.NewError("recv time is over")
 	}
 }
 
 func (p *sNode) runQueue(pLogger anon_logger.ILogger) error {
 	if err := p.GetMessageQueue().Run(); err != nil {
-		return err
+		return errors.WrapError(err, "run queue")
 	}
 
 	go func() {
@@ -363,12 +376,16 @@ func (p *sNode) storeHashWithBroadcast(pLogger anon_logger.ILogger, pConn conn.I
 
 func (p *sNode) networkBroadcast(pLogger anon_logger.ILogger, pMsg message.IMessage) error {
 	// redirect message to another nodes
-	return p.GetNetworkNode().BroadcastPayload(
+	err := p.GetNetworkNode().BroadcastPayload(
 		payload.NewPayload(
 			p.GetSettings().GetNetworkMask(),
 			pMsg.ToBytes(),
 		),
 	)
+	if err != nil {
+		return errors.WrapError(err, "network broadcast payload")
+	}
+	return nil
 }
 
 func (p *sNode) setRoute(pHead uint32, pHandle IHandlerF) {

pkg/network/conn/conn.go

@@ -2,7 +2,6 @@ package conn
 
 import (
 	"bytes"
-	"fmt"
 	"net"
 	"sync"
 	"time"
@@ -10,6 +9,7 @@ import (
 	"github.com/number571/go-peer/pkg/crypto/random"
 	"github.com/number571/go-peer/pkg/crypto/symmetric"
 	"github.com/number571/go-peer/pkg/encoding"
+	"github.com/number571/go-peer/pkg/errors"
 	"github.com/number571/go-peer/pkg/network/message"
 	"github.com/number571/go-peer/pkg/payload"
 )
@@ -28,7 +28,7 @@ type sConn struct {
 func NewConn(pSett ISettings, pAddr string) (IConn, error) {
 	conn, err := net.Dial("tcp", pAddr)
 	if err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "tcp connect")
 	}
 	return LoadConn(pSett, conn), nil
 }
@@ -51,7 +51,7 @@ func (p *sConn) GetSocket() net.Conn {
 
 func (p *sConn) FetchPayload(pPld payload.IPayload) (payload.IPayload, error) {
 	if err := p.WritePayload(pPld); err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "write payload")
 	}
 
 	chPld := make(chan payload.IPayload)
@@ -60,11 +60,11 @@ func (p *sConn) FetchPayload(pPld payload.IPayload) (payload.IPayload, error) {
 	select {
 	case rpld := <-chPld:
 		if rpld == nil {
-			return nil, fmt.Errorf("failed: read payload")
+			return nil, errors.NewError("read payload")
 		}
 		return rpld, nil
 	case <-time.After(p.fSettings.GetFetchTimeWait()):
-		return nil, fmt.Errorf("failed: time out")
+		return nil, errors.NewError("read payload (timeout)")
 	}
 }
 
@@ -88,18 +88,18 @@ func (p *sConn) WritePayload(pPld payload.IPayload) error {
 
 	// send headers with length of blocks
 	if err := p.sendBlockSize(encMsgBytes); err != nil {
-		return err
+		return errors.WrapError(err, "send block size (encrypted message bytes)")
 	}
 	if err := p.sendBlockSize(voidBytes); err != nil {
-		return err
+		return errors.WrapError(err, "send block size (void bytes)")
 	}
 
 	// send blocks
 	if err := p.sendBytes(encMsgBytes); err != nil {
-		return err
+		return errors.WrapError(err, "send encrypted message bytes")
 	}
 	if err := p.sendBytes(voidBytes); err != nil {
-		return err
+		return errors.WrapError(err, "send void bytes")
 	}
 
 	return nil
@@ -116,7 +116,7 @@ func (p *sConn) sendBytes(pBytes []byte) error {
 	for {
 		n, err := p.GetSocket().Write(pBytes[:bytesPtr])
 		if err != nil {
-			return err
+			return errors.WrapError(err, "write tcp bytes")
 		}
 
 		bytesPtr = bytesPtr - uint64(n)
@@ -133,10 +133,10 @@ func (p *sConn) sendBlockSize(pBytes []byte) error {
 	blockSize := encoding.Uint64ToBytes(uint64(len(pBytes)))
 	n, err := p.GetSocket().Write(p.fCipher.EncryptBytes(blockSize[:]))
 	if err != nil {
-		return err
+		return errors.WrapError(err, "write tcp block size")
 	}
 	if n != symmetric.CAESBlockSize+encoding.CSizeUint64 {
-		return fmt.Errorf("invalid size of sent package")
+		return errors.NewError("invalid size of sent package")
 	}
 	return nil
 }
@@ -145,10 +145,10 @@ func (p *sConn) recvBlockSize() (uint64, error) {
 	encBufLen := make([]byte, symmetric.CAESBlockSize+encoding.CSizeUint64)
 	n, err := p.GetSocket().Read(encBufLen)
 	if err != nil {
-		return 0, err
+		return 0, errors.WrapError(err, "read tcp block size")
 	}
 	if n != symmetric.CAESBlockSize+encoding.CSizeUint64 {
-		return 0, fmt.Errorf("block size is invalid")
+		return 0, errors.NewError("block size is invalid")
 	}
 
 	// mustLen = Size[u64] in uint64

pkg/network/conn_keeper/conn_keeper.go

@@ -1,10 +1,10 @@
 package conn_keeper
 
 import (
-	"errors"
 	"sync"
 	"time"
 
+	"github.com/number571/go-peer/pkg/errors"
 	"github.com/number571/go-peer/pkg/network"
 )
 
@@ -40,7 +40,7 @@ func (p *sConnKeeper) Run() error {
 	defer p.fMutex.Unlock()
 
 	if p.fIsRun {
-		return errors.New("conn keeper already started")
+		return errors.NewError("conn keeper already started")
 	}
 	p.fIsRun = true
 
@@ -66,7 +66,7 @@ func (p *sConnKeeper) Stop() error {
 	defer p.fMutex.Unlock()
 
 	if !p.fIsRun {
-		return errors.New("conn keeper already closed or not started")
+		return errors.NewError("conn keeper already closed or not started")
 	}
 	p.fIsRun = false
 

pkg/network/network.go

@@ -1,12 +1,12 @@
 package network
 
 import (
-	"fmt"
 	"net"
 	"sync"
 
 	"github.com/number571/go-peer/pkg/crypto/hashing"
 	"github.com/number571/go-peer/pkg/encoding"
+	"github.com/number571/go-peer/pkg/errors"
 	"github.com/number571/go-peer/pkg/network/conn"
 	"github.com/number571/go-peer/pkg/payload"
 	"github.com/number571/go-peer/pkg/types"
@@ -49,12 +49,8 @@ func (p *sNode) BroadcastPayload(pPld payload.IPayload) error {
 
 	var err error
 	for _, conn := range p.GetConnections() {
-		e := conn.WritePayload(pPld)
-		if e != nil {
-			err = e
-		}
+		err = errors.AppendError(err, conn.WritePayload(pPld))
 	}
-
 	return err
 }
 
@@ -64,7 +60,7 @@ func (p *sNode) BroadcastPayload(pPld payload.IPayload) error {
 func (p *sNode) Run() error {
 	listener, err := net.Listen("tcp", p.GetSettings().GetAddress())
 	if err != nil {
-		return err
+		return errors.WrapError(err, "run node")
 	}
 
 	go func(pListener net.Listener) {
@@ -108,7 +104,10 @@ func (p *sNode) Stop() error {
 		delete(p.fConnections, id)
 	}
 
-	return types.CloseAll(toClose)
+	if err := types.CloseAll(toClose); err != nil {
+		return errors.WrapError(err, "stop node")
+	}
+	return nil
 }
 
 // Saves the function to the map by key for subsequent redirection.
@@ -137,13 +136,13 @@ func (p *sNode) GetConnections() map[string]conn.IConn {
 // Checks the number of connections.
 func (p *sNode) AddConnect(pAddress string) error {
 	if p.hasMaxConnSize() {
-		return fmt.Errorf("has max connections size")
+		return errors.NewError("has max connections size")
 	}
 
 	sett := p.GetSettings().GetConnSettings()
 	conn, err := conn.NewConn(sett, pAddress)
 	if err != nil {
-		return err
+		return errors.WrapError(err, "add connect")
 	}
 
 	p.setConnection(pAddress, conn)
@@ -163,7 +162,10 @@ func (p *sNode) DelConnect(pAddress string) error {
 	}
 
 	delete(p.fConnections, pAddress)
-	return conn.Close()
+	if err := conn.Close(); err != nil {
+		return errors.WrapError(err, "del connect")
+	}
+	return nil
 }
 
 // Processes the received data from the connection.

pkg/storage/database/encrypt.go

@@ -2,10 +2,10 @@ package database
 
 import (
 	"bytes"
-	"fmt"
 
 	"github.com/number571/go-peer/pkg/crypto/hashing"
 	"github.com/number571/go-peer/pkg/crypto/symmetric"
+	"github.com/number571/go-peer/pkg/errors"
 )
 
 func doEncrypt(pCipher symmetric.ICipher, pDataBytes []byte) []byte {
@@ -23,12 +23,12 @@ func doEncrypt(pCipher symmetric.ICipher, pDataBytes []byte) []byte {
 
 func tryDecrypt(pCipher symmetric.ICipher, pEncBytes []byte) ([]byte, error) {
 	if len(pEncBytes) < hashing.CSHA256Size+symmetric.CAESBlockSize {
-		return nil, fmt.Errorf("incorrect size of encrypted data")
+		return nil, errors.NewError("incorrect size of encrypted data")
 	}
 
 	decBytes := pCipher.DecryptBytes(pEncBytes[hashing.CSHA256Size:])
 	if decBytes == nil {
-		return nil, fmt.Errorf("failed decrypt message")
+		return nil, errors.NewError("failed decrypt message")
 	}
 
 	gotHashed := pEncBytes[:hashing.CSHA256Size]
@@ -38,7 +38,7 @@ func tryDecrypt(pCipher symmetric.ICipher, pEncBytes []byte) ([]byte, error) {
 	).ToBytes()
 
 	if !bytes.Equal(gotHashed, newHashed) {
-		return nil, fmt.Errorf("incorrect hash of decrypted data")
+		return nil, errors.NewError("incorrect hash of decrypted data")
 	}
 
 	return decBytes, nil

pkg/storage/database/sqlite.go

@@ -8,6 +8,7 @@ import (
 	"github.com/number571/go-peer/pkg/crypto/random"
 	"github.com/number571/go-peer/pkg/crypto/symmetric"
 	"github.com/number571/go-peer/pkg/encoding"
+	"github.com/number571/go-peer/pkg/errors"
 
 	_ "github.com/mattn/go-sqlite3"
 )
@@ -37,11 +38,11 @@ type sSQLiteDB struct {
 func NewSQLiteDB(pSett ISettings) (IKeyValueDB, error) {
 	db, err := sql.Open("sqlite3", pSett.GetPath())
 	if err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "open database")
 	}
 
 	if _, err := db.Exec(cTabelKV); err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "insert KV table")
 	}
 
 	var saltValue string
@@ -50,7 +51,7 @@ func NewSQLiteDB(pSett ISettings) (IKeyValueDB, error) {
 		saltValue = encoding.HexEncode(random.NewStdPRNG().GetBytes(symmetric.CAESKeySize))
 		_, err := db.Exec("REPLACE INTO kv (key, value) VALUES ($1,$2)", cSaltKey, saltValue)
 		if err != nil {
-			return nil, err
+			return nil, errors.WrapError(err, "insert salt into database")
 		}
 	}
 
@@ -75,7 +76,10 @@ func (p *sSQLiteDB) Set(pKey []byte, pValue []byte) error {
 		encoding.HexEncode(p.tryHash(pKey)),
 		encoding.HexEncode(doEncrypt(p.fCipher, pValue)),
 	)
-	return err
+	if err != nil {
+		return errors.WrapError(err, "insert key/value to database")
+	}
+	return nil
 }
 
 func (p *sSQLiteDB) Get(pKey []byte) ([]byte, error) {
@@ -85,7 +89,7 @@ func (p *sSQLiteDB) Get(pKey []byte) ([]byte, error) {
 	var encValue string
 	row := p.fDB.QueryRow("SELECT value FROM kv WHERE key = $1", encoding.HexEncode(p.tryHash(pKey)))
 	if err := row.Scan(&encValue); err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "read value by key")
 	}
 
 	return tryDecrypt(
@@ -102,14 +106,20 @@ func (p *sSQLiteDB) Del(pKey []byte) error {
 		"DELETE FROM kv WHERE key = $1",
 		encoding.HexEncode(p.tryHash(pKey)),
 	)
-	return err
+	if err != nil {
+		return errors.WrapError(err, "delete value by key")
+	}
+	return nil
 }
 
 func (p *sSQLiteDB) Close() error {
 	p.fMutex.Lock()
 	defer p.fMutex.Unlock()
 
-	return p.fDB.Close()
+	if err := p.fDB.Close(); err != nil {
+		return errors.WrapError(err, "close database")
+	}
+	return nil
 }
 
 func (p *sSQLiteDB) tryHash(pKey []byte) []byte {

pkg/storage/memory.go

@@ -1,10 +1,10 @@
 package storage
 
 import (
-	"fmt"
 	"sync"
 
 	"github.com/number571/go-peer/pkg/encoding"
+	"github.com/number571/go-peer/pkg/errors"
 )
 
 var (
@@ -48,7 +48,7 @@ func (p *sMemoryStorage) Get(pKey []byte) ([]byte, error) {
 
 	value, ok := p.fMapping[encoding.HexEncode(pKey)]
 	if !ok {
-		return nil, fmt.Errorf("undefined value by key")
+		return nil, errors.NewError("undefined value by key")
 	}
 
 	return value, nil
@@ -60,7 +60,7 @@ func (p *sMemoryStorage) Del(pKey []byte) error {
 
 	_, ok := p.fMapping[encoding.HexEncode(pKey)]
 	if !ok {
-		return fmt.Errorf("undefined value by key")
+		return errors.NewError("undefined value by key")
 	}
 
 	delete(p.fMapping, encoding.HexEncode(pKey))

pkg/storage/storage.go

@@ -3,13 +3,13 @@ package storage
 import (
 	"bytes"
 	"encoding/json"
-	"fmt"
 	"sync"
 
 	"github.com/number571/go-peer/pkg/crypto/entropy"
 	"github.com/number571/go-peer/pkg/crypto/hashing"
 	"github.com/number571/go-peer/pkg/crypto/random"
 	"github.com/number571/go-peer/pkg/crypto/symmetric"
+	"github.com/number571/go-peer/pkg/errors"
 	"github.com/number571/go-peer/pkg/filesystem"
 )
 
@@ -69,7 +69,7 @@ func (p *sCryptoStorage) Set(pKey, pValue []byte) error {
 		var err error
 		mapping, err = p.decrypt()
 		if err != nil {
-			return err
+			return errors.WrapError(err, "open & decrypt storage")
 		}
 	}
 
@@ -86,20 +86,20 @@ func (p *sCryptoStorage) Get(pKey []byte) ([]byte, error) {
 
 	// If storage not exists.
 	if !p.isExist() {
-		return nil, fmt.Errorf("error: storage undefined")
+		return nil, errors.NewError("storage undefined")
 	}
 
 	// Open and decrypt storage
 	mapping, err := p.decrypt()
 	if err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "decrypt storage")
 	}
 
 	// Open and decrypt secret
 	cipher, hash := p.newCipherWithKeyHash(pKey)
 	encsecret, ok := mapping.FSecrets[hash]
 	if !ok {
-		return nil, fmt.Errorf("error: key undefined")
+		return nil, errors.NewError("key undefined")
 	}
 	secret := cipher.DecryptBytes(encsecret)
 
@@ -112,7 +112,7 @@ func (p *sCryptoStorage) Del(pKey []byte) error {
 
 	// If storage not exists.
 	if !p.isExist() {
-		return fmt.Errorf("error: storage undefined")
+		return errors.NewError("storage undefined")
 	}
 
 	// Open and decrypt storage
@@ -125,7 +125,7 @@ func (p *sCryptoStorage) Del(pKey []byte) error {
 	_, hash := p.newCipherWithKeyHash(pKey)
 	_, ok := mapping.FSecrets[hash]
 	if !ok {
-		return fmt.Errorf("error: key undefined")
+		return errors.NewError("key undefined")
 	}
 
 	delete(mapping.FSecrets, hash)
@@ -140,7 +140,7 @@ func (p *sCryptoStorage) encrypt(pMapping *storageData) error {
 	// Encrypt and save storage
 	data, err := json.Marshal(pMapping)
 	if err != nil {
-		return err
+		return errors.WrapError(err, "marshal decrypted map")
 	}
 
 	err = filesystem.OpenFile(p.fSettings.GetPath()).Write(
@@ -150,7 +150,7 @@ func (p *sCryptoStorage) encrypt(pMapping *storageData) error {
 		),
 	)
 	if err != nil {
-		return err
+		return errors.WrapError(err, "write to storage")
 	}
 
 	return nil
@@ -161,13 +161,13 @@ func (p *sCryptoStorage) decrypt() (*storageData, error) {
 
 	encdata, err := filesystem.OpenFile(p.fSettings.GetPath()).Read()
 	if err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "open encrypted storage")
 	}
 
 	data := p.fCipher.DecryptBytes(encdata[cSaltSize:])
 	err = json.Unmarshal(data, &mapping)
 	if err != nil {
-		return nil, err
+		return nil, errors.WrapError(err, "unmarshal decrypt map")
 	}
 
 	return &mapping, nil

pkg/types/closer.go

@@ -1,12 +1,12 @@
 package types
 
+import "github.com/number571/go-peer/pkg/errors"
+
 // returns last error from slice
 func CloseAll(pClosers []ICloser) error {
-	var lastErr error
+	var err error
 	for _, c := range pClosers {
-		if err := c.Close(); err != nil {
-			lastErr = err
-		}
+		err = errors.AppendError(err, c.Close())
 	}
-	return lastErr
+	return err
 }

pkg/types/stopper.go

@@ -1,12 +1,12 @@
 package types
 
+import "github.com/number571/go-peer/pkg/errors"
+
 // returns last error from slice
 func StopAll(pCommands []ICommand) error {
-	var lastErr error
+	var err error
 	for _, c := range pCommands {
-		if err := c.Stop(); err != nil {
-			lastErr = err
-		}
+		err = errors.AppendError(err, c.Stop())
 	}
-	return lastErr
+	return err
 }