chore: fix error message

wip: fix lint errors
wip: fix lint
2023-03-14 12:00:29 +05:30 · 2023-03-14 11:50:50 +05:30 · 2023-03-14 11:29:38 +05:30 · 2023-03-14 11:05:23 +05:30
14 changed files with 175 additions and 163 deletions
--- a/x/auction/keeper/grpc_query.go
+++ b/x/auction/keeper/grpc_query.go
@ -3,6 +3,7 @@ package keeper
 import (
 	"context"

+	errors "cosmossdk.io/errors"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"

@ -26,7 +27,7 @@ func (q Querier) Auctions(c context.Context, req *types.AuctionsRequest) (*types
 func (q Querier) GetAuction(c context.Context, req *types.AuctionRequest) (*types.AuctionResponse, error) {
 	ctx := sdk.UnwrapSDKContext(c)
 	if req.Id == "" {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "auction ID is required")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "auction ID is required")
 	}

 	resp := q.Keeper.GetAuction(ctx, req.Id)
@ -37,10 +38,10 @@ func (q Querier) GetAuction(c context.Context, req *types.AuctionRequest) (*type
 func (q Querier) GetBid(c context.Context, req *types.BidRequest) (*types.BidResponse, error) {
 	ctx := sdk.UnwrapSDKContext(c)
 	if req.AuctionId == "" {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "auction ID is required")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "auction ID is required")
 	}
 	if req.Bidder == "" {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "bidder address is required")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "bidder address is required")
 	}
 	resp := q.Keeper.GetBid(ctx, req.AuctionId, req.Bidder)
 	return &types.BidResponse{Bid: &resp}, nil
@ -50,7 +51,7 @@ func (q Querier) GetBid(c context.Context, req *types.BidRequest) (*types.BidRes
 func (q Querier) GetBids(c context.Context, req *types.BidsRequest) (*types.BidsResponse, error) {
 	ctx := sdk.UnwrapSDKContext(c)
 	if req.AuctionId == "" {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "auction ID is required")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "auction ID is required")
 	}
 	resp := q.Keeper.GetBids(ctx, req.AuctionId)
 	return &types.BidsResponse{Bids: resp}, nil
@ -60,7 +61,7 @@ func (q Querier) GetBids(c context.Context, req *types.BidsRequest) (*types.Bids
 func (q Querier) AuctionsByBidder(c context.Context, req *types.AuctionsByBidderRequest) (*types.AuctionsByBidderResponse, error) {
 	ctx := sdk.UnwrapSDKContext(c)
 	if req.BidderAddress == "" {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "bidder address is required")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "bidder address is required")
 	}
 	resp := q.Keeper.QueryAuctionsByBidder(ctx, req.BidderAddress)
 	return &types.AuctionsByBidderResponse{Auctions: &types.Auctions{Auctions: resp}}, nil
@ -70,7 +71,7 @@ func (q Querier) AuctionsByBidder(c context.Context, req *types.AuctionsByBidder
 func (q Querier) AuctionsByOwner(c context.Context, req *types.AuctionsByOwnerRequest) (*types.AuctionsByOwnerResponse, error) {
 	ctx := sdk.UnwrapSDKContext(c)
 	if req.OwnerAddress == "" {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "owner address is required")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "owner address is required")
 	}
 	resp := q.Keeper.QueryAuctionsByOwner(ctx, req.OwnerAddress)
 	return &types.AuctionsByOwnerResponse{Auctions: &types.Auctions{Auctions: resp}}, nil
--- a/x/auction/keeper/keeper.go
+++ b/x/auction/keeper/keeper.go
@ -6,6 +6,7 @@ import (
 	"fmt"
 	"time"

+	errors "cosmossdk.io/errors"
 	"github.com/cerc-io/laconicd/x/auction/types"
 	"github.com/cosmos/cosmos-sdk/codec"
 	storetypes "github.com/cosmos/cosmos-sdk/store/types"
@ -306,7 +307,7 @@ func (k Keeper) CreateAuction(ctx sdk.Context, msg types.MsgCreateAuction) (*typ
 	// Generate auction Id.
 	account := k.accountKeeper.GetAccount(ctx, signerAddress)
 	if account == nil {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "Account not found.")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidAddress, "account not found")
 	}

 	auctionID := types.AuctionID{
@ -340,12 +341,12 @@ func (k Keeper) CreateAuction(ctx sdk.Context, msg types.MsgCreateAuction) (*typ

 func (k Keeper) CommitBid(ctx sdk.Context, msg types.MsgCommitBid) (*types.Bid, error) {
 	if !k.HasAuction(ctx, msg.AuctionId) {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Auction not found.")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "auction not found")
 	}

 	auction := k.GetAuction(ctx, msg.AuctionId)
 	if auction.Status != types.AuctionStatusCommitPhase {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Auction is not in commit phase.")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "auction is not in commit phase")
 	}

 	signerAddress, err := sdk.AccAddressFromBech32(msg.Signer)
@ -390,12 +391,12 @@ func (k Keeper) CommitBid(ctx sdk.Context, msg types.MsgCommitBid) (*types.Bid,
 // RevealBid reeals a bid committed earlier.
 func (k Keeper) RevealBid(ctx sdk.Context, msg types.MsgRevealBid) (*types.Auction, error) {
 	if !k.HasAuction(ctx, msg.AuctionId) {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Auction not found.")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "auction not found")
 	}

 	auction := k.GetAuction(ctx, msg.AuctionId)
 	if auction.Status != types.AuctionStatusRevealPhase {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Auction is not in reveal phase.")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "auction is not in reveal phase")
 	}

 	signerAddress, err := sdk.AccAddressFromBech32(msg.Signer)
@ -404,65 +405,65 @@ func (k Keeper) RevealBid(ctx sdk.Context, msg types.MsgRevealBid) (*types.Aucti
 	}

 	if !k.HasBid(ctx, msg.AuctionId, signerAddress.String()) {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Bid not found.")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "bid not found")
 	}

 	bid := k.GetBid(ctx, auction.Id, signerAddress.String())
 	if bid.Status != types.BidStatusCommitted {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Bid not in committed state.")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "bid not in committed state")
 	}

 	revealBytes, err := hex.DecodeString(msg.Reveal)
 	if err != nil {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Invalid reveal string.")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "invalid reveal string")
 	}

 	cid, err := wnsUtils.CIDFromJSONBytes(revealBytes)
 	if err != nil {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Invalid reveal JSON.")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "invalid reveal JSON")
 	}

 	if bid.CommitHash != cid {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Commit hash mismatch.")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "commit hash mismatch")
 	}

 	var reveal map[string]interface{}
 	err = json.Unmarshal(revealBytes, &reveal)
 	if err != nil {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Reveal JSON unmarshal error.")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "reveal JSON unmarshal error")
 	}

 	chainID, err := wnsUtils.GetAttributeAsString(reveal, "chainId")
 	if err != nil || chainID != ctx.ChainID() {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Invalid reveal chainID.")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "invalid reveal chainID")
 	}

 	auctionID, err := wnsUtils.GetAttributeAsString(reveal, "auctionId")
 	if err != nil || auctionID != msg.AuctionId {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Invalid reveal auction Id.")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "invalid reveal auction Id")
 	}

 	bidderAddress, err := wnsUtils.GetAttributeAsString(reveal, "bidderAddress")
 	if err != nil {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Invalid reveal bid address.")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "invalid reveal bid address")
 	}

 	if bidderAddress != signerAddress.String() {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Reveal bid address mismatch.")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "reveal bid address mismatch")
 	}

 	bidAmountStr, err := wnsUtils.GetAttributeAsString(reveal, "bidAmount")
 	if err != nil {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Invalid reveal bid amount.")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "invalid reveal bid amount")
 	}

 	bidAmount, err := sdk.ParseCoinNormalized(bidAmountStr)
 	if err != nil {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Invalid reveal bid amount.")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "invalid reveal bid amount")
 	}

 	if bidAmount.IsLT(auction.MinimumBid) {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Bid is lower than minimum bid.")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "bid is lower than minimum bid")
 	}

 	// Lock bid amount.
--- a/x/auction/types/msgs.go
+++ b/x/auction/types/msgs.go
@ -1,6 +1,7 @@
 package types

 import (
+	"cosmossdk.io/errors"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 )
@ -32,19 +33,19 @@ func (msg MsgCreateAuction) Type() string { return "create" }
 // ValidateBasic Implements Msg.
 func (msg MsgCreateAuction) ValidateBasic() error {
 	if msg.Signer == "" {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, msg.Signer)
+		return errors.Wrap(sdkerrors.ErrInvalidAddress, msg.Signer)
 	}

 	if msg.CommitsDuration <= 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "commit phase duration invalid.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "commit phase duration invalid")
 	}

 	if msg.RevealsDuration <= 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "reveal phase duration invalid.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "reveal phase duration invalid")
 	}

 	if !msg.MinimumBid.IsPositive() {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "minimum bid should be greater than zero.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "minimum bid should be greater than zero")
 	}

 	return nil
@ -79,15 +80,15 @@ func (msg MsgCommitBid) Type() string { return "commit" }
 // ValidateBasic Implements Msg.
 func (msg MsgCommitBid) ValidateBasic() error {
 	if msg.Signer == "" {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer address.")
+		return errors.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer address")
 	}

 	if msg.AuctionId == "" {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "invalid auction ID.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "invalid auction ID")
 	}

 	if msg.CommitHash == "" {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "invalid commit hash.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "invalid commit hash")
 	}

 	return nil
@ -122,15 +123,15 @@ func (msg MsgRevealBid) Type() string { return "reveal" }
 // ValidateBasic Implements Msg.
 func (msg MsgRevealBid) ValidateBasic() error {
 	if msg.Signer == "" {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer address.")
+		return errors.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer address")
 	}

 	if msg.AuctionId == "" {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "invalid auction ID.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "invalid auction ID")
 	}

 	if msg.Reveal == "" {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "invalid reveal data.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "invalid reveal data")
 	}

 	return nil
--- a/x/bond/keeper/grpc_query.go
+++ b/x/bond/keeper/grpc_query.go
@ -3,6 +3,7 @@ package keeper
 import (
 	"context"

+	"cosmossdk.io/errors"
 	"github.com/cerc-io/laconicd/x/bond/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
@ -30,7 +31,7 @@ func (q Querier) GetBondByID(c context.Context, req *types.QueryGetBondByIDReque
 	ctx := sdk.UnwrapSDKContext(c)
 	bondID := req.GetId()
 	if len(bondID) == 0 {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "bond id required")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "bond id required")
 	}
 	bond := q.Keeper.GetBond(ctx, req.GetId())
 	return &types.QueryGetBondByIDResponse{Bond: &bond}, nil
@ -40,7 +41,7 @@ func (q Querier) GetBondsByOwner(c context.Context, req *types.QueryGetBondsByOw
 	ctx := sdk.UnwrapSDKContext(c)
 	owner := req.GetOwner()
 	if len(owner) == 0 {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "owner id required")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "owner id required")
 	}
 	bonds := q.Keeper.QueryBondsByOwner(ctx, owner)
 	return &types.QueryGetBondsByOwnerResponse{Bonds: bonds}, nil
--- a/x/bond/keeper/keeper.go
+++ b/x/bond/keeper/keeper.go
@ -5,6 +5,7 @@ import (
 	"encoding/hex"
 	"fmt"

+	"cosmossdk.io/errors"
 	"github.com/cerc-io/laconicd/x/bond/types"
 	"github.com/cosmos/cosmos-sdk/codec"
 	storetypes "github.com/cosmos/cosmos-sdk/store/types"
@ -113,7 +114,7 @@ func (k Keeper) CreateBond(ctx sdk.Context, ownerAddress sdk.AccAddress, coins s
 	for _, coin := range coins {
 		balance := k.bankKeeper.HasBalance(ctx, ownerAddress, coin)
 		if !balance {
-			return nil, sdkerrors.Wrap(sdkerrors.ErrInsufficientFunds, "failed to create bond; Insufficient funds")
+			return nil, errors.Wrap(sdkerrors.ErrInsufficientFunds, "failed to create bond; Insufficient funds")
 		}
 	}

@ -129,7 +130,7 @@ func (k Keeper) CreateBond(ctx sdk.Context, ownerAddress sdk.AccAddress, coins s

 	bond := types.Bond{Id: bondID, Owner: ownerAddress.String(), Balance: coins}
 	if bond.Balance.IsAnyGT(maxBondAmount) {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Max bond amount exceeded.")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "max bond amount exceeded")
 	}

 	// Move funds into the bond account module.
@ -221,18 +222,18 @@ func (k Keeper) QueryBondsByOwner(ctx sdk.Context, ownerAddress string) []types.
 // RefillBond refills an existing bond.
 func (k Keeper) RefillBond(ctx sdk.Context, id string, ownerAddress sdk.AccAddress, coins sdk.Coins) (*types.Bond, error) {
 	if !k.HasBond(ctx, id) {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Bond not found.")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "bond not found")
 	}

 	bond := k.GetBond(ctx, id)
 	if bond.Owner != ownerAddress.String() {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "Bond owner mismatch.")
+		return nil, errors.Wrap(sdkerrors.ErrUnauthorized, "bond owner mismatch")
 	}

 	// Check if account has funds.
 	for _, coin := range coins {
 		if !k.bankKeeper.HasBalance(ctx, ownerAddress, coin) {
-			return nil, sdkerrors.Wrap(sdkerrors.ErrInsufficientFunds, "Insufficient funds.")
+			return nil, errors.Wrap(sdkerrors.ErrInsufficientFunds, "insufficient funds")
 		}
 	}

@ -240,7 +241,7 @@ func (k Keeper) RefillBond(ctx sdk.Context, id string, ownerAddress sdk.AccAddre

 	updatedBalance := bond.Balance.Add(coins...)
 	if updatedBalance.IsAnyGT(maxBondAmount) {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Max bond amount exceeded.")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "max bond amount exceeded")
 	}

 	// Move funds into the bond account module.
@ -259,17 +260,17 @@ func (k Keeper) RefillBond(ctx sdk.Context, id string, ownerAddress sdk.AccAddre
 // WithdrawBond withdraws funds from a bond.
 func (k Keeper) WithdrawBond(ctx sdk.Context, id string, ownerAddress sdk.AccAddress, coins sdk.Coins) (*types.Bond, error) {
 	if !k.HasBond(ctx, id) {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Bond not found.")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "bond not found")
 	}

 	bond := k.GetBond(ctx, id)
 	if bond.Owner != ownerAddress.String() {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "Bond owner mismatch.")
+		return nil, errors.Wrap(sdkerrors.ErrUnauthorized, "bond owner mismatch")
 	}

 	updatedBalance, isNeg := bond.Balance.SafeSub(coins...)
 	if isNeg {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInsufficientFunds, "Insufficient bond balance.")
+		return nil, errors.Wrap(sdkerrors.ErrInsufficientFunds, "insufficient bond balance")
 	}

 	// Move funds from the bond into the account.
@ -288,18 +289,18 @@ func (k Keeper) WithdrawBond(ctx sdk.Context, id string, ownerAddress sdk.AccAdd
 // CancelBond cancels a bond, returning funds to the owner.
 func (k Keeper) CancelBond(ctx sdk.Context, id string, ownerAddress sdk.AccAddress) (*types.Bond, error) {
 	if !k.HasBond(ctx, id) {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Bond not found.")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "bond not found")
 	}

 	bond := k.GetBond(ctx, id)
 	if bond.Owner != ownerAddress.String() {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "Bond owner mismatch.")
+		return nil, errors.Wrap(sdkerrors.ErrUnauthorized, "bond owner mismatch")
 	}

 	// Check if bond is used in other modules.
 	for _, usageKeeper := range k.usageKeepers {
 		if usageKeeper.UsesBond(ctx, id) {
-			return nil, sdkerrors.Wrap(sdkerrors.ErrUnauthorized, fmt.Sprintf("Bond in use by the '%s' module.", usageKeeper.ModuleName()))
+			return nil, errors.Wrap(sdkerrors.ErrUnauthorized, fmt.Sprintf("bond in use by the '%s' module", usageKeeper.ModuleName()))
 		}
 	}

@ -330,7 +331,7 @@ func (k Keeper) GetBondModuleBalances(ctx sdk.Context) sdk.Coins {
 // TransferCoinsToModuleAccount moves funds from the bonds module account to another module account.
 func (k Keeper) TransferCoinsToModuleAccount(ctx sdk.Context, id, moduleAccount string, coins sdk.Coins) error {
 	if !k.HasBond(ctx, id) {
-		return sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "Bond not found.")
+		return errors.Wrap(sdkerrors.ErrUnauthorized, "bond not found")
 	}

 	bondObj := k.GetBond(ctx, id)
@ -340,13 +341,13 @@ func (k Keeper) TransferCoinsToModuleAccount(ctx sdk.Context, id, moduleAccount

 	if isNeg {
 		// Check if bond has sufficient funds.
-		return sdkerrors.Wrap(sdkerrors.ErrInsufficientFunds, "Insufficient funds.")
+		return errors.Wrap(sdkerrors.ErrInsufficientFunds, "insufficient funds")
 	}

 	// Move funds from bond module to record rent module.
 	err := k.bankKeeper.SendCoinsFromModuleToModule(ctx, types.ModuleName, moduleAccount, coins)
 	if err != nil {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Error transferring funds.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "error transferring funds")
 	}

 	// Update bond balance.
--- a/x/bond/types/msg.go
+++ b/x/bond/types/msg.go
@ -1,6 +1,7 @@
 package types

 import (
+	"cosmossdk.io/errors"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 )
@ -28,10 +29,10 @@ func (msg MsgCreateBond) Type() string { return "create" }

 func (msg MsgCreateBond) ValidateBasic() error {
 	if len(msg.Signer) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, msg.Signer)
+		return errors.Wrap(sdkerrors.ErrInvalidAddress, msg.Signer)
 	}
 	if len(msg.Coins) == 0 || !msg.Coins.IsValid() {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, "Invalid amount.")
+		return errors.Wrap(sdkerrors.ErrInvalidCoins, "invalid amount")
 	}
 	return nil
 }
@ -64,13 +65,13 @@ func (msg MsgRefillBond) Type() string { return "refill" }

 func (msg MsgRefillBond) ValidateBasic() error {
 	if len(msg.Id) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, msg.Id)
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, msg.Id)
 	}
 	if len(msg.Signer) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, msg.Signer)
+		return errors.Wrap(sdkerrors.ErrInvalidAddress, msg.Signer)
 	}
 	if len(msg.Coins) == 0 || !msg.Coins.IsValid() {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, "Invalid amount.")
+		return errors.Wrap(sdkerrors.ErrInvalidCoins, "invalid amount")
 	}
 	return nil
 }
@ -103,13 +104,13 @@ func (msg MsgWithdrawBond) Type() string { return "withdraw" }

 func (msg MsgWithdrawBond) ValidateBasic() error {
 	if len(msg.Id) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, msg.Id)
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, msg.Id)
 	}
 	if len(msg.Signer) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, msg.Signer)
+		return errors.Wrap(sdkerrors.ErrInvalidAddress, msg.Signer)
 	}
 	if len(msg.Coins) == 0 || !msg.Coins.IsValid() {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, "Invalid amount.")
+		return errors.Wrap(sdkerrors.ErrInvalidCoins, "invalid amount")
 	}
 	return nil
 }
@ -141,10 +142,10 @@ func (msg MsgCancelBond) Type() string { return "cancel" }

 func (msg MsgCancelBond) ValidateBasic() error {
 	if len(msg.Id) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, msg.Id)
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, msg.Id)
 	}
 	if len(msg.Signer) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, msg.Signer)
+		return errors.Wrap(sdkerrors.ErrInvalidAddress, msg.Signer)
 	}
 	return nil
 }
--- a/x/evm/migrations/v2/types/chain_config.go
+++ b/x/evm/migrations/v2/types/chain_config.go
@ -4,10 +4,10 @@ import (
 	"math/big"
 	"strings"

+	"cosmossdk.io/errors"
 	sdkmath "cosmossdk.io/math"

 	sdk "github.com/cosmos/cosmos-sdk/types"
-	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"

 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/params"
@ -91,61 +91,61 @@ func getBlockValue(block *sdkmath.Int) *big.Int {
 // if any of the block values is uninitialized (i.e nil) or if the EIP150Hash is an invalid hash.
 func (cc ChainConfig) Validate() error {
 	if err := validateBlock(cc.HomesteadBlock); err != nil {
-		return sdkerrors.Wrap(err, "homesteadBlock")
+		return errors.Wrap(err, "homesteadBlock")
 	}
 	if err := validateBlock(cc.DAOForkBlock); err != nil {
-		return sdkerrors.Wrap(err, "daoForkBlock")
+		return errors.Wrap(err, "daoForkBlock")
 	}
 	if err := validateBlock(cc.EIP150Block); err != nil {
-		return sdkerrors.Wrap(err, "eip150Block")
+		return errors.Wrap(err, "eip150Block")
 	}
 	if err := validateHash(cc.EIP150Hash); err != nil {
 		return err
 	}
 	if err := validateBlock(cc.EIP155Block); err != nil {
-		return sdkerrors.Wrap(err, "eip155Block")
+		return errors.Wrap(err, "eip155Block")
 	}
 	if err := validateBlock(cc.EIP158Block); err != nil {
-		return sdkerrors.Wrap(err, "eip158Block")
+		return errors.Wrap(err, "eip158Block")
 	}
 	if err := validateBlock(cc.ByzantiumBlock); err != nil {
-		return sdkerrors.Wrap(err, "byzantiumBlock")
+		return errors.Wrap(err, "byzantiumBlock")
 	}
 	if err := validateBlock(cc.ConstantinopleBlock); err != nil {
-		return sdkerrors.Wrap(err, "constantinopleBlock")
+		return errors.Wrap(err, "constantinopleBlock")
 	}
 	if err := validateBlock(cc.PetersburgBlock); err != nil {
-		return sdkerrors.Wrap(err, "petersburgBlock")
+		return errors.Wrap(err, "petersburgBlock")
 	}
 	if err := validateBlock(cc.IstanbulBlock); err != nil {
-		return sdkerrors.Wrap(err, "istanbulBlock")
+		return errors.Wrap(err, "istanbulBlock")
 	}
 	if err := validateBlock(cc.MuirGlacierBlock); err != nil {
-		return sdkerrors.Wrap(err, "muirGlacierBlock")
+		return errors.Wrap(err, "muirGlacierBlock")
 	}
 	if err := validateBlock(cc.BerlinBlock); err != nil {
-		return sdkerrors.Wrap(err, "berlinBlock")
+		return errors.Wrap(err, "berlinBlock")
 	}
 	if err := validateBlock(cc.LondonBlock); err != nil {
-		return sdkerrors.Wrap(err, "londonBlock")
+		return errors.Wrap(err, "londonBlock")
 	}
 	if err := validateBlock(cc.ArrowGlacierBlock); err != nil {
-		return sdkerrors.Wrap(err, "arrowGlacierBlock")
+		return errors.Wrap(err, "arrowGlacierBlock")
 	}
 	if err := validateBlock(cc.MergeForkBlock); err != nil {
-		return sdkerrors.Wrap(err, "mergeForkBlock")
+		return errors.Wrap(err, "mergeForkBlock")
 	}

 	// NOTE: chain ID is not needed to check config order
 	if err := cc.EthereumConfig(nil).CheckConfigForkOrder(); err != nil {
-		return sdkerrors.Wrap(err, "invalid config fork order")
+		return errors.Wrap(err, "invalid config fork order")
 	}
 	return nil
 }

 func validateHash(hex string) error {
 	if hex != "" && strings.TrimSpace(hex) == "" {
-		return sdkerrors.Wrap(types.ErrInvalidChainConfig, "hash cannot be blank")
+		return errors.Wrap(types.ErrInvalidChainConfig, "hash cannot be blank")
 	}

 	return nil
@ -158,7 +158,7 @@ func validateBlock(block *sdkmath.Int) error {
 	}

 	if block.IsNegative() {
-		return sdkerrors.Wrapf(
+		return errors.Wrapf(
 			types.ErrInvalidChainConfig, "block value cannot be negative: %s", block,
 		)
 	}
--- a/x/evm/migrations/v3/types/chain_config.go
+++ b/x/evm/migrations/v3/types/chain_config.go
@ -4,12 +4,12 @@ import (
 	"math/big"
 	"strings"

+	"cosmossdk.io/errors"
 	sdkmath "cosmossdk.io/math"

 	"github.com/cerc-io/laconicd/x/evm/types"

 	sdk "github.com/cosmos/cosmos-sdk/types"
-	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"

 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/params"
@ -90,61 +90,61 @@ func getBlockValue(block *sdkmath.Int) *big.Int {
 // if any of the block values is uninitialized (i.e nil) or if the EIP150Hash is an invalid hash.
 func (cc ChainConfig) Validate() error {
 	if err := validateBlock(cc.HomesteadBlock); err != nil {
-		return sdkerrors.Wrap(err, "homesteadBlock")
+		return errors.Wrap(err, "homesteadBlock")
 	}
 	if err := validateBlock(cc.DAOForkBlock); err != nil {
-		return sdkerrors.Wrap(err, "daoForkBlock")
+		return errors.Wrap(err, "daoForkBlock")
 	}
 	if err := validateBlock(cc.EIP150Block); err != nil {
-		return sdkerrors.Wrap(err, "eip150Block")
+		return errors.Wrap(err, "eip150Block")
 	}
 	if err := validateHash(cc.EIP150Hash); err != nil {
 		return err
 	}
 	if err := validateBlock(cc.EIP155Block); err != nil {
-		return sdkerrors.Wrap(err, "eip155Block")
+		return errors.Wrap(err, "eip155Block")
 	}
 	if err := validateBlock(cc.EIP158Block); err != nil {
-		return sdkerrors.Wrap(err, "eip158Block")
+		return errors.Wrap(err, "eip158Block")
 	}
 	if err := validateBlock(cc.ByzantiumBlock); err != nil {
-		return sdkerrors.Wrap(err, "byzantiumBlock")
+		return errors.Wrap(err, "byzantiumBlock")
 	}
 	if err := validateBlock(cc.ConstantinopleBlock); err != nil {
-		return sdkerrors.Wrap(err, "constantinopleBlock")
+		return errors.Wrap(err, "constantinopleBlock")
 	}
 	if err := validateBlock(cc.PetersburgBlock); err != nil {
-		return sdkerrors.Wrap(err, "petersburgBlock")
+		return errors.Wrap(err, "petersburgBlock")
 	}
 	if err := validateBlock(cc.IstanbulBlock); err != nil {
-		return sdkerrors.Wrap(err, "istanbulBlock")
+		return errors.Wrap(err, "istanbulBlock")
 	}
 	if err := validateBlock(cc.MuirGlacierBlock); err != nil {
-		return sdkerrors.Wrap(err, "muirGlacierBlock")
+		return errors.Wrap(err, "muirGlacierBlock")
 	}
 	if err := validateBlock(cc.BerlinBlock); err != nil {
-		return sdkerrors.Wrap(err, "berlinBlock")
+		return errors.Wrap(err, "berlinBlock")
 	}
 	if err := validateBlock(cc.LondonBlock); err != nil {
-		return sdkerrors.Wrap(err, "londonBlock")
+		return errors.Wrap(err, "londonBlock")
 	}
 	if err := validateBlock(cc.ArrowGlacierBlock); err != nil {
-		return sdkerrors.Wrap(err, "arrowGlacierBlock")
+		return errors.Wrap(err, "arrowGlacierBlock")
 	}
 	if err := validateBlock(cc.MergeForkBlock); err != nil {
-		return sdkerrors.Wrap(err, "mergeForkBlock")
+		return errors.Wrap(err, "mergeForkBlock")
 	}

 	// NOTE: chain ID is not needed to check config order
 	if err := cc.EthereumConfig(nil).CheckConfigForkOrder(); err != nil {
-		return sdkerrors.Wrap(err, "invalid config fork order")
+		return errors.Wrap(err, "invalid config fork order")
 	}
 	return nil
 }

 func validateHash(hex string) error {
 	if hex != "" && strings.TrimSpace(hex) == "" {
-		return sdkerrors.Wrap(types.ErrInvalidChainConfig, "hash cannot be blank")
+		return errors.Wrap(types.ErrInvalidChainConfig, "hash cannot be blank")
 	}

 	return nil
@ -157,7 +157,7 @@ func validateBlock(block *sdkmath.Int) error {
 	}

 	if block.IsNegative() {
-		return sdkerrors.Wrapf(
+		return errors.Wrapf(
 			types.ErrInvalidChainConfig, "block value cannot be negative: %s", block,
 		)
 	}
--- a/x/registry/keeper/grpc_query.go
+++ b/x/registry/keeper/grpc_query.go
@ -3,6 +3,7 @@ package keeper
 import (
 	"context"

+	"cosmossdk.io/errors"
 	"github.com/cerc-io/laconicd/x/registry/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
@ -48,7 +49,7 @@ func (q Querier) GetRecord(c context.Context, req *types.QueryRecordByIDRequest)
 	ctx := sdk.UnwrapSDKContext(c)
 	id := req.GetId()
 	if !q.Keeper.HasRecord(ctx, id) {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, "Record not found.")
+		return nil, errors.Wrap(sdkerrors.ErrUnknownRequest, "record not found")
 	}
 	record := q.Keeper.GetRecord(ctx, id)
 	return &types.QueryRecordByIDResponse{Record: record}, nil
@ -86,11 +87,11 @@ func (q Querier) LookupCrn(c context.Context, req *types.QueryLookupCrn) (*types
 	ctx := sdk.UnwrapSDKContext(c)
 	crn := req.GetCrn()
 	if !q.Keeper.HasNameRecord(ctx, crn) {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, "CRN not found.")
+		return nil, errors.Wrap(sdkerrors.ErrUnknownRequest, "crn not found")
 	}
 	nameRecord := q.Keeper.GetNameRecord(ctx, crn)
 	if nameRecord == nil {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, "name record not found.")
+		return nil, errors.Wrap(sdkerrors.ErrUnknownRequest, "name record not found")
 	}
 	return &types.QueryLookupCrnResponse{Name: nameRecord}, nil
 }
@ -100,7 +101,7 @@ func (q Querier) ResolveCrn(c context.Context, req *types.QueryResolveCrn) (*typ
 	crn := req.GetCrn()
 	record := q.Keeper.ResolveCRN(ctx, crn)
 	if record == nil {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, "record not found.")
+		return nil, errors.Wrap(sdkerrors.ErrUnknownRequest, "record not found")
 	}
 	return &types.QueryResolveCrnResponse{Record: record}, nil
 }
--- a/x/registry/keeper/keeper.go
+++ b/x/registry/keeper/keeper.go
@ -7,6 +7,7 @@ import (
 	"sort"
 	"time"

+	"cosmossdk.io/errors"
 	auctionkeeper "github.com/cerc-io/laconicd/x/auction/keeper"
 	bondkeeper "github.com/cerc-io/laconicd/x/bond/keeper"
 	"github.com/cerc-io/laconicd/x/registry/helpers"
@ -240,7 +241,7 @@ func (k Keeper) ProcessSetRecord(ctx sdk.Context, msg types.MsgSetRecord) (*type
 	resourceSignBytes, _ := record.GetSignBytes()
 	cid, err := record.GetCID()
 	if err != nil {
-		return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Invalid record JSON")
+		return nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "invalid record JSON")
 	}

 	record.ID = cid
@ -255,13 +256,13 @@ func (k Keeper) ProcessSetRecord(ctx sdk.Context, msg types.MsgSetRecord) (*type
 		pubKey, err := legacy.PubKeyFromBytes(helpers.BytesFromBase64(sig.PubKey))
 		if err != nil {
 			fmt.Println("Error decoding pubKey from bytes: ", err)
-			return nil, sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "Invalid public key.")
+			return nil, errors.Wrap(sdkerrors.ErrUnauthorized, "invalid public key")
 		}

 		sigOK := pubKey.VerifySignature(resourceSignBytes, helpers.BytesFromBase64(sig.Sig))
 		if !sigOK {
 			fmt.Println("Signature mismatch: ", sig.PubKey)
-			return nil, sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "Invalid signature.")
+			return nil, errors.Wrap(sdkerrors.ErrUnauthorized, "invalid signature")
 		}
 		record.Owners = append(record.Owners, pubKey.Address().String())
 	}
--- a/x/registry/keeper/naming_keeper.go
+++ b/x/registry/keeper/naming_keeper.go
@ -7,6 +7,7 @@ import (
 	"strings"
 	"time"

+	"cosmossdk.io/errors"
 	auctiontypes "github.com/cerc-io/laconicd/x/auction/types"
 	"github.com/cerc-io/laconicd/x/registry/helpers"
 	"github.com/cerc-io/laconicd/x/registry/types"
@ -112,12 +113,12 @@ func (k Keeper) updateBlockChangeSetForName(ctx sdk.Context, crn string) {
 func (k Keeper) getAuthority(ctx sdk.Context, crn string) (string, *url.URL, *types.NameAuthority, error) {
 	parsedCRN, err := url.Parse(crn)
 	if err != nil {
-		return "", nil, nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Invalid CRN.")
+		return "", nil, nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "invalid CRN")
 	}

 	name := parsedCRN.Host
 	if !k.HasNameAuthority(ctx, name) {
-		return name, nil, nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Name authority not found.")
+		return name, nil, nil, errors.Wrap(sdkerrors.ErrInvalidRequest, "name authority not found")
 	}
 	authority := k.GetNameAuthority(ctx, name)
 	return name, parsedCRN, &authority, nil
@ -131,19 +132,19 @@ func (k Keeper) checkCRNAccess(ctx sdk.Context, signer sdk.AccAddress, crn strin

 	formattedCRN := fmt.Sprintf("crn://%s%s", name, parsedCRN.RequestURI())
 	if formattedCRN != crn {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Invalid CRN.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "invalid CRN")
 	}

 	if authority.OwnerAddress != signer.String() {
-		return sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "Access denied.")
+		return errors.Wrap(sdkerrors.ErrUnauthorized, "access denied")
 	}

 	if authority.Status != types.AuthorityActive {
-		return sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "Authority is not active.")
+		return errors.Wrap(sdkerrors.ErrUnauthorized, "authority is not active")
 	}

 	if authority.BondId == "" || len(authority.BondId) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "Authority bond not found.")
+		return errors.Wrap(sdkerrors.ErrUnauthorized, "authority bond not found")
 	}

 	if authority.OwnerPublicKey == "" {
@ -323,13 +324,13 @@ func (k Keeper) ProcessReserveSubAuthority(ctx sdk.Context, name string, msg typ

 	// Check if parent authority exists.
 	if !k.HasNameAuthority(ctx, parent) {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Parent authority not found.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "parent authority not found")
 	}
 	parentAuthority := k.GetNameAuthority(ctx, parent)

 	// Sub-authority creator needs to be the owner of the parent authority.
 	if parentAuthority.OwnerAddress != msg.Signer {
-		return sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "Access denied.")
+		return errors.Wrap(sdkerrors.ErrUnauthorized, "access denied")
 	}

 	// Sub-authority owner defaults to parent authority owner.
@ -362,17 +363,17 @@ func (k Keeper) createAuthority(ctx sdk.Context, name string, owner string, isRo
 	if k.HasNameAuthority(ctx, name) {
 		authority := k.GetNameAuthority(ctx, name)
 		if authority.Status != types.AuthorityExpired {
-			return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Name already reserved.")
+			return errors.Wrap(sdkerrors.ErrInvalidRequest, "name already reserved")
 		}
 	}

 	ownerAddress, err := sdk.AccAddressFromBech32(owner)
 	if err != nil {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Invalid owner address.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "invalid owner address")
 	}
 	ownerAccount := k.accountKeeper.GetAccount(ctx, ownerAddress)
 	if ownerAccount == nil {
-		return sdkerrors.Wrap(sdkerrors.ErrUnknownAddress, "Account not found.")
+		return errors.Wrap(sdkerrors.ErrUnknownAddress, "account not found")
 	}

 	authority := types.NameAuthority{
@ -430,11 +431,11 @@ func (k Keeper) ProcessReserveAuthority(ctx sdk.Context, msg types.MsgReserveAut
 	crn := fmt.Sprintf("crn://%s", msg.GetName())
 	parsedCrn, err := url.Parse(crn)
 	if err != nil {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Invalid name")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "invalid name")
 	}
 	name := parsedCrn.Host
 	if fmt.Sprintf("crn://%s", name) != crn {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Invalid name")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "invalid name")
 	}
 	if strings.Contains(name, ".") {
 		return k.ProcessReserveSubAuthority(ctx, name, msg)
@ -450,20 +451,20 @@ func (k Keeper) ProcessSetAuthorityBond(ctx sdk.Context, msg types.MsgSetAuthori
 	name := msg.GetName()
 	signer := msg.GetSigner()
 	if !k.HasNameAuthority(ctx, name) {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Name authority not found.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "name authority not found")
 	}
 	authority := k.GetNameAuthority(ctx, name)
 	if authority.OwnerAddress != signer {
-		return sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "Access denied")
+		return errors.Wrap(sdkerrors.ErrUnauthorized, "access denied")
 	}

 	if !k.bondKeeper.HasBond(ctx, msg.BondId) {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Bond not found.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "bond not found")
 	}
 	//
 	bond := k.bondKeeper.GetBond(ctx, msg.BondId)
 	if bond.Owner != signer {
-		return sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "Bond owner mismatch.")
+		return errors.Wrap(sdkerrors.ErrUnauthorized, "bond owner mismatch")
 	}

 	// No-op if bond hasn't changed.
@ -496,7 +497,7 @@ func (k Keeper) ProcessDeleteName(ctx sdk.Context, msg types.MsgDeleteNameAuthor
 	}

 	if !k.HasNameRecord(ctx, msg.Crn) {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Name not found.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "name not found")
 	}

 	// Set CID to empty string.
--- a/x/registry/keeper/record_keeper.go
+++ b/x/registry/keeper/record_keeper.go
@ -4,6 +4,7 @@ import (
 	"fmt"
 	"time"

+	"cosmossdk.io/errors"
 	auctionkeeper "github.com/cerc-io/laconicd/x/auction/keeper"
 	auctiontypes "github.com/cerc-io/laconicd/x/auction/types"
 	bondtypes "github.com/cerc-io/laconicd/x/bond/types"
@ -158,7 +159,7 @@ func (k RecordKeeper) QueryRecordsByBond(ctx sdk.Context, bondID string) []types
 // ProcessRenewRecord renews a record.
 func (k Keeper) ProcessRenewRecord(ctx sdk.Context, msg types.MsgRenewRecord) error {
 	if !k.HasRecord(ctx, msg.RecordId) {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Record not found.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "record not found")
 	}

 	// Check if renewal is required (i.e. expired record marked as deleted).
@ -169,7 +170,7 @@ func (k Keeper) ProcessRenewRecord(ctx sdk.Context, msg types.MsgRenewRecord) er
 	}

 	if !record.Deleted || expiryTime.After(ctx.BlockTime()) {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Renewal not required.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "renewal not required")
 	}

 	recordType := record.ToRecordType()
@ -184,23 +185,23 @@ func (k Keeper) ProcessRenewRecord(ctx sdk.Context, msg types.MsgRenewRecord) er
 // ProcessAssociateBond associates a record with a bond.
 func (k Keeper) ProcessAssociateBond(ctx sdk.Context, msg types.MsgAssociateBond) error {
 	if !k.HasRecord(ctx, msg.RecordId) {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Record not found.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "record not found")
 	}

 	if !k.bondKeeper.HasBond(ctx, msg.BondId) {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Bond not found.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "bond not found")
 	}

 	// Check if already associated with a bond.
 	record := k.GetRecord(ctx, msg.RecordId)
 	if record.BondId != "" || len(record.BondId) != 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "Bond already exists.")
+		return errors.Wrap(sdkerrors.ErrUnauthorized, "bond already exists")
 	}

 	// Only the bond owner can associate a record with the bond.
 	bond := k.bondKeeper.GetBond(ctx, msg.BondId)
 	if msg.Signer != bond.Owner {
-		return sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "Bond owner mismatch.")
+		return errors.Wrap(sdkerrors.ErrUnauthorized, "bond owner mismatch")
 	}

 	record.BondId = msg.BondId
@ -218,20 +219,20 @@ func (k Keeper) ProcessAssociateBond(ctx sdk.Context, msg types.MsgAssociateBond
 // ProcessDissociateBond dissociates a record from its bond.
 func (k Keeper) ProcessDissociateBond(ctx sdk.Context, msg types.MsgDissociateBond) error {
 	if !k.HasRecord(ctx, msg.RecordId) {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Record not found.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "record not found")
 	}

 	// Check if associated with a bond.
 	record := k.GetRecord(ctx, msg.RecordId)
 	bondID := record.BondId
 	if bondID == "" || len(bondID) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "Bond not found.")
+		return errors.Wrap(sdkerrors.ErrUnauthorized, "bond not found")
 	}

 	// Only the bond owner can dissociate a record from the bond.
 	bond := k.bondKeeper.GetBond(ctx, bondID)
 	if msg.Signer != bond.Owner {
-		return sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "Bond owner mismatch.")
+		return errors.Wrap(sdkerrors.ErrUnauthorized, "bond owner mismatch")
 	}

 	// Clear bond ID.
@ -245,13 +246,13 @@ func (k Keeper) ProcessDissociateBond(ctx sdk.Context, msg types.MsgDissociateBo
 // ProcessDissociateRecords dissociates all records associated with a given bond.
 func (k Keeper) ProcessDissociateRecords(ctx sdk.Context, msg types.MsgDissociateRecords) error {
 	if !k.bondKeeper.HasBond(ctx, msg.BondId) {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Bond not found.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "bond not found")
 	}

 	// Only the bond owner can dissociate all records from the bond.
 	bond := k.bondKeeper.GetBond(ctx, msg.BondId)
 	if msg.Signer != bond.Owner {
-		return sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "Bond owner mismatch.")
+		return errors.Wrap(sdkerrors.ErrUnauthorized, "bond owner mismatch")
 	}

 	// Dissociate all records from the bond.
@ -269,22 +270,22 @@ func (k Keeper) ProcessDissociateRecords(ctx sdk.Context, msg types.MsgDissociat
 // ProcessReAssociateRecords switches records from and old to new bond.
 func (k Keeper) ProcessReAssociateRecords(ctx sdk.Context, msg types.MsgReAssociateRecords) error {
 	if !k.bondKeeper.HasBond(ctx, msg.OldBondId) {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Old bond not found.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "old bond not found")
 	}

 	if !k.bondKeeper.HasBond(ctx, msg.NewBondId) {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "New bond not found.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "new bond not found")
 	}

 	// Only the bond owner can re-associate all records.
 	oldBond := k.bondKeeper.GetBond(ctx, msg.OldBondId)
 	if msg.Signer != oldBond.Owner {
-		return sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "Old bond owner mismatch.")
+		return errors.Wrap(sdkerrors.ErrUnauthorized, "old bond owner mismatch")
 	}

 	newBond := k.bondKeeper.GetBond(ctx, msg.NewBondId)
 	if msg.Signer != newBond.Owner {
-		return sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "New bond owner mismatch.")
+		return errors.Wrap(sdkerrors.ErrUnauthorized, "new bond owner mismatch")
 	}

 	// Re-associate all records.
--- a/x/registry/types/msg.go
+++ b/x/registry/types/msg.go
@ -3,6 +3,7 @@ package types
 import (
 	"net/url"

+	"cosmossdk.io/errors"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 )
@ -32,15 +33,15 @@ func (msg MsgSetName) Type() string { return "set-name" }
 // ValidateBasic Implements Msg.
 func (msg MsgSetName) ValidateBasic() error {
 	if msg.Crn == "" {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "CRN is required.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "crn is required")
 	}

 	if msg.Cid == "" {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "CID is required.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "cid is required")
 	}

 	if len(msg.Signer) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer")
+		return errors.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer")
 	}

 	return nil
@ -76,11 +77,11 @@ func (msg MsgReserveAuthority) Type() string { return "reserve-authority" }
 // ValidateBasic Implements Msg.
 func (msg MsgReserveAuthority) ValidateBasic() error {
 	if len(msg.Name) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "name is required.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "name is required")
 	}

 	if len(msg.Signer) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer")
+		return errors.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer")
 	}

 	return nil
@ -116,15 +117,15 @@ func (msg MsgSetAuthorityBond) Type() string { return "authority-bond" }
 // ValidateBasic Implements Msg.
 func (msg MsgSetAuthorityBond) ValidateBasic() error {
 	if len(msg.Name) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "name is required.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "name is required")
 	}

 	if len(msg.Signer) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer.")
+		return errors.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer")
 	}

 	if len(msg.BondId) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "bond id is required.")
+		return errors.Wrap(sdkerrors.ErrInvalidAddress, "bond id is required")
 	}

 	return nil
@ -159,16 +160,16 @@ func (msg MsgDeleteNameAuthority) Type() string { return "delete-name" }
 // ValidateBasic Implements Msg.
 func (msg MsgDeleteNameAuthority) ValidateBasic() error {
 	if len(msg.Crn) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "crn is required.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "crn is required")
 	}

 	if len(msg.Signer) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer.")
+		return errors.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer")
 	}

 	_, err := url.Parse(msg.Crn)
 	if err != nil {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "invalid crn.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "invalid crn")
 	}

 	return nil
--- a/x/registry/types/record_msg.go
+++ b/x/registry/types/record_msg.go
@ -1,6 +1,7 @@
 package types

 import (
+	"cosmossdk.io/errors"
 	cdctypes "github.com/cosmos/cosmos-sdk/codec/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
@ -34,17 +35,17 @@ func (msg MsgSetRecord) Type() string { return "set-record" }

 func (msg MsgSetRecord) ValidateBasic() error {
 	if len(msg.Signer) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, msg.Signer)
+		return errors.Wrap(sdkerrors.ErrInvalidAddress, msg.Signer)
 	}
 	owners := msg.Payload.Record.Owners
 	for _, owner := range owners {
 		if owner == "" {
-			return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "Record owner not set.")
+			return errors.Wrap(sdkerrors.ErrInvalidRequest, "record owner not set")
 		}
 	}

 	if len(msg.BondId) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "Bond ID is required.")
+		return errors.Wrap(sdkerrors.ErrUnauthorized, "bond ID is required")
 	}
 	return nil
 }
@ -83,11 +84,11 @@ func (msg MsgRenewRecord) Type() string { return "renew-record" }
 // ValidateBasic Implements Msg.
 func (msg MsgRenewRecord) ValidateBasic() error {
 	if len(msg.RecordId) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "record id is required.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "record id is required")
 	}

 	if len(msg.Signer) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer.")
+		return errors.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer")
 	}

 	return nil
@ -123,13 +124,13 @@ func (msg MsgAssociateBond) Type() string { return "associate-bond" }
 // ValidateBasic Implements Msg.
 func (msg MsgAssociateBond) ValidateBasic() error {
 	if len(msg.RecordId) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "record id is required.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "record id is required")
 	}
 	if len(msg.BondId) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "bond id is required.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "bond id is required")
 	}
 	if len(msg.Signer) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer.")
+		return errors.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer")
 	}

 	return nil
@ -164,10 +165,10 @@ func (msg MsgDissociateBond) Type() string { return "dissociate-bond" }
 // ValidateBasic Implements Msg.
 func (msg MsgDissociateBond) ValidateBasic() error {
 	if len(msg.RecordId) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "record id is required.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "record id is required")
 	}
 	if len(msg.Signer) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer.")
+		return errors.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer")
 	}

 	return nil
@ -202,10 +203,10 @@ func (msg MsgDissociateRecords) Type() string { return "dissociate-records" }
 // ValidateBasic Implements Msg.
 func (msg MsgDissociateRecords) ValidateBasic() error {
 	if len(msg.BondId) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "bond id is required.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "bond id is required")
 	}
 	if len(msg.Signer) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer.")
+		return errors.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer")
 	}

 	return nil
@ -241,13 +242,13 @@ func (msg MsgReAssociateRecords) Type() string { return "reassociate-records" }
 // ValidateBasic Implements Msg.
 func (msg MsgReAssociateRecords) ValidateBasic() error {
 	if len(msg.OldBondId) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "old-bond-id is required.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "old-bond-id is required")
 	}
 	if len(msg.NewBondId) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "new-bond-id is required.")
+		return errors.Wrap(sdkerrors.ErrInvalidRequest, "new-bond-id is required")
 	}
 	if len(msg.Signer) == 0 {
-		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer.")
+		return errors.Wrap(sdkerrors.ErrInvalidAddress, "invalid signer")
 	}

 	return nil
Author	SHA1	Message	Date
aleem1314	8a575110bf	chore: fix error message	2023-03-14 12:00:29 +05:30
aleem1314	c72302d078	wip: fix lint errors	2023-03-14 11:50:50 +05:30
aleem1314	ddd01ccd8a	wip: fix lint	2023-03-14 11:29:38 +05:30
aleem1314	4b71df048e	chore: fix lint errors	2023-03-14 11:05:23 +05:30