Merge pull request #436 from AssetMantle/deepanshutr/chore

Deepanshutr/chore

helpers/base/error.go

@@ -0,0 +1,12 @@
+package base
+
+import (
+	"github.com/AssetMantle/modules/helpers"
+	sdkErrors "github.com/cosmos/cosmos-sdk/types/errors"
+)
+
+var _ helpers.Error = (*sdkErrors.Error)(nil)
+
+func NewError(codeSpace string, code uint32, description string) helpers.Error {
+	return sdkErrors.Register(codeSpace, code, description)
+}

helpers/base/module.go

@@ -8,7 +8,6 @@ import (
 	"fmt"
 	"math/rand"
 
-	errorConstants "github.com/AssetMantle/schema/go/errors/constants"
 	"github.com/cosmos/cosmos-sdk/client"
 	sdkCodec "github.com/cosmos/cosmos-sdk/codec"
 	"github.com/cosmos/cosmos-sdk/codec/types"
@@ -153,15 +152,15 @@ func (module module) RegisterInvariants(invariantRegistry sdkTypes.InvariantRegi
 func (module module) Route() sdkTypes.Route {
 	return sdkTypes.NewRoute(module.Name(), func(context sdkTypes.Context, msg sdkTypes.Msg) (*sdkTypes.Result, error) {
 		if module.transactions == nil {
-			panic(errorConstants.UninitializedUsage.Wrapf("transactions for module %s not initialized", module.Name()))
+			panic(fmt.Errorf("transactions for module %s not initialized", module.Name()))
 		}
 
 		if message, ok := msg.(helpers.Message); ok {
 			if transaction := module.transactions.GetTransaction(message.Type()); transaction != nil {
 				return transaction.HandleMessage(sdkTypes.WrapSDKContext(context.WithEventManager(sdkTypes.NewEventManager())), message)
 			}
 		}
-		return nil, errorConstants.InvalidMessage.Wrapf("message type %T is not supported by module %s", msg, module.Name())
+		return nil, fmt.Errorf("message type %T is not supported by module %s", msg, module.Name())
 	})
 }
 func (module module) QuerierRoute() string {
@@ -170,7 +169,7 @@ func (module module) QuerierRoute() string {
 func (module module) LegacyQuerierHandler(_ *sdkCodec.LegacyAmino) sdkTypes.Querier {
 	return func(context sdkTypes.Context, path []string, requestQuery abciTypes.RequestQuery) ([]byte, error) {
 		if module.queries == nil {
-			panic(errorConstants.UninitializedUsage.Wrapf("queries for module %s not initialized", module.Name()))
+			panic(fmt.Errorf("queries for module %s not initialized", module.Name()))
 		}
 
 		if query := module.queries.GetQuery(path[0]); query != nil {
@@ -200,7 +199,7 @@ func (module module) InitGenesis(context sdkTypes.Context, jsonCodec sdkCodec.JS
 	genesisState := module.genesisPrototype().Decode(jsonCodec, rawMessage)
 
 	if module.mapper == nil || module.parameterManager == nil {
-		panic(errorConstants.UninitializedUsage.Wrapf("mapper or parameter manager for module %s not initialized", module.Name()))
+		panic(fmt.Errorf("mapper or parameter manager for module %s not initialized", module.Name()))
 	}
 
 	genesisState.Import(sdkTypes.WrapSDKContext(context), module.mapper, module.parameterManager)
@@ -209,7 +208,7 @@ func (module module) InitGenesis(context sdkTypes.Context, jsonCodec sdkCodec.JS
 }
 func (module module) ExportGenesis(context sdkTypes.Context, jsonCodec sdkCodec.JSONCodec) json.RawMessage {
 	if module.mapper == nil || module.parameterManager == nil {
-		panic(errorConstants.UninitializedUsage.Wrapf("mapper or parameter manager for module %s not initialized", module.Name()))
+		panic(fmt.Errorf("mapper or parameter manager for module %s not initialized", module.Name()))
 	}
 
 	return module.genesisPrototype().Export(sdkTypes.WrapSDKContext(context), module.mapper, module.parameterManager).Encode(jsonCodec)
@@ -235,7 +234,7 @@ func (module module) DecodeModuleTransactionRequest(transactionName string, rawM
 		return transaction.DecodeTransactionRequest(rawMessage)
 	}
 
-	return nil, errorConstants.InvalidMessage.Wrapf("transaction %s is not supported by module %s", transactionName, module.Name())
+	return nil, fmt.Errorf("transaction %s is not supported by module %s", transactionName, module.Name())
 }
 func (module module) Initialize(kvStoreKey *sdkTypes.KVStoreKey, paramsSubspace paramsTypes.Subspace, auxiliaryKeepers ...interface{}) helpers.Module {
 	module.mapper = module.mapperPrototype().Initialize(kvStoreKey)

helpers/base/parameter_manager.go

@@ -7,7 +7,6 @@ import (
 	"fmt"
 	"net/http"
 
-	errorConstants "github.com/AssetMantle/schema/go/errors/constants"
 	"github.com/AssetMantle/schema/go/ids"
 	"github.com/AssetMantle/schema/go/lists"
 	baseLists "github.com/AssetMantle/schema/go/lists/base"
@@ -51,15 +50,15 @@ func (parameterManager parameterManager) GetValidatableParameter(propertyID ids.
 	return nil
 }
 func (parameterManager parameterManager) ValidateParameter(parameter parameters.Parameter) error {
-	validator := parameterManager.GetValidatableParameter(parameter.GetMetaProperty().GetID())
-	if validator != nil {
+	if validator := parameterManager.GetValidatableParameter(parameter.GetMetaProperty().GetID()); validator != nil {
 		if err := parameter.ValidateBasic(); err != nil {
 			return err
 		}
 
 		return validator.GetValidator()(parameter.GetMetaProperty().GetData().Get().AsString())
 	}
-	return errorConstants.EntityNotFound.Wrapf("parameter with id %s not found", parameter.GetMetaProperty().GetID().AsString())
+
+	return fmt.Errorf("validator not found for parameter %s", parameter.GetMetaProperty().GetID().AsString())
 }
 func (parameterManager parameterManager) Fetch(context context.Context) helpers.ParameterManager {
 	for _, validatableParameter := range parameterManager.validatableParameters {

helpers/base/query.go

@@ -4,9 +4,9 @@
 package base
 
 import (
+	"fmt"
 	"net/http"
 
-	errorConstants "github.com/AssetMantle/schema/go/errors/constants"
 	"github.com/cosmos/cosmos-sdk/client"
 	sdkModuleTypes "github.com/cosmos/cosmos-sdk/types/module"
 	"github.com/cosmos/cosmos-sdk/types/rest"
@@ -35,7 +35,7 @@ var _ helpers.Query = (*query)(nil)
 
 func (query query) RegisterService(configurator sdkModuleTypes.Configurator) {
 	if query.queryKeeper == nil {
-		panic(errorConstants.UninitializedUsage.Wrapf("query keeper for query %s not initialized", query.name))
+		panic(fmt.Errorf("query keeper for query %s not initialized", query.name))
 	}
 	query.serviceRegistrar(configurator.QueryServer(), query.queryKeeper)
 }

helpers/base/transaction.go

@@ -6,12 +6,9 @@ package base
 import (
 	"context"
 	"encoding/json"
-	"github.com/AssetMantle/modules/utilities/rest/queuing"
-	"net/http"
-	"reflect"
-
+	"fmt"
 	"github.com/AssetMantle/modules/helpers"
-	errorConstants "github.com/AssetMantle/schema/go/errors/constants"
+	"github.com/AssetMantle/modules/utilities/rest/queuing"
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/tx"
 	sdkCodec "github.com/cosmos/cosmos-sdk/codec"
@@ -22,6 +19,8 @@ import (
 	"github.com/gogo/protobuf/grpc"
 	"github.com/grpc-ecosystem/grpc-gateway/runtime"
 	"github.com/spf13/cobra"
+	"net/http"
+	"reflect"
 )
 
 type transaction struct {
@@ -40,12 +39,12 @@ var _ helpers.Transaction = (*transaction)(nil)
 func (transaction transaction) GetName() string { return transaction.name }
 func (transaction transaction) Command() *cobra.Command {
 	runE := func(command *cobra.Command, args []string) error {
-		context, err := client.GetClientTxContext(command)
+		Context, err := client.GetClientTxContext(command)
 		if err != nil {
 			return err
 		}
 
-		transactionRequest, err := transaction.requestPrototype().FromCLI(transaction.cliCommand, context)
+		transactionRequest, err := transaction.requestPrototype().FromCLI(transaction.cliCommand, Context)
 		if err != nil {
 			return err
 		}
@@ -63,7 +62,7 @@ func (transaction transaction) Command() *cobra.Command {
 			return err
 		}
 
-		return tx.GenerateOrBroadcastTxCLI(context, command.Flags(), msg)
+		return tx.GenerateOrBroadcastTxCLI(Context, command.Flags(), msg)
 	}
 
 	return transaction.cliCommand.CreateCommand(runE)
@@ -81,15 +80,15 @@ func (transaction transaction) RESTRequestHandler(context client.Context) http.H
 		if !rest.ReadRESTReq(responseWriter, httpRequest, context.LegacyAmino, &transactionRequest) {
 			return
 		} else if reflect.TypeOf(transaction.requestPrototype()) != reflect.TypeOf(transactionRequest) {
-			rest.CheckBadRequestError(responseWriter, errorConstants.InvalidRequest.Wrapf("expected %s, got %s", reflect.TypeOf(transaction.requestPrototype()), reflect.TypeOf(transactionRequest)))
+			rest.CheckBadRequestError(responseWriter, fmt.Errorf("expected %s, got %s", reflect.TypeOf(transaction.requestPrototype()), reflect.TypeOf(transactionRequest)))
 			return
 		} else if rest.CheckBadRequestError(responseWriter, transactionRequest.Validate()) {
 			return
 		}
 
 		baseReq := transactionRequest.GetBaseReq().Sanitize()
 		if !baseReq.ValidateBasic(responseWriter) {
-			rest.CheckBadRequestError(responseWriter, errorConstants.InvalidRequest.Wrapf("invalid base request"))
+			rest.CheckBadRequestError(responseWriter, fmt.Errorf("invalid base request"))
 		}
 
 		msg, err := transactionRequest.MakeMsg()
@@ -112,7 +111,7 @@ func (transaction transaction) RegisterInterfaces(interfaceRegistry codecTypes.I
 }
 func (transaction transaction) RegisterService(configurator sdkModuleTypes.Configurator) {
 	if transaction.keeper == nil {
-		panic(errorConstants.UninitializedUsage.Wrapf("keeper for transaction %s is not initialized", transaction.name))
+		panic(fmt.Errorf("keeper for transaction %s is not initialized", transaction.name))
 	}
 	transaction.serviceRegistrar(configurator.MsgServer(), transaction.keeper)
 }

helpers/constants/errors.go

@@ -0,0 +1,25 @@
+// Copyright [2021] - [2022], AssetMantle Pte. Ltd. and the code contributors
+// SPDX-License-Identifier: Apache-2.0
+
+package constants
+
+import (
+	"github.com/AssetMantle/modules/helpers/base"
+)
+
+const projectRoute = "/AssetMantle"
+
+var (
+	MockError           = base.NewError(projectRoute, 100, "mock error")
+	EntityAlreadyExists = base.NewError(projectRoute, 102, "entity already exists")
+	EntityNotFound      = base.NewError(projectRoute, 103, "entity not found")
+	IncorrectFormat     = base.NewError(projectRoute, 104, "incorrect format")
+	InvalidMessage      = base.NewError(projectRoute, 105, "invalid message")
+	InsufficientBalance = base.NewError(projectRoute, 106, "insufficient balance")
+	InvalidParameter    = base.NewError(projectRoute, 107, "invalid parameter")
+	InvalidRequest      = base.NewError(projectRoute, 108, "invalid request")
+	MetaDataError       = base.NewError(projectRoute, 109, "meta data error")
+	NotAuthorized       = base.NewError(projectRoute, 110, "not authorized")
+	UninitializedUsage  = base.NewError(projectRoute, 111, "uninitialized usage")
+	InvalidKey          = base.NewError(projectRoute, 112, "invalid key")
+)

helpers/constants/queryRequest.go

@@ -0,0 +1,3 @@
+package constants
+
+const PaginationLimit = 100

helpers/error.go

@@ -0,0 +1,7 @@
+package helpers
+
+type Error interface {
+	Wrapf(string, ...interface{}) error
+	Is(error) bool
+	error
+}

helpers/key.go

@@ -5,6 +5,7 @@ package helpers
 
 // Key SHOULD be derivable from the object it is referencing and SHOULD not be totally arbitrary or sequential
 type Key interface {
+	ValidateBasic() error
 	GenerateStorePrefixBytes() []byte
 	GenerateStoreKeyBytes() []byte
 	GeneratePrefixedStoreKeyBytes() []byte

helpers/legacy_codec.go

@@ -9,4 +9,7 @@ func RegisterLegacyAminoCodec(legacyAmino *codec.LegacyAmino) {
 	legacyAmino.RegisterInterface((*QueryResponse)(nil), nil)
 	legacyAmino.RegisterInterface((*QueryRequest)(nil), nil)
 	legacyAmino.RegisterInterface((*TransactionRequest)(nil), nil)
+	legacyAmino.RegisterInterface((*Request)(nil), nil)
+	legacyAmino.RegisterInterface((*Error)(nil), nil)
+	legacyAmino.RegisterInterface((*error)(nil), nil)
 }

utilities/rest/id_getters/docs/identity.go

@@ -1,11 +1,11 @@
 package docs
 
 import (
+	"fmt"
 	"net/http"
 
 	baseData "github.com/AssetMantle/schema/go/data/base"
 	baseDocuments "github.com/AssetMantle/schema/go/documents/base"
-	errorConstants "github.com/AssetMantle/schema/go/errors/constants"
 	baseIDs "github.com/AssetMantle/schema/go/ids/base"
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/types/rest"
@@ -15,11 +15,11 @@ func nameIdentityIDHandler(context client.Context) http.HandlerFunc {
 	return func(responseWriter http.ResponseWriter, httpRequest *http.Request) {
 		transactionRequest := Prototype()
 		if !rest.ReadRESTReq(responseWriter, httpRequest, context.LegacyAmino, &transactionRequest) {
-			panic(errorConstants.IncorrectFormat)
+			panic(fmt.Errorf("failed to read request"))
 		}
 
 		if rest.CheckBadRequestError(responseWriter, transactionRequest.Validate()) {
-			panic(errorConstants.IncorrectFormat)
+			panic(fmt.Errorf("failed to validate request"))
 		}
 
 		rest.PostProcessResponse(responseWriter, context, newResponse(baseDocuments.NewNameIdentity(baseIDs.NewStringID(transactionRequest.(request).Name), baseData.PrototypeListData()).GetNameIdentityID().AsString(), nil))

utilities/rest/id_getters/docs/request.go

@@ -4,12 +4,6 @@
 package docs
 
 import (
-	"encoding/json"
-
-	"github.com/asaskevich/govalidator"
-	"github.com/cosmos/cosmos-sdk/client"
-	"github.com/cosmos/cosmos-sdk/codec"
-	sdkTypes "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/rest"
 
 	"github.com/AssetMantle/modules/helpers"
@@ -34,37 +28,16 @@ type request struct {
 	Coins                   string       `json:"coins" valid:"optional"`
 }
 
-var _ helpers.TransactionRequest = &request{}
-
-func (request request) FromCLI(command helpers.CLICommand, context client.Context) (helpers.TransactionRequest, error) {
-	// TODO implement me
-	panic("implement me")
-}
-
-func (request) RegisterLegacyAminoCodec(legacyAmino *codec.LegacyAmino) {
-	// TODO implement me
-	panic("implement me")
-}
-
-func (request request) FromJSON(message json.RawMessage) (helpers.TransactionRequest, error) {
-	// TODO implement me
-	panic("implement me")
-}
-
-func (request request) MakeMsg() (sdkTypes.Msg, error) {
-	// TODO implement me
-	panic("implement me")
-}
+var _ helpers.Request = &request{}
 
 func (request request) Validate() error {
-	_, err := govalidator.ValidateStruct(request)
-	return err
+	return nil
 }
 
 func (request request) GetBaseReq() rest.BaseReq {
 	return request.BaseReq
 }
 
-func Prototype() helpers.TransactionRequest {
+func Prototype() helpers.Request {
 	return request{}
 }

utilities/rest/id_getters/docs/split.go

@@ -1,26 +1,25 @@
 package docs
 
 import (
-	"net/http"
-
+	"fmt"
 	baseDocuments "github.com/AssetMantle/schema/go/documents/base"
-	errorConstants "github.com/AssetMantle/schema/go/errors/constants"
 	"github.com/AssetMantle/schema/go/ids"
 	baseIDs "github.com/AssetMantle/schema/go/ids/base"
 	"github.com/cosmos/cosmos-sdk/client"
 	sdkTypes "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/rest"
+	"net/http"
 )
 
 func splitIDHandler(context client.Context) http.HandlerFunc {
 	return func(responseWriter http.ResponseWriter, httpRequest *http.Request) {
 		transactionRequest := Prototype()
 		if !rest.ReadRESTReq(responseWriter, httpRequest, context.LegacyAmino, &transactionRequest) {
-			panic(errorConstants.IncorrectFormat)
+			panic(fmt.Errorf("failed to read request"))
 		}
 
 		if rest.CheckBadRequestError(responseWriter, transactionRequest.Validate()) {
-			panic(errorConstants.IncorrectFormat)
+			panic(fmt.Errorf("failed to validate request"))
 		}
 
 		req := transactionRequest.(request)

utilities/wasm/custom_encoder.go

@@ -5,9 +5,9 @@ package wasm
 
 import (
 	"encoding/json"
+	errorConstants "github.com/AssetMantle/modules/helpers/constants"
 	"strings"
 
-	errorConstants "github.com/AssetMantle/schema/go/errors/constants"
 	"github.com/CosmWasm/wasmd/x/wasm"
 	sdkTypes "github.com/cosmos/cosmos-sdk/types"
 

x/assets/genesis/genesis.go

@@ -2,8 +2,8 @@ package genesis
 
 import (
 	"context"
+	errorConstants "github.com/AssetMantle/modules/helpers/constants"
 
-	errorConstants "github.com/AssetMantle/schema/go/errors/constants"
 	"github.com/AssetMantle/schema/go/lists"
 	"github.com/AssetMantle/schema/go/lists/base"
 	sdkCodec "github.com/cosmos/cosmos-sdk/codec"
@@ -34,11 +34,11 @@ func (genesis *Genesis) ValidateBasic(parameterManager helpers.ParameterManager)
 		}
 
 		if !isPresent {
-			return errorConstants.IncorrectFormat.Wrapf("expected parameter %s not found", parameter.GetMetaProperty().GetKey().AsString())
+			return errorConstants.EntityNotFound.Wrapf("expected parameter %s not found", parameter.GetMetaProperty().GetKey().AsString())
 		}
 
 		if err := parameterManager.ValidateParameter(parameter); err != nil {
-			return err
+			return errorConstants.InvalidParameter.Wrapf("parameter %s: %s", parameter.GetMetaProperty().GetKey().AsString(), err.Error())
 		}
 	}