diff --git a/baseapp/abci.go b/baseapp/abci.go index 62b3fad846..4ec863cc0e 100644 --- a/baseapp/abci.go +++ b/baseapp/abci.go @@ -16,6 +16,7 @@ import ( "google.golang.org/grpc/codes" grpcstatus "google.golang.org/grpc/status" + errorsmod "cosmossdk.io/errors" snapshottypes "cosmossdk.io/store/snapshots/types" storetypes "cosmossdk.io/store/types" @@ -507,7 +508,7 @@ func (app *BaseApp) Query(req abci.RequestQuery) (res abci.ResponseQuery) { // ref: https://github.com/cosmos/cosmos-sdk/pull/8039 defer func() { if r := recover(); r != nil { - res = sdkerrors.QueryResult(sdkerrors.Wrapf(sdkerrors.ErrPanic, "%v", r), app.trace) + res = sdkerrors.QueryResult(errorsmod.Wrapf(sdkerrors.ErrPanic, "%v", r), app.trace) } }() @@ -521,7 +522,7 @@ func (app *BaseApp) Query(req abci.RequestQuery) (res abci.ResponseQuery) { defer telemetry.MeasureSince(time.Now(), req.Path) if req.Path == "/cosmos.tx.v1beta1.Service/BroadcastTx" { - return sdkerrors.QueryResult(sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "can't route a broadcast tx message"), app.trace) + return sdkerrors.QueryResult(errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "can't route a broadcast tx message"), app.trace) } // handle gRPC routes first rather than calling splitPath because '/' characters @@ -532,7 +533,7 @@ func (app *BaseApp) Query(req abci.RequestQuery) (res abci.ResponseQuery) { path := SplitABCIQueryPath(req.Path) if len(path) == 0 { - return sdkerrors.QueryResult(sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, "no query path provided"), app.trace) + return sdkerrors.QueryResult(errorsmod.Wrap(sdkerrors.ErrUnknownRequest, "no query path provided"), app.trace) } switch path[0] { @@ -547,7 +548,7 @@ func (app *BaseApp) Query(req abci.RequestQuery) (res abci.ResponseQuery) { return handleQueryP2P(app, path) } - return sdkerrors.QueryResult(sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, "unknown query path"), app.trace) + return sdkerrors.QueryResult(errorsmod.Wrap(sdkerrors.ErrUnknownRequest, "unknown query path"), app.trace) } // ListSnapshots implements the ABCI interface. It delegates to app.snapshotManager if set. @@ -693,27 +694,27 @@ func (app *BaseApp) handleQueryGRPC(handler GRPCQueryHandler, req abci.RequestQu func gRPCErrorToSDKError(err error) error { status, ok := grpcstatus.FromError(err) if !ok { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, err.Error()) + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, err.Error()) } switch status.Code() { case codes.NotFound: - return sdkerrors.Wrap(sdkerrors.ErrKeyNotFound, err.Error()) + return errorsmod.Wrap(sdkerrors.ErrKeyNotFound, err.Error()) case codes.InvalidArgument: - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, err.Error()) + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, err.Error()) case codes.FailedPrecondition: - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, err.Error()) + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, err.Error()) case codes.Unauthenticated: - return sdkerrors.Wrap(sdkerrors.ErrUnauthorized, err.Error()) + return errorsmod.Wrap(sdkerrors.ErrUnauthorized, err.Error()) default: - return sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, err.Error()) + return errorsmod.Wrap(sdkerrors.ErrUnknownRequest, err.Error()) } } func checkNegativeHeight(height int64) error { if height < 0 { // Reject invalid heights. - return sdkerrors.Wrap( + return errorsmod.Wrap( sdkerrors.ErrInvalidRequest, "cannot query with height < 0; please provide a valid height", ) @@ -736,12 +737,12 @@ func (app *BaseApp) CreateQueryContext(height int64, prove bool) (sdk.Context, e lastBlockHeight := qms.LatestVersion() if lastBlockHeight == 0 { - return sdk.Context{}, sdkerrors.Wrapf(sdkerrors.ErrInvalidHeight, "%s is not ready; please wait for first block", app.Name()) + return sdk.Context{}, errorsmod.Wrapf(sdkerrors.ErrInvalidHeight, "%s is not ready; please wait for first block", app.Name()) } if height > lastBlockHeight { return sdk.Context{}, - sdkerrors.Wrap( + errorsmod.Wrap( sdkerrors.ErrInvalidHeight, "cannot query with height in the future; please provide a valid height", ) @@ -754,7 +755,7 @@ func (app *BaseApp) CreateQueryContext(height int64, prove bool) (sdk.Context, e if height <= 1 && prove { return sdk.Context{}, - sdkerrors.Wrap( + errorsmod.Wrap( sdkerrors.ErrInvalidRequest, "cannot query with proof when height <= 1; please provide a valid height", ) @@ -763,7 +764,7 @@ func (app *BaseApp) CreateQueryContext(height int64, prove bool) (sdk.Context, e cacheMS, err := qms.CacheMultiStoreWithVersion(height) if err != nil { return sdk.Context{}, - sdkerrors.Wrapf( + errorsmod.Wrapf( sdkerrors.ErrInvalidRequest, "failed to load state at height %d; %s (latest height: %d)", height, err, lastBlockHeight, ) @@ -858,7 +859,7 @@ func handleQueryApp(app *BaseApp, path []string, req abci.RequestQuery) abci.Res gInfo, res, err := app.Simulate(txBytes) if err != nil { - return sdkerrors.QueryResult(sdkerrors.Wrap(err, "failed to simulate tx"), app.trace) + return sdkerrors.QueryResult(errorsmod.Wrap(err, "failed to simulate tx"), app.trace) } simRes := &sdk.SimulationResponse{ @@ -868,7 +869,7 @@ func handleQueryApp(app *BaseApp, path []string, req abci.RequestQuery) abci.Res bz, err := codec.ProtoMarshalJSON(simRes, app.interfaceRegistry) if err != nil { - return sdkerrors.QueryResult(sdkerrors.Wrap(err, "failed to JSON encode simulation response"), app.trace) + return sdkerrors.QueryResult(errorsmod.Wrap(err, "failed to JSON encode simulation response"), app.trace) } return abci.ResponseQuery{ @@ -885,12 +886,12 @@ func handleQueryApp(app *BaseApp, path []string, req abci.RequestQuery) abci.Res } default: - return sdkerrors.QueryResult(sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "unknown query: %s", path), app.trace) + return sdkerrors.QueryResult(errorsmod.Wrapf(sdkerrors.ErrUnknownRequest, "unknown query: %s", path), app.trace) } } return sdkerrors.QueryResult( - sdkerrors.Wrap( + errorsmod.Wrap( sdkerrors.ErrUnknownRequest, "expected second parameter to be either 'simulate' or 'version', neither was present", ), app.trace) @@ -900,14 +901,14 @@ func handleQueryStore(app *BaseApp, path []string, req abci.RequestQuery) abci.R // "/store" prefix for store queries queryable, ok := app.cms.(storetypes.Queryable) if !ok { - return sdkerrors.QueryResult(sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, "multistore doesn't support queries"), app.trace) + return sdkerrors.QueryResult(errorsmod.Wrap(sdkerrors.ErrUnknownRequest, "multistore doesn't support queries"), app.trace) } req.Path = "/" + strings.Join(path[1:], "/") if req.Height <= 1 && req.Prove { return sdkerrors.QueryResult( - sdkerrors.Wrap( + errorsmod.Wrap( sdkerrors.ErrInvalidRequest, "cannot query with proof when height <= 1; please provide a valid height", ), app.trace) @@ -923,7 +924,7 @@ func handleQueryP2P(app *BaseApp, path []string) abci.ResponseQuery { // "/p2p" prefix for p2p queries if len(path) < 4 { return sdkerrors.QueryResult( - sdkerrors.Wrap( + errorsmod.Wrap( sdkerrors.ErrUnknownRequest, "path should be p2p filter ", ), app.trace) } @@ -942,7 +943,7 @@ func handleQueryP2P(app *BaseApp, path []string) abci.ResponseQuery { } default: - resp = sdkerrors.QueryResult(sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, "expected second parameter to be 'filter'"), app.trace) + resp = sdkerrors.QueryResult(errorsmod.Wrap(sdkerrors.ErrUnknownRequest, "expected second parameter to be 'filter'"), app.trace) } return resp diff --git a/baseapp/abci_test.go b/baseapp/abci_test.go index 887dbb1cfb..1b6e205cf5 100644 --- a/baseapp/abci_test.go +++ b/baseapp/abci_test.go @@ -14,6 +14,7 @@ import ( "github.com/cosmos/gogoproto/jsonpb" "github.com/stretchr/testify/require" + errorsmod "cosmossdk.io/errors" pruningtypes "cosmossdk.io/store/pruning/types" "cosmossdk.io/store/snapshots" snapshottypes "cosmossdk.io/store/snapshots/types" @@ -835,7 +836,7 @@ func TestABCI_InvalidTransaction(t *testing.T) { require.Error(t, err) require.Nil(t, result) - space, code, _ := sdkerrors.ABCIInfo(err, false) + space, code, _ := errorsmod.ABCIInfo(err, false) require.EqualValues(t, sdkerrors.ErrInvalidRequest.Codespace(), space, err) require.EqualValues(t, sdkerrors.ErrInvalidRequest.ABCICode(), code, err) } @@ -863,7 +864,7 @@ func TestABCI_InvalidTransaction(t *testing.T) { if testCase.fail { require.Error(t, err) - space, code, _ := sdkerrors.ABCIInfo(err, false) + space, code, _ := errorsmod.ABCIInfo(err, false) require.EqualValues(t, sdkerrors.ErrInvalidSequence.Codespace(), space, err) require.EqualValues(t, sdkerrors.ErrInvalidSequence.ABCICode(), code, err) } else { @@ -883,7 +884,7 @@ func TestABCI_InvalidTransaction(t *testing.T) { require.Error(t, err) require.Nil(t, result) - space, code, _ := sdkerrors.ABCIInfo(err, false) + space, code, _ := errorsmod.ABCIInfo(err, false) require.EqualValues(t, sdkerrors.ErrUnknownRequest.Codespace(), space, err) require.EqualValues(t, sdkerrors.ErrUnknownRequest.ABCICode(), code, err) @@ -896,7 +897,7 @@ func TestABCI_InvalidTransaction(t *testing.T) { require.Error(t, err) require.Nil(t, result) - space, code, _ = sdkerrors.ABCIInfo(err, false) + space, code, _ = errorsmod.ABCIInfo(err, false) require.EqualValues(t, sdkerrors.ErrUnknownRequest.Codespace(), space, err) require.EqualValues(t, sdkerrors.ErrUnknownRequest.ABCICode(), code, err) } @@ -930,7 +931,7 @@ func TestABCI_TxGasLimits(t *testing.T) { if r := recover(); r != nil { switch rType := r.(type) { case storetypes.ErrorOutOfGas: - err = sdkerrors.Wrapf(sdkerrors.ErrOutOfGas, "out of gas in location: %v", rType.Descriptor) + err = errorsmod.Wrapf(sdkerrors.ErrOutOfGas, "out of gas in location: %v", rType.Descriptor) default: panic(r) } @@ -992,7 +993,7 @@ func TestABCI_TxGasLimits(t *testing.T) { require.Error(t, err) require.Nil(t, result) - space, code, _ := sdkerrors.ABCIInfo(err, false) + space, code, _ := errorsmod.ABCIInfo(err, false) require.EqualValues(t, sdkerrors.ErrOutOfGas.Codespace(), space, err) require.EqualValues(t, sdkerrors.ErrOutOfGas.ABCICode(), code, err) } @@ -1009,7 +1010,7 @@ func TestABCI_MaxBlockGasLimits(t *testing.T) { if r := recover(); r != nil { switch rType := r.(type) { case storetypes.ErrorOutOfGas: - err = sdkerrors.Wrapf(sdkerrors.ErrOutOfGas, "out of gas in location: %v", rType.Descriptor) + err = errorsmod.Wrapf(sdkerrors.ErrOutOfGas, "out of gas in location: %v", rType.Descriptor) default: panic(r) } @@ -1074,7 +1075,7 @@ func TestABCI_MaxBlockGasLimits(t *testing.T) { require.Error(t, err, fmt.Sprintf("tc #%d; result: %v, err: %s", i, result, err)) require.Nil(t, result, fmt.Sprintf("tc #%d; result: %v, err: %s", i, result, err)) - space, code, _ := sdkerrors.ABCIInfo(err, false) + space, code, _ := errorsmod.ABCIInfo(err, false) require.EqualValues(t, sdkerrors.ErrOutOfGas.Codespace(), space, err) require.EqualValues(t, sdkerrors.ErrOutOfGas.ABCICode(), code, err) require.True(t, ctx.BlockGasMeter().IsOutOfGas()) @@ -1105,7 +1106,7 @@ func TestABCI_GasConsumptionBadTx(t *testing.T) { switch rType := r.(type) { case storetypes.ErrorOutOfGas: log := fmt.Sprintf("out of gas in location: %v", rType.Descriptor) - err = sdkerrors.Wrap(sdkerrors.ErrOutOfGas, log) + err = errorsmod.Wrap(sdkerrors.ErrOutOfGas, log) default: panic(r) } @@ -1115,7 +1116,7 @@ func TestABCI_GasConsumptionBadTx(t *testing.T) { counter, failOnAnte := parseTxMemo(t, tx) newCtx.GasMeter().ConsumeGas(uint64(counter), "counter-ante") if failOnAnte { - return newCtx, sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "ante handler failure") + return newCtx, errorsmod.Wrap(sdkerrors.ErrUnauthorized, "ante handler failure") } return diff --git a/baseapp/baseapp.go b/baseapp/baseapp.go index ac0185dfc2..cff9075464 100644 --- a/baseapp/baseapp.go +++ b/baseapp/baseapp.go @@ -14,6 +14,7 @@ import ( "github.com/cosmos/gogoproto/proto" "golang.org/x/exp/maps" + errorsmod "cosmossdk.io/errors" "cosmossdk.io/store" storemetrics "cosmossdk.io/store/metrics" "cosmossdk.io/store/snapshots" @@ -523,7 +524,7 @@ func (app *BaseApp) validateHeight(req abci.RequestBeginBlock) error { // validateBasicTxMsgs executes basic validator calls for messages. func validateBasicTxMsgs(msgs []sdk.Msg) error { if len(msgs) == 0 { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "must contain at least one message") + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "must contain at least one message") } for _, msg := range msgs { @@ -623,7 +624,7 @@ func (app *BaseApp) runTx(mode runTxMode, txBytes []byte) (gInfo sdk.GasInfo, re // only run the tx if there is block gas remaining if mode == runTxModeDeliver && ctx.BlockGasMeter().IsOutOfGas() { - return gInfo, nil, nil, 0, sdkerrors.Wrap(sdkerrors.ErrOutOfGas, "no block gas left to run tx") + return gInfo, nil, nil, 0, errorsmod.Wrap(sdkerrors.ErrOutOfGas, "no block gas left to run tx") } defer func() { @@ -784,13 +785,13 @@ func (app *BaseApp) runMsgs(ctx sdk.Context, msgs []sdk.Msg, mode runTxMode) (*s handler := app.msgServiceRouter.Handler(msg) if handler == nil { - return nil, sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "can't route message %+v", msg) + return nil, errorsmod.Wrapf(sdkerrors.ErrUnknownRequest, "can't route message %+v", msg) } // ADR 031 request type routing msgResult, err := handler(ctx, msg) if err != nil { - return nil, sdkerrors.Wrapf(err, "failed to execute message; message index: %d", i) + return nil, errorsmod.Wrapf(err, "failed to execute message; message index: %d", i) } // create message events @@ -820,7 +821,7 @@ func (app *BaseApp) runMsgs(ctx sdk.Context, msgs []sdk.Msg, mode runTxMode) (*s data, err := makeABCIData(msgResponses) if err != nil { - return nil, sdkerrors.Wrap(err, "failed to marshal tx data") + return nil, errorsmod.Wrap(err, "failed to marshal tx data") } return &sdk.Result{ diff --git a/baseapp/baseapp_test.go b/baseapp/baseapp_test.go index a27f8efdd8..4874a371c6 100644 --- a/baseapp/baseapp_test.go +++ b/baseapp/baseapp_test.go @@ -6,6 +6,7 @@ import ( "testing" "time" + errorsmod "cosmossdk.io/errors" "cosmossdk.io/log" "cosmossdk.io/store/metrics" pruningtypes "cosmossdk.io/store/pruning/types" @@ -25,7 +26,6 @@ import ( codectypes "github.com/cosmos/cosmos-sdk/codec/types" "github.com/cosmos/cosmos-sdk/testutil" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" authtx "github.com/cosmos/cosmos-sdk/x/auth/tx" ) @@ -426,10 +426,10 @@ func TestTxDecoder(t *testing.T) { func TestCustomRunTxPanicHandler(t *testing.T) { customPanicMsg := "test panic" - anteErr := sdkerrors.Register("fakeModule", 100500, "fakeError") + anteErr := errorsmod.Register("fakeModule", 100500, "fakeError") anteOpt := func(bapp *baseapp.BaseApp) { bapp.SetAnteHandler(func(ctx sdk.Context, tx sdk.Tx, simulate bool) (newCtx sdk.Context, err error) { - panic(sdkerrors.Wrap(anteErr, "anteHandler")) + panic(errorsmod.Wrap(anteErr, "anteHandler")) }) } suite := NewBaseAppSuite(t, anteOpt) diff --git a/baseapp/grpcserver.go b/baseapp/grpcserver.go index d04f71d1ab..b49efbb162 100644 --- a/baseapp/grpcserver.go +++ b/baseapp/grpcserver.go @@ -4,6 +4,7 @@ import ( "context" "strconv" + errorsmod "cosmossdk.io/errors" gogogrpc "github.com/cosmos/gogoproto/grpc" grpcmiddleware "github.com/grpc-ecosystem/go-grpc-middleware" grpcrecovery "github.com/grpc-ecosystem/go-grpc-middleware/recovery" @@ -36,7 +37,7 @@ func (app *BaseApp) RegisterGRPCServer(server gogogrpc.Server) { if heightHeaders := md.Get(grpctypes.GRPCBlockHeightHeader); len(heightHeaders) == 1 { height, err = strconv.ParseInt(heightHeaders[0], 10, 64) if err != nil { - return nil, sdkerrors.Wrapf( + return nil, errorsmod.Wrapf( sdkerrors.ErrInvalidRequest, "Baseapp.RegisterGRPCServer: invalid height header %q: %v", grpctypes.GRPCBlockHeightHeader, err) } diff --git a/baseapp/msg_service_router.go b/baseapp/msg_service_router.go index 38c6990e4e..ed08986d47 100644 --- a/baseapp/msg_service_router.go +++ b/baseapp/msg_service_router.go @@ -8,6 +8,8 @@ import ( "github.com/cosmos/gogoproto/proto" "google.golang.org/grpc" + errorsmod "cosmossdk.io/errors" + codectypes "github.com/cosmos/cosmos-sdk/codec/types" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" @@ -132,7 +134,7 @@ func (msr *MsgServiceRouter) RegisterService(sd *grpc.ServiceDesc, handler inter resMsg, ok := res.(proto.Message) if !ok { - return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidType, "Expecting proto.Message, got %T", resMsg) + return nil, errorsmod.Wrapf(sdkerrors.ErrInvalidType, "Expecting proto.Message, got %T", resMsg) } return sdk.WrapServiceResult(ctx, resMsg, err) diff --git a/baseapp/recovery.go b/baseapp/recovery.go index 35f8398172..ca6cfca062 100644 --- a/baseapp/recovery.go +++ b/baseapp/recovery.go @@ -4,6 +4,7 @@ import ( "fmt" "runtime/debug" + errorsmod "cosmossdk.io/errors" storetypes "cosmossdk.io/store/types" sdk "github.com/cosmos/cosmos-sdk/types" @@ -54,7 +55,7 @@ func newOutOfGasRecoveryMiddleware(gasWanted uint64, ctx sdk.Context, next recov return nil } - return sdkerrors.Wrap( + return errorsmod.Wrap( sdkerrors.ErrOutOfGas, fmt.Sprintf( "out of gas in location: %v; gasWanted: %d, gasUsed: %d", err.Descriptor, gasWanted, ctx.GasMeter().GasConsumed(), @@ -68,7 +69,7 @@ func newOutOfGasRecoveryMiddleware(gasWanted uint64, ctx sdk.Context, next recov // newDefaultRecoveryMiddleware creates a default (last in chain) recovery middleware for app.runTx method. func newDefaultRecoveryMiddleware() recoveryMiddleware { handler := func(recoveryObj interface{}) error { - return sdkerrors.Wrap( + return errorsmod.Wrap( sdkerrors.ErrPanic, fmt.Sprintf( "recovered: %v\nstack:\n%v", recoveryObj, string(debug.Stack()), ), diff --git a/baseapp/test_helpers.go b/baseapp/test_helpers.go index 81be264ef8..d3f24d6ef4 100644 --- a/baseapp/test_helpers.go +++ b/baseapp/test_helpers.go @@ -3,6 +3,8 @@ package baseapp import ( cmtproto "github.com/cometbft/cometbft/proto/tendermint/types" + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) @@ -14,7 +16,7 @@ func (app *BaseApp) SimCheck(txEncoder sdk.TxEncoder, tx sdk.Tx) (sdk.GasInfo, * // this helper is only used in tests/simulation, it's fine. bz, err := txEncoder(tx) if err != nil { - return sdk.GasInfo{}, nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "%s", err) + return sdk.GasInfo{}, nil, errorsmod.Wrapf(sdkerrors.ErrInvalidRequest, "%s", err) } gasInfo, result, _, _, err := app.runTx(runTxModeCheck, bz) return gasInfo, result, err @@ -30,7 +32,7 @@ func (app *BaseApp) SimDeliver(txEncoder sdk.TxEncoder, tx sdk.Tx) (sdk.GasInfo, // See comment for Check(). bz, err := txEncoder(tx) if err != nil { - return sdk.GasInfo{}, nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "%s", err) + return sdk.GasInfo{}, nil, errorsmod.Wrapf(sdkerrors.ErrInvalidRequest, "%s", err) } gasInfo, result, _, _, err := app.runTx(runTxModeDeliver, bz) return gasInfo, result, err diff --git a/baseapp/testutil/messages.go b/baseapp/testutil/messages.go index b98c192a7e..a4b1cd9abb 100644 --- a/baseapp/testutil/messages.go +++ b/baseapp/testutil/messages.go @@ -1,6 +1,8 @@ package testutil import ( + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/codec/types" "github.com/cosmos/cosmos-sdk/crypto/codec" sdk "github.com/cosmos/cosmos-sdk/types" @@ -29,7 +31,7 @@ func (msg *MsgCounter) ValidateBasic() error { if msg.Counter >= 0 { return nil } - return sdkerrors.Wrap(sdkerrors.ErrInvalidSequence, "counter should be a non-negative integer") + return errorsmod.Wrap(sdkerrors.ErrInvalidSequence, "counter should be a non-negative integer") } var _ sdk.Msg = &MsgCounter2{} @@ -39,7 +41,7 @@ func (msg *MsgCounter2) ValidateBasic() error { if msg.Counter >= 0 { return nil } - return sdkerrors.Wrap(sdkerrors.ErrInvalidSequence, "counter should be a non-negative integer") + return errorsmod.Wrap(sdkerrors.ErrInvalidSequence, "counter should be a non-negative integer") } var _ sdk.Msg = &MsgKeyValue{} @@ -54,10 +56,10 @@ func (msg *MsgKeyValue) GetSigners() []sdk.AccAddress { func (msg *MsgKeyValue) ValidateBasic() error { if msg.Key == nil { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "key cannot be nil") + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "key cannot be nil") } if msg.Value == nil { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "value cannot be nil") + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "value cannot be nil") } return nil } diff --git a/baseapp/utils_test.go b/baseapp/utils_test.go index e87e563626..53eb3cfaab 100644 --- a/baseapp/utils_test.go +++ b/baseapp/utils_test.go @@ -18,15 +18,15 @@ import ( appv1alpha1 "cosmossdk.io/api/cosmos/app/v1alpha1" "cosmossdk.io/core/appconfig" "cosmossdk.io/depinject" + errorsmod "cosmossdk.io/errors" sdkmath "cosmossdk.io/math" + storetypes "cosmossdk.io/store/types" "github.com/cometbft/cometbft/libs/log" cmtproto "github.com/cometbft/cometbft/proto/tendermint/types" cmttypes "github.com/cometbft/cometbft/types" dbm "github.com/cosmos/cosmos-db" "github.com/stretchr/testify/require" - storetypes "cosmossdk.io/store/types" - "github.com/cosmos/cosmos-sdk/baseapp" baseapptestutil "github.com/cosmos/cosmos-sdk/baseapp/testutil" "github.com/cosmos/cosmos-sdk/client" @@ -178,12 +178,12 @@ func incrementCounter(ctx context.Context, switch m := msg.(type) { case *baseapptestutil.MsgCounter: if m.FailOnHandler { - return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "message handler failure") + return nil, errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "message handler failure") } msgCount = m.Counter case *baseapptestutil.MsgCounter2: if m.FailOnHandler { - return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "message handler failure") + return nil, errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "message handler failure") } msgCount = m.Counter } @@ -215,7 +215,7 @@ func anteHandlerTxTest(t *testing.T, capKey storetypes.StoreKey, storeKey []byte counter, failOnAnte := parseTxMemo(t, tx) if failOnAnte { - return ctx, sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "ante handler failure") + return ctx, errorsmod.Wrap(sdkerrors.ErrUnauthorized, "ante handler failure") } _, err := incrementingCounter(t, store, storeKey, counter) diff --git a/client/debug/main.go b/client/debug/main.go index 645e6fe36e..f5a033c527 100644 --- a/client/debug/main.go +++ b/client/debug/main.go @@ -9,6 +9,8 @@ import ( "github.com/spf13/cobra" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519" "github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1" @@ -143,7 +145,7 @@ $ %s debug pubkey-raw cosmos1e0jnq2sun3dzjh8p2xq95kk0expwmd7shwjpfg } pubkeyType = strings.ToLower(pubkeyType) if pubkeyType != "secp256k1" && pubkeyType != ed { - return errors.Wrapf(errors.ErrInvalidType, "invalid pubkey type, expected oneof ed25519 or secp256k1") + return errorsmod.Wrapf(errors.ErrInvalidType, "invalid pubkey type, expected oneof ed25519 or secp256k1") } pk, err := getPubKeyFromRawString(args[0], pubkeyType) diff --git a/client/grpc_query.go b/client/grpc_query.go index 569eff03f4..5342115183 100644 --- a/client/grpc_query.go +++ b/client/grpc_query.go @@ -12,6 +12,7 @@ import ( "github.com/cosmos/cosmos-sdk/codec" + errorsmod "cosmossdk.io/errors" abci "github.com/cometbft/cometbft/abci/types" gogogrpc "github.com/cosmos/gogoproto/grpc" "google.golang.org/grpc" @@ -39,14 +40,14 @@ func (ctx Context) Invoke(grpcCtx gocontext.Context, method string, req, reply i // In both cases, we don't allow empty request args (it will panic unexpectedly). if reflect.ValueOf(req).IsNil() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "request cannot be nil") + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "request cannot be nil") } // Case 1. Broadcasting a Tx. if reqProto, ok := req.(*tx.BroadcastTxRequest); ok { res, ok := reply.(*tx.BroadcastTxResponse) if !ok { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "expected %T, got %T", (*tx.BroadcastTxResponse)(nil), req) + return errorsmod.Wrapf(sdkerrors.ErrInvalidRequest, "expected %T, got %T", (*tx.BroadcastTxResponse)(nil), req) } broadcastRes, err := TxServiceBroadcast(grpcCtx, ctx, reqProto) @@ -77,7 +78,7 @@ func (ctx Context) Invoke(grpcCtx gocontext.Context, method string, req, reply i return err } if height < 0 { - return sdkerrors.Wrapf( + return errorsmod.Wrapf( sdkerrors.ErrInvalidRequest, "client.Context.Invoke: height (%d) from %q must be >= 0", height, grpctypes.GRPCBlockHeightHeader) } diff --git a/client/keys/show.go b/client/keys/show.go index 422dd79c7f..21c800b482 100644 --- a/client/keys/show.go +++ b/client/keys/show.go @@ -7,6 +7,8 @@ import ( "github.com/cometbft/cometbft/libs/cli" "github.com/spf13/cobra" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/crypto/keyring" "github.com/cosmos/cosmos-sdk/crypto/keys/multisig" @@ -173,7 +175,7 @@ func fetchKey(kb keyring.Keyring, keyref string) (*keyring.Record, error) { // if the key is not there or if we have a problem with a keyring itself then we move to a // fallback: searching for key by address. - if err == nil || !sdkerr.IsOf(err, sdkerr.ErrIO, sdkerr.ErrKeyNotFound) { + if err == nil || !errorsmod.IsOf(err, sdkerr.ErrIO, sdkerr.ErrKeyNotFound) { return k, err } @@ -183,7 +185,7 @@ func fetchKey(kb keyring.Keyring, keyref string) (*keyring.Record, error) { } k, err = kb.KeyByAddress(accAddr) - return k, sdkerr.Wrap(err, "Invalid key") + return k, errorsmod.Wrap(err, "Invalid key") } func validateMultisigThreshold(k, nKeys int) error { diff --git a/client/utils.go b/client/utils.go index e2f3a2a4cf..72e12e785f 100644 --- a/client/utils.go +++ b/client/utils.go @@ -6,6 +6,8 @@ import ( rpchttp "github.com/cometbft/cometbft/rpc/client/http" "github.com/spf13/pflag" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/client/flags" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/types/query" @@ -57,7 +59,7 @@ func ReadPageRequest(flagSet *pflag.FlagSet) (*query.PageRequest, error) { reverse, _ := flagSet.GetBool(flags.FlagReverse) if page > 1 && offset > 0 { - return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "page and offset cannot be used together") + return nil, errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "page and offset cannot be used together") } if page > 1 { diff --git a/codec/types/any.go b/codec/types/any.go index b1d8973f57..5ecc297f8e 100644 --- a/codec/types/any.go +++ b/codec/types/any.go @@ -6,6 +6,8 @@ import ( "github.com/cosmos/gogoproto/proto" + errorsmod "cosmossdk.io/errors" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) @@ -58,7 +60,7 @@ type Any struct { // unmarshaling func NewAnyWithValue(v proto.Message) (*Any, error) { if v == nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrPackAny, "Expecting non nil value to create a new Any") + return nil, errorsmod.Wrap(sdkerrors.ErrPackAny, "Expecting non nil value to create a new Any") } bz, err := proto.Marshal(v) diff --git a/collections/indexes/helpers.go b/collections/indexes/helpers.go index 666f6cc6c9..ddafaf0f0b 100644 --- a/collections/indexes/helpers.go +++ b/collections/indexes/helpers.go @@ -2,6 +2,7 @@ package indexes import ( "context" + "cosmossdk.io/collections" ) @@ -23,7 +24,8 @@ type Iterator[K any] interface { func CollectKeyValues[K, V any, I Iterator[K], Idx collections.Indexes[K, V]]( ctx context.Context, indexedMap *collections.IndexedMap[K, V, Idx], - iter I) (kvs []collections.KeyValue[K, V], err error) { + iter I, +) (kvs []collections.KeyValue[K, V], err error) { err = ScanKeyValues(ctx, indexedMap, iter, func(kv collections.KeyValue[K, V]) bool { kvs = append(kvs, kv) return false @@ -38,8 +40,8 @@ func ScanKeyValues[K, V any, I Iterator[K], Idx collections.Indexes[K, V]]( ctx context.Context, indexedMap *collections.IndexedMap[K, V, Idx], iter I, - do func(kv collections.KeyValue[K, V]) (stop bool)) (err error) { - + do func(kv collections.KeyValue[K, V]) (stop bool), +) (err error) { defer iter.Close() for ; iter.Valid(); iter.Next() { @@ -71,7 +73,8 @@ func ScanKeyValues[K, V any, I Iterator[K], Idx collections.Indexes[K, V]]( func CollectValues[K, V any, I Iterator[K], Idx collections.Indexes[K, V]]( ctx context.Context, indexedMap *collections.IndexedMap[K, V, Idx], - iter I) (values []V, err error) { + iter I, +) (values []V, err error) { err = ScanValues(ctx, indexedMap, iter, func(value V) (stop bool) { values = append(values, value) return false diff --git a/collections/indexes/helpers_test.go b/collections/indexes/helpers_test.go index 691bec55ad..00052bd5e1 100644 --- a/collections/indexes/helpers_test.go +++ b/collections/indexes/helpers_test.go @@ -1,9 +1,10 @@ package indexes import ( + "testing" + "cosmossdk.io/collections" "github.com/stretchr/testify/require" - "testing" ) func TestHelpers(t *testing.T) { diff --git a/collections/indexes/indexes_test.go b/collections/indexes/indexes_test.go index be65add9ad..a2754ae7d4 100644 --- a/collections/indexes/indexes_test.go +++ b/collections/indexes/indexes_test.go @@ -2,6 +2,7 @@ package indexes import ( "context" + "cosmossdk.io/core/store" db "github.com/cosmos/cosmos-db" ) diff --git a/collections/indexes/multi.go b/collections/indexes/multi.go index 24cb07534e..0ae0018222 100644 --- a/collections/indexes/multi.go +++ b/collections/indexes/multi.go @@ -2,6 +2,7 @@ package indexes import ( "context" + "cosmossdk.io/collections" ) diff --git a/collections/indexes/multi_pair.go b/collections/indexes/multi_pair.go index 819730b384..a71690d3e9 100644 --- a/collections/indexes/multi_pair.go +++ b/collections/indexes/multi_pair.go @@ -2,6 +2,7 @@ package indexes import ( "context" + "cosmossdk.io/collections" ) diff --git a/collections/indexes/multi_pair_test.go b/collections/indexes/multi_pair_test.go index 3e88f04f7b..052a62ebea 100644 --- a/collections/indexes/multi_pair_test.go +++ b/collections/indexes/multi_pair_test.go @@ -1,14 +1,17 @@ package indexes import ( + "testing" + "cosmossdk.io/collections" "github.com/stretchr/testify/require" - "testing" ) -type Address = string -type Denom = string -type Amount = uint64 +type ( + Address = string + Denom = string + Amount = uint64 +) // our balance index, allows us to efficiently create an index between the key that maps // balances which is a collections.Pair[Address, Denom] and the Denom. diff --git a/collections/indexes/multi_test.go b/collections/indexes/multi_test.go index 8c2ffa0ffb..98518cd1be 100644 --- a/collections/indexes/multi_test.go +++ b/collections/indexes/multi_test.go @@ -1,9 +1,10 @@ package indexes import ( + "testing" + "cosmossdk.io/collections" "github.com/stretchr/testify/require" - "testing" ) func TestMultiIndex(t *testing.T) { diff --git a/collections/indexes/unique.go b/collections/indexes/unique.go index 4385f2d11e..eaeabcae9a 100644 --- a/collections/indexes/unique.go +++ b/collections/indexes/unique.go @@ -2,6 +2,7 @@ package indexes import ( "context" + "cosmossdk.io/collections" ) @@ -84,9 +85,11 @@ func (i UniqueIterator[ReferenceKey, PrimaryKey]) FullKeys() ([]collections.Pair func (i UniqueIterator[ReferenceKey, PrimaryKey]) Next() { (collections.Iterator[ReferenceKey, PrimaryKey])(i).Next() } + func (i UniqueIterator[ReferenceKey, PrimaryKey]) Valid() bool { return (collections.Iterator[ReferenceKey, PrimaryKey])(i).Valid() } + func (i UniqueIterator[ReferenceKey, PrimaryKey]) Close() error { return (collections.Iterator[ReferenceKey, PrimaryKey])(i).Close() } diff --git a/collections/indexes/unique_test.go b/collections/indexes/unique_test.go index 7e9be93103..6a03e94215 100644 --- a/collections/indexes/unique_test.go +++ b/collections/indexes/unique_test.go @@ -1,9 +1,10 @@ package indexes import ( + "testing" + "cosmossdk.io/collections" "github.com/stretchr/testify/require" - "testing" ) func TestUniqueIndex(t *testing.T) { diff --git a/core/genesis/source_test.go b/core/genesis/source_test.go index c46775656b..3efdfb4d54 100644 --- a/core/genesis/source_test.go +++ b/core/genesis/source_test.go @@ -29,7 +29,6 @@ func expectJSON(t *testing.T, source appmodule.GenesisSource, field, contents st bz, err := io.ReadAll(r) require.NoError(t, err) require.Equal(t, contents, string(bz)) - } const ( diff --git a/crypto/armor.go b/crypto/armor.go index aa6097b774..83215bf876 100644 --- a/crypto/armor.go +++ b/crypto/armor.go @@ -9,6 +9,8 @@ import ( "github.com/cometbft/cometbft/crypto" "golang.org/x/crypto/openpgp/armor" //nolint:staticcheck + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/codec/legacy" "github.com/cosmos/cosmos-sdk/crypto/keys/bcrypt" cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" @@ -149,7 +151,7 @@ func encryptPrivKey(privKey cryptotypes.PrivKey, passphrase string) (saltBytes [ saltBytes = crypto.CRandBytes(16) key, err := bcrypt.GenerateFromPassword(saltBytes, []byte(passphrase), BcryptSecurityParameter) if err != nil { - panic(sdkerrors.Wrap(err, "error generating bcrypt key from passphrase")) + panic(errorsmod.Wrap(err, "error generating bcrypt key from passphrase")) } key = crypto.Sha256(key) // get 32 bytes @@ -194,7 +196,7 @@ func UnarmorDecryptPrivKey(armorStr string, passphrase string) (privKey cryptoty func decryptPrivKey(saltBytes []byte, encBytes []byte, passphrase string) (privKey cryptotypes.PrivKey, err error) { key, err := bcrypt.GenerateFromPassword(saltBytes, []byte(passphrase), BcryptSecurityParameter) if err != nil { - return privKey, sdkerrors.Wrap(err, "error generating bcrypt key from passphrase") + return privKey, errorsmod.Wrap(err, "error generating bcrypt key from passphrase") } key = crypto.Sha256(key) // Get 32 bytes diff --git a/crypto/codec/cmt.go b/crypto/codec/cmt.go index bf11c8f47c..ee8889fd2f 100644 --- a/crypto/codec/cmt.go +++ b/crypto/codec/cmt.go @@ -1,11 +1,12 @@ package codec import ( - "cosmossdk.io/errors" cmtcrypto "github.com/cometbft/cometbft/crypto" "github.com/cometbft/cometbft/crypto/encoding" cmtprotocrypto "github.com/cometbft/cometbft/proto/tendermint/crypto" + "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519" "github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1" cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" diff --git a/crypto/keyring/keyring.go b/crypto/keyring/keyring.go index 1c0e813380..59e672ec0e 100644 --- a/crypto/keyring/keyring.go +++ b/crypto/keyring/keyring.go @@ -14,6 +14,10 @@ import ( "github.com/cockroachdb/errors" cmtcrypto "github.com/cometbft/cometbft/crypto" + "github.com/cosmos/go-bip39" + + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/client/input" "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/crypto" @@ -24,7 +28,6 @@ import ( sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/types/tx/signing" - "github.com/cosmos/go-bip39" ) // Backend options for Keyring @@ -194,7 +197,7 @@ func New( case BackendPass: db, err = keyring.Open(newPassBackendKeyringConfig(appName, rootDir, userInput)) default: - return nil, errors.Wrap(ErrUnknownBacked, backend) + return nil, errorsmod.Wrap(ErrUnknownBacked, backend) } if err != nil { @@ -317,13 +320,13 @@ func (ks keystore) ExportPrivKeyArmorByAddress(address sdk.Address, encryptPassp func (ks keystore) ImportPrivKey(uid, armor, passphrase string) error { if k, err := ks.Key(uid); err == nil { if uid == k.Name { - return errors.Wrap(ErrOverwriteKey, uid) + return errorsmod.Wrap(ErrOverwriteKey, uid) } } privKey, _, err := crypto.UnarmorDecryptPrivKey(armor, passphrase) if err != nil { - return errors.Wrap(err, "failed to decrypt private key") + return errorsmod.Wrap(err, "failed to decrypt private key") } _, err = ks.writeLocalKey(uid, privKey) @@ -336,7 +339,7 @@ func (ks keystore) ImportPrivKey(uid, armor, passphrase string) error { func (ks keystore) ImportPubKey(uid, armor string) error { if _, err := ks.Key(uid); err == nil { - return errors.Wrap(ErrOverwriteKey, uid) + return errorsmod.Wrap(ErrOverwriteKey, uid) } pubBytes, _, err := crypto.UnarmorPubKeyBytes(armor) @@ -401,7 +404,7 @@ func (ks keystore) SignByAddress(address sdk.Address, msg []byte, signMode signi func (ks keystore) SaveLedgerKey(uid string, algo SignatureAlgo, hrp string, coinType, account, index uint32) (*Record, error) { if !ks.options.SupportedAlgosLedger.Contains(algo) { - return nil, errors.Wrap(ErrUnsupportedSigningAlgo, fmt.Sprintf("signature algo %s is not defined in the keyring options", algo.Name())) + return nil, errorsmod.Wrap(ErrUnsupportedSigningAlgo, fmt.Sprintf("signature algo %s is not defined in the keyring options", algo.Name())) } hdPath := hd.NewFundraiserParams(account, coinType, index) @@ -448,7 +451,7 @@ func (ks keystore) DeleteByAddress(address sdk.Address) error { func (ks keystore) Rename(oldName, newName string) error { _, err := ks.Key(newName) if err == nil { - return errors.Wrap(ErrKeyAlreadyExists, fmt.Sprintf("rename failed, %s", newName)) + return errorsmod.Wrap(ErrKeyAlreadyExists, fmt.Sprintf("rename failed, %s", newName)) } armor, err := ks.ExportPrivKeyArmor(oldName, passPhrase) @@ -508,7 +511,7 @@ func (ks keystore) KeyByAddress(address sdk.Address) (*Record, error) { func wrapKeyNotFound(err error, msg string) error { if err == keyring.ErrKeyNotFound { - return errors.Wrap(sdkerrors.ErrKeyNotFound, msg) + return errorsmod.Wrap(sdkerrors.ErrKeyNotFound, msg) } return err } @@ -620,7 +623,7 @@ func SignWithLedger(k *Record, msg []byte, signMode signing.SignMode) (sig []byt return nil, nil, err } default: - return nil, nil, errors.Wrap(ErrInvalidSignMode, fmt.Sprintf("%v", signMode)) + return nil, nil, errorsmod.Wrap(ErrInvalidSignMode, fmt.Sprintf("%v", signMode)) } if !priv.PubKey().VerifySignature(msg, sig) { @@ -693,7 +696,7 @@ func newRealPrompt(dir string, buf io.Reader) func(string) (string, error) { case err == nil: keyhash, err = os.ReadFile(keyhashFilePath) if err != nil { - return "", errors.Wrap(err, fmt.Sprintf("failed to read %s", keyhashFilePath)) + return "", errorsmod.Wrap(err, fmt.Sprintf("failed to read %s", keyhashFilePath)) } keyhashStored = true @@ -702,7 +705,7 @@ func newRealPrompt(dir string, buf io.Reader) func(string) (string, error) { keyhashStored = false default: - return "", errors.Wrap(err, fmt.Sprintf("failed to open %s", keyhashFilePath)) + return "", errorsmod.Wrap(err, fmt.Sprintf("failed to open %s", keyhashFilePath)) } failureCounter := 0 @@ -791,7 +794,7 @@ func (ks keystore) writeRecord(k *Record) error { return err } if exists { - return errors.Wrap(ErrKeyAlreadyExists, key) + return errorsmod.Wrap(ErrKeyAlreadyExists, key) } serializedRecord, err := ks.cdc.Marshal(k) @@ -923,7 +926,7 @@ func (ks keystore) migrate(key string) (*Record, error) { } if len(item.Data) == 0 { - return nil, errors.Wrap(sdkerrors.ErrKeyNotFound, key) + return nil, errorsmod.Wrap(sdkerrors.ErrKeyNotFound, key) } // 2. Try to deserialize using proto @@ -936,13 +939,13 @@ func (ks keystore) migrate(key string) (*Record, error) { // 4. Try to decode with amino legacyInfo, err := unMarshalLegacyInfo(item.Data) if err != nil { - return nil, errors.Wrap(err, "unable to unmarshal item.Data") + return nil, errorsmod.Wrap(err, "unable to unmarshal item.Data") } // 5. Convert and serialize info using proto k, err = ks.convertFromLegacyInfo(legacyInfo) if err != nil { - return nil, errors.Wrap(err, "convertFromLegacyInfo") + return nil, errorsmod.Wrap(err, "convertFromLegacyInfo") } serializedRecord, err := ks.cdc.Marshal(k) @@ -957,7 +960,7 @@ func (ks keystore) migrate(key string) (*Record, error) { // 6. Overwrite the keyring entry with the new proto-encoded key. if err := ks.SetItem(item); err != nil { - return nil, errors.Wrap(err, "unable to set keyring.Item") + return nil, errorsmod.Wrap(err, "unable to set keyring.Item") } fmt.Printf("Successfully migrated key %s.\n", key) @@ -980,7 +983,7 @@ func (ks keystore) SetItem(item keyring.Item) error { func (ks keystore) convertFromLegacyInfo(info LegacyInfo) (*Record, error) { if info == nil { - return nil, errors.Wrap(ErrLegacyToRecord, "info is nil") + return nil, errorsmod.Wrap(ErrLegacyToRecord, "info is nil") } name := info.GetName() diff --git a/crypto/keyring/keyring_test.go b/crypto/keyring/keyring_test.go index af6aab4da9..a1e42900dc 100644 --- a/crypto/keyring/keyring_test.go +++ b/crypto/keyring/keyring_test.go @@ -269,7 +269,6 @@ func TestGetPub(t *testing.T) { keyS, err := kb.List() require.NoError(t, err) require.Equal(t, 1, len(keyS)) - }) } } diff --git a/crypto/keyring/migration_test.go b/crypto/keyring/migration_test.go index 4f320c2f3f..1e07fd1677 100644 --- a/crypto/keyring/migration_test.go +++ b/crypto/keyring/migration_test.go @@ -10,6 +10,8 @@ import ( "github.com/cosmos/cosmos-sdk/codec/legacy" "github.com/cosmos/cosmos-sdk/crypto/hd" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/crypto/keys/multisig" "github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1" cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" @@ -215,7 +217,7 @@ func (s *MigrationTestSuite) TestMigrateErrUnknownItemKey() { incorrectItemKey := n1 + "1" _, err := s.ks.migrate(incorrectItemKey) - s.Require().EqualError(err, sdkerrors.Wrap(sdkerrors.ErrKeyNotFound, infoKey(incorrectItemKey)).Error()) + s.Require().EqualError(err, errorsmod.Wrap(sdkerrors.ErrKeyNotFound, infoKey(incorrectItemKey)).Error()) } func (s *MigrationTestSuite) TestMigrateErrEmptyItemData() { @@ -228,7 +230,7 @@ func (s *MigrationTestSuite) TestMigrateErrEmptyItemData() { s.Require().NoError(s.ks.SetItem(item)) _, err := s.ks.migrate(n1) - s.Require().EqualError(err, sdkerrors.Wrap(sdkerrors.ErrKeyNotFound, n1).Error()) + s.Require().EqualError(err, errorsmod.Wrap(sdkerrors.ErrKeyNotFound, n1).Error()) } func TestMigrationTestSuite(t *testing.T) { diff --git a/crypto/keyring/record.go b/crypto/keyring/record.go index 16a1b9adeb..c461f7f6a4 100644 --- a/crypto/keyring/record.go +++ b/crypto/keyring/record.go @@ -3,6 +3,8 @@ package keyring import ( "github.com/cockroachdb/errors" + errorsmod "cosmossdk.io/errors" + codectypes "github.com/cosmos/cosmos-sdk/codec/types" "github.com/cosmos/cosmos-sdk/crypto/hd" cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" @@ -69,7 +71,7 @@ func NewMultiRecord(name string, pk cryptotypes.PubKey) (*Record, error) { func (k *Record) GetPubKey() (cryptotypes.PubKey, error) { pk, ok := k.PubKey.GetCachedValue().(cryptotypes.PubKey) if !ok { - return nil, errors.Wrap(ErrCastAny, "PubKey") + return nil, errorsmod.Wrap(ErrCastAny, "PubKey") } return pk, nil @@ -131,7 +133,7 @@ func extractPrivKeyFromLocal(rl *Record_Local) (cryptotypes.PrivKey, error) { priv, ok := rl.PrivKey.GetCachedValue().(cryptotypes.PrivKey) if !ok { - return nil, errors.Wrap(ErrCastAny, "PrivKey") + return nil, errorsmod.Wrap(ErrCastAny, "PrivKey") } return priv, nil diff --git a/crypto/keyring/signing_algorithms_test.go b/crypto/keyring/signing_algorithms_test.go index dd61663497..624e491d09 100644 --- a/crypto/keyring/signing_algorithms_test.go +++ b/crypto/keyring/signing_algorithms_test.go @@ -82,7 +82,6 @@ func TestDerive(t *testing.T) { decodedPriv, err := hex.DecodeString(tt.derivedPriv) require.NoError(t, err) require.Equal(t, derivedPriv, decodedPriv) - }) } } diff --git a/crypto/keys/ed25519/ed25519.go b/crypto/keys/ed25519/ed25519.go index beb11077ac..d2dc54a32d 100644 --- a/crypto/keys/ed25519/ed25519.go +++ b/crypto/keys/ed25519/ed25519.go @@ -10,6 +10,8 @@ import ( "github.com/cometbft/cometbft/crypto/tmhash" "github.com/hdevalence/ed25519consensus" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/codec" cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" "github.com/cosmos/cosmos-sdk/types/errors" @@ -209,7 +211,7 @@ func (pubKey PubKey) MarshalAmino() ([]byte, error) { // UnmarshalAmino overrides Amino binary marshalling. func (pubKey *PubKey) UnmarshalAmino(bz []byte) error { if len(bz) != PubKeySize { - return errors.Wrap(errors.ErrInvalidPubKey, "invalid pubkey size") + return errorsmod.Wrap(errors.ErrInvalidPubKey, "invalid pubkey size") } pubKey.Key = bz diff --git a/crypto/keys/internal/ecdsa/pubkey.go b/crypto/keys/internal/ecdsa/pubkey.go index 93795f0d00..a0b5df4401 100644 --- a/crypto/keys/internal/ecdsa/pubkey.go +++ b/crypto/keys/internal/ecdsa/pubkey.go @@ -9,6 +9,8 @@ import ( cmtcrypto "github.com/cometbft/cometbft/crypto" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/types/address" "github.com/cosmos/cosmos-sdk/types/errors" ) @@ -95,12 +97,12 @@ func (pk *PubKey) MarshalTo(dAtA []byte) (int, error) { // Unmarshal implements proto.Marshaler interface. func (pk *PubKey) Unmarshal(bz []byte, curve elliptic.Curve, expectedSize int) error { if len(bz) != expectedSize { - return errors.Wrapf(errors.ErrInvalidPubKey, "wrong ECDSA PK bytes, expecting %d bytes, got %d", expectedSize, len(bz)) + return errorsmod.Wrapf(errors.ErrInvalidPubKey, "wrong ECDSA PK bytes, expecting %d bytes, got %d", expectedSize, len(bz)) } cpk := ecdsa.PublicKey{Curve: curve} cpk.X, cpk.Y = elliptic.UnmarshalCompressed(curve, bz) if cpk.X == nil || cpk.Y == nil { - return errors.Wrapf(errors.ErrInvalidPubKey, "wrong ECDSA PK bytes, unknown curve type: %d", bz[0]) + return errorsmod.Wrapf(errors.ErrInvalidPubKey, "wrong ECDSA PK bytes, unknown curve type: %d", bz[0]) } pk.PublicKey = cpk return nil diff --git a/crypto/keys/multisig/amino.go b/crypto/keys/multisig/amino.go index 6caae9ab7d..8c83b27021 100644 --- a/crypto/keys/multisig/amino.go +++ b/crypto/keys/multisig/amino.go @@ -1,6 +1,8 @@ package multisig import ( + errorsmod "cosmossdk.io/errors" + types "github.com/cosmos/cosmos-sdk/codec/types" cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" @@ -36,7 +38,7 @@ func protoToTm(protoPk *LegacyAminoPubKey) (tmMultisig, error) { for i, pk := range protoPk.PubKeys { pks[i], ok = pk.GetCachedValue().(cryptotypes.PubKey) if !ok { - return tmMultisig{}, sdkerrors.Wrapf(sdkerrors.ErrInvalidType, "expected %T, got %T", (cryptotypes.PubKey)(nil), pk.GetCachedValue()) + return tmMultisig{}, errorsmod.Wrapf(sdkerrors.ErrInvalidType, "expected %T, got %T", (cryptotypes.PubKey)(nil), pk.GetCachedValue()) } } diff --git a/crypto/keys/secp256k1/internal/secp256k1/curve.go b/crypto/keys/secp256k1/internal/secp256k1/curve.go index 764769033f..cbdf3a3ddd 100644 --- a/crypto/keys/secp256k1/internal/secp256k1/curve.go +++ b/crypto/keys/secp256k1/internal/secp256k1/curve.go @@ -6,17 +6,17 @@ // modification, are permitted provided that the following conditions are // met: // -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// * The name of ThePiachu may not be used to endorse or promote products -// derived from this software without specific prior written permission. +// - Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// - Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// - Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// - The name of ThePiachu may not be used to endorse or promote products +// derived from this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT @@ -29,7 +29,7 @@ // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -//nolint // this nolint lets us use this file in its original and unmodified form. +// nolint // this nolint lets us use this file in its original and unmodified form. package secp256k1 import ( diff --git a/crypto/keys/secp256k1/internal/secp256k1/scalar_mult_cgo.go b/crypto/keys/secp256k1/internal/secp256k1/scalar_mult_cgo.go index d3e0d2eb2c..33566723c1 100644 --- a/crypto/keys/secp256k1/internal/secp256k1/scalar_mult_cgo.go +++ b/crypto/keys/secp256k1/internal/secp256k1/scalar_mult_cgo.go @@ -5,7 +5,7 @@ //go:build !gofuzz && cgo // +build !gofuzz,cgo -//nolint // this nolint lets us use this file in its original and unmodified form. +// nolint // this nolint lets us use this file in its original and unmodified form. package secp256k1 import ( diff --git a/crypto/keys/secp256k1/internal/secp256k1/scalar_mult_nocgo.go b/crypto/keys/secp256k1/internal/secp256k1/scalar_mult_nocgo.go index 0c1f96f3e7..e95e855869 100644 --- a/crypto/keys/secp256k1/internal/secp256k1/scalar_mult_nocgo.go +++ b/crypto/keys/secp256k1/internal/secp256k1/scalar_mult_nocgo.go @@ -5,7 +5,7 @@ //go:build gofuzz || !cgo // +build gofuzz !cgo -//nolint // this nolint lets us use this file in its original and unmodified form. +// nolint // this nolint lets us use this file in its original and unmodified form. package secp256k1 import "math/big" diff --git a/crypto/keys/secp256k1/secp256k1.go b/crypto/keys/secp256k1/secp256k1.go index 74fd858469..68208f859a 100644 --- a/crypto/keys/secp256k1/secp256k1.go +++ b/crypto/keys/secp256k1/secp256k1.go @@ -8,6 +8,7 @@ import ( "io" "math/big" + errorsmod "cosmossdk.io/errors" "github.com/cometbft/cometbft/crypto" secp256k1 "github.com/decred/dcrd/dcrec/secp256k1/v4" "golang.org/x/crypto/ripemd160" //nolint: staticcheck @@ -186,7 +187,7 @@ func (pubKey PubKey) MarshalAmino() ([]byte, error) { // UnmarshalAmino overrides Amino binary marshalling. func (pubKey *PubKey) UnmarshalAmino(bz []byte) error { if len(bz) != PubKeySize { - return errors.Wrap(errors.ErrInvalidPubKey, "invalid pubkey size") + return errorsmod.Wrap(errors.ErrInvalidPubKey, "invalid pubkey size") } pubKey.Key = bz diff --git a/docs/architecture/adr-022-custom-panic-handling.md b/docs/architecture/adr-022-custom-panic-handling.md index 6ed7b6246a..8cb5d9687d 100644 --- a/docs/architecture/adr-022-custom-panic-handling.md +++ b/docs/architecture/adr-022-custom-panic-handling.md @@ -107,7 +107,7 @@ func newOutOfGasRecoveryMiddleware(gasWanted uint64, ctx sdk.Context, next recov err, ok := recoveryObj.(sdk.ErrorOutOfGas) if !ok { return nil } - return sdkerrors.Wrap( + return errorsmod.Wrap( sdkerrors.ErrOutOfGas, fmt.Sprintf( "out of gas in location: %v; gasWanted: %d, gasUsed: %d", err.Descriptor, gasWanted, ctx.GasMeter().GasConsumed(), ), @@ -123,7 +123,7 @@ func newOutOfGasRecoveryMiddleware(gasWanted uint64, ctx sdk.Context, next recov ```go func newDefaultRecoveryMiddleware() recoveryMiddleware { handler := func(recoveryObj interface{}) error { - return sdkerrors.Wrap( + return errorsmod.Wrap( sdkerrors.ErrPanic, fmt.Sprintf("recovered: %v\nstack:\n%v", recoveryObj, string(debug.Stack())), ) } diff --git a/docs/docs/basics/03-accounts.md b/docs/docs/basics/03-accounts.md index 8f98194aef..cb833be431 100644 --- a/docs/docs/basics/03-accounts.md +++ b/docs/docs/basics/03-accounts.md @@ -199,7 +199,7 @@ First a new function to create a private key from a secret number is needed in t func NewPrivKeyFromSecret(secret []byte) (*PrivKey, error) { var d = new(big.Int).SetBytes(secret) if d.Cmp(secp256r1.Params().N) >= 1 { - return nil, sdkerrors.Wrap(errors.ErrInvalidRequest, "secret not in the curve base field") + return nil, errorsmod.Wrap(errors.ErrInvalidRequest, "secret not in the curve base field") } sk := new(ecdsa.PrivKey) return &PrivKey{&ecdsaSK{*sk}}, nil diff --git a/docs/docs/core/11-runtx_middleware.md b/docs/docs/core/11-runtx_middleware.md index 1db62be7a2..40210085f8 100644 --- a/docs/docs/core/11-runtx_middleware.md +++ b/docs/docs/core/11-runtx_middleware.md @@ -39,7 +39,7 @@ We have a module keeper that panics: func (k FooKeeper) Do(obj interface{}) { if obj == nil { // that shouldn't happen, we need to crash the app - err := sdkErrors.Wrap(fooTypes.InternalError, "obj is nil") + err := errorsmod.Wrap(fooTypes.InternalError, "obj is nil") panic(err) } } diff --git a/docs/docs/core/14-tips.md b/docs/docs/core/14-tips.md index 2c566cfcfd..7a3261233f 100644 --- a/docs/docs/core/14-tips.md +++ b/docs/docs/core/14-tips.md @@ -93,7 +93,7 @@ type HandlerOptions struct { // MyPostHandler returns a posthandler chain with the TipDecorator. func MyPostHandler(options HandlerOptions) (sdk.AnteHandler, error) { if options.BankKeeper == nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "bank keeper is required for posthandler") + return nil, errorsmod.Wrap(sdkerrors.ErrLogic, "bank keeper is required for posthandler") } postDecorators := []sdk.AnteDecorator{ diff --git a/errors/doc.go b/errors/doc.go index ed6b9a69bf..b003b74841 100644 --- a/errors/doc.go +++ b/errors/doc.go @@ -18,7 +18,7 @@ information by using Wrap function, for example: func safeDiv(val, div int) (int, err) { if div == 0 { - return 0, errors.Wrapf(ErrZeroDivision, "cannot divide %d", val) + return 0, errorsmod.Wrapf(ErrZeroDivision, "cannot divide %d", val) } return val / div, nil } diff --git a/errors/errors_test.go b/errors/errors_test.go index 1dda2344e6..8251b5c995 100644 --- a/errors/errors_test.go +++ b/errors/errors_test.go @@ -67,12 +67,12 @@ func (s *errorsTestSuite) TestErrorIs() { }, "successful comparison to a wrapped error": { a: ErrUnauthorized, - b: errors.Wrap(ErrUnauthorized, "gone"), + b: errorsmod.Wrap(ErrUnauthorized, "gone"), wantIs: true, }, "unsuccessful comparison to a wrapped error": { a: ErrUnauthorized, - b: errors.Wrap(ErrInsufficientFee, "too big"), + b: errorsmod.Wrap(ErrInsufficientFee, "too big"), wantIs: false, }, "not equal to stdlib error": { @@ -82,7 +82,7 @@ func (s *errorsTestSuite) TestErrorIs() { }, "not equal to a wrapped stdlib error": { a: ErrUnauthorized, - b: errors.Wrap(fmt.Errorf("stdlib error"), "wrapped"), + b: errorsmod.Wrap(fmt.Errorf("stdlib error"), "wrapped"), wantIs: false, }, "nil is nil": { @@ -226,7 +226,7 @@ func (s *errorsTestSuite) TestGRPCStatus() { func ExampleWrap() { err1 := Wrap(ErrInsufficientFunds, "90 is smaller than 100") - err2 := errors.Wrap(ErrInsufficientFunds, "90 is smaller than 100") + err2 := errorsmod.Wrap(ErrInsufficientFunds, "90 is smaller than 100") fmt.Println(err1.Error()) fmt.Println(err2.Error()) // Output: @@ -236,7 +236,7 @@ func ExampleWrap() { func ExampleWrapf() { err1 := Wrap(ErrInsufficientFunds, "90 is smaller than 100") - err2 := errors.Wrap(ErrInsufficientFunds, "90 is smaller than 100") + err2 := errorsmod.Wrap(ErrInsufficientFunds, "90 is smaller than 100") fmt.Println(err1.Error()) fmt.Println(err2.Error()) // Output: diff --git a/orm/encoding/ormfield/timestamp.go b/orm/encoding/ormfield/timestamp.go index 4342be5f8b..eb13c3de74 100644 --- a/orm/encoding/ormfield/timestamp.go +++ b/orm/encoding/ormfield/timestamp.go @@ -96,7 +96,7 @@ func (t TimestampCodec) Decode(r Reader) (protoreflect.Value, error) { return protoreflect.Value{}, io.EOF } - var seconds = int64(b0) + seconds := int64(b0) for i := 0; i < 4; i++ { seconds <<= 8 seconds |= int64(secondsBz[i]) @@ -124,7 +124,7 @@ func (t TimestampCodec) Decode(r Reader) (protoreflect.Value, error) { return protoreflect.Value{}, io.EOF } - var nanos = int32(b0) & 0x3F // clear first two bits + nanos := int32(b0) & 0x3F // clear first two bits for i := 0; i < 3; i++ { nanos <<= 8 nanos |= int32(nanosBz[i]) diff --git a/orm/model/ormdb/module.go b/orm/model/ormdb/module.go index 598fdbb31d..ff0c0ccf1a 100644 --- a/orm/model/ormdb/module.go +++ b/orm/model/ormdb/module.go @@ -212,6 +212,7 @@ func (m moduleDB) EncodeEntry(entry ormkv.Entry) (k, v []byte, err error) { func (m moduleDB) GetTable(message proto.Message) ormtable.Table { return m.tablesByName[message.ProtoReflect().Descriptor().FullName()] } + func (m moduleDB) GenesisHandler() appmodule.HasGenesis { return appModuleGenesisWrapper{m} } diff --git a/server/mock/tx.go b/server/mock/tx.go index 18c42a3e92..f9f1c394dc 100644 --- a/server/mock/tx.go +++ b/server/mock/tx.go @@ -6,6 +6,8 @@ import ( "github.com/cosmos/cosmos-sdk/x/auth/signing" + errorsmod "cosmossdk.io/errors" + cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" @@ -126,7 +128,7 @@ func decodeTx(txBytes []byte) (sdk.Tx, error) { k, v := split[0], split[1] tx = &KVStoreTx{k, v, txBytes, nil} } else { - return nil, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "too many '='") + return nil, errorsmod.Wrap(sdkerrors.ErrTxDecode, "too many '='") } return tx, nil diff --git a/simapp/go.sum b/simapp/go.sum index 63d90e795a..2d9cc05438 100644 --- a/simapp/go.sum +++ b/simapp/go.sum @@ -200,8 +200,6 @@ cosmossdk.io/depinject v1.0.0-alpha.3 h1:6evFIgj//Y3w09bqOUOzEpFj5tsxBqdc5CfkO7z cosmossdk.io/depinject v1.0.0-alpha.3/go.mod h1:eRbcdQ7MRpIPEM5YUJh8k97nxHpYbc3sMUnEtt8HPWU= cosmossdk.io/errors v1.0.0-beta.7 h1:gypHW76pTQGVnHKo6QBkb4yFOJjC+sUGRc5Al3Odj1w= cosmossdk.io/errors v1.0.0-beta.7/go.mod h1:mz6FQMJRku4bY7aqS/Gwfcmr/ue91roMEKAmDUDpBfE= -cosmossdk.io/math v1.0.0-beta.6 h1:WF29SiFYNde5eYvqO2kdOM9nYbDb44j3YW5B8M1m9KE= -cosmossdk.io/math v1.0.0-beta.6/go.mod h1:gUVtWwIzfSXqcOT+lBVz2jyjfua8DoBdzRsIyaUAT/8= cosmossdk.io/math v1.0.0-beta.6.0.20230216172121-959ce49135e4 h1:/jnzJ9zFsL7qkV8LCQ1JH3dYHh2EsKZ3k8Mr6AqqiOA= cosmossdk.io/math v1.0.0-beta.6.0.20230216172121-959ce49135e4/go.mod h1:gUVtWwIzfSXqcOT+lBVz2jyjfua8DoBdzRsIyaUAT/8= cosmossdk.io/store v0.0.0-20230206092147-e03195e4b8a7 h1:IwyDN/YaQmF+Pmuv8d7vRWMM/k2RjSmPBycMcmd3ICE= diff --git a/simapp/upgrades.go b/simapp/upgrades.go index 568b48bd39..891d72d476 100644 --- a/simapp/upgrades.go +++ b/simapp/upgrades.go @@ -48,7 +48,7 @@ func (app SimApp) RegisterUpgradeHandlers() { case slashingtypes.ModuleName: keyTable = slashingtypes.ParamKeyTable() case govtypes.ModuleName: - keyTable = govv1.ParamKeyTable() + keyTable = govv1.ParamKeyTable() //nolint:staticcheck // we still need this for upgrades case crisistypes.ModuleName: keyTable = crisistypes.ParamKeyTable() } diff --git a/store/iavl/store.go b/store/iavl/store.go index f2c2192683..5b55b52604 100644 --- a/store/iavl/store.go +++ b/store/iavl/store.go @@ -12,7 +12,7 @@ import ( dbm "github.com/cosmos/cosmos-db" "github.com/cosmos/iavl" - sdkerrors "cosmossdk.io/errors" + errorsmod "cosmossdk.io/errors" "cosmossdk.io/store/cachekv" "cosmossdk.io/store/internal/kv" "cosmossdk.io/store/metrics" @@ -275,7 +275,7 @@ func (st *Store) SetInitialVersion(version int64) { func (st *Store) Export(version int64) (*iavl.Exporter, error) { istore, err := st.GetImmutable(version) if err != nil { - return nil, sdkerrors.Wrapf(err, "iavl export failed for version %v", version) + return nil, errorsmod.Wrapf(err, "iavl export failed for version %v", version) } tree, ok := istore.tree.(*immutableTree) if !ok || tree == nil { @@ -322,7 +322,7 @@ func (st *Store) Query(req abci.RequestQuery) (res abci.ResponseQuery) { defer st.metrics.MeasureSince("store", "iavl", "query") if len(req.Data) == 0 { - return types.QueryResult(sdkerrors.Wrap(types.ErrTxDecode, "query cannot be zero length"), false) + return types.QueryResult(errorsmod.Wrap(types.ErrTxDecode, "query cannot be zero length"), false) } tree := st.tree @@ -387,7 +387,7 @@ func (st *Store) Query(req abci.RequestQuery) (res abci.ResponseQuery) { res.Value = bz default: - return types.QueryResult(sdkerrors.Wrapf(types.ErrUnknownRequest, "unexpected query path: %v", req.Path), false) + return types.QueryResult(errorsmod.Wrapf(types.ErrUnknownRequest, "unexpected query path: %v", req.Path), false) } return res diff --git a/store/rootmulti/store.go b/store/rootmulti/store.go index 849bca630f..38f54607c1 100644 --- a/store/rootmulti/store.go +++ b/store/rootmulti/store.go @@ -16,7 +16,7 @@ import ( gogotypes "github.com/cosmos/gogoproto/types" iavltree "github.com/cosmos/iavl" - sdkerrors "cosmossdk.io/errors" + errorsmod "cosmossdk.io/errors" "cosmossdk.io/store/cachemulti" "cosmossdk.io/store/dbadapter" "cosmossdk.io/store/iavl" @@ -258,7 +258,7 @@ func (rs *Store) loadVersion(ver int64, upgrades *types.StoreUpgrades) error { store, err := rs.loadCommitStoreFromParams(key, commitID, storeParams) if err != nil { - return sdkerrors.Wrap(err, "failed to load store") + return errorsmod.Wrap(err, "failed to load store") } newStores[key] = store @@ -266,7 +266,7 @@ func (rs *Store) loadVersion(ver int64, upgrades *types.StoreUpgrades) error { // If it was deleted, remove all data if upgrades.IsDeleted(key.Name()) { if err := deleteKVStore(store.(types.KVStore)); err != nil { - return sdkerrors.Wrapf(err, "failed to delete store %s", key.Name()) + return errorsmod.Wrapf(err, "failed to delete store %s", key.Name()) } rs.removalMap[key] = true } else if oldName := upgrades.RenamedFrom(key.Name()); oldName != "" { @@ -278,12 +278,12 @@ func (rs *Store) loadVersion(ver int64, upgrades *types.StoreUpgrades) error { // load from the old name oldStore, err := rs.loadCommitStoreFromParams(oldKey, rs.getCommitID(infos, oldName), oldParams) if err != nil { - return sdkerrors.Wrapf(err, "failed to load old store %s", oldName) + return errorsmod.Wrapf(err, "failed to load old store %s", oldName) } // move all data if err := moveKVStoreData(oldStore.(types.KVStore), store.(types.KVStore)); err != nil { - return sdkerrors.Wrapf(err, "failed to move store %s -> %s", oldName, key.Name()) + return errorsmod.Wrapf(err, "failed to move store %s -> %s", oldName, key.Name()) } // add the old key so its deletion is committed @@ -654,12 +654,12 @@ func (rs *Store) Query(req abci.RequestQuery) abci.ResponseQuery { store := rs.GetStoreByName(storeName) if store == nil { - return types.QueryResult(sdkerrors.Wrapf(types.ErrUnknownRequest, "no such store: %s", storeName), false) + return types.QueryResult(errorsmod.Wrapf(types.ErrUnknownRequest, "no such store: %s", storeName), false) } queryable, ok := store.(types.Queryable) if !ok { - return types.QueryResult(sdkerrors.Wrapf(types.ErrUnknownRequest, "store %s (type %T) doesn't support queries", storeName, store), false) + return types.QueryResult(errorsmod.Wrapf(types.ErrUnknownRequest, "store %s (type %T) doesn't support queries", storeName, store), false) } // trim the path and make the query @@ -671,7 +671,7 @@ func (rs *Store) Query(req abci.RequestQuery) abci.ResponseQuery { } if res.ProofOps == nil || len(res.ProofOps.Ops) == 0 { - return types.QueryResult(sdkerrors.Wrap(types.ErrInvalidRequest, "proof is unexpectedly empty; ensure height has not been pruned"), false) + return types.QueryResult(errorsmod.Wrap(types.ErrInvalidRequest, "proof is unexpectedly empty; ensure height has not been pruned"), false) } // If the request's height is the latest height we've committed, then utilize @@ -718,7 +718,7 @@ func (rs *Store) SetInitialVersion(version int64) error { // Returns error if it doesn't start with / func parsePath(path string) (storeName string, subpath string, err error) { if !strings.HasPrefix(path, "/") { - return storeName, subpath, sdkerrors.Wrapf(types.ErrUnknownRequest, "invalid path: %s", path) + return storeName, subpath, errorsmod.Wrapf(types.ErrUnknownRequest, "invalid path: %s", path) } paths := strings.SplitN(path[1:], "/", 2) @@ -739,10 +739,10 @@ func parsePath(path string) (storeName string, subpath string, err error) { // TestMultistoreSnapshot_Checksum test. func (rs *Store) Snapshot(height uint64, protoWriter protoio.Writer) error { if height == 0 { - return sdkerrors.Wrap(types.ErrLogic, "cannot snapshot height 0") + return errorsmod.Wrap(types.ErrLogic, "cannot snapshot height 0") } if height > uint64(GetLatestVersion(rs.db)) { - return sdkerrors.Wrapf(types.ErrLogic, "cannot snapshot future height %v", height) + return errorsmod.Wrapf(types.ErrLogic, "cannot snapshot future height %v", height) } // Collect stores to snapshot (only IAVL stores are supported) @@ -760,7 +760,7 @@ func (rs *Store) Snapshot(height uint64, protoWriter protoio.Writer) error { // Non-persisted stores shouldn't be snapshotted continue default: - return sdkerrors.Wrapf(types.ErrLogic, + return errorsmod.Wrapf(types.ErrLogic, "don't know how to snapshot store %q of type %T", key.Name(), store) } } @@ -842,7 +842,7 @@ loop: if err == io.EOF { break } else if err != nil { - return snapshottypes.SnapshotItem{}, sdkerrors.Wrap(err, "invalid protobuf message") + return snapshottypes.SnapshotItem{}, errorsmod.Wrap(err, "invalid protobuf message") } switch item := snapshotItem.Item.(type) { @@ -850,26 +850,26 @@ loop: if importer != nil { err = importer.Commit() if err != nil { - return snapshottypes.SnapshotItem{}, sdkerrors.Wrap(err, "IAVL commit failed") + return snapshottypes.SnapshotItem{}, errorsmod.Wrap(err, "IAVL commit failed") } importer.Close() } store, ok := rs.GetStoreByName(item.Store.Name).(*iavl.Store) if !ok || store == nil { - return snapshottypes.SnapshotItem{}, sdkerrors.Wrapf(types.ErrLogic, "cannot import into non-IAVL store %q", item.Store.Name) + return snapshottypes.SnapshotItem{}, errorsmod.Wrapf(types.ErrLogic, "cannot import into non-IAVL store %q", item.Store.Name) } importer, err = store.Import(int64(height)) if err != nil { - return snapshottypes.SnapshotItem{}, sdkerrors.Wrap(err, "import failed") + return snapshottypes.SnapshotItem{}, errorsmod.Wrap(err, "import failed") } defer importer.Close() case *snapshottypes.SnapshotItem_IAVL: if importer == nil { - return snapshottypes.SnapshotItem{}, sdkerrors.Wrap(types.ErrLogic, "received IAVL node item before store item") + return snapshottypes.SnapshotItem{}, errorsmod.Wrap(types.ErrLogic, "received IAVL node item before store item") } if item.IAVL.Height > math.MaxInt8 { - return snapshottypes.SnapshotItem{}, sdkerrors.Wrapf(types.ErrLogic, "node height %v cannot exceed %v", + return snapshottypes.SnapshotItem{}, errorsmod.Wrapf(types.ErrLogic, "node height %v cannot exceed %v", item.IAVL.Height, math.MaxInt8) } node := &iavltree.ExportNode{ @@ -888,7 +888,7 @@ loop: } err := importer.Add(node) if err != nil { - return snapshottypes.SnapshotItem{}, sdkerrors.Wrap(err, "IAVL node import failed") + return snapshottypes.SnapshotItem{}, errorsmod.Wrap(err, "IAVL node import failed") } default: @@ -899,7 +899,7 @@ loop: if importer != nil { err := importer.Commit() if err != nil { - return snapshottypes.SnapshotItem{}, sdkerrors.Wrap(err, "IAVL commit failed") + return snapshottypes.SnapshotItem{}, errorsmod.Wrap(err, "IAVL commit failed") } importer.Close() } @@ -1116,14 +1116,14 @@ func getCommitInfo(db dbm.DB, ver int64) (*types.CommitInfo, error) { bz, err := db.Get([]byte(cInfoKey)) if err != nil { - return nil, sdkerrors.Wrap(err, "failed to get commit info") + return nil, errorsmod.Wrap(err, "failed to get commit info") } else if bz == nil { return nil, errors.New("no commit info found") } cInfo := &types.CommitInfo{} if err = cInfo.Unmarshal(bz); err != nil { - return nil, sdkerrors.Wrap(err, "failed unmarshal commit info") + return nil, errorsmod.Wrap(err, "failed unmarshal commit info") } return cInfo, nil diff --git a/store/snapshots/chunk.go b/store/snapshots/chunk.go index 16cafc09ec..7cfce63302 100644 --- a/store/snapshots/chunk.go +++ b/store/snapshots/chunk.go @@ -5,7 +5,6 @@ import ( "math" "cosmossdk.io/errors" - snapshottypes "cosmossdk.io/store/snapshots/types" storetypes "cosmossdk.io/store/types" ) diff --git a/store/snapshots/helpers_test.go b/store/snapshots/helpers_test.go index 327d311707..3472af6068 100644 --- a/store/snapshots/helpers_test.go +++ b/store/snapshots/helpers_test.go @@ -16,7 +16,7 @@ import ( protoio "github.com/cosmos/gogoproto/io" "github.com/stretchr/testify/require" - sdkerrors "cosmossdk.io/errors" + errorsmod "cosmossdk.io/errors" "cosmossdk.io/store/snapshots" snapshottypes "cosmossdk.io/store/snapshots/types" "cosmossdk.io/store/types" @@ -130,7 +130,7 @@ func (m *mockSnapshotter) Restore( if err == io.EOF { break } else if err != nil { - return snapshottypes.SnapshotItem{}, sdkerrors.Wrap(err, "invalid protobuf message") + return snapshottypes.SnapshotItem{}, errorsmod.Wrap(err, "invalid protobuf message") } payload := item.GetExtensionPayload() if payload == nil { diff --git a/store/snapshots/manager.go b/store/snapshots/manager.go index b7eb560abe..bacffe5f6f 100644 --- a/store/snapshots/manager.go +++ b/store/snapshots/manager.go @@ -10,9 +10,9 @@ import ( "sort" "sync" - sdkerrors "cosmossdk.io/errors" "cosmossdk.io/log" + errorsmod "cosmossdk.io/errors" "cosmossdk.io/store/snapshots/types" storetypes "cosmossdk.io/store/types" ) @@ -111,10 +111,10 @@ func (m *Manager) begin(op operation) error { // beginLocked begins an operation while already holding the mutex. func (m *Manager) beginLocked(op operation) error { if op == opNone { - return sdkerrors.Wrap(storetypes.ErrLogic, "can't begin a none operation") + return errorsmod.Wrap(storetypes.ErrLogic, "can't begin a none operation") } if m.operation != opNone { - return sdkerrors.Wrapf(storetypes.ErrConflict, "a %v operation is in progress", m.operation) + return errorsmod.Wrapf(storetypes.ErrConflict, "a %v operation is in progress", m.operation) } m.operation = op return nil @@ -160,7 +160,7 @@ func (m *Manager) GetSnapshotBlockRetentionHeights() int64 { // Create creates a snapshot and returns its metadata. func (m *Manager) Create(height uint64) (*types.Snapshot, error) { if m == nil { - return nil, sdkerrors.Wrap(storetypes.ErrLogic, "no snapshot store configured") + return nil, errorsmod.Wrap(storetypes.ErrLogic, "no snapshot store configured") } defer m.multistore.PruneSnapshotHeight(int64(height)) @@ -173,10 +173,10 @@ func (m *Manager) Create(height uint64) (*types.Snapshot, error) { latest, err := m.store.GetLatest() if err != nil { - return nil, sdkerrors.Wrap(err, "failed to examine latest snapshot") + return nil, errorsmod.Wrap(err, "failed to examine latest snapshot") } if latest != nil && latest.Height >= height { - return nil, sdkerrors.Wrapf(storetypes.ErrConflict, + return nil, errorsmod.Wrapf(storetypes.ErrConflict, "a more recent snapshot already exists at height %v", latest.Height) } @@ -263,10 +263,10 @@ func (m *Manager) Prune(retain uint32) (uint64, error) { // via RestoreChunk() until the restore is complete or a chunk fails. func (m *Manager) Restore(snapshot types.Snapshot) error { if snapshot.Chunks == 0 { - return sdkerrors.Wrap(types.ErrInvalidMetadata, "no chunks") + return errorsmod.Wrap(types.ErrInvalidMetadata, "no chunks") } if uint32(len(snapshot.Metadata.ChunkHashes)) != snapshot.Chunks { - return sdkerrors.Wrapf(types.ErrInvalidMetadata, "snapshot has %v chunk hashes, but %v chunks", + return errorsmod.Wrapf(types.ErrInvalidMetadata, "snapshot has %v chunk hashes, but %v chunks", uint32(len(snapshot.Metadata.ChunkHashes)), snapshot.Chunks) } @@ -275,13 +275,13 @@ func (m *Manager) Restore(snapshot types.Snapshot) error { // check multistore supported format preemptive if snapshot.Format != types.CurrentFormat { - return sdkerrors.Wrapf(types.ErrUnknownFormat, "snapshot format %v", snapshot.Format) + return errorsmod.Wrapf(types.ErrUnknownFormat, "snapshot format %v", snapshot.Format) } if snapshot.Height == 0 { - return sdkerrors.Wrap(storetypes.ErrLogic, "cannot restore snapshot at height 0") + return errorsmod.Wrap(storetypes.ErrLogic, "cannot restore snapshot at height 0") } if snapshot.Height > uint64(math.MaxInt64) { - return sdkerrors.Wrapf(types.ErrInvalidMetadata, + return errorsmod.Wrapf(types.ErrInvalidMetadata, "snapshot height %v cannot exceed %v", snapshot.Height, int64(math.MaxInt64)) } @@ -335,7 +335,7 @@ func (m *Manager) restoreSnapshot(snapshot types.Snapshot, chChunks <-chan io.Re nextItem, err = m.multistore.Restore(snapshot.Height, snapshot.Format, streamReader) if err != nil { - return sdkerrors.Wrap(err, "multistore restore") + return errorsmod.Wrap(err, "multistore restore") } for { @@ -345,22 +345,22 @@ func (m *Manager) restoreSnapshot(snapshot types.Snapshot, chChunks <-chan io.Re } metadata := nextItem.GetExtension() if metadata == nil { - return sdkerrors.Wrapf(storetypes.ErrLogic, "unknown snapshot item %T", nextItem.Item) + return errorsmod.Wrapf(storetypes.ErrLogic, "unknown snapshot item %T", nextItem.Item) } extension, ok := m.extensions[metadata.Name] if !ok { - return sdkerrors.Wrapf(storetypes.ErrLogic, "unknown extension snapshotter %s", metadata.Name) + return errorsmod.Wrapf(storetypes.ErrLogic, "unknown extension snapshotter %s", metadata.Name) } if !IsFormatSupported(extension, metadata.Format) { - return sdkerrors.Wrapf(types.ErrUnknownFormat, "format %v for extension %s", metadata.Format, metadata.Name) + return errorsmod.Wrapf(types.ErrUnknownFormat, "format %v for extension %s", metadata.Format, metadata.Name) } if err := extension.RestoreExtension(snapshot.Height, metadata.Format, payloadReader); err != nil { - return sdkerrors.Wrapf(err, "extension %s restore", metadata.Name) + return errorsmod.Wrapf(err, "extension %s restore", metadata.Name) } if nextItem.GetExtensionPayload() != nil { - return sdkerrors.Wrapf(err, "extension %s don't exhausted payload stream", metadata.Name) + return errorsmod.Wrapf(err, "extension %s don't exhausted payload stream", metadata.Name) } } return nil @@ -372,11 +372,11 @@ func (m *Manager) RestoreChunk(chunk []byte) (bool, error) { m.mtx.Lock() defer m.mtx.Unlock() if m.operation != opRestore { - return false, sdkerrors.Wrap(storetypes.ErrLogic, "no restore operation in progress") + return false, errorsmod.Wrap(storetypes.ErrLogic, "no restore operation in progress") } if int(m.restoreChunkIndex) >= len(m.restoreChunkHashes) { - return false, sdkerrors.Wrap(storetypes.ErrLogic, "received unexpected chunk") + return false, errorsmod.Wrap(storetypes.ErrLogic, "received unexpected chunk") } // Check if any errors have occurred yet. @@ -386,7 +386,7 @@ func (m *Manager) RestoreChunk(chunk []byte) (bool, error) { if done.err != nil { return false, done.err } - return false, sdkerrors.Wrap(storetypes.ErrLogic, "restore ended unexpectedly") + return false, errorsmod.Wrap(storetypes.ErrLogic, "restore ended unexpectedly") default: } @@ -394,7 +394,7 @@ func (m *Manager) RestoreChunk(chunk []byte) (bool, error) { hash := sha256.Sum256(chunk) expected := m.restoreChunkHashes[m.restoreChunkIndex] if !bytes.Equal(hash[:], expected) { - return false, sdkerrors.Wrapf(types.ErrChunkHashMismatch, + return false, errorsmod.Wrapf(types.ErrChunkHashMismatch, "expected %x, got %x", hash, expected) } @@ -411,7 +411,7 @@ func (m *Manager) RestoreChunk(chunk []byte) (bool, error) { return false, done.err } if !done.complete { - return false, sdkerrors.Wrap(storetypes.ErrLogic, "restore ended prematurely") + return false, errorsmod.Wrap(storetypes.ErrLogic, "restore ended prematurely") } return true, nil } diff --git a/store/snapshots/store.go b/store/snapshots/store.go index cb52e93711..8434c9f37d 100644 --- a/store/snapshots/store.go +++ b/store/snapshots/store.go @@ -10,10 +10,10 @@ import ( "strconv" "sync" - "cosmossdk.io/errors" db "github.com/cosmos/cosmos-db" "github.com/cosmos/gogoproto/proto" + "cosmossdk.io/errors" "cosmossdk.io/store/snapshots/types" storetypes "cosmossdk.io/store/types" ) diff --git a/store/snapshots/stream.go b/store/snapshots/stream.go index 1c858d2249..9c4c8a9412 100644 --- a/store/snapshots/stream.go +++ b/store/snapshots/stream.go @@ -6,7 +6,6 @@ import ( "io" "cosmossdk.io/errors" - protoio "github.com/cosmos/gogoproto/io" "github.com/cosmos/gogoproto/proto" ) diff --git a/store/snapshots/types/convert.go b/store/snapshots/types/convert.go index 90deead3bf..71b3d0642b 100644 --- a/store/snapshots/types/convert.go +++ b/store/snapshots/types/convert.go @@ -1,10 +1,9 @@ package types import ( + "cosmossdk.io/errors" abci "github.com/cometbft/cometbft/abci/types" proto "github.com/cosmos/gogoproto/proto" - - "cosmossdk.io/errors" ) // Converts an ABCI snapshot to a snapshot. Mainly to decode the SDK metadata. diff --git a/store/tracekv/store.go b/store/tracekv/store.go index c18ef21081..9895d8ec41 100644 --- a/store/tracekv/store.go +++ b/store/tracekv/store.go @@ -6,6 +6,7 @@ import ( "io" "cosmossdk.io/errors" + "cosmossdk.io/store/types" ) diff --git a/store/types/proof.go b/store/types/proof.go index a63c99a75a..bb3abdc855 100644 --- a/store/types/proof.go +++ b/store/types/proof.go @@ -7,7 +7,7 @@ import ( cmtprotocrypto "github.com/cometbft/cometbft/proto/tendermint/crypto" ics23 "github.com/confio/ics23/go" - sdkerrors "cosmossdk.io/errors" + errorsmod "cosmossdk.io/errors" sdkmaps "cosmossdk.io/store/internal/maps" sdkproofs "cosmossdk.io/store/internal/proofs" ) @@ -73,7 +73,7 @@ func CommitmentOpDecoder(pop cmtprotocrypto.ProofOp) (merkle.ProofOperator, erro case ProofOpSMTCommitment: spec = ics23.SmtSpec default: - return nil, sdkerrors.Wrapf(ErrInvalidProof, "unexpected ProofOp.Type; got %s, want supported ics23 subtypes 'ProofOpSimpleMerkleCommitment', 'ProofOpIAVLCommitment', or 'ProofOpSMTCommitment'", pop.Type) + return nil, errorsmod.Wrapf(ErrInvalidProof, "unexpected ProofOp.Type; got %s, want supported ics23 subtypes 'ProofOpSimpleMerkleCommitment', 'ProofOpIAVLCommitment', or 'ProofOpSMTCommitment'", pop.Type) } proof := &ics23.CommitmentProof{} @@ -108,7 +108,7 @@ func (op CommitmentOp) Run(args [][]byte) ([][]byte, error) { // calculate root from proof root, err := op.Proof.Calculate() if err != nil { - return nil, sdkerrors.Wrapf(ErrInvalidProof, "could not calculate root for proof: %v", err) + return nil, errorsmod.Wrapf(ErrInvalidProof, "could not calculate root for proof: %v", err) } // Only support an existence proof or nonexistence proof (batch proofs currently unsupported) switch len(args) { @@ -116,16 +116,16 @@ func (op CommitmentOp) Run(args [][]byte) ([][]byte, error) { // Args are nil, so we verify the absence of the key. absent := ics23.VerifyNonMembership(op.Spec, root, op.Proof, op.Key) if !absent { - return nil, sdkerrors.Wrapf(ErrInvalidProof, "proof did not verify absence of key: %s", string(op.Key)) + return nil, errorsmod.Wrapf(ErrInvalidProof, "proof did not verify absence of key: %s", string(op.Key)) } case 1: // Args is length 1, verify existence of key with value args[0] if !ics23.VerifyMembership(op.Spec, root, op.Proof, op.Key, args[0]) { - return nil, sdkerrors.Wrapf(ErrInvalidProof, "proof did not verify existence of key %s with given value %x", op.Key, args[0]) + return nil, errorsmod.Wrapf(ErrInvalidProof, "proof did not verify existence of key %s with given value %x", op.Key, args[0]) } default: - return nil, sdkerrors.Wrapf(ErrInvalidProof, "args must be length 0 or 1, got: %d", len(args)) + return nil, errorsmod.Wrapf(ErrInvalidProof, "args must be length 0 or 1, got: %d", len(args)) } return [][]byte{root}, nil diff --git a/tests/e2e/server/export_test.go b/tests/e2e/server/export_test.go index 3f1c13388d..5b911c904d 100644 --- a/tests/e2e/server/export_test.go +++ b/tests/e2e/server/export_test.go @@ -22,13 +22,13 @@ import ( "github.com/spf13/cobra" "github.com/stretchr/testify/require" + errorsmod "cosmossdk.io/errors" "cosmossdk.io/simapp" "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/client/flags" "github.com/cosmos/cosmos-sdk/server" "github.com/cosmos/cosmos-sdk/server/types" simtestutil "github.com/cosmos/cosmos-sdk/testutil/sims" - "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/genutil" ) @@ -227,7 +227,7 @@ func createConfigFolder(dir string) error { func saveGenesisFile(genDoc *cmttypes.GenesisDoc, dir string) error { err := genutil.ExportGenesisFile(genDoc, dir) if err != nil { - return errors.Wrap(err, "error creating file") + return errorsmod.Wrap(err, "error creating file") } return nil diff --git a/tests/e2e/tx/service_test.go b/tests/e2e/tx/service_test.go index c30129073b..c7767ac089 100644 --- a/tests/e2e/tx/service_test.go +++ b/tests/e2e/tx/service_test.go @@ -10,8 +10,8 @@ import ( "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" + errorsmod "cosmossdk.io/errors" "cosmossdk.io/simapp" - "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/client/flags" clienttx "github.com/cosmos/cosmos-sdk/client/tx" @@ -1155,7 +1155,7 @@ type protoTxProvider interface { func txBuilderToProtoTx(txBuilder client.TxBuilder) (*tx.Tx, error) { // nolint protoProvider, ok := txBuilder.(protoTxProvider) if !ok { - return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidType, "expected proto tx builder, got %T", txBuilder) + return nil, errorsmod.Wrapf(sdkerrors.ErrInvalidType, "expected proto tx builder, got %T", txBuilder) } return protoProvider.GetProtoTx(), nil diff --git a/tests/go.mod b/tests/go.mod index b32ae990bc..88437f9eb3 100644 --- a/tests/go.mod +++ b/tests/go.mod @@ -5,6 +5,7 @@ go 1.20 require ( cosmossdk.io/api v0.3.0 cosmossdk.io/depinject v1.0.0-alpha.3 + cosmossdk.io/errors v1.0.0-beta.7 cosmossdk.io/log v0.0.0 cosmossdk.io/math v1.0.0-beta.6.0.20230216172121-959ce49135e4 cosmossdk.io/simapp v0.0.0-00010101000000-000000000000 @@ -36,7 +37,6 @@ require ( cosmossdk.io/client/v2 v2.0.0-20230104083136-11f46a0bae58 // indirect cosmossdk.io/collections v0.0.0-20230204135315-697871069999 // indirect cosmossdk.io/core v0.5.1 // indirect - cosmossdk.io/errors v1.0.0-beta.7 // indirect cosmossdk.io/x/tx v0.2.0 // indirect filippo.io/edwards25519 v1.0.0-rc.1 // indirect github.com/99designs/go-keychain v0.0.0-20191008050251-8e49817e8af4 // indirect diff --git a/testutil/sims/address_helpers.go b/testutil/sims/address_helpers.go index d95279c323..0b8ede8203 100644 --- a/testutil/sims/address_helpers.go +++ b/testutil/sims/address_helpers.go @@ -6,7 +6,9 @@ import ( "fmt" "strconv" + errorsmod "cosmossdk.io/errors" "cosmossdk.io/math" + "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519" cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" sdk "github.com/cosmos/cosmos-sdk/types" @@ -154,7 +156,7 @@ func NewPubKeyFromHex(pk string) (res cryptotypes.PubKey) { panic(err) } if len(pkBytes) != ed25519.PubKeySize { - panic(errors.Wrap(errors.ErrInvalidPubKey, "invalid pubkey size")) + panic(errorsmod.Wrap(errors.ErrInvalidPubKey, "invalid pubkey size")) } return &ed25519.PubKey{Key: pkBytes} } diff --git a/testutil/testdata/table.go b/testutil/testdata/table.go index 691d6c8cc3..86bad55ddb 100644 --- a/testutil/testdata/table.go +++ b/testutil/testdata/table.go @@ -1,6 +1,6 @@ package testdata -import "github.com/cosmos/cosmos-sdk/types/errors" +import "cosmossdk.io/errors" var ErrTest = errors.Register("table_testdata", 2, "test") diff --git a/tools/confix/migrations.go b/tools/confix/migrations.go index fa1e9a2374..7d1f17400e 100644 --- a/tools/confix/migrations.go +++ b/tools/confix/migrations.go @@ -19,15 +19,13 @@ const ( // MigrationMap defines a mapping from a version to a transformation plan. type MigrationMap map[string]func(from *tomledit.Document, to string) transform.Plan -var ( - Migrations = MigrationMap{ - "v0.45": NoPlan, // Confix supports only the current supported SDK version. So we do not support v0.44 -> v0.45. - "v0.46": PlanBuilder, - "v0.47": PlanBuilder, - "v0.48": PlanBuilder, - // "v0.xx.x": PlanBuilder, // add specific migration in case of configuration changes in minor versions - } -) +var Migrations = MigrationMap{ + "v0.45": NoPlan, // Confix supports only the current supported SDK version. So we do not support v0.44 -> v0.45. + "v0.46": PlanBuilder, + "v0.47": PlanBuilder, + "v0.48": PlanBuilder, + // "v0.xx.x": PlanBuilder, // add specific migration in case of configuration changes in minor versions +} // PlanBuilder is a function that returns a transformation plan for a given diff between two files. func PlanBuilder(from *tomledit.Document, to string) transform.Plan { @@ -58,7 +56,8 @@ func PlanBuilder(from *tomledit.Document, to string) transform.Plan { Block: parser.Comments{ "###############################################################################", fmt.Sprintf("### %s Configuration ###", strings.Title(kv.Key)), - "###############################################################################"}, + "###############################################################################", + }, Name: keys, }, }) @@ -73,7 +72,8 @@ func PlanBuilder(from *tomledit.Document, to string) transform.Plan { Block: kv.Block, Name: parser.Key{keys[0]}, Value: parser.MustValue(kv.Value), - })} + }), + } } else if len(keys) > 1 { step = transform.Step{ Desc: fmt.Sprintf("add %s key", kv.Key), @@ -81,7 +81,8 @@ func PlanBuilder(from *tomledit.Document, to string) transform.Plan { Block: kv.Block, Name: parser.Key{keys[1]}, Value: parser.MustValue(kv.Value), - })} + }), + } } default: panic(fmt.Errorf("unknown diff type: %s", diff.Type)) diff --git a/tools/confix/upgrade.go b/tools/confix/upgrade.go index ab9328350a..203410d163 100644 --- a/tools/confix/upgrade.go +++ b/tools/confix/upgrade.go @@ -59,7 +59,7 @@ func Upgrade(ctx context.Context, plan transform.Plan, configPath, outputPath st if outputPath == "" { _, err = os.Stdout.Write(buf.Bytes()) } else { - err = atomicfile.WriteData(outputPath, buf.Bytes(), 0600) + err = atomicfile.WriteData(outputPath, buf.Bytes(), 0o600) } return err diff --git a/tools/cosmovisor/go.sum b/tools/cosmovisor/go.sum index ecd960db4b..ce6b408680 100644 --- a/tools/cosmovisor/go.sum +++ b/tools/cosmovisor/go.sum @@ -198,8 +198,6 @@ cosmossdk.io/depinject v1.0.0-alpha.3 h1:6evFIgj//Y3w09bqOUOzEpFj5tsxBqdc5CfkO7z cosmossdk.io/depinject v1.0.0-alpha.3/go.mod h1:eRbcdQ7MRpIPEM5YUJh8k97nxHpYbc3sMUnEtt8HPWU= cosmossdk.io/errors v1.0.0-beta.7 h1:gypHW76pTQGVnHKo6QBkb4yFOJjC+sUGRc5Al3Odj1w= cosmossdk.io/errors v1.0.0-beta.7/go.mod h1:mz6FQMJRku4bY7aqS/Gwfcmr/ue91roMEKAmDUDpBfE= -cosmossdk.io/math v1.0.0-beta.6 h1:WF29SiFYNde5eYvqO2kdOM9nYbDb44j3YW5B8M1m9KE= -cosmossdk.io/math v1.0.0-beta.6/go.mod h1:gUVtWwIzfSXqcOT+lBVz2jyjfua8DoBdzRsIyaUAT/8= cosmossdk.io/math v1.0.0-beta.6.0.20230216172121-959ce49135e4 h1:/jnzJ9zFsL7qkV8LCQ1JH3dYHh2EsKZ3k8Mr6AqqiOA= cosmossdk.io/math v1.0.0-beta.6.0.20230216172121-959ce49135e4/go.mod h1:gUVtWwIzfSXqcOT+lBVz2jyjfua8DoBdzRsIyaUAT/8= cosmossdk.io/store v0.0.0-20230206092147-e03195e4b8a7 h1:IwyDN/YaQmF+Pmuv8d7vRWMM/k2RjSmPBycMcmd3ICE= diff --git a/tools/hubl/internal/config.go b/tools/hubl/internal/config.go index 4a921381db..c25269ccfc 100644 --- a/tools/hubl/internal/config.go +++ b/tools/hubl/internal/config.go @@ -49,12 +49,12 @@ func SaveConfig(configDir string, config *Config) error { return err } - if err := os.MkdirAll(configDir, 0755); err != nil { + if err := os.MkdirAll(configDir, 0o755); err != nil { return err } configPath := configFilename(configDir) - if err := os.WriteFile(configPath, buf.Bytes(), 0644); err != nil { + if err := os.WriteFile(configPath, buf.Bytes(), 0o644); err != nil { return err } diff --git a/tools/hubl/internal/load.go b/tools/hubl/internal/load.go index 14d4218c82..bb389a8d45 100644 --- a/tools/hubl/internal/load.go +++ b/tools/hubl/internal/load.go @@ -44,7 +44,7 @@ func NewChainInfo(configDir string, chain string, config *ChainConfig) *ChainInf func (c *ChainInfo) getCacheDir() (string, error) { cacheDir := path.Join(c.ConfigDir, "cache") - return cacheDir, os.MkdirAll(cacheDir, 0755) + return cacheDir, os.MkdirAll(cacheDir, 0o755) } func (c *ChainInfo) fdsCacheFilename() (string, error) { @@ -92,7 +92,7 @@ func (c *ChainInfo) Load(reload bool) error { return err } - if err = os.WriteFile(fdsFilename, bz, 0644); err != nil { + if err = os.WriteFile(fdsFilename, bz, 0o644); err != nil { return err } } else { @@ -133,7 +133,7 @@ func (c *ChainInfo) Load(reload bool) error { return err } - err = os.WriteFile(appOptsFilename, bz, 0644) + err = os.WriteFile(appOptsFilename, bz, 0o644) if err != nil { return err } diff --git a/tools/hubl/internal/remote.go b/tools/hubl/internal/remote.go index 1b89f233e8..a347b9a561 100644 --- a/tools/hubl/internal/remote.go +++ b/tools/hubl/internal/remote.go @@ -187,8 +187,10 @@ type dynamicTypeResolver struct { *ChainInfo } -var _ protoregistry.MessageTypeResolver = dynamicTypeResolver{} -var _ protoregistry.ExtensionTypeResolver = dynamicTypeResolver{} +var ( + _ protoregistry.MessageTypeResolver = dynamicTypeResolver{} + _ protoregistry.ExtensionTypeResolver = dynamicTypeResolver{} +) func (d dynamicTypeResolver) FindMessageByName(message protoreflect.FullName) (protoreflect.MessageType, error) { desc, err := d.ProtoFiles.FindDescriptorByName(message) diff --git a/types/address.go b/types/address.go index 5b7f1b5785..9c1a521c32 100644 --- a/types/address.go +++ b/types/address.go @@ -12,6 +12,8 @@ import ( "github.com/hashicorp/golang-lru/simplelru" "sigs.k8s.io/yaml" + errorsmod "cosmossdk.io/errors" + cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" "github.com/cosmos/cosmos-sdk/internal/conv" "github.com/cosmos/cosmos-sdk/types/address" @@ -153,11 +155,11 @@ func VerifyAddressFormat(bz []byte) error { } if len(bz) == 0 { - return sdkerrors.Wrap(sdkerrors.ErrUnknownAddress, "addresses cannot be empty") + return errorsmod.Wrap(sdkerrors.ErrUnknownAddress, "addresses cannot be empty") } if len(bz) > address.MaxAddrLen { - return sdkerrors.Wrapf(sdkerrors.ErrUnknownAddress, "address max length is %d, got %d", address.MaxAddrLen, len(bz)) + return errorsmod.Wrapf(sdkerrors.ErrUnknownAddress, "address max length is %d, got %d", address.MaxAddrLen, len(bz)) } return nil diff --git a/types/address/hash.go b/types/address/hash.go index c4e31872f5..994bf722d6 100644 --- a/types/address/hash.go +++ b/types/address/hash.go @@ -8,8 +8,9 @@ import ( "github.com/cometbft/cometbft/crypto" + "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/internal/conv" - "github.com/cosmos/cosmos-sdk/types/errors" ) // Len is the length of base addresses diff --git a/types/address/store_key.go b/types/address/store_key.go index 9484919729..1c4c88465f 100644 --- a/types/address/store_key.go +++ b/types/address/store_key.go @@ -1,6 +1,8 @@ package address import ( + errorsmod "cosmossdk.io/errors" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) @@ -16,7 +18,7 @@ func LengthPrefix(bz []byte) ([]byte, error) { } if bzLen > MaxAddrLen { - return nil, sdkerrors.Wrapf(sdkerrors.ErrUnknownAddress, "address length should be max %d bytes, got %d", MaxAddrLen, bzLen) + return nil, errorsmod.Wrapf(sdkerrors.ErrUnknownAddress, "address length should be max %d bytes, got %d", MaxAddrLen, bzLen) } return append([]byte{byte(bzLen)}, bz...), nil diff --git a/types/address_test.go b/types/address_test.go index 8dc4530dc0..c463af8537 100644 --- a/types/address_test.go +++ b/types/address_test.go @@ -2,9 +2,10 @@ package types_test import ( "bytes" + "crypto/rand" "encoding/hex" "fmt" - "math/rand" + mathrand "math/rand" "strings" "testing" @@ -211,7 +212,7 @@ const letterBytes = "abcdefghijklmnopqrstuvwxyz" func RandString(n int) string { b := make([]byte, n) for i := range b { - b[i] = letterBytes[rand.Intn(len(letterBytes))] + b[i] = letterBytes[mathrand.Intn(len(letterBytes))] } return string(b) } diff --git a/types/errors/abci.go b/types/errors/abci.go index 542ab5dbce..14573bda48 100644 --- a/types/errors/abci.go +++ b/types/errors/abci.go @@ -1,13 +1,14 @@ package errors import ( + errorsmod "cosmossdk.io/errors" abci "github.com/cometbft/cometbft/abci/types" ) // ResponseCheckTxWithEvents returns an ABCI ResponseCheckTx object with fields filled in // from the given error, gas values and events. func ResponseCheckTxWithEvents(err error, gw, gu uint64, events []abci.Event, debug bool) abci.ResponseCheckTx { - space, code, log := ABCIInfo(err, debug) + space, code, log := errorsmod.ABCIInfo(err, debug) return abci.ResponseCheckTx{ Codespace: space, Code: code, @@ -21,7 +22,7 @@ func ResponseCheckTxWithEvents(err error, gw, gu uint64, events []abci.Event, de // ResponseDeliverTxWithEvents returns an ABCI ResponseDeliverTx object with fields filled in // from the given error, gas values and events. func ResponseDeliverTxWithEvents(err error, gw, gu uint64, events []abci.Event, debug bool) abci.ResponseDeliverTx { - space, code, log := ABCIInfo(err, debug) + space, code, log := errorsmod.ABCIInfo(err, debug) return abci.ResponseDeliverTx{ Codespace: space, Code: code, @@ -35,7 +36,7 @@ func ResponseDeliverTxWithEvents(err error, gw, gu uint64, events []abci.Event, // QueryResult returns a ResponseQuery from an error. It will try to parse ABCI // info from the error. func QueryResult(err error, debug bool) abci.ResponseQuery { - space, code, log := ABCIInfo(err, debug) + space, code, log := errorsmod.ABCIInfo(err, debug) return abci.ResponseQuery{ Codespace: space, Code: code, diff --git a/types/errors/errors.go b/types/errors/errors.go index 1c2036f8eb..ff93324c37 100644 --- a/types/errors/errors.go +++ b/types/errors/errors.go @@ -37,135 +37,135 @@ const RootCodespace = "sdk" var ( // ErrTxDecode is returned if we cannot parse a transaction - ErrTxDecode = Register(RootCodespace, 2, "tx parse error") + ErrTxDecode = errorsmod.Register(RootCodespace, 2, "tx parse error") // ErrInvalidSequence is used the sequence number (nonce) is incorrect // for the signature - ErrInvalidSequence = Register(RootCodespace, 3, "invalid sequence") + ErrInvalidSequence = errorsmod.Register(RootCodespace, 3, "invalid sequence") // ErrUnauthorized is used whenever a request without sufficient // authorization is handled. - ErrUnauthorized = Register(RootCodespace, 4, "unauthorized") + ErrUnauthorized = errorsmod.Register(RootCodespace, 4, "unauthorized") // ErrInsufficientFunds is used when the account cannot pay requested amount. - ErrInsufficientFunds = Register(RootCodespace, 5, "insufficient funds") + ErrInsufficientFunds = errorsmod.Register(RootCodespace, 5, "insufficient funds") // ErrUnknownRequest to doc - ErrUnknownRequest = Register(RootCodespace, 6, "unknown request") + ErrUnknownRequest = errorsmod.Register(RootCodespace, 6, "unknown request") // ErrInvalidAddress to doc - ErrInvalidAddress = Register(RootCodespace, 7, "invalid address") + ErrInvalidAddress = errorsmod.Register(RootCodespace, 7, "invalid address") // ErrInvalidPubKey to doc - ErrInvalidPubKey = Register(RootCodespace, 8, "invalid pubkey") + ErrInvalidPubKey = errorsmod.Register(RootCodespace, 8, "invalid pubkey") // ErrUnknownAddress to doc - ErrUnknownAddress = Register(RootCodespace, 9, "unknown address") + ErrUnknownAddress = errorsmod.Register(RootCodespace, 9, "unknown address") // ErrInvalidCoins to doc - ErrInvalidCoins = Register(RootCodespace, 10, "invalid coins") + ErrInvalidCoins = errorsmod.Register(RootCodespace, 10, "invalid coins") // ErrOutOfGas to doc - ErrOutOfGas = Register(RootCodespace, 11, "out of gas") + ErrOutOfGas = errorsmod.Register(RootCodespace, 11, "out of gas") // ErrMemoTooLarge to doc - ErrMemoTooLarge = Register(RootCodespace, 12, "memo too large") + ErrMemoTooLarge = errorsmod.Register(RootCodespace, 12, "memo too large") // ErrInsufficientFee to doc - ErrInsufficientFee = Register(RootCodespace, 13, "insufficient fee") + ErrInsufficientFee = errorsmod.Register(RootCodespace, 13, "insufficient fee") // ErrTooManySignatures to doc - ErrTooManySignatures = Register(RootCodespace, 14, "maximum number of signatures exceeded") + ErrTooManySignatures = errorsmod.Register(RootCodespace, 14, "maximum number of signatures exceeded") // ErrNoSignatures to doc - ErrNoSignatures = Register(RootCodespace, 15, "no signatures supplied") + ErrNoSignatures = errorsmod.Register(RootCodespace, 15, "no signatures supplied") // ErrJSONMarshal defines an ABCI typed JSON marshalling error - ErrJSONMarshal = Register(RootCodespace, 16, "failed to marshal JSON bytes") + ErrJSONMarshal = errorsmod.Register(RootCodespace, 16, "failed to marshal JSON bytes") // ErrJSONUnmarshal defines an ABCI typed JSON unmarshalling error - ErrJSONUnmarshal = Register(RootCodespace, 17, "failed to unmarshal JSON bytes") + ErrJSONUnmarshal = errorsmod.Register(RootCodespace, 17, "failed to unmarshal JSON bytes") // ErrInvalidRequest defines an ABCI typed error where the request contains // invalid data. - ErrInvalidRequest = Register(RootCodespace, 18, "invalid request") + ErrInvalidRequest = errorsmod.Register(RootCodespace, 18, "invalid request") // ErrTxInMempoolCache defines an ABCI typed error where a tx already exists // in the mempool. - ErrTxInMempoolCache = Register(RootCodespace, 19, "tx already in mempool") + ErrTxInMempoolCache = errorsmod.Register(RootCodespace, 19, "tx already in mempool") // ErrMempoolIsFull defines an ABCI typed error where the mempool is full. - ErrMempoolIsFull = Register(RootCodespace, 20, "mempool is full") + ErrMempoolIsFull = errorsmod.Register(RootCodespace, 20, "mempool is full") // ErrTxTooLarge defines an ABCI typed error where tx is too large. - ErrTxTooLarge = Register(RootCodespace, 21, "tx too large") + ErrTxTooLarge = errorsmod.Register(RootCodespace, 21, "tx too large") // ErrKeyNotFound defines an error when the key doesn't exist - ErrKeyNotFound = Register(RootCodespace, 22, "key not found") + ErrKeyNotFound = errorsmod.Register(RootCodespace, 22, "key not found") // ErrWrongPassword defines an error when the key password is invalid. - ErrWrongPassword = Register(RootCodespace, 23, "invalid account password") + ErrWrongPassword = errorsmod.Register(RootCodespace, 23, "invalid account password") // ErrorInvalidSigner defines an error when the tx intended signer does not match the given signer. - ErrorInvalidSigner = Register(RootCodespace, 24, "tx intended signer does not match the given signer") + ErrorInvalidSigner = errorsmod.Register(RootCodespace, 24, "tx intended signer does not match the given signer") // ErrorInvalidGasAdjustment defines an error for an invalid gas adjustment - ErrorInvalidGasAdjustment = Register(RootCodespace, 25, "invalid gas adjustment") + ErrorInvalidGasAdjustment = errorsmod.Register(RootCodespace, 25, "invalid gas adjustment") // ErrInvalidHeight defines an error for an invalid height - ErrInvalidHeight = Register(RootCodespace, 26, "invalid height") + ErrInvalidHeight = errorsmod.Register(RootCodespace, 26, "invalid height") // ErrInvalidVersion defines a general error for an invalid version - ErrInvalidVersion = Register(RootCodespace, 27, "invalid version") + ErrInvalidVersion = errorsmod.Register(RootCodespace, 27, "invalid version") // ErrInvalidChainID defines an error when the chain-id is invalid. - ErrInvalidChainID = Register(RootCodespace, 28, "invalid chain-id") + ErrInvalidChainID = errorsmod.Register(RootCodespace, 28, "invalid chain-id") // ErrInvalidType defines an error an invalid type. - ErrInvalidType = Register(RootCodespace, 29, "invalid type") + ErrInvalidType = errorsmod.Register(RootCodespace, 29, "invalid type") // ErrTxTimeoutHeight defines an error for when a tx is rejected out due to an // explicitly set timeout height. - ErrTxTimeoutHeight = Register(RootCodespace, 30, "tx timeout height") + ErrTxTimeoutHeight = errorsmod.Register(RootCodespace, 30, "tx timeout height") // ErrUnknownExtensionOptions defines an error for unknown extension options. - ErrUnknownExtensionOptions = Register(RootCodespace, 31, "unknown extension options") + ErrUnknownExtensionOptions = errorsmod.Register(RootCodespace, 31, "unknown extension options") // ErrWrongSequence defines an error where the account sequence defined in // the signer info doesn't match the account's actual sequence number. - ErrWrongSequence = Register(RootCodespace, 32, "incorrect account sequence") + ErrWrongSequence = errorsmod.Register(RootCodespace, 32, "incorrect account sequence") // ErrPackAny defines an error when packing a protobuf message to Any fails. - ErrPackAny = Register(RootCodespace, 33, "failed packing protobuf message to Any") + ErrPackAny = errorsmod.Register(RootCodespace, 33, "failed packing protobuf message to Any") // ErrUnpackAny defines an error when unpacking a protobuf message from Any fails. - ErrUnpackAny = Register(RootCodespace, 34, "failed unpacking protobuf message from Any") + ErrUnpackAny = errorsmod.Register(RootCodespace, 34, "failed unpacking protobuf message from Any") // ErrLogic defines an internal logic error, e.g. an invariant or assertion // that is violated. It is a programmer error, not a user-facing error. - ErrLogic = Register(RootCodespace, 35, "internal logic error") + ErrLogic = errorsmod.Register(RootCodespace, 35, "internal logic error") // ErrConflict defines a conflict error, e.g. when two goroutines try to access // the same resource and one of them fails. - ErrConflict = Register(RootCodespace, 36, "conflict") + ErrConflict = errorsmod.Register(RootCodespace, 36, "conflict") // ErrNotSupported is returned when we call a branch of a code which is currently not // supported. - ErrNotSupported = Register(RootCodespace, 37, "feature not supported") + ErrNotSupported = errorsmod.Register(RootCodespace, 37, "feature not supported") // ErrNotFound defines an error when requested entity doesn't exist in the state. - ErrNotFound = Register(RootCodespace, 38, "not found") + ErrNotFound = errorsmod.Register(RootCodespace, 38, "not found") // ErrIO should be used to wrap internal errors caused by external operation. // Examples: not DB domain error, file writing etc... - ErrIO = Register(RootCodespace, 39, "Internal IO error") + ErrIO = errorsmod.Register(RootCodespace, 39, "Internal IO error") // ErrAppConfig defines an error occurred if min-gas-prices field in BaseConfig is empty. - ErrAppConfig = Register(RootCodespace, 40, "error in app.toml") + ErrAppConfig = errorsmod.Register(RootCodespace, 40, "error in app.toml") // ErrInvalidGasLimit defines an error when an invalid GasWanted value is // supplied. - ErrInvalidGasLimit = Register(RootCodespace, 41, "invalid gas limit") + ErrInvalidGasLimit = errorsmod.Register(RootCodespace, 41, "invalid gas limit") // ErrPanic should only be set when we recovering from a panic ErrPanic = errorsmod.ErrPanic diff --git a/types/module/configurator.go b/types/module/configurator.go index 97c2ad7ed3..82125f7961 100644 --- a/types/module/configurator.go +++ b/types/module/configurator.go @@ -5,6 +5,8 @@ import ( "github.com/cosmos/gogoproto/grpc" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/codec" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" @@ -70,7 +72,7 @@ func (c configurator) QueryServer() grpc.Server { // RegisterMigration implements the Configurator.RegisterMigration method func (c configurator) RegisterMigration(moduleName string, fromVersion uint64, handler MigrationHandler) error { if fromVersion == 0 { - return sdkerrors.Wrap(sdkerrors.ErrInvalidVersion, "module migration versions should start at 1") + return errorsmod.Wrap(sdkerrors.ErrInvalidVersion, "module migration versions should start at 1") } if c.migrations[moduleName] == nil { @@ -78,7 +80,7 @@ func (c configurator) RegisterMigration(moduleName string, fromVersion uint64, h } if c.migrations[moduleName][fromVersion] != nil { - return sdkerrors.Wrapf(sdkerrors.ErrLogic, "another migration for module %s and version %d already exists", moduleName, fromVersion) + return errorsmod.Wrapf(sdkerrors.ErrLogic, "another migration for module %s and version %d already exists", moduleName, fromVersion) } c.migrations[moduleName][fromVersion] = handler @@ -96,14 +98,14 @@ func (c configurator) runModuleMigrations(ctx sdk.Context, moduleName string, fr moduleMigrationsMap, found := c.migrations[moduleName] if !found { - return sdkerrors.Wrapf(sdkerrors.ErrNotFound, "no migrations found for module %s", moduleName) + return errorsmod.Wrapf(sdkerrors.ErrNotFound, "no migrations found for module %s", moduleName) } // Run in-place migrations for the module sequentially until toVersion. for i := fromVersion; i < toVersion; i++ { migrateFn, found := moduleMigrationsMap[i] if !found { - return sdkerrors.Wrapf(sdkerrors.ErrNotFound, "no migration found for module %s from version %d to version %d", moduleName, i, i+1) + return errorsmod.Wrapf(sdkerrors.ErrNotFound, "no migration found for module %s from version %d to version %d", moduleName, i, i+1) } ctx.Logger().Info(fmt.Sprintf("migrating module %s from version %d to version %d", moduleName, i, i+1)) diff --git a/types/module/module.go b/types/module/module.go index f30ef97ccd..591052387b 100644 --- a/types/module/module.go +++ b/types/module/module.go @@ -43,6 +43,8 @@ import ( storetypes "cosmossdk.io/store/types" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/codec/types" @@ -586,7 +588,7 @@ type VersionMap map[string]uint64 func (m Manager) RunMigrations(ctx sdk.Context, cfg Configurator, fromVM VersionMap) (VersionMap, error) { c, ok := cfg.(configurator) if !ok { - return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidType, "expected %T, got %T", configurator{}, cfg) + return nil, errorsmod.Wrapf(sdkerrors.ErrInvalidType, "expected %T, got %T", configurator{}, cfg) } modules := m.OrderMigrations if modules == nil { @@ -622,7 +624,7 @@ func (m Manager) RunMigrations(ctx sdk.Context, cfg Configurator, fromVM Version // The module manager assumes only one module will update the // validator set, and it can't be a new module. if len(moduleValUpdates) > 0 { - return nil, sdkerrors.Wrapf(sdkerrors.ErrLogic, "validator InitGenesis update is already set by another module") + return nil, errorsmod.Wrapf(sdkerrors.ErrLogic, "validator InitGenesis update is already set by another module") } } } diff --git a/types/tx/types.go b/types/tx/types.go index 089243e5e9..8ef5b915f0 100644 --- a/types/tx/types.go +++ b/types/tx/types.go @@ -3,6 +3,8 @@ package tx import ( "fmt" + errorsmod "cosmossdk.io/errors" + codectypes "github.com/cosmos/cosmos-sdk/codec/types" cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" sdk "github.com/cosmos/cosmos-sdk/types" @@ -54,21 +56,21 @@ func (t *Tx) ValidateBasic() error { } if fee.GasLimit > MaxGasWanted { - return sdkerrors.Wrapf( + return errorsmod.Wrapf( sdkerrors.ErrInvalidRequest, "invalid gas supplied; %d > %d", fee.GasLimit, MaxGasWanted, ) } if fee.Amount.IsAnyNil() { - return sdkerrors.Wrapf( + return errorsmod.Wrapf( sdkerrors.ErrInsufficientFee, "invalid fee provided: null", ) } if fee.Amount.IsAnyNegative() { - return sdkerrors.Wrapf( + return errorsmod.Wrapf( sdkerrors.ErrInsufficientFee, "invalid fee provided: %s", fee.Amount, ) @@ -77,7 +79,7 @@ func (t *Tx) ValidateBasic() error { if fee.Payer != "" { _, err := sdk.AccAddressFromBech32(fee.Payer) if err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid fee payer address (%s)", err) + return errorsmod.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid fee payer address (%s)", err) } } @@ -88,7 +90,7 @@ func (t *Tx) ValidateBasic() error { } if len(sigs) != len(t.GetSigners()) { - return sdkerrors.Wrapf( + return errorsmod.Wrapf( sdkerrors.ErrUnauthorized, "wrong number of signers; expected %d, got %d", len(t.GetSigners()), len(sigs), ) diff --git a/x/auth/ante/ante.go b/x/auth/ante/ante.go index a87f654c59..f3b4ebb6a1 100644 --- a/x/auth/ante/ante.go +++ b/x/auth/ante/ante.go @@ -3,6 +3,8 @@ package ante import ( storetypes "cosmossdk.io/store/types" + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/types/tx/signing" @@ -26,15 +28,15 @@ type HandlerOptions struct { // signer. func NewAnteHandler(options HandlerOptions) (sdk.AnteHandler, error) { if options.AccountKeeper == nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "account keeper is required for ante builder") + return nil, errorsmod.Wrap(sdkerrors.ErrLogic, "account keeper is required for ante builder") } if options.BankKeeper == nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "bank keeper is required for ante builder") + return nil, errorsmod.Wrap(sdkerrors.ErrLogic, "bank keeper is required for ante builder") } if options.SignModeHandler == nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "sign mode handler is required for ante builder") + return nil, errorsmod.Wrap(sdkerrors.ErrLogic, "sign mode handler is required for ante builder") } anteDecorators := []sdk.AnteDecorator{ diff --git a/x/auth/ante/ante_test.go b/x/auth/ante/ante_test.go index f3493db2fa..1fa833c66d 100644 --- a/x/auth/ante/ante_test.go +++ b/x/auth/ante/ante_test.go @@ -13,6 +13,8 @@ import ( storetypes "cosmossdk.io/store/types" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519" kmultisig "github.com/cosmos/cosmos-sdk/crypto/keys/multisig" "github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1" @@ -1376,7 +1378,7 @@ func TestCustomSignatureVerificationGasConsumer(t *testing.T) { meter.ConsumeGas(params.SigVerifyCostED25519, "ante verify: ed25519") return nil default: - return sdkerrors.Wrapf(sdkerrors.ErrInvalidPubKey, "unrecognized public key type: %T", pubkey) + return errorsmod.Wrapf(sdkerrors.ErrInvalidPubKey, "unrecognized public key type: %T", pubkey) } }, }, diff --git a/x/auth/ante/basic.go b/x/auth/ante/basic.go index 94b866f72f..8d335fc32b 100644 --- a/x/auth/ante/basic.go +++ b/x/auth/ante/basic.go @@ -3,6 +3,8 @@ package ante import ( storetypes "cosmossdk.io/store/types" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/codec/legacy" "github.com/cosmos/cosmos-sdk/crypto/keys/multisig" cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" @@ -52,14 +54,14 @@ func NewValidateMemoDecorator(ak AccountKeeper) ValidateMemoDecorator { func (vmd ValidateMemoDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (sdk.Context, error) { memoTx, ok := tx.(sdk.TxWithMemo) if !ok { - return ctx, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "invalid transaction type") + return ctx, errorsmod.Wrap(sdkerrors.ErrTxDecode, "invalid transaction type") } memoLength := len(memoTx.GetMemo()) if memoLength > 0 { params := vmd.ak.GetParams(ctx) if uint64(memoLength) > params.MaxMemoCharacters { - return ctx, sdkerrors.Wrapf(sdkerrors.ErrMemoTooLarge, + return ctx, errorsmod.Wrapf(sdkerrors.ErrMemoTooLarge, "maximum number of characters is %d but received %d characters", params.MaxMemoCharacters, memoLength, ) @@ -91,7 +93,7 @@ func NewConsumeGasForTxSizeDecorator(ak AccountKeeper) ConsumeTxSizeGasDecorator func (cgts ConsumeTxSizeGasDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (sdk.Context, error) { sigTx, ok := tx.(authsigning.SigVerifiableTx) if !ok { - return ctx, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "invalid tx type") + return ctx, errorsmod.Wrap(sdkerrors.ErrTxDecode, "invalid tx type") } params := cgts.ak.GetParams(ctx) @@ -195,12 +197,12 @@ func NewTxTimeoutHeightDecorator() TxTimeoutHeightDecorator { func (txh TxTimeoutHeightDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (sdk.Context, error) { timeoutTx, ok := tx.(TxWithTimeoutHeight) if !ok { - return ctx, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "expected tx to implement TxWithTimeoutHeight") + return ctx, errorsmod.Wrap(sdkerrors.ErrTxDecode, "expected tx to implement TxWithTimeoutHeight") } timeoutHeight := timeoutTx.GetTimeoutHeight() if timeoutHeight > 0 && uint64(ctx.BlockHeight()) > timeoutHeight { - return ctx, sdkerrors.Wrapf( + return ctx, errorsmod.Wrapf( sdkerrors.ErrTxTimeoutHeight, "block height: %d, timeout height: %d", ctx.BlockHeight(), timeoutHeight, ) } diff --git a/x/auth/ante/fee.go b/x/auth/ante/fee.go index 20cace9403..c7404a5d6e 100644 --- a/x/auth/ante/fee.go +++ b/x/auth/ante/fee.go @@ -3,6 +3,8 @@ package ante import ( "fmt" + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/auth/types" @@ -39,11 +41,11 @@ func NewDeductFeeDecorator(ak AccountKeeper, bk types.BankKeeper, fk FeegrantKee func (dfd DeductFeeDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (sdk.Context, error) { feeTx, ok := tx.(sdk.FeeTx) if !ok { - return ctx, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "Tx must be a FeeTx") + return ctx, errorsmod.Wrap(sdkerrors.ErrTxDecode, "Tx must be a FeeTx") } if !simulate && ctx.BlockHeight() > 0 && feeTx.GetGas() == 0 { - return ctx, sdkerrors.Wrap(sdkerrors.ErrInvalidGasLimit, "must provide positive gas") + return ctx, errorsmod.Wrap(sdkerrors.ErrInvalidGasLimit, "must provide positive gas") } var ( @@ -70,7 +72,7 @@ func (dfd DeductFeeDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bo func (dfd DeductFeeDecorator) checkDeductFee(ctx sdk.Context, sdkTx sdk.Tx, fee sdk.Coins) error { feeTx, ok := sdkTx.(sdk.FeeTx) if !ok { - return sdkerrors.Wrap(sdkerrors.ErrTxDecode, "Tx must be a FeeTx") + return errorsmod.Wrap(sdkerrors.ErrTxDecode, "Tx must be a FeeTx") } if addr := dfd.accountKeeper.GetModuleAddress(types.FeeCollectorName); addr == nil { @@ -89,7 +91,7 @@ func (dfd DeductFeeDecorator) checkDeductFee(ctx sdk.Context, sdkTx sdk.Tx, fee } else if !feeGranter.Equals(feePayer) { err := dfd.feegrantKeeper.UseGrantedFees(ctx, feeGranter, feePayer, fee, sdkTx.GetMsgs()) if err != nil { - return sdkerrors.Wrapf(err, "%s does not allow to pay fees for %s", feeGranter, feePayer) + return errorsmod.Wrapf(err, "%s does not allow to pay fees for %s", feeGranter, feePayer) } } @@ -124,12 +126,12 @@ func (dfd DeductFeeDecorator) checkDeductFee(ctx sdk.Context, sdkTx sdk.Tx, fee // DeductFees deducts fees from the given account. func DeductFees(bankKeeper types.BankKeeper, ctx sdk.Context, acc sdk.AccountI, fees sdk.Coins) error { if !fees.IsValid() { - return sdkerrors.Wrapf(sdkerrors.ErrInsufficientFee, "invalid fee amount: %s", fees) + return errorsmod.Wrapf(sdkerrors.ErrInsufficientFee, "invalid fee amount: %s", fees) } err := bankKeeper.SendCoinsFromAccountToModule(ctx, acc.GetAddress(), types.FeeCollectorName, fees) if err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrInsufficientFunds, err.Error()) + return errorsmod.Wrapf(sdkerrors.ErrInsufficientFunds, err.Error()) } return nil diff --git a/x/auth/ante/setup.go b/x/auth/ante/setup.go index 14f98dacc4..2cdb345583 100644 --- a/x/auth/ante/setup.go +++ b/x/auth/ante/setup.go @@ -5,6 +5,8 @@ import ( storetypes "cosmossdk.io/store/types" + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/auth/migrations/legacytx" @@ -36,7 +38,7 @@ func (sud SetUpContextDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate // Set a gas meter with limit 0 as to prevent an infinite gas meter attack // during runTx. newCtx = SetGasMeter(simulate, ctx, 0) - return newCtx, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "Tx must be GasTx") + return newCtx, errorsmod.Wrap(sdkerrors.ErrTxDecode, "Tx must be GasTx") } newCtx = SetGasMeter(simulate, ctx, gasTx.GetGas()) @@ -54,7 +56,7 @@ func (sud SetUpContextDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate "out of gas in location: %v; gasWanted: %d, gasUsed: %d", rType.Descriptor, gasTx.GetGas(), newCtx.GasMeter().GasConsumed()) - err = sdkerrors.Wrap(sdkerrors.ErrOutOfGas, log) + err = errorsmod.Wrap(sdkerrors.ErrOutOfGas, log) default: panic(r) } diff --git a/x/auth/ante/sigverify.go b/x/auth/ante/sigverify.go index 9006bd38b4..977a9284d8 100644 --- a/x/auth/ante/sigverify.go +++ b/x/auth/ante/sigverify.go @@ -6,6 +6,7 @@ import ( "encoding/hex" "fmt" + errorsmod "cosmossdk.io/errors" storetypes "cosmossdk.io/store/types" "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519" @@ -59,7 +60,7 @@ func NewSetPubKeyDecorator(ak AccountKeeper) SetPubKeyDecorator { func (spkd SetPubKeyDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (sdk.Context, error) { sigTx, ok := tx.(authsigning.SigVerifiableTx) if !ok { - return ctx, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "invalid tx type") + return ctx, errorsmod.Wrap(sdkerrors.ErrTxDecode, "invalid tx type") } pubkeys, err := sigTx.GetPubKeys() @@ -78,7 +79,7 @@ func (spkd SetPubKeyDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate b } // Only make check if simulate=false if !simulate && !bytes.Equal(pk.Address(), signers[i]) { - return ctx, sdkerrors.Wrapf(sdkerrors.ErrInvalidPubKey, + return ctx, errorsmod.Wrapf(sdkerrors.ErrInvalidPubKey, "pubKey does not match signer address %s with signer index: %d", signers[i], i) } @@ -92,7 +93,7 @@ func (spkd SetPubKeyDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate b } err = acc.SetPubKey(pk) if err != nil { - return ctx, sdkerrors.Wrap(sdkerrors.ErrInvalidPubKey, err.Error()) + return ctx, errorsmod.Wrap(sdkerrors.ErrInvalidPubKey, err.Error()) } spkd.ak.SetAccount(ctx, acc) } @@ -151,7 +152,7 @@ func NewSigGasConsumeDecorator(ak AccountKeeper, sigGasConsumer SignatureVerific func (sgcd SigGasConsumeDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (newCtx sdk.Context, err error) { sigTx, ok := tx.(authsigning.SigVerifiableTx) if !ok { - return ctx, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "invalid transaction type") + return ctx, errorsmod.Wrap(sdkerrors.ErrTxDecode, "invalid transaction type") } params := sgcd.ak.GetParams(ctx) @@ -237,7 +238,7 @@ func OnlyLegacyAminoSigners(sigData signing.SignatureData) bool { func (svd SigVerificationDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (newCtx sdk.Context, err error) { sigTx, ok := tx.(authsigning.SigVerifiableTx) if !ok { - return ctx, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "invalid transaction type") + return ctx, errorsmod.Wrap(sdkerrors.ErrTxDecode, "invalid transaction type") } // stdSigs contains the sequence number, account number, and signatures. @@ -251,7 +252,7 @@ func (svd SigVerificationDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simul // check that signer length and signature length are the same if len(sigs) != len(signerAddrs) { - return ctx, sdkerrors.Wrapf(sdkerrors.ErrUnauthorized, "invalid number of signer; expected: %d, got %d", len(signerAddrs), len(sigs)) + return ctx, errorsmod.Wrapf(sdkerrors.ErrUnauthorized, "invalid number of signer; expected: %d, got %d", len(signerAddrs), len(sigs)) } for i, sig := range sigs { @@ -263,12 +264,12 @@ func (svd SigVerificationDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simul // retrieve pubkey pubKey := acc.GetPubKey() if !simulate && pubKey == nil { - return ctx, sdkerrors.Wrap(sdkerrors.ErrInvalidPubKey, "pubkey on account is not set") + return ctx, errorsmod.Wrap(sdkerrors.ErrInvalidPubKey, "pubkey on account is not set") } // Check account sequence number. if sig.Sequence != acc.GetSequence() { - return ctx, sdkerrors.Wrapf( + return ctx, errorsmod.Wrapf( sdkerrors.ErrWrongSequence, "account sequence mismatch, expected %d, got %d", acc.GetSequence(), sig.Sequence, ) @@ -301,7 +302,7 @@ func (svd SigVerificationDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simul } else { errMsg = fmt.Sprintf("signature verification failed; please verify account number (%d) and chain-id (%s)", accNum, chainID) } - return ctx, sdkerrors.Wrap(sdkerrors.ErrUnauthorized, errMsg) + return ctx, errorsmod.Wrap(sdkerrors.ErrUnauthorized, errMsg) } } @@ -332,7 +333,7 @@ func NewIncrementSequenceDecorator(ak AccountKeeper) IncrementSequenceDecorator func (isd IncrementSequenceDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (sdk.Context, error) { sigTx, ok := tx.(authsigning.SigVerifiableTx) if !ok { - return ctx, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "invalid transaction type") + return ctx, errorsmod.Wrap(sdkerrors.ErrTxDecode, "invalid transaction type") } // increment sequence of all signers @@ -365,7 +366,7 @@ func NewValidateSigCountDecorator(ak AccountKeeper) ValidateSigCountDecorator { func (vscd ValidateSigCountDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (sdk.Context, error) { sigTx, ok := tx.(authsigning.SigVerifiableTx) if !ok { - return ctx, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "Tx must be a sigTx") + return ctx, errorsmod.Wrap(sdkerrors.ErrTxDecode, "Tx must be a sigTx") } params := vscd.ak.GetParams(ctx) @@ -378,7 +379,7 @@ func (vscd ValidateSigCountDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, sim for _, pk := range pubKeys { sigCount += CountSubKeys(pk) if uint64(sigCount) > params.TxSigLimit { - return ctx, sdkerrors.Wrapf(sdkerrors.ErrTooManySignatures, + return ctx, errorsmod.Wrapf(sdkerrors.ErrTooManySignatures, "signatures: %d, limit: %d", sigCount, params.TxSigLimit) } } @@ -396,7 +397,7 @@ func DefaultSigVerificationGasConsumer( switch pubkey := pubkey.(type) { case *ed25519.PubKey: meter.ConsumeGas(params.SigVerifyCostED25519, "ante verify: ed25519") - return sdkerrors.Wrap(sdkerrors.ErrInvalidPubKey, "ED25519 public keys are unsupported") + return errorsmod.Wrap(sdkerrors.ErrInvalidPubKey, "ED25519 public keys are unsupported") case *secp256k1.PubKey: meter.ConsumeGas(params.SigVerifyCostSecp256k1, "ante verify: secp256k1") @@ -418,7 +419,7 @@ func DefaultSigVerificationGasConsumer( return nil default: - return sdkerrors.Wrapf(sdkerrors.ErrInvalidPubKey, "unrecognized public key type: %T", pubkey) + return errorsmod.Wrapf(sdkerrors.ErrInvalidPubKey, "unrecognized public key type: %T", pubkey) } } @@ -456,7 +457,7 @@ func GetSignerAcc(ctx sdk.Context, ak AccountKeeper, addr sdk.AccAddress) (sdk.A return acc, nil } - return nil, sdkerrors.Wrapf(sdkerrors.ErrUnknownAddress, "account %s does not exist", addr) + return nil, errorsmod.Wrapf(sdkerrors.ErrUnknownAddress, "account %s does not exist", addr) } // CountSubKeys counts the total number of keys for a multi-sig public key. diff --git a/x/auth/ante/validator_tx_fee.go b/x/auth/ante/validator_tx_fee.go index e8c865b757..fdde15ec86 100644 --- a/x/auth/ante/validator_tx_fee.go +++ b/x/auth/ante/validator_tx_fee.go @@ -3,7 +3,9 @@ package ante import ( "math" + errorsmod "cosmossdk.io/errors" sdkmath "cosmossdk.io/math" + sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) @@ -13,7 +15,7 @@ import ( func checkTxFeeWithValidatorMinGasPrices(ctx sdk.Context, tx sdk.Tx) (sdk.Coins, int64, error) { feeTx, ok := tx.(sdk.FeeTx) if !ok { - return nil, 0, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "Tx must be a FeeTx") + return nil, 0, errorsmod.Wrap(sdkerrors.ErrTxDecode, "Tx must be a FeeTx") } feeCoins := feeTx.GetFee() @@ -36,7 +38,7 @@ func checkTxFeeWithValidatorMinGasPrices(ctx sdk.Context, tx sdk.Tx) (sdk.Coins, } if !feeCoins.IsAnyGTE(requiredFees) { - return nil, 0, sdkerrors.Wrapf(sdkerrors.ErrInsufficientFee, "insufficient fees; got: %s required: %s", feeCoins, requiredFees) + return nil, 0, errorsmod.Wrapf(sdkerrors.ErrInsufficientFee, "insufficient fees; got: %s required: %s", feeCoins, requiredFees) } } } diff --git a/x/auth/client/cli/query.go b/x/auth/client/cli/query.go index 89c18cfcd8..a07f710602 100644 --- a/x/auth/client/cli/query.go +++ b/x/auth/client/cli/query.go @@ -9,6 +9,8 @@ import ( cmttypes "github.com/cometbft/cometbft/types" "github.com/spf13/cobra" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/client/flags" sdk "github.com/cosmos/cosmos-sdk/types" @@ -116,7 +118,7 @@ func GetAccountCmd() *cobra.Command { } catchingUp := status.SyncInfo.CatchingUp if !catchingUp { - return errors.Wrapf(err, "your node may be syncing, please check node status using `/status`") + return errorsmod.Wrapf(err, "your node may be syncing, please check node status using `/status`") } return err } diff --git a/x/auth/client/cli/tx_multisign.go b/x/auth/client/cli/tx_multisign.go index e8a7453c08..d5f271b3bd 100644 --- a/x/auth/client/cli/tx_multisign.go +++ b/x/auth/client/cli/tx_multisign.go @@ -9,6 +9,8 @@ import ( "github.com/spf13/cobra" "github.com/spf13/viper" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/client/flags" "github.com/cosmos/cosmos-sdk/client/tx" @@ -16,7 +18,6 @@ import ( kmultisig "github.com/cosmos/cosmos-sdk/crypto/keys/multisig" "github.com/cosmos/cosmos-sdk/crypto/types/multisig" sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/types/errors" signingtypes "github.com/cosmos/cosmos-sdk/types/tx/signing" "github.com/cosmos/cosmos-sdk/version" authclient "github.com/cosmos/cosmos-sdk/x/auth/client" @@ -420,7 +421,7 @@ func getMultisigRecord(clientCtx client.Context, name string) (*keyring.Record, kb := clientCtx.Keyring multisigRecord, err := kb.Key(name) if err != nil { - return nil, errors.Wrap(err, "error getting keybase multisig account") + return nil, errorsmod.Wrap(err, "error getting keybase multisig account") } return multisigRecord, nil diff --git a/x/auth/client/tx.go b/x/auth/client/tx.go index 98d351c796..18935e92ba 100644 --- a/x/auth/client/tx.go +++ b/x/auth/client/tx.go @@ -17,7 +17,7 @@ import ( "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/crypto/keyring" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/types/tx/signing" "github.com/cosmos/cosmos-sdk/x/auth/migrations/legacytx" ) @@ -52,7 +52,7 @@ func SignTx(txFactory tx.Factory, clientCtx client.Context, name string, txBuild } addr := sdk.AccAddress(pubKey.Address()) if !isTxSigner(addr, txBuilder.GetTx().GetSigners()) { - return fmt.Errorf("%s: %s", sdkerrors.ErrorInvalidSigner, name) + return fmt.Errorf("%s: %s", errors.ErrorInvalidSigner, name) } if !offline { txFactory, err = populateAccountFromState(txFactory, clientCtx, addr) @@ -80,7 +80,7 @@ func SignTxWithSignerAddress(txFactory tx.Factory, clientCtx client.Context, add // check whether the address is a signer if !isTxSigner(addr, txBuilder.GetTx().GetSigners()) { - return fmt.Errorf("%s: %s", sdkerrors.ErrorInvalidSigner, name) + return fmt.Errorf("%s: %s", errors.ErrorInvalidSigner, name) } if !offline { diff --git a/x/auth/keeper/bech32_codec.go b/x/auth/keeper/bech32_codec.go index b107b67de9..298a5813f2 100644 --- a/x/auth/keeper/bech32_codec.go +++ b/x/auth/keeper/bech32_codec.go @@ -1,6 +1,8 @@ package keeper import ( + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/address" "github.com/cosmos/cosmos-sdk/types/bech32" @@ -25,7 +27,7 @@ func (bc bech32Codec) StringToBytes(text string) ([]byte, error) { } if hrp != bc.bech32Prefix { - return nil, sdkerrors.Wrap(sdkerrors.ErrLogic, "hrp does not match bech32Prefix") + return nil, errorsmod.Wrap(sdkerrors.ErrLogic, "hrp does not match bech32Prefix") } if err := sdk.VerifyAddressFormat(bz); err != nil { diff --git a/x/auth/keeper/keeper.go b/x/auth/keeper/keeper.go index ddbab10aaa..ad64e02264 100644 --- a/x/auth/keeper/keeper.go +++ b/x/auth/keeper/keeper.go @@ -6,6 +6,7 @@ import ( "cosmossdk.io/log" gogotypes "github.com/cosmos/gogoproto/types" + errorsmod "cosmossdk.io/errors" storetypes "cosmossdk.io/store/types" "github.com/cosmos/cosmos-sdk/codec" @@ -111,7 +112,7 @@ func (ak AccountKeeper) Logger(ctx sdk.Context) log.Logger { func (ak AccountKeeper) GetPubKey(ctx sdk.Context, addr sdk.AccAddress) (cryptotypes.PubKey, error) { acc := ak.GetAccount(ctx, addr) if acc == nil { - return nil, sdkerrors.Wrapf(sdkerrors.ErrUnknownAddress, "account %s does not exist", addr) + return nil, errorsmod.Wrapf(sdkerrors.ErrUnknownAddress, "account %s does not exist", addr) } return acc.GetPubKey(), nil @@ -121,7 +122,7 @@ func (ak AccountKeeper) GetPubKey(ctx sdk.Context, addr sdk.AccAddress) (cryptot func (ak AccountKeeper) GetSequence(ctx sdk.Context, addr sdk.AccAddress) (uint64, error) { acc := ak.GetAccount(ctx, addr) if acc == nil { - return 0, sdkerrors.Wrapf(sdkerrors.ErrUnknownAddress, "account %s does not exist", addr) + return 0, errorsmod.Wrapf(sdkerrors.ErrUnknownAddress, "account %s does not exist", addr) } return acc.GetSequence(), nil diff --git a/x/auth/keeper/msg_server.go b/x/auth/keeper/msg_server.go index b79d8cbacc..8a7b324fdb 100644 --- a/x/auth/keeper/msg_server.go +++ b/x/auth/keeper/msg_server.go @@ -3,8 +3,9 @@ package keeper import ( "context" + "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/auth/types" govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" ) diff --git a/x/auth/migrations/legacytx/amino_signing.go b/x/auth/migrations/legacytx/amino_signing.go index 4115efa704..f663d80c63 100644 --- a/x/auth/migrations/legacytx/amino_signing.go +++ b/x/auth/migrations/legacytx/amino_signing.go @@ -3,10 +3,11 @@ package legacytx import ( "fmt" + "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/crypto/types/multisig" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" signingtypes "github.com/cosmos/cosmos-sdk/types/tx/signing" "github.com/cosmos/cosmos-sdk/x/auth/signing" ) @@ -80,7 +81,7 @@ func MultiSignatureDataToAminoMultisignature(cdc *codec.LegacyAmino, mSig *signi var err error sigs[i], err = SignatureDataToAminoSignature(cdc, mSig.Signatures[i]) if err != nil { - return multisig.AminoMultisignature{}, sdkerrors.Wrapf(err, "Unable to convert Signature Data to signature %d", i) + return multisig.AminoMultisignature{}, errors.Wrapf(err, "Unable to convert Signature Data to signature %d", i) } } diff --git a/x/auth/migrations/legacytx/stdsign.go b/x/auth/migrations/legacytx/stdsign.go index 634a5ef27d..5e31a88f61 100644 --- a/x/auth/migrations/legacytx/stdsign.go +++ b/x/auth/migrations/legacytx/stdsign.go @@ -6,13 +6,14 @@ import ( "sigs.k8s.io/yaml" + "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/codec/legacy" codectypes "github.com/cosmos/cosmos-sdk/codec/types" cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" "github.com/cosmos/cosmos-sdk/crypto/types/multisig" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/types/tx" "github.com/cosmos/cosmos-sdk/types/tx/signing" ) @@ -167,7 +168,7 @@ func pubKeySigToSigData(cdc *codec.LegacyAmino, key cryptotypes.PubKey, sig []by if bitArray.GetIndex(i) { data, err := pubKeySigToSigData(cdc, pubKeys[i], multiSig.Sigs[sigIdx]) if err != nil { - return nil, sdkerrors.Wrapf(err, "Unable to convert Signature to SigData %d", sigIdx) + return nil, errors.Wrapf(err, "Unable to convert Signature to SigData %d", sigIdx) } sigDatas[sigIdx] = data diff --git a/x/auth/migrations/legacytx/stdtx.go b/x/auth/migrations/legacytx/stdtx.go index ea7de42476..ec14124037 100644 --- a/x/auth/migrations/legacytx/stdtx.go +++ b/x/auth/migrations/legacytx/stdtx.go @@ -1,7 +1,9 @@ package legacytx import ( + errorsmod "cosmossdk.io/errors" "cosmossdk.io/math" + "github.com/cosmos/cosmos-sdk/codec/legacy" codectypes "github.com/cosmos/cosmos-sdk/codec/types" cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" @@ -113,13 +115,13 @@ func (stdTx StdTx) ValidateBasic() error { stdSigs := stdTx.GetSignatures() if stdTx.Fee.Gas > tx.MaxGasWanted { - return sdkerrors.Wrapf( + return errorsmod.Wrapf( sdkerrors.ErrInvalidRequest, "invalid gas supplied; %d > %d", stdTx.Fee.Gas, tx.MaxGasWanted, ) } if stdTx.Fee.Amount.IsAnyNegative() { - return sdkerrors.Wrapf( + return errorsmod.Wrapf( sdkerrors.ErrInsufficientFee, "invalid fee provided: %s", stdTx.Fee.Amount, ) @@ -128,7 +130,7 @@ func (stdTx StdTx) ValidateBasic() error { return sdkerrors.ErrNoSignatures } if len(stdSigs) != len(stdTx.GetSigners()) { - return sdkerrors.Wrapf( + return errorsmod.Wrapf( sdkerrors.ErrUnauthorized, "wrong number of signers; expected %d, got %d", len(stdTx.GetSigners()), len(stdSigs), ) @@ -196,7 +198,7 @@ func (tx StdTx) GetSignaturesV2() ([]signing.SignatureV2, error) { var err error res[i], err = StdSignatureToSignatureV2(legacy.Cdc, sig) if err != nil { - return nil, sdkerrors.Wrapf(err, "Unable to convert signature %v to V2", sig) + return nil, errorsmod.Wrapf(err, "Unable to convert signature %v to V2", sig) } } diff --git a/x/auth/migrations/legacytx/stdtx_builder.go b/x/auth/migrations/legacytx/stdtx_builder.go index 35d26ce02e..df0b930b39 100644 --- a/x/auth/migrations/legacytx/stdtx_builder.go +++ b/x/auth/migrations/legacytx/stdtx_builder.go @@ -3,6 +3,8 @@ package legacytx import ( "fmt" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" sdk "github.com/cosmos/cosmos-sdk/types" @@ -188,14 +190,14 @@ type Unmarshaler func(bytes []byte, ptr interface{}) error func mkDecoder(unmarshaler Unmarshaler) sdk.TxDecoder { return func(txBytes []byte) (sdk.Tx, error) { if len(txBytes) == 0 { - return nil, sdkerrors.Wrap(sdkerrors.ErrTxDecode, "tx bytes are empty") + return nil, errorsmod.Wrap(sdkerrors.ErrTxDecode, "tx bytes are empty") } tx := StdTx{} // StdTx.Msg is an interface. The concrete types // are registered by MakeTxCodec err := unmarshaler(txBytes, &tx) if err != nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrTxDecode, err.Error()) + return nil, errorsmod.Wrap(sdkerrors.ErrTxDecode, err.Error()) } return tx, nil } diff --git a/x/auth/migrations/legacytx/stdtx_test.go b/x/auth/migrations/legacytx/stdtx_test.go index 1dab542930..626bc6f1ac 100644 --- a/x/auth/migrations/legacytx/stdtx_test.go +++ b/x/auth/migrations/legacytx/stdtx_test.go @@ -8,6 +8,8 @@ import ( cmtproto "github.com/cometbft/cometbft/proto/tendermint/types" "github.com/stretchr/testify/require" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/codec" cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec" "github.com/cosmos/cosmos-sdk/crypto/keys/ed25519" @@ -169,7 +171,7 @@ func TestTxValidateBasic(t *testing.T) { err := tx.ValidateBasic() require.Error(t, err) - _, code, _ := sdkerrors.ABCIInfo(err, false) + _, code, _ := errorsmod.ABCIInfo(err, false) require.Equal(t, sdkerrors.ErrInsufficientFee.ABCICode(), code) // require to fail validation when no signatures exist @@ -178,7 +180,7 @@ func TestTxValidateBasic(t *testing.T) { err = tx.ValidateBasic() require.Error(t, err) - _, code, _ = sdkerrors.ABCIInfo(err, false) + _, code, _ = errorsmod.ABCIInfo(err, false) require.Equal(t, sdkerrors.ErrNoSignatures.ABCICode(), code) // require to fail validation when signatures do not match expected signers @@ -187,7 +189,7 @@ func TestTxValidateBasic(t *testing.T) { err = tx.ValidateBasic() require.Error(t, err) - _, code, _ = sdkerrors.ABCIInfo(err, false) + _, code, _ = errorsmod.ABCIInfo(err, false) require.Equal(t, sdkerrors.ErrUnauthorized.ABCICode(), code) // require to fail with invalid gas supplied @@ -197,7 +199,7 @@ func TestTxValidateBasic(t *testing.T) { err = tx.ValidateBasic() require.Error(t, err) - _, code, _ = sdkerrors.ABCIInfo(err, false) + _, code, _ = errorsmod.ABCIInfo(err, false) require.Equal(t, sdkerrors.ErrInvalidRequest.ABCICode(), code) // require to pass when above criteria are matched diff --git a/x/auth/tx/builder.go b/x/auth/tx/builder.go index 2c4da2181f..e796f6884d 100644 --- a/x/auth/tx/builder.go +++ b/x/auth/tx/builder.go @@ -3,6 +3,8 @@ package tx import ( "github.com/cosmos/gogoproto/proto" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" codectypes "github.com/cosmos/cosmos-sdk/codec/types" @@ -122,7 +124,7 @@ func (w *wrapper) GetPubKeys() ([]cryptotypes.PubKey, error) { if ok { pks[i] = pk } else { - return nil, sdkerrors.Wrapf(sdkerrors.ErrLogic, "Expecting PubKey, got: %T", pkAny) + return nil, errorsmod.Wrapf(sdkerrors.ErrLogic, "Expecting PubKey, got: %T", pkAny) } } diff --git a/x/auth/tx/builder_test.go b/x/auth/tx/builder_test.go index 41d7c7d891..6b4fac9586 100644 --- a/x/auth/tx/builder_test.go +++ b/x/auth/tx/builder_test.go @@ -5,6 +5,8 @@ import ( "github.com/stretchr/testify/require" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/codec/legacy" codectypes "github.com/cosmos/cosmos-sdk/codec/types" @@ -165,7 +167,7 @@ func TestBuilderValidateBasic(t *testing.T) { txBuilder.SetFeeAmount(badFeeAmount) err = txBuilder.ValidateBasic() require.Error(t, err) - _, code, _ := sdkerrors.ABCIInfo(err, false) + _, code, _ := errorsmod.ABCIInfo(err, false) require.Equal(t, sdkerrors.ErrInsufficientFee.ABCICode(), code) // require to fail validation when no signatures exist @@ -174,7 +176,7 @@ func TestBuilderValidateBasic(t *testing.T) { txBuilder.SetFeeAmount(feeAmount) err = txBuilder.ValidateBasic() require.Error(t, err) - _, code, _ = sdkerrors.ABCIInfo(err, false) + _, code, _ = errorsmod.ABCIInfo(err, false) require.Equal(t, sdkerrors.ErrNoSignatures.ABCICode(), code) // require to fail with nil values for tx, authinfo @@ -189,7 +191,7 @@ func TestBuilderValidateBasic(t *testing.T) { err = txBuilder.ValidateBasic() require.Error(t, err) - _, code, _ = sdkerrors.ABCIInfo(err, false) + _, code, _ = errorsmod.ABCIInfo(err, false) require.Equal(t, sdkerrors.ErrUnauthorized.ABCICode(), code) require.Error(t, err) diff --git a/x/auth/tx/decoder.go b/x/auth/tx/decoder.go index 2fef6312b9..2bfd2fbe95 100644 --- a/x/auth/tx/decoder.go +++ b/x/auth/tx/decoder.go @@ -5,6 +5,8 @@ import ( "google.golang.org/protobuf/encoding/protowire" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/codec/unknownproto" sdk "github.com/cosmos/cosmos-sdk/types" @@ -18,7 +20,7 @@ func DefaultTxDecoder(cdc codec.ProtoCodecMarshaler) sdk.TxDecoder { // Make sure txBytes follow ADR-027. err := rejectNonADR027TxRaw(txBytes) if err != nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrTxDecode, err.Error()) + return nil, errorsmod.Wrap(sdkerrors.ErrTxDecode, err.Error()) } var raw tx.TxRaw @@ -26,7 +28,7 @@ func DefaultTxDecoder(cdc codec.ProtoCodecMarshaler) sdk.TxDecoder { // reject all unknown proto fields in the root TxRaw err = unknownproto.RejectUnknownFieldsStrict(txBytes, &raw, cdc.InterfaceRegistry()) if err != nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrTxDecode, err.Error()) + return nil, errorsmod.Wrap(sdkerrors.ErrTxDecode, err.Error()) } err = cdc.Unmarshal(txBytes, &raw) @@ -39,12 +41,12 @@ func DefaultTxDecoder(cdc codec.ProtoCodecMarshaler) sdk.TxDecoder { // allow non-critical unknown fields in TxBody txBodyHasUnknownNonCriticals, err := unknownproto.RejectUnknownFields(raw.BodyBytes, &body, true, cdc.InterfaceRegistry()) if err != nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrTxDecode, err.Error()) + return nil, errorsmod.Wrap(sdkerrors.ErrTxDecode, err.Error()) } err = cdc.Unmarshal(raw.BodyBytes, &body) if err != nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrTxDecode, err.Error()) + return nil, errorsmod.Wrap(sdkerrors.ErrTxDecode, err.Error()) } var authInfo tx.AuthInfo @@ -52,12 +54,12 @@ func DefaultTxDecoder(cdc codec.ProtoCodecMarshaler) sdk.TxDecoder { // reject all unknown proto fields in AuthInfo err = unknownproto.RejectUnknownFieldsStrict(raw.AuthInfoBytes, &authInfo, cdc.InterfaceRegistry()) if err != nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrTxDecode, err.Error()) + return nil, errorsmod.Wrap(sdkerrors.ErrTxDecode, err.Error()) } err = cdc.Unmarshal(raw.AuthInfoBytes, &authInfo) if err != nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrTxDecode, err.Error()) + return nil, errorsmod.Wrap(sdkerrors.ErrTxDecode, err.Error()) } theTx := &tx.Tx{ @@ -81,7 +83,7 @@ func DefaultJSONTxDecoder(cdc codec.ProtoCodecMarshaler) sdk.TxDecoder { var theTx tx.Tx err := cdc.UnmarshalJSON(txBytes, &theTx) if err != nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrTxDecode, err.Error()) + return nil, errorsmod.Wrap(sdkerrors.ErrTxDecode, err.Error()) } return &wrapper{ diff --git a/x/auth/tx/direct_aux.go b/x/auth/tx/direct_aux.go index 6361309813..ff09cfd2b8 100644 --- a/x/auth/tx/direct_aux.go +++ b/x/auth/tx/direct_aux.go @@ -3,6 +3,8 @@ package tx import ( "fmt" + errorsmod "cosmossdk.io/errors" + codectypes "github.com/cosmos/cosmos-sdk/codec/types" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" @@ -46,7 +48,7 @@ func (signModeDirectAuxHandler) GetSignBytes( addr := data.Address if addr == "" { - return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "got empty address in %s handler", signingtypes.SignMode_SIGN_MODE_DIRECT_AUX) + return nil, errorsmod.Wrapf(sdkerrors.ErrInvalidRequest, "got empty address in %s handler", signingtypes.SignMode_SIGN_MODE_DIRECT_AUX) } feePayer := protoTx.FeePayer().String() diff --git a/x/auth/tx/legacy_amino_json.go b/x/auth/tx/legacy_amino_json.go index 01274f9f6e..c920c96bd7 100644 --- a/x/auth/tx/legacy_amino_json.go +++ b/x/auth/tx/legacy_amino_json.go @@ -3,6 +3,8 @@ package tx import ( "fmt" + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" signingtypes "github.com/cosmos/cosmos-sdk/types/tx/signing" @@ -37,18 +39,18 @@ func (s signModeLegacyAminoJSONHandler) GetSignBytes(mode signingtypes.SignMode, } if protoTx.txBodyHasUnknownNonCriticals { - return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, aminoNonCriticalFieldsError) + return nil, errorsmod.Wrap(sdkerrors.ErrInvalidRequest, aminoNonCriticalFieldsError) } body := protoTx.tx.Body if len(body.ExtensionOptions) != 0 || len(body.NonCriticalExtensionOptions) != 0 { - return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "%s does not support protobuf extension options", signingtypes.SignMode_SIGN_MODE_LEGACY_AMINO_JSON) + return nil, errorsmod.Wrapf(sdkerrors.ErrInvalidRequest, "%s does not support protobuf extension options", signingtypes.SignMode_SIGN_MODE_LEGACY_AMINO_JSON) } addr := data.Address if addr == "" { - return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "got empty address in %s handler", signingtypes.SignMode_SIGN_MODE_LEGACY_AMINO_JSON) + return nil, errorsmod.Wrapf(sdkerrors.ErrInvalidRequest, "got empty address in %s handler", signingtypes.SignMode_SIGN_MODE_LEGACY_AMINO_JSON) } tip := protoTx.GetTip() diff --git a/x/auth/types/msgs.go b/x/auth/types/msgs.go index 4220cfee57..8774549e9a 100644 --- a/x/auth/types/msgs.go +++ b/x/auth/types/msgs.go @@ -1,8 +1,9 @@ package types import ( + "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/auth/migrations/legacytx" ) @@ -25,7 +26,7 @@ func (msg MsgUpdateParams) GetSigners() []sdk.AccAddress { // ValidateBasic does a sanity check on the provided data. func (msg MsgUpdateParams) ValidateBasic() error { if _, err := sdk.AccAddressFromBech32(msg.Authority); err != nil { - return sdkerrors.Wrap(err, "invalid authority address") + return errors.Wrap(err, "invalid authority address") } if err := msg.Params.Validate(); err != nil { diff --git a/x/auth/vesting/msg_server.go b/x/auth/vesting/msg_server.go index eb9f2497fe..ec962ba366 100644 --- a/x/auth/vesting/msg_server.go +++ b/x/auth/vesting/msg_server.go @@ -5,6 +5,8 @@ import ( "github.com/armon/go-metrics" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/telemetry" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" @@ -45,11 +47,11 @@ func (s msgServer) CreateVestingAccount(goCtx context.Context, msg *types.MsgCre } if bk.BlockedAddr(to) { - return nil, sdkerrors.Wrapf(sdkerrors.ErrUnauthorized, "%s is not allowed to receive funds", msg.ToAddress) + return nil, errorsmod.Wrapf(sdkerrors.ErrUnauthorized, "%s is not allowed to receive funds", msg.ToAddress) } if acc := ak.GetAccount(ctx, to); acc != nil { - return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "account %s already exists", msg.ToAddress) + return nil, errorsmod.Wrapf(sdkerrors.ErrInvalidRequest, "account %s already exists", msg.ToAddress) } baseAccount := authtypes.NewBaseAccountWithAddress(to) @@ -106,11 +108,11 @@ func (s msgServer) CreatePermanentLockedAccount(goCtx context.Context, msg *type } if bk.BlockedAddr(to) { - return nil, sdkerrors.Wrapf(sdkerrors.ErrUnauthorized, "%s is not allowed to receive funds", msg.ToAddress) + return nil, errorsmod.Wrapf(sdkerrors.ErrUnauthorized, "%s is not allowed to receive funds", msg.ToAddress) } if acc := ak.GetAccount(ctx, to); acc != nil { - return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "account %s already exists", msg.ToAddress) + return nil, errorsmod.Wrapf(sdkerrors.ErrInvalidRequest, "account %s already exists", msg.ToAddress) } baseAccount := authtypes.NewBaseAccountWithAddress(to) @@ -157,7 +159,7 @@ func (s msgServer) CreatePeriodicVestingAccount(goCtx context.Context, msg *type } if acc := ak.GetAccount(ctx, to); acc != nil { - return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "account %s already exists", msg.ToAddress) + return nil, errorsmod.Wrapf(sdkerrors.ErrInvalidRequest, "account %s already exists", msg.ToAddress) } var totalCoins sdk.Coins diff --git a/x/auth/vesting/types/msgs.go b/x/auth/vesting/types/msgs.go index f21fe53d1d..4bd31fdb9a 100644 --- a/x/auth/vesting/types/msgs.go +++ b/x/auth/vesting/types/msgs.go @@ -3,6 +3,8 @@ package types import ( "fmt" + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/auth/migrations/legacytx" @@ -41,15 +43,15 @@ func (msg MsgCreateVestingAccount) ValidateBasic() error { } if !msg.Amount.IsValid() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, msg.Amount.String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, msg.Amount.String()) } if !msg.Amount.IsAllPositive() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, msg.Amount.String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, msg.Amount.String()) } if msg.EndTime <= 0 { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "invalid end time") + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "invalid end time") } return nil @@ -148,11 +150,11 @@ func (msg MsgCreatePeriodicVestingAccount) ValidateBasic() error { return err } if err := sdk.VerifyAddressFormat(from); err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid sender address: %s", err) + return errorsmod.Wrapf(sdkerrors.ErrInvalidAddress, "invalid sender address: %s", err) } if err := sdk.VerifyAddressFormat(to); err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid recipient address: %s", err) + return errorsmod.Wrapf(sdkerrors.ErrInvalidAddress, "invalid recipient address: %s", err) } if msg.StartTime < 1 { diff --git a/x/authz/authorization_grant.go b/x/authz/authorization_grant.go index 87653e7da0..edf74f0f6c 100644 --- a/x/authz/authorization_grant.go +++ b/x/authz/authorization_grant.go @@ -3,6 +3,7 @@ package authz import ( "time" + errorsmod "cosmossdk.io/errors" proto "github.com/cosmos/gogoproto/proto" cdctypes "github.com/cosmos/cosmos-sdk/codec/types" @@ -14,7 +15,7 @@ import ( // which is passed into the `blockTime` arg. func NewGrant(blockTime time.Time, a Authorization, expiration *time.Time) (Grant, error) { if expiration != nil && !expiration.After(blockTime) { - return Grant{}, sdkerrors.Wrapf(ErrInvalidExpirationTime, "expiration must be after the current block time (%v), got %v", blockTime.Format(time.RFC3339), expiration.Format(time.RFC3339)) + return Grant{}, errorsmod.Wrapf(ErrInvalidExpirationTime, "expiration must be after the current block time (%v), got %v", blockTime.Format(time.RFC3339), expiration.Format(time.RFC3339)) } msg, ok := a.(proto.Message) if !ok { diff --git a/x/authz/errors.go b/x/authz/errors.go index 2aaac7122f..2c35372620 100644 --- a/x/authz/errors.go +++ b/x/authz/errors.go @@ -1,25 +1,23 @@ package authz -import ( - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" -) +import "cosmossdk.io/errors" // x/authz module sentinel errors var ( // ErrNoAuthorizationFound error if there is no authorization found given a grant key - ErrNoAuthorizationFound = sdkerrors.Register(ModuleName, 2, "authorization not found") + ErrNoAuthorizationFound = errors.Register(ModuleName, 2, "authorization not found") // ErrInvalidExpirationTime error if the set expiration time is in the past - ErrInvalidExpirationTime = sdkerrors.Register(ModuleName, 3, "expiration time of authorization should be more than current time") + ErrInvalidExpirationTime = errors.Register(ModuleName, 3, "expiration time of authorization should be more than current time") // ErrUnknownAuthorizationType error for unknown authorization type - ErrUnknownAuthorizationType = sdkerrors.Register(ModuleName, 4, "unknown authorization type") + ErrUnknownAuthorizationType = errors.Register(ModuleName, 4, "unknown authorization type") // ErrNoGrantKeyFound error if the requested grant key does not exist - ErrNoGrantKeyFound = sdkerrors.Register(ModuleName, 5, "grant key not found") + ErrNoGrantKeyFound = errors.Register(ModuleName, 5, "grant key not found") // ErrAuthorizationExpired error if the authorization has expired - ErrAuthorizationExpired = sdkerrors.Register(ModuleName, 6, "authorization expired") + ErrAuthorizationExpired = errors.Register(ModuleName, 6, "authorization expired") // ErrGranteeIsGranter error if the grantee and the granter are the same - ErrGranteeIsGranter = sdkerrors.Register(ModuleName, 7, "grantee and granter should be different") + ErrGranteeIsGranter = errors.Register(ModuleName, 7, "grantee and granter should be different") // ErrAuthorizationNumOfSigners error if an authorization message does not have only one signer - ErrAuthorizationNumOfSigners = sdkerrors.Register(ModuleName, 9, "authorization can be given to msg with only one signer") + ErrAuthorizationNumOfSigners = errors.Register(ModuleName, 9, "authorization can be given to msg with only one signer") // ErrNegativeMaxTokens error if the max tokens is negative - ErrNegativeMaxTokens = sdkerrors.Register(ModuleName, 12, "max tokens should be positive") + ErrNegativeMaxTokens = errors.Register(ModuleName, 12, "max tokens should be positive") ) diff --git a/x/authz/keeper/grpc_query.go b/x/authz/keeper/grpc_query.go index 299de079b9..a014a3a81b 100644 --- a/x/authz/keeper/grpc_query.go +++ b/x/authz/keeper/grpc_query.go @@ -6,11 +6,11 @@ import ( "google.golang.org/grpc/codes" "google.golang.org/grpc/status" + "cosmossdk.io/errors" "cosmossdk.io/store/prefix" codectypes "github.com/cosmos/cosmos-sdk/codec/types" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/types/query" "github.com/cosmos/cosmos-sdk/x/authz" ) @@ -38,7 +38,7 @@ func (k Keeper) Grants(c context.Context, req *authz.QueryGrantsRequest) (*authz if req.MsgTypeUrl != "" { grant, found := k.getGrant(ctx, grantStoreKey(grantee, granter, req.MsgTypeUrl)) if !found { - return nil, sdkerrors.Wrapf(authz.ErrNoAuthorizationFound, "authorization not found for %s type", req.MsgTypeUrl) + return nil, errors.Wrapf(authz.ErrNoAuthorizationFound, "authorization not found for %s type", req.MsgTypeUrl) } authorization, err := grant.GetAuthorization() diff --git a/x/authz/keeper/keeper.go b/x/authz/keeper/keeper.go index 295d4dbd38..501da89035 100644 --- a/x/authz/keeper/keeper.go +++ b/x/authz/keeper/keeper.go @@ -9,6 +9,7 @@ import ( abci "github.com/cometbft/cometbft/abci/types" "github.com/cosmos/gogoproto/proto" + errorsmod "cosmossdk.io/errors" storetypes "cosmossdk.io/store/types" "github.com/cosmos/cosmos-sdk/baseapp" @@ -102,7 +103,7 @@ func (k Keeper) DispatchActions(ctx sdk.Context, grantee sdk.AccAddress, msgs [] grant, found := k.getGrant(ctx, skey) if !found { - return nil, sdkerrors.Wrapf(authz.ErrNoAuthorizationFound, "failed to update grant with key %s", string(skey)) + return nil, errorsmod.Wrapf(authz.ErrNoAuthorizationFound, "failed to update grant with key %s", string(skey)) } if grant.Expiration != nil && grant.Expiration.Before(now) { @@ -140,7 +141,7 @@ func (k Keeper) DispatchActions(ctx sdk.Context, grantee sdk.AccAddress, msgs [] msgResp, err := handler(ctx, msg) if err != nil { - return nil, sdkerrors.Wrapf(err, "failed to execute message; message %v", msg) + return nil, errorsmod.Wrapf(err, "failed to execute message; message %v", msg) } results[i] = msgResp.Data @@ -209,7 +210,7 @@ func (k Keeper) DeleteGrant(ctx sdk.Context, grantee sdk.AccAddress, granter sdk skey := grantStoreKey(grantee, granter, msgType) grant, found := k.getGrant(ctx, skey) if !found { - return sdkerrors.Wrapf(authz.ErrNoAuthorizationFound, "failed to delete grant with key %s", string(skey)) + return errorsmod.Wrapf(authz.ErrNoAuthorizationFound, "failed to delete grant with key %s", string(skey)) } if grant.Expiration != nil { @@ -344,7 +345,7 @@ func (k Keeper) removeFromGrantQueue(ctx sdk.Context, grantKey []byte, granter, key := GrantQueueKey(expiration, granter, grantee) bz := store.Get(key) if bz == nil { - return sdkerrors.Wrap(authz.ErrNoGrantKeyFound, "can't remove grant from the expire queue, grant key not found") + return errorsmod.Wrap(authz.ErrNoGrantKeyFound, "can't remove grant from the expire queue, grant key not found") } var queueItem authz.GrantQueueItem diff --git a/x/authz/module/module.go b/x/authz/module/module.go index 89178ae7d2..13688dfdae 100644 --- a/x/authz/module/module.go +++ b/x/authz/module/module.go @@ -14,6 +14,7 @@ import ( "cosmossdk.io/depinject" + "cosmossdk.io/errors" store "cosmossdk.io/store/types" "github.com/cosmos/cosmos-sdk/baseapp" @@ -21,7 +22,6 @@ import ( "github.com/cosmos/cosmos-sdk/codec" cdctypes "github.com/cosmos/cosmos-sdk/codec/types" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/types/module" simtypes "github.com/cosmos/cosmos-sdk/types/simulation" "github.com/cosmos/cosmos-sdk/x/authz" @@ -78,7 +78,7 @@ func (AppModuleBasic) DefaultGenesis(cdc codec.JSONCodec) json.RawMessage { func (AppModuleBasic) ValidateGenesis(cdc codec.JSONCodec, config sdkclient.TxEncodingConfig, bz json.RawMessage) error { var data authz.GenesisState if err := cdc.UnmarshalJSON(bz, &data); err != nil { - return sdkerrors.Wrapf(err, "failed to unmarshal %s genesis state", authz.ModuleName) + return errors.Wrapf(err, "failed to unmarshal %s genesis state", authz.ModuleName) } return authz.ValidateGenesis(data) diff --git a/x/bank/keeper/keeper.go b/x/bank/keeper/keeper.go index c03ada6b3c..7dc0d202f9 100644 --- a/x/bank/keeper/keeper.go +++ b/x/bank/keeper/keeper.go @@ -5,6 +5,7 @@ import ( "cosmossdk.io/math" + errorsmod "cosmossdk.io/errors" "cosmossdk.io/store/prefix" storetypes "cosmossdk.io/store/types" @@ -143,11 +144,11 @@ func (k BaseKeeper) WithMintCoinsRestriction(check MintingRestrictionFn) BaseKee func (k BaseKeeper) DelegateCoins(ctx sdk.Context, delegatorAddr, moduleAccAddr sdk.AccAddress, amt sdk.Coins) error { moduleAcc := k.ak.GetAccount(ctx, moduleAccAddr) if moduleAcc == nil { - return sdkerrors.Wrapf(sdkerrors.ErrUnknownAddress, "module account %s does not exist", moduleAccAddr) + return errorsmod.Wrapf(sdkerrors.ErrUnknownAddress, "module account %s does not exist", moduleAccAddr) } if !amt.IsValid() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, amt.String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, amt.String()) } balances := sdk.NewCoins() @@ -155,7 +156,7 @@ func (k BaseKeeper) DelegateCoins(ctx sdk.Context, delegatorAddr, moduleAccAddr for _, coin := range amt { balance := k.GetBalance(ctx, delegatorAddr, coin.GetDenom()) if balance.IsLT(coin) { - return sdkerrors.Wrapf( + return errorsmod.Wrapf( sdkerrors.ErrInsufficientFunds, "failed to delegate; %s is smaller than %s", balance, amt, ) } @@ -168,7 +169,7 @@ func (k BaseKeeper) DelegateCoins(ctx sdk.Context, delegatorAddr, moduleAccAddr } if err := k.trackDelegation(ctx, delegatorAddr, balances, amt); err != nil { - return sdkerrors.Wrap(err, "failed to track delegation") + return errorsmod.Wrap(err, "failed to track delegation") } // emit coin spent event ctx.EventManager().EmitEvent( @@ -191,11 +192,11 @@ func (k BaseKeeper) DelegateCoins(ctx sdk.Context, delegatorAddr, moduleAccAddr func (k BaseKeeper) UndelegateCoins(ctx sdk.Context, moduleAccAddr, delegatorAddr sdk.AccAddress, amt sdk.Coins) error { moduleAcc := k.ak.GetAccount(ctx, moduleAccAddr) if moduleAcc == nil { - return sdkerrors.Wrapf(sdkerrors.ErrUnknownAddress, "module account %s does not exist", moduleAccAddr) + return errorsmod.Wrapf(sdkerrors.ErrUnknownAddress, "module account %s does not exist", moduleAccAddr) } if !amt.IsValid() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, amt.String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, amt.String()) } err := k.subUnlockedCoins(ctx, moduleAccAddr, amt) @@ -204,7 +205,7 @@ func (k BaseKeeper) UndelegateCoins(ctx sdk.Context, moduleAccAddr, delegatorAdd } if err := k.trackUndelegation(ctx, delegatorAddr, amt); err != nil { - return sdkerrors.Wrap(err, "failed to track undelegation") + return errorsmod.Wrap(err, "failed to track undelegation") } err = k.addCoins(ctx, delegatorAddr, amt) @@ -319,11 +320,11 @@ func (k BaseKeeper) SendCoinsFromModuleToAccount( ) error { senderAddr := k.ak.GetModuleAddress(senderModule) if senderAddr == nil { - panic(sdkerrors.Wrapf(sdkerrors.ErrUnknownAddress, "module account %s does not exist", senderModule)) + panic(errorsmod.Wrapf(sdkerrors.ErrUnknownAddress, "module account %s does not exist", senderModule)) } if k.BlockedAddr(recipientAddr) { - return sdkerrors.Wrapf(sdkerrors.ErrUnauthorized, "%s is not allowed to receive funds", recipientAddr) + return errorsmod.Wrapf(sdkerrors.ErrUnauthorized, "%s is not allowed to receive funds", recipientAddr) } return k.SendCoins(ctx, senderAddr, recipientAddr, amt) @@ -336,12 +337,12 @@ func (k BaseKeeper) SendCoinsFromModuleToModule( ) error { senderAddr := k.ak.GetModuleAddress(senderModule) if senderAddr == nil { - panic(sdkerrors.Wrapf(sdkerrors.ErrUnknownAddress, "module account %s does not exist", senderModule)) + panic(errorsmod.Wrapf(sdkerrors.ErrUnknownAddress, "module account %s does not exist", senderModule)) } recipientAcc := k.ak.GetModuleAccount(ctx, recipientModule) if recipientAcc == nil { - panic(sdkerrors.Wrapf(sdkerrors.ErrUnknownAddress, "module account %s does not exist", recipientModule)) + panic(errorsmod.Wrapf(sdkerrors.ErrUnknownAddress, "module account %s does not exist", recipientModule)) } return k.SendCoins(ctx, senderAddr, recipientAcc.GetAddress(), amt) @@ -354,7 +355,7 @@ func (k BaseKeeper) SendCoinsFromAccountToModule( ) error { recipientAcc := k.ak.GetModuleAccount(ctx, recipientModule) if recipientAcc == nil { - panic(sdkerrors.Wrapf(sdkerrors.ErrUnknownAddress, "module account %s does not exist", recipientModule)) + panic(errorsmod.Wrapf(sdkerrors.ErrUnknownAddress, "module account %s does not exist", recipientModule)) } return k.SendCoins(ctx, senderAddr, recipientAcc.GetAddress(), amt) @@ -368,11 +369,11 @@ func (k BaseKeeper) DelegateCoinsFromAccountToModule( ) error { recipientAcc := k.ak.GetModuleAccount(ctx, recipientModule) if recipientAcc == nil { - panic(sdkerrors.Wrapf(sdkerrors.ErrUnknownAddress, "module account %s does not exist", recipientModule)) + panic(errorsmod.Wrapf(sdkerrors.ErrUnknownAddress, "module account %s does not exist", recipientModule)) } if !recipientAcc.HasPermission(authtypes.Staking) { - panic(sdkerrors.Wrapf(sdkerrors.ErrUnauthorized, "module account %s does not have permissions to receive delegated coins", recipientModule)) + panic(errorsmod.Wrapf(sdkerrors.ErrUnauthorized, "module account %s does not have permissions to receive delegated coins", recipientModule)) } return k.DelegateCoins(ctx, senderAddr, recipientAcc.GetAddress(), amt) @@ -386,11 +387,11 @@ func (k BaseKeeper) UndelegateCoinsFromModuleToAccount( ) error { acc := k.ak.GetModuleAccount(ctx, senderModule) if acc == nil { - panic(sdkerrors.Wrapf(sdkerrors.ErrUnknownAddress, "module account %s does not exist", senderModule)) + panic(errorsmod.Wrapf(sdkerrors.ErrUnknownAddress, "module account %s does not exist", senderModule)) } if !acc.HasPermission(authtypes.Staking) { - panic(sdkerrors.Wrapf(sdkerrors.ErrUnauthorized, "module account %s does not have permissions to undelegate coins", senderModule)) + panic(errorsmod.Wrapf(sdkerrors.ErrUnauthorized, "module account %s does not have permissions to undelegate coins", senderModule)) } return k.UndelegateCoins(ctx, acc.GetAddress(), recipientAddr, amt) @@ -406,11 +407,11 @@ func (k BaseKeeper) MintCoins(ctx sdk.Context, moduleName string, amounts sdk.Co } acc := k.ak.GetModuleAccount(ctx, moduleName) if acc == nil { - panic(sdkerrors.Wrapf(sdkerrors.ErrUnknownAddress, "module account %s does not exist", moduleName)) + panic(errorsmod.Wrapf(sdkerrors.ErrUnknownAddress, "module account %s does not exist", moduleName)) } if !acc.HasPermission(authtypes.Minter) { - panic(sdkerrors.Wrapf(sdkerrors.ErrUnauthorized, "module account %s does not have permissions to mint tokens", moduleName)) + panic(errorsmod.Wrapf(sdkerrors.ErrUnauthorized, "module account %s does not have permissions to mint tokens", moduleName)) } err = k.addCoins(ctx, acc.GetAddress(), amounts) @@ -440,11 +441,11 @@ func (k BaseKeeper) MintCoins(ctx sdk.Context, moduleName string, amounts sdk.Co func (k BaseKeeper) BurnCoins(ctx sdk.Context, moduleName string, amounts sdk.Coins) error { acc := k.ak.GetModuleAccount(ctx, moduleName) if acc == nil { - panic(sdkerrors.Wrapf(sdkerrors.ErrUnknownAddress, "module account %s does not exist", moduleName)) + panic(errorsmod.Wrapf(sdkerrors.ErrUnknownAddress, "module account %s does not exist", moduleName)) } if !acc.HasPermission(authtypes.Burner) { - panic(sdkerrors.Wrapf(sdkerrors.ErrUnauthorized, "module account %s does not have permissions to burn tokens", moduleName)) + panic(errorsmod.Wrapf(sdkerrors.ErrUnauthorized, "module account %s does not have permissions to burn tokens", moduleName)) } err := k.subUnlockedCoins(ctx, acc.GetAddress(), amounts) @@ -491,7 +492,7 @@ func (k BaseKeeper) setSupply(ctx sdk.Context, coin sdk.Coin) { func (k BaseKeeper) trackDelegation(ctx sdk.Context, addr sdk.AccAddress, balance, amt sdk.Coins) error { acc := k.ak.GetAccount(ctx, addr) if acc == nil { - return sdkerrors.Wrapf(sdkerrors.ErrUnknownAddress, "account %s does not exist", addr) + return errorsmod.Wrapf(sdkerrors.ErrUnknownAddress, "account %s does not exist", addr) } vacc, ok := acc.(types.VestingAccount) @@ -508,7 +509,7 @@ func (k BaseKeeper) trackDelegation(ctx sdk.Context, addr sdk.AccAddress, balanc func (k BaseKeeper) trackUndelegation(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) error { acc := k.ak.GetAccount(ctx, addr) if acc == nil { - return sdkerrors.Wrapf(sdkerrors.ErrUnknownAddress, "account %s does not exist", addr) + return errorsmod.Wrapf(sdkerrors.ErrUnknownAddress, "account %s does not exist", addr) } vacc, ok := acc.(types.VestingAccount) diff --git a/x/bank/keeper/msg_server.go b/x/bank/keeper/msg_server.go index 3f2d5bac11..996e6e8796 100644 --- a/x/bank/keeper/msg_server.go +++ b/x/bank/keeper/msg_server.go @@ -5,6 +5,8 @@ import ( "github.com/armon/go-metrics" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/telemetry" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" @@ -41,7 +43,7 @@ func (k msgServer) Send(goCtx context.Context, msg *types.MsgSend) (*types.MsgSe } if k.BlockedAddr(to) { - return nil, sdkerrors.Wrapf(sdkerrors.ErrUnauthorized, "%s is not allowed to receive funds", msg.ToAddress) + return nil, errorsmod.Wrapf(sdkerrors.ErrUnauthorized, "%s is not allowed to receive funds", msg.ToAddress) } err = k.SendCoins(ctx, from, to, msg.Amount) @@ -78,7 +80,7 @@ func (k msgServer) MultiSend(goCtx context.Context, msg *types.MsgMultiSend) (*t accAddr := sdk.MustAccAddressFromBech32(out.Address) if k.BlockedAddr(accAddr) { - return nil, sdkerrors.Wrapf(sdkerrors.ErrUnauthorized, "%s is not allowed to receive funds", out.Address) + return nil, errorsmod.Wrapf(sdkerrors.ErrUnauthorized, "%s is not allowed to receive funds", out.Address) } } @@ -92,7 +94,7 @@ func (k msgServer) MultiSend(goCtx context.Context, msg *types.MsgMultiSend) (*t func (k msgServer) UpdateParams(goCtx context.Context, req *types.MsgUpdateParams) (*types.MsgUpdateParamsResponse, error) { if k.GetAuthority() != req.Authority { - return nil, sdkerrors.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", k.GetAuthority(), req.Authority) + return nil, errorsmod.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", k.GetAuthority(), req.Authority) } ctx := sdk.UnwrapSDKContext(goCtx) @@ -105,7 +107,7 @@ func (k msgServer) UpdateParams(goCtx context.Context, req *types.MsgUpdateParam func (k msgServer) SetSendEnabled(goCtx context.Context, msg *types.MsgSetSendEnabled) (*types.MsgSetSendEnabledResponse, error) { if k.GetAuthority() != msg.Authority { - return nil, sdkerrors.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", k.GetAuthority(), msg.Authority) + return nil, errorsmod.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", k.GetAuthority(), msg.Authority) } ctx := sdk.UnwrapSDKContext(goCtx) diff --git a/x/bank/keeper/send.go b/x/bank/keeper/send.go index fd8c80cf8b..c3cd5d0a28 100644 --- a/x/bank/keeper/send.go +++ b/x/bank/keeper/send.go @@ -5,6 +5,7 @@ import ( gogotypes "github.com/cosmos/gogoproto/types" + errorsmod "cosmossdk.io/errors" "cosmossdk.io/store/prefix" storetypes "cosmossdk.io/store/types" @@ -233,7 +234,7 @@ func (k BaseSendKeeper) SendCoins(ctx sdk.Context, fromAddr sdk.AccAddress, toAd // A coin_spent event is emitted after. func (k BaseSendKeeper) subUnlockedCoins(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) error { if !amt.IsValid() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, amt.String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, amt.String()) } lockedCoins := k.LockedCoins(ctx, addr) @@ -244,12 +245,12 @@ func (k BaseSendKeeper) subUnlockedCoins(ctx sdk.Context, addr sdk.AccAddress, a spendable, hasNeg := sdk.Coins{balance}.SafeSub(locked) if hasNeg { - return sdkerrors.Wrapf(sdkerrors.ErrInsufficientFunds, + return errorsmod.Wrapf(sdkerrors.ErrInsufficientFunds, "locked amount exceeds account balance funds: %s > %s", locked, balance) } if _, hasNeg := spendable.SafeSub(coin); hasNeg { - return sdkerrors.Wrapf( + return errorsmod.Wrapf( sdkerrors.ErrInsufficientFunds, "spendable balance %s is smaller than %s", spendable, coin, @@ -274,7 +275,7 @@ func (k BaseSendKeeper) subUnlockedCoins(ctx sdk.Context, addr sdk.AccAddress, a // amt is invalid. It emits a coin received event. func (k BaseSendKeeper) addCoins(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coins) error { if !amt.IsValid() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, amt.String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, amt.String()) } for _, coin := range amt { @@ -304,7 +305,7 @@ func (k BaseSendKeeper) initBalances(ctx sdk.Context, addr sdk.AccAddress, balan for i := range balances { balance := balances[i] if !balance.IsValid() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, balance.String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, balance.String()) } // x/bank invariants prohibit persistence of zero balances @@ -336,7 +337,7 @@ func (k BaseSendKeeper) initBalances(ctx sdk.Context, addr sdk.AccAddress, balan // setBalance sets the coin balance for an account by address. func (k BaseSendKeeper) setBalance(ctx sdk.Context, addr sdk.AccAddress, balance sdk.Coin) error { if !balance.IsValid() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, balance.String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, balance.String()) } accountStore := k.getAccountStore(ctx, addr) diff --git a/x/bank/keeper/view.go b/x/bank/keeper/view.go index b6bae1f9ae..48d48d4291 100644 --- a/x/bank/keeper/view.go +++ b/x/bank/keeper/view.go @@ -6,6 +6,7 @@ import ( "cosmossdk.io/log" "cosmossdk.io/math" + errorsmod "cosmossdk.io/errors" "cosmossdk.io/store/prefix" storetypes "cosmossdk.io/store/types" @@ -220,7 +221,7 @@ func (k BaseViewKeeper) spendableCoins(ctx sdk.Context, addr sdk.AccAddress) (sp func (k BaseViewKeeper) ValidateBalance(ctx sdk.Context, addr sdk.AccAddress) error { acc := k.ak.GetAccount(ctx, addr) if acc == nil { - return sdkerrors.Wrapf(sdkerrors.ErrUnknownAddress, "account %s does not exist", addr) + return errorsmod.Wrapf(sdkerrors.ErrUnknownAddress, "account %s does not exist", addr) } balances := k.GetAllBalances(ctx, addr) diff --git a/x/bank/types/errors.go b/x/bank/types/errors.go index 13af3dc4c7..6988af108d 100644 --- a/x/bank/types/errors.go +++ b/x/bank/types/errors.go @@ -1,17 +1,15 @@ package types -import ( - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" -) +import "cosmossdk.io/errors" // x/bank module sentinel errors var ( - ErrNoInputs = sdkerrors.Register(ModuleName, 2, "no inputs to send transaction") - ErrNoOutputs = sdkerrors.Register(ModuleName, 3, "no outputs to send transaction") - ErrInputOutputMismatch = sdkerrors.Register(ModuleName, 4, "sum inputs != sum outputs") - ErrSendDisabled = sdkerrors.Register(ModuleName, 5, "send transactions are disabled") - ErrDenomMetadataNotFound = sdkerrors.Register(ModuleName, 6, "client denom metadata not found") - ErrInvalidKey = sdkerrors.Register(ModuleName, 7, "invalid key") - ErrDuplicateEntry = sdkerrors.Register(ModuleName, 8, "duplicate entry") - ErrMultipleSenders = sdkerrors.Register(ModuleName, 9, "multiple senders not allowed") + ErrNoInputs = errors.Register(ModuleName, 2, "no inputs to send transaction") + ErrNoOutputs = errors.Register(ModuleName, 3, "no outputs to send transaction") + ErrInputOutputMismatch = errors.Register(ModuleName, 4, "sum inputs != sum outputs") + ErrSendDisabled = errors.Register(ModuleName, 5, "send transactions are disabled") + ErrDenomMetadataNotFound = errors.Register(ModuleName, 6, "client denom metadata not found") + ErrInvalidKey = errors.Register(ModuleName, 7, "invalid key") + ErrDuplicateEntry = errors.Register(ModuleName, 8, "duplicate entry") + ErrMultipleSenders = errors.Register(ModuleName, 9, "multiple senders not allowed") ) diff --git a/x/bank/types/msgs.go b/x/bank/types/msgs.go index 8bb09b461a..592f6baed4 100644 --- a/x/bank/types/msgs.go +++ b/x/bank/types/msgs.go @@ -1,6 +1,8 @@ package types import ( + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/auth/migrations/legacytx" @@ -34,11 +36,11 @@ func (msg MsgSend) ValidateBasic() error { } if !msg.Amount.IsValid() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, msg.Amount.String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, msg.Amount.String()) } if !msg.Amount.IsAllPositive() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, msg.Amount.String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, msg.Amount.String()) } return nil @@ -103,11 +105,11 @@ func (in Input) ValidateBasic() error { } if !in.Coins.IsValid() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, in.Coins.String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, in.Coins.String()) } if !in.Coins.IsAllPositive() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, in.Coins.String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, in.Coins.String()) } return nil @@ -130,11 +132,11 @@ func (out Output) ValidateBasic() error { } if !out.Coins.IsValid() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, out.Coins.String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, out.Coins.String()) } if !out.Coins.IsAllPositive() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, out.Coins.String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, out.Coins.String()) } return nil diff --git a/x/capability/keeper/keeper.go b/x/capability/keeper/keeper.go index 41959ad0c8..cb2294e9c8 100644 --- a/x/capability/keeper/keeper.go +++ b/x/capability/keeper/keeper.go @@ -9,9 +9,10 @@ import ( "cosmossdk.io/store/prefix" storetypes "cosmossdk.io/store/types" + "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/codec" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/capability/types" ) @@ -234,12 +235,12 @@ func (k Keeper) InitializeCapability(ctx sdk.Context, index uint64, owners types // with the module name and no two ScopedKeeper can have the same module name. func (sk ScopedKeeper) NewCapability(ctx sdk.Context, name string) (*types.Capability, error) { if strings.TrimSpace(name) == "" { - return nil, sdkerrors.Wrap(types.ErrInvalidCapabilityName, "capability name cannot be empty") + return nil, errors.Wrap(types.ErrInvalidCapabilityName, "capability name cannot be empty") } store := ctx.KVStore(sk.storeKey) if _, ok := sk.GetCapability(ctx, name); ok { - return nil, sdkerrors.Wrapf(types.ErrCapabilityTaken, fmt.Sprintf("module: %s, name: %s", sk.module, name)) + return nil, errors.Wrapf(types.ErrCapabilityTaken, fmt.Sprintf("module: %s, name: %s", sk.module, name)) } // create new capability with the current global index @@ -296,10 +297,10 @@ func (sk ScopedKeeper) AuthenticateCapability(ctx sdk.Context, cap *types.Capabi // also set a forward and reverse index for the capability and capability name. func (sk ScopedKeeper) ClaimCapability(ctx sdk.Context, cap *types.Capability, name string) error { if cap == nil { - return sdkerrors.Wrap(types.ErrNilCapability, "cannot claim nil capability") + return errors.Wrap(types.ErrNilCapability, "cannot claim nil capability") } if strings.TrimSpace(name) == "" { - return sdkerrors.Wrap(types.ErrInvalidCapabilityName, "capability name cannot be empty") + return errors.Wrap(types.ErrInvalidCapabilityName, "capability name cannot be empty") } // update capability owner set if err := sk.addOwner(ctx, cap, name); err != nil { @@ -328,11 +329,11 @@ func (sk ScopedKeeper) ClaimCapability(ctx sdk.Context, cap *types.Capability, n // owners exist, the capability will be globally removed. func (sk ScopedKeeper) ReleaseCapability(ctx sdk.Context, cap *types.Capability) error { if cap == nil { - return sdkerrors.Wrap(types.ErrNilCapability, "cannot release nil capability") + return errors.Wrap(types.ErrNilCapability, "cannot release nil capability") } name := sk.GetCapabilityName(ctx, cap) if len(name) == 0 { - return sdkerrors.Wrap(types.ErrCapabilityNotOwned, sk.module) + return errors.Wrap(types.ErrCapabilityNotOwned, sk.module) } memStore := ctx.KVStore(sk.memKey) @@ -440,16 +441,16 @@ func (sk ScopedKeeper) GetOwners(ctx sdk.Context, name string) (*types.Capabilit // retreived from the memstore. func (sk ScopedKeeper) LookupModules(ctx sdk.Context, name string) ([]string, *types.Capability, error) { if strings.TrimSpace(name) == "" { - return nil, nil, sdkerrors.Wrap(types.ErrInvalidCapabilityName, "cannot lookup modules with empty capability name") + return nil, nil, errors.Wrap(types.ErrInvalidCapabilityName, "cannot lookup modules with empty capability name") } cap, ok := sk.GetCapability(ctx, name) if !ok { - return nil, nil, sdkerrors.Wrap(types.ErrCapabilityNotFound, name) + return nil, nil, errors.Wrap(types.ErrCapabilityNotFound, name) } capOwners, ok := sk.GetOwners(ctx, name) if !ok { - return nil, nil, sdkerrors.Wrap(types.ErrCapabilityOwnersNotFound, name) + return nil, nil, errors.Wrap(types.ErrCapabilityOwnersNotFound, name) } mods := make([]string, len(capOwners.Owners)) diff --git a/x/capability/types/errors.go b/x/capability/types/errors.go index 957191eb1c..edd46a3de3 100644 --- a/x/capability/types/errors.go +++ b/x/capability/types/errors.go @@ -1,16 +1,14 @@ package types -import ( - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" -) +import "cosmossdk.io/errors" // x/capability module sentinel errors var ( - ErrInvalidCapabilityName = sdkerrors.Register(ModuleName, 2, "capability name not valid") - ErrNilCapability = sdkerrors.Register(ModuleName, 3, "provided capability is nil") - ErrCapabilityTaken = sdkerrors.Register(ModuleName, 4, "capability name already taken") - ErrOwnerClaimed = sdkerrors.Register(ModuleName, 5, "given owner already claimed capability") - ErrCapabilityNotOwned = sdkerrors.Register(ModuleName, 6, "capability not owned by module") - ErrCapabilityNotFound = sdkerrors.Register(ModuleName, 7, "capability not found") - ErrCapabilityOwnersNotFound = sdkerrors.Register(ModuleName, 8, "owners not found for capability") + ErrInvalidCapabilityName = errors.Register(ModuleName, 2, "capability name not valid") + ErrNilCapability = errors.Register(ModuleName, 3, "provided capability is nil") + ErrCapabilityTaken = errors.Register(ModuleName, 4, "capability name already taken") + ErrOwnerClaimed = errors.Register(ModuleName, 5, "given owner already claimed capability") + ErrCapabilityNotOwned = errors.Register(ModuleName, 6, "capability not owned by module") + ErrCapabilityNotFound = errors.Register(ModuleName, 7, "capability not found") + ErrCapabilityOwnersNotFound = errors.Register(ModuleName, 8, "owners not found for capability") ) diff --git a/x/capability/types/types.go b/x/capability/types/types.go index 982543bae5..5771992555 100644 --- a/x/capability/types/types.go +++ b/x/capability/types/types.go @@ -4,7 +4,7 @@ import ( "fmt" "sort" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "cosmossdk.io/errors" ) // NewCapability returns a reference to a new Capability to be used as an @@ -33,7 +33,7 @@ func (co *CapabilityOwners) Set(owner Owner) error { i, ok := co.Get(owner) if ok { // owner already exists at co.Owners[i] - return sdkerrors.Wrapf(ErrOwnerClaimed, owner.String()) + return errors.Wrapf(ErrOwnerClaimed, owner.String()) } // owner does not exist in the set of owners, so we insert at position i diff --git a/x/circuit/go.mod b/x/circuit/go.mod index e203c97b0a..3fcd78b4ed 100644 --- a/x/circuit/go.mod +++ b/x/circuit/go.mod @@ -18,7 +18,7 @@ require ( cosmossdk.io/depinject v1.0.0-alpha.3 // indirect cosmossdk.io/errors v1.0.0-beta.7 // indirect cosmossdk.io/log v0.0.0-00010101000000-000000000000 // indirect - cosmossdk.io/math v1.0.0-beta.6 // indirect + cosmossdk.io/math v1.0.0-beta.6.0.20230216172121-959ce49135e4 // indirect github.com/DataDog/zstd v1.5.2 // indirect github.com/alecthomas/participle/v2 v2.0.0-alpha7 // indirect github.com/armon/go-metrics v0.4.1 // indirect diff --git a/x/circuit/go.sum b/x/circuit/go.sum index 00a89bbe91..eaafe0a6de 100644 --- a/x/circuit/go.sum +++ b/x/circuit/go.sum @@ -45,8 +45,8 @@ cosmossdk.io/depinject v1.0.0-alpha.3 h1:6evFIgj//Y3w09bqOUOzEpFj5tsxBqdc5CfkO7z cosmossdk.io/depinject v1.0.0-alpha.3/go.mod h1:eRbcdQ7MRpIPEM5YUJh8k97nxHpYbc3sMUnEtt8HPWU= cosmossdk.io/errors v1.0.0-beta.7 h1:gypHW76pTQGVnHKo6QBkb4yFOJjC+sUGRc5Al3Odj1w= cosmossdk.io/errors v1.0.0-beta.7/go.mod h1:mz6FQMJRku4bY7aqS/Gwfcmr/ue91roMEKAmDUDpBfE= -cosmossdk.io/math v1.0.0-beta.6 h1:WF29SiFYNde5eYvqO2kdOM9nYbDb44j3YW5B8M1m9KE= -cosmossdk.io/math v1.0.0-beta.6/go.mod h1:gUVtWwIzfSXqcOT+lBVz2jyjfua8DoBdzRsIyaUAT/8= +cosmossdk.io/math v1.0.0-beta.6.0.20230216172121-959ce49135e4 h1:/jnzJ9zFsL7qkV8LCQ1JH3dYHh2EsKZ3k8Mr6AqqiOA= +cosmossdk.io/math v1.0.0-beta.6.0.20230216172121-959ce49135e4/go.mod h1:gUVtWwIzfSXqcOT+lBVz2jyjfua8DoBdzRsIyaUAT/8= cosmossdk.io/store v0.0.0-20230206092147-e03195e4b8a7 h1:IwyDN/YaQmF+Pmuv8d7vRWMM/k2RjSmPBycMcmd3ICE= cosmossdk.io/store v0.0.0-20230206092147-e03195e4b8a7/go.mod h1:1XOtuYs7jsfQkn7G3VQXB6I+2tHXKHZw2U/AafNbnlk= cosmossdk.io/x/tx v0.2.0 h1:53f5TIXhpPYJGMm47SUslcV2i8JNBEN3eE08BmxE/Zg= diff --git a/x/circuit/keeper/msg_authorize_test.go b/x/circuit/keeper/msg_authorize_test.go index 4cc39e8cc7..d4a012ab19 100644 --- a/x/circuit/keeper/msg_authorize_test.go +++ b/x/circuit/keeper/msg_authorize_test.go @@ -18,7 +18,6 @@ type authorizeSuite struct { func (s *authorizeSuite) Before(t *testing.T) { s.baseFixture = initFixture(t) - } func (s *authorizeSuite) HasPermission(a string, b string) { diff --git a/x/circuit/keeper/msg_reset_test.go b/x/circuit/keeper/msg_reset_test.go index d95f22c641..8b935c35b7 100644 --- a/x/circuit/keeper/msg_reset_test.go +++ b/x/circuit/keeper/msg_reset_test.go @@ -18,7 +18,6 @@ type resetSuite struct { func (s *resetSuite) Before(t *testing.T) { s.baseFixture = initFixture(t) - } func (s *resetSuite) HasPermission(a string, b string) { diff --git a/x/circuit/keeper/msg_trip_test.go b/x/circuit/keeper/msg_trip_test.go index 456480e28a..7977eb808d 100644 --- a/x/circuit/keeper/msg_trip_test.go +++ b/x/circuit/keeper/msg_trip_test.go @@ -18,7 +18,6 @@ type tripSuite struct { func (s *tripSuite) Before(t *testing.T) { s.baseFixture = initFixture(t) - } func (s *tripSuite) HasPermission(a string, b string) { diff --git a/x/consensus/keeper/msg_server.go b/x/consensus/keeper/msg_server.go index f4312bbbf4..ed43cfdf29 100644 --- a/x/consensus/keeper/msg_server.go +++ b/x/consensus/keeper/msg_server.go @@ -5,8 +5,9 @@ import ( cmttypes "github.com/cometbft/cometbft/types" + "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/consensus/types" govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" ) @@ -25,7 +26,7 @@ func NewMsgServerImpl(keeper Keeper) types.MsgServer { func (k msgServer) UpdateParams(goCtx context.Context, req *types.MsgUpdateParams) (*types.MsgUpdateParamsResponse, error) { if k.GetAuthority() != req.Authority { - return nil, sdkerrors.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", k.GetAuthority(), req.Authority) + return nil, errors.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", k.GetAuthority(), req.Authority) } ctx := sdk.UnwrapSDKContext(goCtx) diff --git a/x/crisis/keeper/msg_server.go b/x/crisis/keeper/msg_server.go index 6b1ad58342..729bbd5700 100644 --- a/x/crisis/keeper/msg_server.go +++ b/x/crisis/keeper/msg_server.go @@ -3,8 +3,9 @@ package keeper import ( "context" + "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/crisis/types" govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" ) diff --git a/x/crisis/keeper/params.go b/x/crisis/keeper/params.go index e24eb58bd4..4724d9a6a3 100644 --- a/x/crisis/keeper/params.go +++ b/x/crisis/keeper/params.go @@ -1,6 +1,8 @@ package keeper import ( + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/crisis/types" @@ -20,7 +22,7 @@ func (k *Keeper) GetConstantFee(ctx sdk.Context) (constantFee sdk.Coin) { // GetConstantFee set's the constant fee in the store func (k *Keeper) SetConstantFee(ctx sdk.Context, constantFee sdk.Coin) error { if !constantFee.IsValid() || constantFee.IsNegative() { - return errors.Wrapf(errors.ErrInvalidCoins, "negative or invalid constant fee: %s", constantFee) + return errorsmod.Wrapf(errors.ErrInvalidCoins, "negative or invalid constant fee: %s", constantFee) } store := ctx.KVStore(k.storeKey) diff --git a/x/crisis/types/errors.go b/x/crisis/types/errors.go index cf8c4901b3..9086c5abf0 100644 --- a/x/crisis/types/errors.go +++ b/x/crisis/types/errors.go @@ -1,11 +1,9 @@ package types -import ( - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" -) +import "cosmossdk.io/errors" // x/crisis module sentinel errors var ( - ErrNoSender = sdkerrors.Register(ModuleName, 2, "sender address is empty") - ErrUnknownInvariant = sdkerrors.Register(ModuleName, 3, "unknown invariant") + ErrNoSender = errors.Register(ModuleName, 2, "sender address is empty") + ErrUnknownInvariant = errors.Register(ModuleName, 3, "unknown invariant") ) diff --git a/x/crisis/types/msgs.go b/x/crisis/types/msgs.go index 665183b98a..02ca572f45 100644 --- a/x/crisis/types/msgs.go +++ b/x/crisis/types/msgs.go @@ -1,6 +1,8 @@ package types import ( + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/auth/migrations/legacytx" @@ -65,15 +67,15 @@ func (msg MsgUpdateParams) GetSignBytes() []byte { // ValidateBasic performs basic MsgUpdateParams message validation. func (msg MsgUpdateParams) ValidateBasic() error { if _, err := sdk.AccAddressFromBech32(msg.Authority); err != nil { - return sdkerrors.Wrap(err, "invalid authority address") + return errorsmod.Wrap(err, "invalid authority address") } if !msg.ConstantFee.IsValid() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, "invalid costant fee") + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, "invalid costant fee") } if msg.ConstantFee.IsNegative() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, "negative costant fee") + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, "negative costant fee") } return nil diff --git a/x/distribution/keeper/grpc_query.go b/x/distribution/keeper/grpc_query.go index 9ac23186e9..af27568999 100644 --- a/x/distribution/keeper/grpc_query.go +++ b/x/distribution/keeper/grpc_query.go @@ -8,8 +8,9 @@ import ( "cosmossdk.io/store/prefix" + "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/types/query" "github.com/cosmos/cosmos-sdk/x/distribution/types" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" @@ -53,7 +54,7 @@ func (k Querier) ValidatorDistributionInfo(c context.Context, req *types.QueryVa // self-delegation rewards val := k.stakingKeeper.Validator(ctx, valAdr) if val == nil { - return nil, sdkerrors.Wrap(types.ErrNoValidatorExists, req.ValidatorAddress) + return nil, errors.Wrap(types.ErrNoValidatorExists, req.ValidatorAddress) } delAdr := sdk.AccAddress(valAdr) @@ -184,7 +185,7 @@ func (k Querier) DelegationRewards(c context.Context, req *types.QueryDelegation val := k.stakingKeeper.Validator(ctx, valAdr) if val == nil { - return nil, sdkerrors.Wrap(types.ErrNoValidatorExists, req.ValidatorAddress) + return nil, errors.Wrap(types.ErrNoValidatorExists, req.ValidatorAddress) } delAdr, err := sdk.AccAddressFromBech32(req.DelegatorAddress) diff --git a/x/distribution/keeper/keeper.go b/x/distribution/keeper/keeper.go index 13ed8679ef..ab80c8aeb7 100644 --- a/x/distribution/keeper/keeper.go +++ b/x/distribution/keeper/keeper.go @@ -3,6 +3,7 @@ package keeper import ( "fmt" + errorsmod "cosmossdk.io/errors" "cosmossdk.io/log" storetypes "cosmossdk.io/store/types" @@ -61,7 +62,7 @@ func (k Keeper) Logger(ctx sdk.Context) log.Logger { // SetWithdrawAddr sets a new address that will receive the rewards upon withdrawal func (k Keeper) SetWithdrawAddr(ctx sdk.Context, delegatorAddr sdk.AccAddress, withdrawAddr sdk.AccAddress) error { if k.bankKeeper.BlockedAddr(withdrawAddr) { - return sdkerrors.Wrapf(sdkerrors.ErrUnauthorized, "%s is not allowed to receive external funds", withdrawAddr) + return errorsmod.Wrapf(sdkerrors.ErrUnauthorized, "%s is not allowed to receive external funds", withdrawAddr) } if !k.GetWithdrawAddrEnabled(ctx) { diff --git a/x/distribution/keeper/msg_server.go b/x/distribution/keeper/msg_server.go index f9e87eb826..37b66e0145 100644 --- a/x/distribution/keeper/msg_server.go +++ b/x/distribution/keeper/msg_server.go @@ -5,6 +5,8 @@ import ( "github.com/armon/go-metrics" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/telemetry" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/errors" @@ -117,12 +119,12 @@ func (k msgServer) FundCommunityPool(goCtx context.Context, msg *types.MsgFundCo func (k msgServer) UpdateParams(goCtx context.Context, req *types.MsgUpdateParams) (*types.MsgUpdateParamsResponse, error) { if k.authority != req.Authority { - return nil, errors.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", k.authority, req.Authority) + return nil, errorsmod.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", k.authority, req.Authority) } if (!req.Params.BaseProposerReward.IsNil() && !req.Params.BaseProposerReward.IsZero()) || //nolint:staticcheck (!req.Params.BonusProposerReward.IsNil() && !req.Params.BonusProposerReward.IsZero()) { //nolint:staticcheck - return nil, errors.Wrapf(errors.ErrInvalidRequest, "cannot update base or bonus proposer reward because these are deprecated fields") + return nil, errorsmod.Wrapf(errors.ErrInvalidRequest, "cannot update base or bonus proposer reward because these are deprecated fields") } ctx := sdk.UnwrapSDKContext(goCtx) @@ -135,7 +137,7 @@ func (k msgServer) UpdateParams(goCtx context.Context, req *types.MsgUpdateParam func (k msgServer) CommunityPoolSpend(goCtx context.Context, req *types.MsgCommunityPoolSpend) (*types.MsgCommunityPoolSpendResponse, error) { if k.authority != req.Authority { - return nil, errors.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", k.authority, req.Authority) + return nil, errorsmod.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", k.authority, req.Authority) } ctx := sdk.UnwrapSDKContext(goCtx) @@ -146,7 +148,7 @@ func (k msgServer) CommunityPoolSpend(goCtx context.Context, req *types.MsgCommu } if k.bankKeeper.BlockedAddr(recipient) { - return nil, errors.Wrapf(errors.ErrUnauthorized, "%s is not allowed to receive external funds", req.Recipient) + return nil, errorsmod.Wrapf(errors.ErrUnauthorized, "%s is not allowed to receive external funds", req.Recipient) } if err := k.DistributeFromFeePool(ctx, req.Amount, recipient); err != nil { @@ -179,7 +181,7 @@ func (k msgServer) DepositValidatorRewardsPool(goCtx context.Context, req *types validator := k.stakingKeeper.Validator(ctx, valAddr) if validator == nil { - return nil, errors.Wrapf(types.ErrNoValidatorExists, valAddr.String()) + return nil, errorsmod.Wrapf(types.ErrNoValidatorExists, valAddr.String()) } // Allocate tokens from the distribution module to the validator, which are diff --git a/x/distribution/types/errors.go b/x/distribution/types/errors.go index 147cfd3203..808d3f86b7 100644 --- a/x/distribution/types/errors.go +++ b/x/distribution/types/errors.go @@ -1,21 +1,19 @@ package types -import ( - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" -) +import "cosmossdk.io/errors" // x/distribution module sentinel errors var ( - ErrEmptyDelegatorAddr = sdkerrors.Register(ModuleName, 2, "delegator address is empty") - ErrEmptyWithdrawAddr = sdkerrors.Register(ModuleName, 3, "withdraw address is empty") - ErrEmptyValidatorAddr = sdkerrors.Register(ModuleName, 4, "validator address is empty") - ErrEmptyDelegationDistInfo = sdkerrors.Register(ModuleName, 5, "no delegation distribution info") - ErrNoValidatorDistInfo = sdkerrors.Register(ModuleName, 6, "no validator distribution info") - ErrNoValidatorCommission = sdkerrors.Register(ModuleName, 7, "no validator commission to withdraw") - ErrSetWithdrawAddrDisabled = sdkerrors.Register(ModuleName, 8, "set withdraw address disabled") - ErrBadDistribution = sdkerrors.Register(ModuleName, 9, "community pool does not have sufficient coins to distribute") - ErrInvalidProposalAmount = sdkerrors.Register(ModuleName, 10, "invalid community pool spend proposal amount") - ErrEmptyProposalRecipient = sdkerrors.Register(ModuleName, 11, "invalid community pool spend proposal recipient") - ErrNoValidatorExists = sdkerrors.Register(ModuleName, 12, "validator does not exist") - ErrNoDelegationExists = sdkerrors.Register(ModuleName, 13, "delegation does not exist") + ErrEmptyDelegatorAddr = errors.Register(ModuleName, 2, "delegator address is empty") + ErrEmptyWithdrawAddr = errors.Register(ModuleName, 3, "withdraw address is empty") + ErrEmptyValidatorAddr = errors.Register(ModuleName, 4, "validator address is empty") + ErrEmptyDelegationDistInfo = errors.Register(ModuleName, 5, "no delegation distribution info") + ErrNoValidatorDistInfo = errors.Register(ModuleName, 6, "no validator distribution info") + ErrNoValidatorCommission = errors.Register(ModuleName, 7, "no validator commission to withdraw") + ErrSetWithdrawAddrDisabled = errors.Register(ModuleName, 8, "set withdraw address disabled") + ErrBadDistribution = errors.Register(ModuleName, 9, "community pool does not have sufficient coins to distribute") + ErrInvalidProposalAmount = errors.Register(ModuleName, 10, "invalid community pool spend proposal amount") + ErrEmptyProposalRecipient = errors.Register(ModuleName, 11, "invalid community pool spend proposal recipient") + ErrNoValidatorExists = errors.Register(ModuleName, 12, "validator does not exist") + ErrNoDelegationExists = errors.Register(ModuleName, 13, "delegation does not exist") ) diff --git a/x/distribution/types/msg.go b/x/distribution/types/msg.go index 1bd3edcdcc..9e5038664b 100644 --- a/x/distribution/types/msg.go +++ b/x/distribution/types/msg.go @@ -3,6 +3,8 @@ package types import ( "errors" + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/auth/migrations/legacytx" @@ -138,7 +140,7 @@ func (msg MsgFundCommunityPool) GetSignBytes() []byte { // ValidateBasic performs basic MsgFundCommunityPool message validation. func (msg MsgFundCommunityPool) ValidateBasic() error { if !msg.Amount.IsValid() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, msg.Amount.String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, msg.Amount.String()) } if _, err := sdk.AccAddressFromBech32(msg.Depositor); err != nil { return sdkerrors.ErrInvalidAddress.Wrapf("invalid depositor address: %s", err) diff --git a/x/evidence/README.md b/x/evidence/README.md index c3f0731af9..f8ca0505d2 100644 --- a/x/evidence/README.md +++ b/x/evidence/README.md @@ -153,15 +153,15 @@ as follows: ```go func SubmitEvidence(ctx Context, evidence Evidence) error { if _, ok := GetEvidence(ctx, evidence.Hash()); ok { - return sdkerrors.Wrap(types.ErrEvidenceExists, evidence.Hash().String()) + return errorsmod.Wrap(types.ErrEvidenceExists, evidence.Hash().String()) } if !router.HasRoute(evidence.Route()) { - return sdkerrors.Wrap(types.ErrNoEvidenceHandlerExists, evidence.Route()) + return errorsmod.Wrap(types.ErrNoEvidenceHandlerExists, evidence.Route()) } handler := router.GetRoute(evidence.Route()) if err := handler(ctx, evidence); err != nil { - return sdkerrors.Wrap(types.ErrInvalidEvidence, err.Error()) + return errorsmod.Wrap(types.ErrInvalidEvidence, err.Error()) } ctx.EventManager().EmitEvent( diff --git a/x/evidence/go.mod b/x/evidence/go.mod index c760f8576d..a7abf9429a 100644 --- a/x/evidence/go.mod +++ b/x/evidence/go.mod @@ -6,8 +6,9 @@ require ( cosmossdk.io/api v0.3.0 cosmossdk.io/core v0.5.1 cosmossdk.io/depinject v1.0.0-alpha.3 + cosmossdk.io/errors v1.0.0-beta.7 cosmossdk.io/log v0.0.0-00010101000000-000000000000 - cosmossdk.io/math v1.0.0-beta.6 + cosmossdk.io/math v1.0.0-beta.6.0.20230216172121-959ce49135e4 cosmossdk.io/store v0.0.0-20230206092147-e03195e4b8a7 github.com/cometbft/cometbft v0.0.0-20230203130311-387422ac220d github.com/cosmos/cosmos-proto v1.0.0-beta.1 @@ -25,7 +26,6 @@ require ( require ( cosmossdk.io/collections v0.0.0-20230204135315-697871069999 // indirect - cosmossdk.io/errors v1.0.0-beta.7 // indirect cosmossdk.io/x/tx v0.2.0 // indirect filippo.io/edwards25519 v1.0.0-rc.1 // indirect github.com/99designs/go-keychain v0.0.0-20191008050251-8e49817e8af4 // indirect diff --git a/x/evidence/go.sum b/x/evidence/go.sum index 8a1a453b95..6caf6f64a9 100644 --- a/x/evidence/go.sum +++ b/x/evidence/go.sum @@ -45,8 +45,8 @@ cosmossdk.io/depinject v1.0.0-alpha.3 h1:6evFIgj//Y3w09bqOUOzEpFj5tsxBqdc5CfkO7z cosmossdk.io/depinject v1.0.0-alpha.3/go.mod h1:eRbcdQ7MRpIPEM5YUJh8k97nxHpYbc3sMUnEtt8HPWU= cosmossdk.io/errors v1.0.0-beta.7 h1:gypHW76pTQGVnHKo6QBkb4yFOJjC+sUGRc5Al3Odj1w= cosmossdk.io/errors v1.0.0-beta.7/go.mod h1:mz6FQMJRku4bY7aqS/Gwfcmr/ue91roMEKAmDUDpBfE= -cosmossdk.io/math v1.0.0-beta.6 h1:WF29SiFYNde5eYvqO2kdOM9nYbDb44j3YW5B8M1m9KE= -cosmossdk.io/math v1.0.0-beta.6/go.mod h1:gUVtWwIzfSXqcOT+lBVz2jyjfua8DoBdzRsIyaUAT/8= +cosmossdk.io/math v1.0.0-beta.6.0.20230216172121-959ce49135e4 h1:/jnzJ9zFsL7qkV8LCQ1JH3dYHh2EsKZ3k8Mr6AqqiOA= +cosmossdk.io/math v1.0.0-beta.6.0.20230216172121-959ce49135e4/go.mod h1:gUVtWwIzfSXqcOT+lBVz2jyjfua8DoBdzRsIyaUAT/8= cosmossdk.io/store v0.0.0-20230206092147-e03195e4b8a7 h1:IwyDN/YaQmF+Pmuv8d7vRWMM/k2RjSmPBycMcmd3ICE= cosmossdk.io/store v0.0.0-20230206092147-e03195e4b8a7/go.mod h1:1XOtuYs7jsfQkn7G3VQXB6I+2tHXKHZw2U/AafNbnlk= cosmossdk.io/x/tx v0.2.0 h1:53f5TIXhpPYJGMm47SUslcV2i8JNBEN3eE08BmxE/Zg= diff --git a/x/evidence/keeper/keeper.go b/x/evidence/keeper/keeper.go index ed9097aed7..0581484e66 100644 --- a/x/evidence/keeper/keeper.go +++ b/x/evidence/keeper/keeper.go @@ -8,12 +8,12 @@ import ( "cosmossdk.io/x/evidence/types" cmtbytes "github.com/cometbft/cometbft/libs/bytes" + "cosmossdk.io/errors" "cosmossdk.io/store/prefix" storetypes "cosmossdk.io/store/types" "github.com/cosmos/cosmos-sdk/codec" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) // Keeper defines the evidence module's keeper. The keeper is responsible for @@ -67,7 +67,7 @@ func (k *Keeper) SetRouter(rtr types.Router) { // no handler exists, an error is returned. func (k Keeper) GetEvidenceHandler(evidenceRoute string) (types.Handler, error) { if !k.router.HasRoute(evidenceRoute) { - return nil, sdkerrors.Wrap(types.ErrNoEvidenceHandlerExists, evidenceRoute) + return nil, errors.Wrap(types.ErrNoEvidenceHandlerExists, evidenceRoute) } return k.router.GetRoute(evidenceRoute), nil @@ -79,15 +79,15 @@ func (k Keeper) GetEvidenceHandler(evidenceRoute string) (types.Handler, error) // persisted. func (k Keeper) SubmitEvidence(ctx sdk.Context, evidence exported.Evidence) error { if _, ok := k.GetEvidence(ctx, evidence.Hash()); ok { - return sdkerrors.Wrap(types.ErrEvidenceExists, evidence.Hash().String()) + return errors.Wrap(types.ErrEvidenceExists, evidence.Hash().String()) } if !k.router.HasRoute(evidence.Route()) { - return sdkerrors.Wrap(types.ErrNoEvidenceHandlerExists, evidence.Route()) + return errors.Wrap(types.ErrNoEvidenceHandlerExists, evidence.Route()) } handler := k.router.GetRoute(evidence.Route()) if err := handler(ctx, evidence); err != nil { - return sdkerrors.Wrap(types.ErrInvalidEvidence, err.Error()) + return errors.Wrap(types.ErrInvalidEvidence, err.Error()) } ctx.EventManager().EmitEvent( diff --git a/x/evidence/testutil/app_config.go b/x/evidence/testutil/app_config.go index 3eebf16298..547943e574 100644 --- a/x/evidence/testutil/app_config.go +++ b/x/evidence/testutil/app_config.go @@ -1,24 +1,24 @@ package testutil import ( + "cosmossdk.io/core/appconfig" _ "cosmossdk.io/x/evidence" // import as blank for app wiring + evidencetypes "cosmossdk.io/x/evidence/types" _ "github.com/cosmos/cosmos-sdk/x/auth" // import as blank for app wiring _ "github.com/cosmos/cosmos-sdk/x/auth/tx/config" // import as blank for app wiring - _ "github.com/cosmos/cosmos-sdk/x/bank" // import as blank for app wiring - _ "github.com/cosmos/cosmos-sdk/x/consensus" // import as blank for app wiring - _ "github.com/cosmos/cosmos-sdk/x/genutil" // import as blank for app wiring - _ "github.com/cosmos/cosmos-sdk/x/params" // import as blank for app wiring - _ "github.com/cosmos/cosmos-sdk/x/slashing" // import as blank for app wiring - _ "github.com/cosmos/cosmos-sdk/x/staking" // import as blank for app wiring - "cosmossdk.io/core/appconfig" - evidencetypes "cosmossdk.io/x/evidence/types" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" + _ "github.com/cosmos/cosmos-sdk/x/bank" // import as blank for app wiring banktypes "github.com/cosmos/cosmos-sdk/x/bank/types" + _ "github.com/cosmos/cosmos-sdk/x/consensus" // import as blank for app wiring consensustypes "github.com/cosmos/cosmos-sdk/x/consensus/types" + _ "github.com/cosmos/cosmos-sdk/x/genutil" // import as blank for app wiring genutiltypes "github.com/cosmos/cosmos-sdk/x/genutil/types" minttypes "github.com/cosmos/cosmos-sdk/x/mint/types" + _ "github.com/cosmos/cosmos-sdk/x/params" // import as blank for app wiring paramstypes "github.com/cosmos/cosmos-sdk/x/params/types" + _ "github.com/cosmos/cosmos-sdk/x/slashing" // import as blank for app wiring slashingtypes "github.com/cosmos/cosmos-sdk/x/slashing/types" + _ "github.com/cosmos/cosmos-sdk/x/staking" // import as blank for app wiring stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" runtimev1alpha1 "cosmossdk.io/api/cosmos/app/runtime/v1alpha1" diff --git a/x/evidence/types/errors.go b/x/evidence/types/errors.go index 5e5d12e383..178ca4e84e 100644 --- a/x/evidence/types/errors.go +++ b/x/evidence/types/errors.go @@ -1,13 +1,11 @@ package types -import ( - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" -) +import "cosmossdk.io/errors" // x/evidence module sentinel errors var ( - ErrNoEvidenceHandlerExists = sdkerrors.Register(ModuleName, 2, "unregistered handler for evidence type") - ErrInvalidEvidence = sdkerrors.Register(ModuleName, 3, "invalid evidence") - ErrNoEvidenceExists = sdkerrors.Register(ModuleName, 4, "evidence does not exist") - ErrEvidenceExists = sdkerrors.Register(ModuleName, 5, "evidence already exists") + ErrNoEvidenceHandlerExists = errors.Register(ModuleName, 2, "unregistered handler for evidence type") + ErrInvalidEvidence = errors.Register(ModuleName, 3, "invalid evidence") + ErrNoEvidenceExists = errors.Register(ModuleName, 4, "evidence does not exist") + ErrEvidenceExists = errors.Register(ModuleName, 5, "evidence already exists") ) diff --git a/x/evidence/types/msgs.go b/x/evidence/types/msgs.go index 25a99e6e05..f70dd01ae7 100644 --- a/x/evidence/types/msgs.go +++ b/x/evidence/types/msgs.go @@ -3,6 +3,7 @@ package types import ( "fmt" + errorsmod "cosmossdk.io/errors" "cosmossdk.io/x/evidence/exported" "github.com/cosmos/gogoproto/proto" @@ -42,7 +43,7 @@ func (m MsgSubmitEvidence) ValidateBasic() error { evi := m.GetEvidence() if evi == nil { - return sdkerrors.Wrap(ErrInvalidEvidence, "missing evidence") + return errorsmod.Wrap(ErrInvalidEvidence, "missing evidence") } if err := evi.ValidateBasic(); err != nil { return err diff --git a/x/feegrant/basic_fee.go b/x/feegrant/basic_fee.go index 81419b6d57..5425afb35d 100644 --- a/x/feegrant/basic_fee.go +++ b/x/feegrant/basic_fee.go @@ -3,6 +3,8 @@ package feegrant import ( time "time" + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) @@ -21,13 +23,13 @@ var _ FeeAllowanceI = (*BasicAllowance)(nil) // (eg. when it is used up). (See call to RevokeAllowance in Keeper.UseGrantedFees) func (a *BasicAllowance) Accept(ctx sdk.Context, fee sdk.Coins, _ []sdk.Msg) (bool, error) { if a.Expiration != nil && a.Expiration.Before(ctx.BlockTime()) { - return true, sdkerrors.Wrap(ErrFeeLimitExpired, "basic allowance") + return true, errorsmod.Wrap(ErrFeeLimitExpired, "basic allowance") } if a.SpendLimit != nil { left, invalid := a.SpendLimit.SafeSub(fee...) if invalid { - return false, sdkerrors.Wrap(ErrFeeLimitExceeded, "basic allowance") + return false, errorsmod.Wrap(ErrFeeLimitExceeded, "basic allowance") } a.SpendLimit = left @@ -41,15 +43,15 @@ func (a *BasicAllowance) Accept(ctx sdk.Context, fee sdk.Coins, _ []sdk.Msg) (bo func (a BasicAllowance) ValidateBasic() error { if a.SpendLimit != nil { if !a.SpendLimit.IsValid() { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidCoins, "send amount is invalid: %s", a.SpendLimit) + return errorsmod.Wrapf(sdkerrors.ErrInvalidCoins, "send amount is invalid: %s", a.SpendLimit) } if !a.SpendLimit.IsAllPositive() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, "spend limit must be positive") + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, "spend limit must be positive") } } if a.Expiration != nil && a.Expiration.Unix() < 0 { - return sdkerrors.Wrap(ErrInvalidDuration, "expiration time cannot be negative") + return errorsmod.Wrap(ErrInvalidDuration, "expiration time cannot be negative") } return nil diff --git a/x/feegrant/errors.go b/x/feegrant/errors.go index 232020e6a2..edd6fb7ac0 100644 --- a/x/feegrant/errors.go +++ b/x/feegrant/errors.go @@ -1,8 +1,6 @@ package feegrant -import ( - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" -) +import "cosmossdk.io/errors" // Codes for governance errors const ( @@ -11,15 +9,15 @@ const ( var ( // ErrFeeLimitExceeded error if there are not enough allowance to cover the fees - ErrFeeLimitExceeded = sdkerrors.Register(DefaultCodespace, 2, "fee limit exceeded") + ErrFeeLimitExceeded = errors.Register(DefaultCodespace, 2, "fee limit exceeded") // ErrFeeLimitExpired error if the allowance has expired - ErrFeeLimitExpired = sdkerrors.Register(DefaultCodespace, 3, "fee allowance expired") + ErrFeeLimitExpired = errors.Register(DefaultCodespace, 3, "fee allowance expired") // ErrInvalidDuration error if the Duration is invalid or doesn't match the expiration - ErrInvalidDuration = sdkerrors.Register(DefaultCodespace, 4, "invalid duration") + ErrInvalidDuration = errors.Register(DefaultCodespace, 4, "invalid duration") // ErrNoAllowance error if there is no allowance for that pair - ErrNoAllowance = sdkerrors.Register(DefaultCodespace, 5, "no allowance") + ErrNoAllowance = errors.Register(DefaultCodespace, 5, "no allowance") // ErrNoMessages error if there is no message - ErrNoMessages = sdkerrors.Register(DefaultCodespace, 6, "allowed messages are empty") + ErrNoMessages = errors.Register(DefaultCodespace, 6, "allowed messages are empty") // ErrMessageNotAllowed error if message is not allowed - ErrMessageNotAllowed = sdkerrors.Register(DefaultCodespace, 7, "message not allowed") + ErrMessageNotAllowed = errors.Register(DefaultCodespace, 7, "message not allowed") ) diff --git a/x/feegrant/filtered_fee.go b/x/feegrant/filtered_fee.go index 28679ed5a4..fea7371774 100644 --- a/x/feegrant/filtered_fee.go +++ b/x/feegrant/filtered_fee.go @@ -3,6 +3,7 @@ package feegrant import ( "time" + errorsmod "cosmossdk.io/errors" "github.com/cosmos/gogoproto/proto" "github.com/cosmos/cosmos-sdk/codec/types" @@ -31,7 +32,7 @@ func (a *AllowedMsgAllowance) UnpackInterfaces(unpacker types.AnyUnpacker) error func NewAllowedMsgAllowance(allowance FeeAllowanceI, allowedMsgs []string) (*AllowedMsgAllowance, error) { msg, ok := allowance.(proto.Message) if !ok { - return nil, sdkerrors.Wrapf(sdkerrors.ErrPackAny, "cannot proto marshal %T", msg) + return nil, errorsmod.Wrapf(sdkerrors.ErrPackAny, "cannot proto marshal %T", msg) } any, err := types.NewAnyWithValue(msg) if err != nil { @@ -48,7 +49,7 @@ func NewAllowedMsgAllowance(allowance FeeAllowanceI, allowedMsgs []string) (*All func (a *AllowedMsgAllowance) GetAllowance() (FeeAllowanceI, error) { allowance, ok := a.Allowance.GetCachedValue().(FeeAllowanceI) if !ok { - return nil, sdkerrors.Wrap(ErrNoAllowance, "failed to get allowance") + return nil, errorsmod.Wrap(ErrNoAllowance, "failed to get allowance") } return allowance, nil @@ -59,7 +60,7 @@ func (a *AllowedMsgAllowance) SetAllowance(allowance FeeAllowanceI) error { var err error a.Allowance, err = types.NewAnyWithValue(allowance.(proto.Message)) if err != nil { - return sdkerrors.Wrapf(sdkerrors.ErrPackAny, "cannot proto marshal %T", allowance) + return errorsmod.Wrapf(sdkerrors.ErrPackAny, "cannot proto marshal %T", allowance) } return nil @@ -68,7 +69,7 @@ func (a *AllowedMsgAllowance) SetAllowance(allowance FeeAllowanceI) error { // Accept method checks for the filtered messages has valid expiry func (a *AllowedMsgAllowance) Accept(ctx sdk.Context, fee sdk.Coins, msgs []sdk.Msg) (bool, error) { if !a.allMsgTypesAllowed(ctx, msgs) { - return false, sdkerrors.Wrap(ErrMessageNotAllowed, "message does not exist in allowed messages") + return false, errorsmod.Wrap(ErrMessageNotAllowed, "message does not exist in allowed messages") } allowance, err := a.GetAllowance() @@ -111,10 +112,10 @@ func (a *AllowedMsgAllowance) allMsgTypesAllowed(ctx sdk.Context, msgs []sdk.Msg // ValidateBasic implements FeeAllowance and enforces basic sanity checks func (a *AllowedMsgAllowance) ValidateBasic() error { if a.Allowance == nil { - return sdkerrors.Wrap(ErrNoAllowance, "allowance should not be empty") + return errorsmod.Wrap(ErrNoAllowance, "allowance should not be empty") } if len(a.AllowedMessages) == 0 { - return sdkerrors.Wrap(ErrNoMessages, "allowed messages shouldn't be empty") + return errorsmod.Wrap(ErrNoMessages, "allowed messages shouldn't be empty") } allowance, err := a.GetAllowance() diff --git a/x/feegrant/go.mod b/x/feegrant/go.mod index 523abbe9ee..42216645ab 100644 --- a/x/feegrant/go.mod +++ b/x/feegrant/go.mod @@ -6,8 +6,9 @@ require ( cosmossdk.io/api v0.3.0 cosmossdk.io/core v0.5.1 cosmossdk.io/depinject v1.0.0-alpha.3 + cosmossdk.io/errors v1.0.0-beta.7 cosmossdk.io/log v0.0.0-20230207163452-bd8e9f2d1206 - cosmossdk.io/math v1.0.0-beta.6 + cosmossdk.io/math v1.0.0-beta.6.0.20230216172121-959ce49135e4 cosmossdk.io/store v0.0.0-20230206092147-e03195e4b8a7 github.com/cometbft/cometbft v0.0.0-20230203130311-387422ac220d github.com/cosmos/cosmos-proto v1.0.0-beta.1 @@ -25,7 +26,6 @@ require ( require ( cosmossdk.io/collections v0.0.0-20230204135315-697871069999 // indirect - cosmossdk.io/errors v1.0.0-beta.7 // indirect cosmossdk.io/x/tx v0.2.0 // indirect filippo.io/edwards25519 v1.0.0-rc.1 // indirect github.com/99designs/go-keychain v0.0.0-20191008050251-8e49817e8af4 // indirect diff --git a/x/feegrant/go.sum b/x/feegrant/go.sum index 8406210ca9..86fe08eacd 100644 --- a/x/feegrant/go.sum +++ b/x/feegrant/go.sum @@ -45,8 +45,8 @@ cosmossdk.io/depinject v1.0.0-alpha.3 h1:6evFIgj//Y3w09bqOUOzEpFj5tsxBqdc5CfkO7z cosmossdk.io/depinject v1.0.0-alpha.3/go.mod h1:eRbcdQ7MRpIPEM5YUJh8k97nxHpYbc3sMUnEtt8HPWU= cosmossdk.io/errors v1.0.0-beta.7 h1:gypHW76pTQGVnHKo6QBkb4yFOJjC+sUGRc5Al3Odj1w= cosmossdk.io/errors v1.0.0-beta.7/go.mod h1:mz6FQMJRku4bY7aqS/Gwfcmr/ue91roMEKAmDUDpBfE= -cosmossdk.io/math v1.0.0-beta.6 h1:WF29SiFYNde5eYvqO2kdOM9nYbDb44j3YW5B8M1m9KE= -cosmossdk.io/math v1.0.0-beta.6/go.mod h1:gUVtWwIzfSXqcOT+lBVz2jyjfua8DoBdzRsIyaUAT/8= +cosmossdk.io/math v1.0.0-beta.6.0.20230216172121-959ce49135e4 h1:/jnzJ9zFsL7qkV8LCQ1JH3dYHh2EsKZ3k8Mr6AqqiOA= +cosmossdk.io/math v1.0.0-beta.6.0.20230216172121-959ce49135e4/go.mod h1:gUVtWwIzfSXqcOT+lBVz2jyjfua8DoBdzRsIyaUAT/8= cosmossdk.io/store v0.0.0-20230206092147-e03195e4b8a7 h1:IwyDN/YaQmF+Pmuv8d7vRWMM/k2RjSmPBycMcmd3ICE= cosmossdk.io/store v0.0.0-20230206092147-e03195e4b8a7/go.mod h1:1XOtuYs7jsfQkn7G3VQXB6I+2tHXKHZw2U/AafNbnlk= cosmossdk.io/x/tx v0.2.0 h1:53f5TIXhpPYJGMm47SUslcV2i8JNBEN3eE08BmxE/Zg= diff --git a/x/feegrant/grant.go b/x/feegrant/grant.go index caa4cea7f9..8ea74bbce6 100644 --- a/x/feegrant/grant.go +++ b/x/feegrant/grant.go @@ -3,6 +3,8 @@ package feegrant import ( "github.com/cosmos/gogoproto/proto" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/codec/types" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" @@ -16,7 +18,7 @@ var _ types.UnpackInterfacesMessage = &Grant{} func NewGrant(granter, grantee sdk.AccAddress, feeAllowance FeeAllowanceI) (Grant, error) { msg, ok := feeAllowance.(proto.Message) if !ok { - return Grant{}, sdkerrors.Wrapf(sdkerrors.ErrPackAny, "cannot proto marshal %T", feeAllowance) + return Grant{}, errorsmod.Wrapf(sdkerrors.ErrPackAny, "cannot proto marshal %T", feeAllowance) } any, err := types.NewAnyWithValue(msg) @@ -35,13 +37,13 @@ func NewGrant(granter, grantee sdk.AccAddress, feeAllowance FeeAllowanceI) (Gran // FeeAllowanceGrant func (a Grant) ValidateBasic() error { if a.Granter == "" { - return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "missing granter address") + return errorsmod.Wrap(sdkerrors.ErrInvalidAddress, "missing granter address") } if a.Grantee == "" { - return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "missing grantee address") + return errorsmod.Wrap(sdkerrors.ErrInvalidAddress, "missing grantee address") } if a.Grantee == a.Granter { - return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "cannot self-grant fee authorization") + return errorsmod.Wrap(sdkerrors.ErrInvalidAddress, "cannot self-grant fee authorization") } f, err := a.GetGrant() @@ -56,7 +58,7 @@ func (a Grant) ValidateBasic() error { func (a Grant) GetGrant() (FeeAllowanceI, error) { allowance, ok := a.Allowance.GetCachedValue().(FeeAllowanceI) if !ok { - return nil, sdkerrors.Wrap(ErrNoAllowance, "failed to get allowance") + return nil, errorsmod.Wrap(ErrNoAllowance, "failed to get allowance") } return allowance, nil diff --git a/x/feegrant/keeper/keeper.go b/x/feegrant/keeper/keeper.go index 81822a0ead..582c997eb9 100644 --- a/x/feegrant/keeper/keeper.go +++ b/x/feegrant/keeper/keeper.go @@ -4,6 +4,7 @@ import ( "fmt" "time" + errorsmod "cosmossdk.io/errors" "cosmossdk.io/log" storetypes "cosmossdk.io/store/types" "cosmossdk.io/x/feegrant" @@ -42,7 +43,7 @@ func (k Keeper) Logger(ctx sdk.Context) log.Logger { func (k Keeper) GrantAllowance(ctx sdk.Context, granter, grantee sdk.AccAddress, feeAllowance feegrant.FeeAllowanceI) error { // Checking for duplicate entry if f, _ := k.GetAllowance(ctx, granter, grantee); f != nil { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "fee allowance already exists") + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "fee allowance already exists") } // create the account if it is not in account state @@ -62,7 +63,7 @@ func (k Keeper) GrantAllowance(ctx sdk.Context, granter, grantee sdk.AccAddress, // expiration shouldn't be in the past. if exp != nil && exp.Before(ctx.BlockTime()) { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "expiration is before current block time") + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "expiration is before current block time") } // if expiry is not nil, add the new key to pruning queue. diff --git a/x/feegrant/module/module.go b/x/feegrant/module/module.go index 8f63a67e3d..db0f97134a 100644 --- a/x/feegrant/module/module.go +++ b/x/feegrant/module/module.go @@ -10,6 +10,7 @@ import ( "github.com/spf13/cobra" "cosmossdk.io/core/appmodule" + "cosmossdk.io/errors" modulev1 "cosmossdk.io/api/cosmos/feegrant/module/v1" @@ -25,7 +26,6 @@ import ( "github.com/cosmos/cosmos-sdk/codec" cdctypes "github.com/cosmos/cosmos-sdk/codec/types" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/types/module" simtypes "github.com/cosmos/cosmos-sdk/types/simulation" ) @@ -82,7 +82,7 @@ func (AppModuleBasic) DefaultGenesis(cdc codec.JSONCodec) json.RawMessage { func (a AppModuleBasic) ValidateGenesis(cdc codec.JSONCodec, config sdkclient.TxEncodingConfig, bz json.RawMessage) error { var data feegrant.GenesisState if err := cdc.UnmarshalJSON(bz, &data); err != nil { - sdkerrors.Wrapf(err, "failed to unmarshal %s genesis state", feegrant.ModuleName) + return errors.Wrapf(err, "failed to unmarshal %s genesis state", feegrant.ModuleName) } return feegrant.ValidateGenesis(data) diff --git a/x/feegrant/msgs.go b/x/feegrant/msgs.go index 13f9a09ccd..050feb8c7c 100644 --- a/x/feegrant/msgs.go +++ b/x/feegrant/msgs.go @@ -3,6 +3,8 @@ package feegrant import ( "github.com/cosmos/gogoproto/proto" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/codec/types" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" @@ -23,7 +25,7 @@ var ( func NewMsgGrantAllowance(feeAllowance FeeAllowanceI, granter, grantee sdk.AccAddress) (*MsgGrantAllowance, error) { msg, ok := feeAllowance.(proto.Message) if !ok { - return nil, sdkerrors.Wrapf(sdkerrors.ErrPackAny, "cannot proto marshal %T", msg) + return nil, errorsmod.Wrapf(sdkerrors.ErrPackAny, "cannot proto marshal %T", msg) } any, err := types.NewAnyWithValue(msg) if err != nil { @@ -46,7 +48,7 @@ func (msg MsgGrantAllowance) ValidateBasic() error { return sdkerrors.ErrInvalidAddress.Wrapf("invalid grantee address: %s", err) } if msg.Grantee == msg.Granter { - return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "cannot self-grant fee authorization") + return errorsmod.Wrap(sdkerrors.ErrInvalidAddress, "cannot self-grant fee authorization") } allowance, err := msg.GetFeeAllowanceI() if err != nil { @@ -71,7 +73,7 @@ func (msg MsgGrantAllowance) GetSignBytes() []byte { func (msg MsgGrantAllowance) GetFeeAllowanceI() (FeeAllowanceI, error) { allowance, ok := msg.Allowance.GetCachedValue().(FeeAllowanceI) if !ok { - return nil, sdkerrors.Wrap(ErrNoAllowance, "failed to get allowance") + return nil, errorsmod.Wrap(ErrNoAllowance, "failed to get allowance") } return allowance, nil @@ -100,7 +102,7 @@ func (msg MsgRevokeAllowance) ValidateBasic() error { return sdkerrors.ErrInvalidAddress.Wrapf("invalid grantee address: %s", err) } if msg.Grantee == msg.Granter { - return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "addresses must be different") + return errorsmod.Wrap(sdkerrors.ErrInvalidAddress, "addresses must be different") } return nil diff --git a/x/feegrant/periodic_fee.go b/x/feegrant/periodic_fee.go index 0e496ce5a9..800e9e84f5 100644 --- a/x/feegrant/periodic_fee.go +++ b/x/feegrant/periodic_fee.go @@ -3,6 +3,8 @@ package feegrant import ( "time" + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) @@ -23,7 +25,7 @@ func (a *PeriodicAllowance) Accept(ctx sdk.Context, fee sdk.Coins, _ []sdk.Msg) blockTime := ctx.BlockTime() if a.Basic.Expiration != nil && blockTime.After(*a.Basic.Expiration) { - return true, sdkerrors.Wrap(ErrFeeLimitExpired, "absolute limit") + return true, errorsmod.Wrap(ErrFeeLimitExpired, "absolute limit") } a.tryResetPeriod(blockTime) @@ -32,13 +34,13 @@ func (a *PeriodicAllowance) Accept(ctx sdk.Context, fee sdk.Coins, _ []sdk.Msg) var isNeg bool a.PeriodCanSpend, isNeg = a.PeriodCanSpend.SafeSub(fee...) if isNeg { - return false, sdkerrors.Wrap(ErrFeeLimitExceeded, "period limit") + return false, errorsmod.Wrap(ErrFeeLimitExceeded, "period limit") } if a.Basic.SpendLimit != nil { a.Basic.SpendLimit, isNeg = a.Basic.SpendLimit.SafeSub(fee...) if isNeg { - return false, sdkerrors.Wrap(ErrFeeLimitExceeded, "absolute limit") + return false, errorsmod.Wrap(ErrFeeLimitExceeded, "absolute limit") } return a.Basic.SpendLimit.IsZero(), nil @@ -80,27 +82,27 @@ func (a PeriodicAllowance) ValidateBasic() error { } if !a.PeriodSpendLimit.IsValid() { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidCoins, "spend amount is invalid: %s", a.PeriodSpendLimit) + return errorsmod.Wrapf(sdkerrors.ErrInvalidCoins, "spend amount is invalid: %s", a.PeriodSpendLimit) } if !a.PeriodSpendLimit.IsAllPositive() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, "spend limit must be positive") + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, "spend limit must be positive") } if !a.PeriodCanSpend.IsValid() { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidCoins, "can spend amount is invalid: %s", a.PeriodCanSpend) + return errorsmod.Wrapf(sdkerrors.ErrInvalidCoins, "can spend amount is invalid: %s", a.PeriodCanSpend) } // We allow 0 for CanSpend if a.PeriodCanSpend.IsAnyNegative() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, "can spend must not be negative") + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, "can spend must not be negative") } // ensure PeriodSpendLimit can be subtracted from total (same coin types) if a.Basic.SpendLimit != nil && !a.PeriodSpendLimit.DenomsSubsetOf(a.Basic.SpendLimit) { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, "period spend limit has different currency than basic spend limit") + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, "period spend limit has different currency than basic spend limit") } // check times if a.Period.Seconds() < 0 { - return sdkerrors.Wrap(ErrInvalidDuration, "negative clock step") + return errorsmod.Wrap(ErrInvalidDuration, "negative clock step") } return nil diff --git a/x/genutil/client/cli/collect.go b/x/genutil/client/cli/collect.go index 84860c9f51..1d0db8ce8d 100644 --- a/x/genutil/client/cli/collect.go +++ b/x/genutil/client/cli/collect.go @@ -5,9 +5,10 @@ import ( "path/filepath" cmttypes "github.com/cometbft/cometbft/types" - "github.com/pkg/errors" "github.com/spf13/cobra" + "github.com/pkg/errors" + "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/client/flags" "github.com/cosmos/cosmos-sdk/server" diff --git a/x/genutil/client/cli/gentx.go b/x/genutil/client/cli/gentx.go index 70fc441004..1a8c8cc7f4 100644 --- a/x/genutil/client/cli/gentx.go +++ b/x/genutil/client/cli/gentx.go @@ -10,9 +10,10 @@ import ( "path/filepath" cmttypes "github.com/cometbft/cometbft/types" - "github.com/pkg/errors" "github.com/spf13/cobra" + "github.com/pkg/errors" + "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/client/flags" "github.com/cosmos/cosmos-sdk/client/tx" diff --git a/x/gov/keeper/deposit.go b/x/gov/keeper/deposit.go index eae18f7cdb..e7901e11d4 100644 --- a/x/gov/keeper/deposit.go +++ b/x/gov/keeper/deposit.go @@ -3,10 +3,10 @@ package keeper import ( "fmt" + "cosmossdk.io/errors" storetypes "cosmossdk.io/store/types" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" disttypes "github.com/cosmos/cosmos-sdk/x/distribution/types" "github.com/cosmos/cosmos-sdk/x/gov/types" v1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1" @@ -113,12 +113,12 @@ func (keeper Keeper) AddDeposit(ctx sdk.Context, proposalID uint64, depositorAdd // Checks to see if proposal exists proposal, ok := keeper.GetProposal(ctx, proposalID) if !ok { - return false, sdkerrors.Wrapf(types.ErrUnknownProposal, "%d", proposalID) + return false, errors.Wrapf(types.ErrUnknownProposal, "%d", proposalID) } // Check if proposal is still depositable if (proposal.Status != v1.StatusDepositPeriod) && (proposal.Status != v1.StatusVotingPeriod) { - return false, sdkerrors.Wrapf(types.ErrInactiveProposal, "%d", proposalID) + return false, errors.Wrapf(types.ErrInactiveProposal, "%d", proposalID) } // update the governance module's account coins pool @@ -278,7 +278,7 @@ func (keeper Keeper) validateInitialDeposit(ctx sdk.Context, initialDeposit sdk. minDepositCoins[i].Amount = sdk.NewDecFromInt(minDepositCoins[i].Amount).Mul(minInitialDepositRatio).RoundInt() } if !initialDeposit.IsAllGTE(minDepositCoins) { - return sdkerrors.Wrapf(types.ErrMinDepositTooSmall, "was (%s), need (%s)", initialDeposit, minDepositCoins) + return errors.Wrapf(types.ErrMinDepositTooSmall, "was (%s), need (%s)", initialDeposit, minDepositCoins) } return nil } diff --git a/x/gov/keeper/proposal.go b/x/gov/keeper/proposal.go index 2a111b231d..adf5c227ad 100644 --- a/x/gov/keeper/proposal.go +++ b/x/gov/keeper/proposal.go @@ -5,11 +5,11 @@ import ( "fmt" "time" + errorsmod "cosmossdk.io/errors" storetypes "cosmossdk.io/store/types" "github.com/cosmos/cosmos-sdk/client" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/gov/types" v1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1" ) @@ -43,7 +43,7 @@ func (keeper Keeper) SubmitProposal(ctx sdk.Context, messages []sdk.Msg, metadat // perform a basic validation of the message if err := msg.ValidateBasic(); err != nil { - return v1.Proposal{}, sdkerrors.Wrap(types.ErrInvalidProposalMsg, err.Error()) + return v1.Proposal{}, errorsmod.Wrap(types.ErrInvalidProposalMsg, err.Error()) } signers := msg.GetSigners() @@ -53,13 +53,13 @@ func (keeper Keeper) SubmitProposal(ctx sdk.Context, messages []sdk.Msg, metadat // assert that the governance module account is the only signer of the messages if !signers[0].Equals(keeper.GetGovernanceAccount(ctx).GetAddress()) { - return v1.Proposal{}, sdkerrors.Wrapf(types.ErrInvalidSigner, signers[0].String()) + return v1.Proposal{}, errorsmod.Wrapf(types.ErrInvalidSigner, signers[0].String()) } // use the msg service router to see that there is a valid route for that message. handler := keeper.router.Handler(msg) if handler == nil { - return v1.Proposal{}, sdkerrors.Wrap(types.ErrUnroutableProposalMsg, sdk.MsgTypeURL(msg)) + return v1.Proposal{}, errorsmod.Wrap(types.ErrUnroutableProposalMsg, sdk.MsgTypeURL(msg)) } // Only if it's a MsgExecLegacyContent do we try to execute the @@ -73,7 +73,7 @@ func (keeper Keeper) SubmitProposal(ctx sdk.Context, messages []sdk.Msg, metadat if errors.Is(types.ErrNoProposalHandlerExists, err) { return v1.Proposal{}, err } - return v1.Proposal{}, sdkerrors.Wrap(types.ErrInvalidProposalContent, err.Error()) + return v1.Proposal{}, errorsmod.Wrap(types.ErrInvalidProposalContent, err.Error()) } } @@ -114,7 +114,7 @@ func (keeper Keeper) SubmitProposal(ctx sdk.Context, messages []sdk.Msg, metadat func (keeper Keeper) CancelProposal(ctx sdk.Context, proposalID uint64, proposer string) error { proposal, ok := keeper.GetProposal(ctx, proposalID) if !ok { - return sdkerrors.Wrapf(types.ErrProposalNotFound, "proposal_id %d", proposalID) + return errorsmod.Wrapf(types.ErrProposalNotFound, "proposal_id %d", proposalID) } // Checking proposal have proposer or not because old proposal doesn't have proposer field, @@ -298,7 +298,7 @@ func (keeper Keeper) GetProposalID(ctx sdk.Context) (proposalID uint64, err erro store := ctx.KVStore(keeper.storeKey) bz := store.Get(types.ProposalIDKey) if bz == nil { - return 0, sdkerrors.Wrap(types.ErrInvalidGenesis, "initial proposal ID hasn't been set") + return 0, errorsmod.Wrap(types.ErrInvalidGenesis, "initial proposal ID hasn't been set") } proposalID = types.GetProposalIDFromBytes(bz) diff --git a/x/gov/keeper/vote.go b/x/gov/keeper/vote.go index 3645c5ebb2..79295b9ed0 100644 --- a/x/gov/keeper/vote.go +++ b/x/gov/keeper/vote.go @@ -3,10 +3,10 @@ package keeper import ( "fmt" + "cosmossdk.io/errors" storetypes "cosmossdk.io/store/types" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/gov/types" v1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1" ) @@ -16,7 +16,7 @@ func (keeper Keeper) AddVote(ctx sdk.Context, proposalID uint64, voterAddr sdk.A // Check if proposal is in voting period. store := ctx.KVStore(keeper.storeKey) if !store.Has(types.VotingPeriodProposalKey(proposalID)) { - return sdkerrors.Wrapf(types.ErrInactiveProposal, "%d", proposalID) + return errors.Wrapf(types.ErrInactiveProposal, "%d", proposalID) } err := keeper.assertMetadataLength(metadata) @@ -26,7 +26,7 @@ func (keeper Keeper) AddVote(ctx sdk.Context, proposalID uint64, voterAddr sdk.A for _, option := range options { if !v1.ValidWeightedVoteOption(*option) { - return sdkerrors.Wrap(types.ErrInvalidVote, option.String()) + return errors.Wrap(types.ErrInvalidVote, option.String()) } } diff --git a/x/gov/module.go b/x/gov/module.go index c1fd892357..dcf5eafe64 100644 --- a/x/gov/module.go +++ b/x/gov/module.go @@ -219,7 +219,7 @@ func ProvideModule(in GovInputs) GovOutputs { } func ProvideKeyTable() paramtypes.KeyTable { - return v1.ParamKeyTable() + return v1.ParamKeyTable() //nolint:staticcheck // we still need this for upgrades } func InvokeAddRoutes(keeper *keeper.Keeper, routes []v1beta1.HandlerRoute) { diff --git a/x/gov/types/errors.go b/x/gov/types/errors.go index b7496b59f2..ae9142c92c 100644 --- a/x/gov/types/errors.go +++ b/x/gov/types/errors.go @@ -1,30 +1,30 @@ package types import ( - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "cosmossdk.io/errors" ) // x/gov module sentinel errors var ( - ErrUnknownProposal = sdkerrors.Register(ModuleName, 2, "unknown proposal") - ErrInactiveProposal = sdkerrors.Register(ModuleName, 3, "inactive proposal") - ErrAlreadyActiveProposal = sdkerrors.Register(ModuleName, 4, "proposal already active") + ErrUnknownProposal = errors.Register(ModuleName, 2, "unknown proposal") + ErrInactiveProposal = errors.Register(ModuleName, 3, "inactive proposal") + ErrAlreadyActiveProposal = errors.Register(ModuleName, 4, "proposal already active") // Errors 5 & 6 are legacy errors related to v1beta1.Proposal. - ErrInvalidProposalContent = sdkerrors.Register(ModuleName, 5, "invalid proposal content") - ErrInvalidProposalType = sdkerrors.Register(ModuleName, 6, "invalid proposal type") - ErrInvalidVote = sdkerrors.Register(ModuleName, 7, "invalid vote option") - ErrInvalidGenesis = sdkerrors.Register(ModuleName, 8, "invalid genesis state") - ErrNoProposalHandlerExists = sdkerrors.Register(ModuleName, 9, "no handler exists for proposal type") - ErrUnroutableProposalMsg = sdkerrors.Register(ModuleName, 10, "proposal message not recognized by router") - ErrNoProposalMsgs = sdkerrors.Register(ModuleName, 11, "no messages proposed") - ErrInvalidProposalMsg = sdkerrors.Register(ModuleName, 12, "invalid proposal message") - ErrInvalidSigner = sdkerrors.Register(ModuleName, 13, "expected gov account as only signer for proposal message") - ErrInvalidSignalMsg = sdkerrors.Register(ModuleName, 14, "signal message is invalid") - ErrMetadataTooLong = sdkerrors.Register(ModuleName, 15, "metadata too long") - ErrMinDepositTooSmall = sdkerrors.Register(ModuleName, 16, "minimum deposit is too small") - ErrProposalNotFound = sdkerrors.Register(ModuleName, 17, "proposal is not found") - ErrInvalidProposer = sdkerrors.Register(ModuleName, 18, "invalid proposer") - ErrNoDeposits = sdkerrors.Register(ModuleName, 19, "no deposits found") - ErrVotingPeriodEnded = sdkerrors.Register(ModuleName, 20, "voting period already ended") - ErrInvalidProposal = sdkerrors.Register(ModuleName, 21, "invalid proposal") + ErrInvalidProposalContent = errors.Register(ModuleName, 5, "invalid proposal content") + ErrInvalidProposalType = errors.Register(ModuleName, 6, "invalid proposal type") + ErrInvalidVote = errors.Register(ModuleName, 7, "invalid vote option") + ErrInvalidGenesis = errors.Register(ModuleName, 8, "invalid genesis state") + ErrNoProposalHandlerExists = errors.Register(ModuleName, 9, "no handler exists for proposal type") + ErrUnroutableProposalMsg = errors.Register(ModuleName, 10, "proposal message not recognized by router") + ErrNoProposalMsgs = errors.Register(ModuleName, 11, "no messages proposed") + ErrInvalidProposalMsg = errors.Register(ModuleName, 12, "invalid proposal message") + ErrInvalidSigner = errors.Register(ModuleName, 13, "expected gov account as only signer for proposal message") + ErrInvalidSignalMsg = errors.Register(ModuleName, 14, "signal message is invalid") + ErrMetadataTooLong = errors.Register(ModuleName, 15, "metadata too long") + ErrMinDepositTooSmall = errors.Register(ModuleName, 16, "minimum deposit is too small") + ErrProposalNotFound = errors.Register(ModuleName, 17, "proposal is not found") + ErrInvalidProposer = errors.Register(ModuleName, 18, "invalid proposer") + ErrNoDeposits = errors.Register(ModuleName, 19, "no deposits found") + ErrVotingPeriodEnded = errors.Register(ModuleName, 20, "voting period already ended") + ErrInvalidProposal = errors.Register(ModuleName, 21, "invalid proposal") ) diff --git a/x/gov/types/v1/msgs.go b/x/gov/types/v1/msgs.go index 27ca03d484..ac10428e23 100644 --- a/x/gov/types/v1/msgs.go +++ b/x/gov/types/v1/msgs.go @@ -3,6 +3,7 @@ package v1 import ( "fmt" + errorsmod "cosmossdk.io/errors" "cosmossdk.io/math" codectypes "github.com/cosmos/cosmos-sdk/codec/types" @@ -69,10 +70,10 @@ func (m *MsgSubmitProposal) SetMsgs(msgs []sdk.Msg) error { // ValidateBasic implements the sdk.Msg interface. func (m MsgSubmitProposal) ValidateBasic() error { if m.Title == "" { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "proposal title cannot be empty") + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "proposal title cannot be empty") } if m.Summary == "" { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "proposal summary cannot be empty") + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "proposal summary cannot be empty") } if _, err := sdk.AccAddressFromBech32(m.Proposer); err != nil { @@ -81,16 +82,16 @@ func (m MsgSubmitProposal) ValidateBasic() error { deposit := sdk.NewCoins(m.InitialDeposit...) if !deposit.IsValid() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, deposit.String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, deposit.String()) } if deposit.IsAnyNegative() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, deposit.String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, deposit.String()) } // Check that either metadata or Msgs length is non nil. if len(m.Messages) == 0 && len(m.Metadata) == 0 { - return sdkerrors.Wrap(types.ErrNoProposalMsgs, "either metadata or Msgs length must be non-nil") + return errorsmod.Wrap(types.ErrNoProposalMsgs, "either metadata or Msgs length must be non-nil") } msgs, err := m.GetMsgs() @@ -100,7 +101,7 @@ func (m MsgSubmitProposal) ValidateBasic() error { for idx, msg := range msgs { if err := msg.ValidateBasic(); err != nil { - return sdkerrors.Wrap(types.ErrInvalidProposalMsg, + return errorsmod.Wrap(types.ErrInvalidProposalMsg, fmt.Sprintf("msg: %d, err: %s", idx, err.Error())) } } @@ -139,10 +140,10 @@ func (msg MsgDeposit) ValidateBasic() error { } amount := sdk.NewCoins(msg.Amount...) if !amount.IsValid() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, amount.String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, amount.String()) } if amount.IsAnyNegative() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, amount.String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, amount.String()) } return nil @@ -173,7 +174,7 @@ func (msg MsgVote) ValidateBasic() error { return sdkerrors.ErrInvalidAddress.Wrapf("invalid voter address: %s", err) } if !ValidVoteOption(msg.Option) { - return sdkerrors.Wrap(types.ErrInvalidVote, msg.Option.String()) + return errorsmod.Wrap(types.ErrInvalidVote, msg.Option.String()) } return nil @@ -204,32 +205,32 @@ func (msg MsgVoteWeighted) ValidateBasic() error { return sdkerrors.ErrInvalidAddress.Wrapf("invalid voter address: %s", err) } if len(msg.Options) == 0 { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, WeightedVoteOptions(msg.Options).String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, WeightedVoteOptions(msg.Options).String()) } totalWeight := math.LegacyNewDec(0) usedOptions := make(map[VoteOption]bool) for _, option := range msg.Options { if !option.IsValid() { - return sdkerrors.Wrap(types.ErrInvalidVote, option.String()) + return errorsmod.Wrap(types.ErrInvalidVote, option.String()) } weight, err := sdk.NewDecFromStr(option.Weight) if err != nil { - return sdkerrors.Wrapf(types.ErrInvalidVote, "Invalid weight: %s", err) + return errorsmod.Wrapf(types.ErrInvalidVote, "Invalid weight: %s", err) } totalWeight = totalWeight.Add(weight) if usedOptions[option.Option] { - return sdkerrors.Wrap(types.ErrInvalidVote, "Duplicated vote option") + return errorsmod.Wrap(types.ErrInvalidVote, "Duplicated vote option") } usedOptions[option.Option] = true } if totalWeight.GT(math.LegacyNewDec(1)) { - return sdkerrors.Wrap(types.ErrInvalidVote, "Total weight overflow 1.00") + return errorsmod.Wrap(types.ErrInvalidVote, "Total weight overflow 1.00") } if totalWeight.LT(math.LegacyNewDec(1)) { - return sdkerrors.Wrap(types.ErrInvalidVote, "Total weight lower than 1.00") + return errorsmod.Wrap(types.ErrInvalidVote, "Total weight lower than 1.00") } return nil diff --git a/x/gov/types/v1beta1/msgs.go b/x/gov/types/v1beta1/msgs.go index 3bff5eff98..c02b93fd9b 100644 --- a/x/gov/types/v1beta1/msgs.go +++ b/x/gov/types/v1beta1/msgs.go @@ -6,6 +6,8 @@ import ( "cosmossdk.io/math" "github.com/cosmos/gogoproto/proto" + errorsmod "cosmossdk.io/errors" + codectypes "github.com/cosmos/cosmos-sdk/codec/types" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" @@ -92,18 +94,18 @@ func (m MsgSubmitProposal) ValidateBasic() error { return sdkerrors.ErrInvalidAddress.Wrapf("invalid proposer address: %s", err) } if !m.InitialDeposit.IsValid() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, m.InitialDeposit.String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, m.InitialDeposit.String()) } if m.InitialDeposit.IsAnyNegative() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, m.InitialDeposit.String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, m.InitialDeposit.String()) } content := m.GetContent() if content == nil { - return sdkerrors.Wrap(types.ErrInvalidProposalContent, "missing content") + return errorsmod.Wrap(types.ErrInvalidProposalContent, "missing content") } if !IsValidProposalType(content.ProposalType()) { - return sdkerrors.Wrap(types.ErrInvalidProposalType, content.ProposalType()) + return errorsmod.Wrap(types.ErrInvalidProposalType, content.ProposalType()) } if err := content.ValidateBasic(); err != nil { return err @@ -143,10 +145,10 @@ func (msg MsgDeposit) ValidateBasic() error { return sdkerrors.ErrInvalidAddress.Wrapf("invalid depositor address: %s", err) } if !msg.Amount.IsValid() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, msg.Amount.String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, msg.Amount.String()) } if msg.Amount.IsAnyNegative() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, msg.Amount.String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidCoins, msg.Amount.String()) } return nil @@ -177,7 +179,7 @@ func (msg MsgVote) ValidateBasic() error { return sdkerrors.ErrInvalidAddress.Wrapf("invalid voter address: %s", err) } if !ValidVoteOption(msg.Option) { - return sdkerrors.Wrap(types.ErrInvalidVote, msg.Option.String()) + return errorsmod.Wrap(types.ErrInvalidVote, msg.Option.String()) } return nil @@ -208,28 +210,28 @@ func (msg MsgVoteWeighted) ValidateBasic() error { return sdkerrors.ErrInvalidAddress.Wrapf("invalid voter address: %s", err) } if len(msg.Options) == 0 { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, WeightedVoteOptions(msg.Options).String()) + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, WeightedVoteOptions(msg.Options).String()) } totalWeight := math.LegacyNewDec(0) usedOptions := make(map[VoteOption]bool) for _, option := range msg.Options { if !ValidWeightedVoteOption(option) { - return sdkerrors.Wrap(types.ErrInvalidVote, option.String()) + return errorsmod.Wrap(types.ErrInvalidVote, option.String()) } totalWeight = totalWeight.Add(option.Weight) if usedOptions[option.Option] { - return sdkerrors.Wrap(types.ErrInvalidVote, "Duplicated vote option") + return errorsmod.Wrap(types.ErrInvalidVote, "Duplicated vote option") } usedOptions[option.Option] = true } if totalWeight.GT(math.LegacyNewDec(1)) { - return sdkerrors.Wrap(types.ErrInvalidVote, "Total weight overflow 1.00") + return errorsmod.Wrap(types.ErrInvalidVote, "Total weight overflow 1.00") } if totalWeight.LT(math.LegacyNewDec(1)) { - return sdkerrors.Wrap(types.ErrInvalidVote, "Total weight lower than 1.00") + return errorsmod.Wrap(types.ErrInvalidVote, "Total weight lower than 1.00") } return nil diff --git a/x/gov/types/v1beta1/proposal.go b/x/gov/types/v1beta1/proposal.go index c6e2da46fc..e603ee1676 100644 --- a/x/gov/types/v1beta1/proposal.go +++ b/x/gov/types/v1beta1/proposal.go @@ -7,6 +7,8 @@ import ( "github.com/cosmos/gogoproto/proto" + errorsmod "cosmossdk.io/errors" + codectypes "github.com/cosmos/cosmos-sdk/codec/types" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" @@ -194,18 +196,18 @@ func ValidProposalStatus(status ProposalStatus) bool { func ValidateAbstract(c Content) error { title := c.GetTitle() if len(strings.TrimSpace(title)) == 0 { - return sdkerrors.Wrap(types.ErrInvalidProposalContent, "proposal title cannot be blank") + return errorsmod.Wrap(types.ErrInvalidProposalContent, "proposal title cannot be blank") } if len(title) > MaxTitleLength { - return sdkerrors.Wrapf(types.ErrInvalidProposalContent, "proposal title is longer than max length of %d", MaxTitleLength) + return errorsmod.Wrapf(types.ErrInvalidProposalContent, "proposal title is longer than max length of %d", MaxTitleLength) } description := c.GetDescription() if len(description) == 0 { - return sdkerrors.Wrap(types.ErrInvalidProposalContent, "proposal description cannot be blank") + return errorsmod.Wrap(types.ErrInvalidProposalContent, "proposal description cannot be blank") } if len(description) > MaxDescriptionLength { - return sdkerrors.Wrapf(types.ErrInvalidProposalContent, "proposal description is longer than max length of %d", MaxDescriptionLength) + return errorsmod.Wrapf(types.ErrInvalidProposalContent, "proposal description is longer than max length of %d", MaxDescriptionLength) } return nil @@ -254,6 +256,6 @@ func ProposalHandler(_ sdk.Context, c Content) error { return nil default: - return sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "unrecognized gov proposal type: %s", c.ProposalType()) + return errorsmod.Wrapf(sdkerrors.ErrUnknownRequest, "unrecognized gov proposal type: %s", c.ProposalType()) } } diff --git a/x/group/errors/errors.go b/x/group/errors/errors.go index 71ce3fcf44..bc15909c53 100644 --- a/x/group/errors/errors.go +++ b/x/group/errors/errors.go @@ -1,8 +1,6 @@ package errors -import ( - "github.com/cosmos/cosmos-sdk/types/errors" -) +import "cosmossdk.io/errors" // groupCodespace is the codespace for all errors defined in group package const groupCodespace = "group" diff --git a/x/group/errors/math.go b/x/group/errors/math.go index ff753ed220..74a094e9cf 100644 --- a/x/group/errors/math.go +++ b/x/group/errors/math.go @@ -1,6 +1,6 @@ package errors -import "github.com/cosmos/cosmos-sdk/types/errors" +import "cosmossdk.io/errors" // mathCodespace is the codespace for all errors defined in math package const mathCodespace = "math" diff --git a/x/group/errors/orm.go b/x/group/errors/orm.go index 84dab68eeb..370abdb882 100644 --- a/x/group/errors/orm.go +++ b/x/group/errors/orm.go @@ -1,8 +1,6 @@ package errors -import ( - "github.com/cosmos/cosmos-sdk/types/errors" -) +import "cosmossdk.io/errors" // mathCodespace is the codespace for all errors defined in orm package const ormCodespace = "orm" diff --git a/x/group/genesis.go b/x/group/genesis.go index 51c64424ac..eccf1f941e 100644 --- a/x/group/genesis.go +++ b/x/group/genesis.go @@ -3,6 +3,8 @@ package group import ( "fmt" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/codec/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) @@ -22,7 +24,7 @@ func (s GenesisState) Validate() error { for _, g := range s.Groups { if err := g.ValidateBasic(); err != nil { - return sdkerrors.Wrap(err, "Group validation failed") + return errorsmod.Wrap(err, "Group validation failed") } groups[g.Id] = *g } @@ -31,11 +33,11 @@ func (s GenesisState) Validate() error { // check that group with group policy's GroupId exists if _, exists := groups[g.GroupId]; !exists { - return sdkerrors.Wrap(sdkerrors.ErrNotFound, fmt.Sprintf("group with GroupId %d doesn't exist", g.GroupId)) + return errorsmod.Wrap(sdkerrors.ErrNotFound, fmt.Sprintf("group with GroupId %d doesn't exist", g.GroupId)) } if err := g.ValidateBasic(); err != nil { - return sdkerrors.Wrap(err, "GroupPolicy validation failed") + return errorsmod.Wrap(err, "GroupPolicy validation failed") } groupPolicies[g.Address] = *g } @@ -44,11 +46,11 @@ func (s GenesisState) Validate() error { // check that group with group member's GroupId exists if _, exists := groups[g.GroupId]; !exists { - return sdkerrors.Wrap(sdkerrors.ErrNotFound, fmt.Sprintf("group member with GroupId %d doesn't exist", g.GroupId)) + return errorsmod.Wrap(sdkerrors.ErrNotFound, fmt.Sprintf("group member with GroupId %d doesn't exist", g.GroupId)) } if err := g.ValidateBasic(); err != nil { - return sdkerrors.Wrap(err, "GroupMember validation failed") + return errorsmod.Wrap(err, "GroupMember validation failed") } groupMembers[g.GroupId] = *g } @@ -57,11 +59,11 @@ func (s GenesisState) Validate() error { // check that group policy with proposal address exists if _, exists := groupPolicies[p.GroupPolicyAddress]; !exists { - return sdkerrors.Wrap(sdkerrors.ErrNotFound, fmt.Sprintf("group policy account with address %s doesn't correspond to proposal address", p.GroupPolicyAddress)) + return errorsmod.Wrap(sdkerrors.ErrNotFound, fmt.Sprintf("group policy account with address %s doesn't correspond to proposal address", p.GroupPolicyAddress)) } if err := p.ValidateBasic(); err != nil { - return sdkerrors.Wrap(err, "Proposal validation failed") + return errorsmod.Wrap(err, "Proposal validation failed") } proposals[p.Id] = *p } @@ -69,12 +71,12 @@ func (s GenesisState) Validate() error { for _, v := range s.Votes { if err := v.ValidateBasic(); err != nil { - return sdkerrors.Wrap(err, "Vote validation failed") + return errorsmod.Wrap(err, "Vote validation failed") } // check that proposal exists if _, exists := proposals[v.ProposalId]; !exists { - return sdkerrors.Wrap(sdkerrors.ErrNotFound, fmt.Sprintf("proposal with ProposalId %d doesn't exist", v.ProposalId)) + return errorsmod.Wrap(sdkerrors.ErrNotFound, fmt.Sprintf("proposal with ProposalId %d doesn't exist", v.ProposalId)) } } return nil diff --git a/x/group/internal/math/dec.go b/x/group/internal/math/dec.go index b720624037..bdf19691c2 100644 --- a/x/group/internal/math/dec.go +++ b/x/group/internal/math/dec.go @@ -6,7 +6,8 @@ import ( "github.com/cockroachdb/apd/v2" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/x/group/errors" ) @@ -76,7 +77,7 @@ func NewDecFromInt64(x int64) Dec { func (x Dec) Add(y Dec) (Dec, error) { var z Dec _, err := apd.BaseContext.Add(&z.dec, &x.dec, &y.dec) - return z, sdkerrors.Wrap(err, "decimal addition error") + return z, errorsmod.Wrap(err, "decimal addition error") } // Sub returns a new Dec with value `x-y` without mutating any argument and error if @@ -84,7 +85,7 @@ func (x Dec) Add(y Dec) (Dec, error) { func (x Dec) Sub(y Dec) (Dec, error) { var z Dec _, err := apd.BaseContext.Sub(&z.dec, &x.dec, &y.dec) - return z, sdkerrors.Wrap(err, "decimal subtraction error") + return z, errorsmod.Wrap(err, "decimal subtraction error") } func (x Dec) Int64() (int64, error) { @@ -120,7 +121,7 @@ var dec128Context = apd.Context{ func (x Dec) Quo(y Dec) (Dec, error) { var z Dec _, err := dec128Context.Quo(&z.dec, &x.dec, &y.dec) - return z, sdkerrors.Wrap(err, "decimal quotient error") + return z, errorsmod.Wrap(err, "decimal quotient error") } func (x Dec) IsZero() bool { diff --git a/x/group/internal/orm/auto_uint64.go b/x/group/internal/orm/auto_uint64.go index 794ca4f764..bb081f0a3d 100644 --- a/x/group/internal/orm/auto_uint64.go +++ b/x/group/internal/orm/auto_uint64.go @@ -5,8 +5,9 @@ import ( storetypes "cosmossdk.io/store/types" + "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/codec" - "github.com/cosmos/cosmos-sdk/types/errors" ) var ( diff --git a/x/group/internal/orm/auto_uint64_test.go b/x/group/internal/orm/auto_uint64_test.go index 2b5d068497..2296c86d02 100644 --- a/x/group/internal/orm/auto_uint64_test.go +++ b/x/group/internal/orm/auto_uint64_test.go @@ -4,6 +4,7 @@ import ( "math" "testing" + errorsmod "cosmossdk.io/errors" storetypes "cosmossdk.io/store/types" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -11,7 +12,6 @@ import ( "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/codec/types" "github.com/cosmos/cosmos-sdk/testutil/testdata" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/group/errors" ) @@ -51,7 +51,7 @@ func TestAutoUInt64PrefixScan(t *testing.T) { start, end uint64 expResult []testdata.TableModel expRowIDs []RowID - expError *sdkerrors.Error //nolint:staticcheck // SA1019: sdkerrors.Error is deprecated: the type has been moved to cosmossdk.io/errors module. Please use the above module instead of this package + expError *errorsmod.Error method func(store storetypes.KVStore, start uint64, end uint64) (Iterator, error) }{ "first element": { diff --git a/x/group/internal/orm/index.go b/x/group/internal/orm/index.go index 2a469cef67..b5ab7d9589 100644 --- a/x/group/internal/orm/index.go +++ b/x/group/internal/orm/index.go @@ -8,7 +8,8 @@ import ( "cosmossdk.io/store/prefix" "cosmossdk.io/store/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/types/query" "github.com/cosmos/cosmos-sdk/x/group/errors" ) @@ -177,7 +178,7 @@ func getStartEndBz(startI interface{}, endI interface{}) ([]byte, []byte, error) } if start != nil && end != nil && bytes.Compare(start, end) >= 0 { - return nil, nil, sdkerrors.Wrap(errors.ErrORMInvalidArgument, "start must be less than end") + return nil, nil, errorsmod.Wrap(errors.ErrORMInvalidArgument, "start must be less than end") } return start, end, nil diff --git a/x/group/internal/orm/index_test.go b/x/group/internal/orm/index_test.go index b5c849cbb6..4e2ec6beca 100644 --- a/x/group/internal/orm/index_test.go +++ b/x/group/internal/orm/index_test.go @@ -5,10 +5,11 @@ import ( storetypes "cosmossdk.io/store/types" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/codec/types" "github.com/cosmos/cosmos-sdk/testutil/testdata" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/types/query" "github.com/cosmos/cosmos-sdk/x/group/errors" @@ -129,7 +130,7 @@ func TestIndexPrefixScan(t *testing.T) { start, end interface{} expResult []testdata.TableModel expRowIDs []RowID - expError *sdkerrors.Error //nolint:staticcheck // SA1019: sdkerrors.Error is deprecated: the type has been moved to cosmossdk.io/errors module. Please use the above module instead of this package + expError *errorsmod.Error method func(store storetypes.KVStore, start, end interface{}) (Iterator, error) }{ "exact match with a single result": { diff --git a/x/group/internal/orm/indexer.go b/x/group/internal/orm/indexer.go index f25c9f836a..6dcdf4e519 100644 --- a/x/group/internal/orm/indexer.go +++ b/x/group/internal/orm/indexer.go @@ -3,7 +3,8 @@ package orm import ( storetypes "cosmossdk.io/store/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/x/group/errors" ) @@ -127,7 +128,7 @@ func uniqueKeysAddFunc(store storetypes.KVStore, secondaryIndexKey interface{}, return err } if len(secondaryIndexKeyBytes) == 0 { - return sdkerrors.Wrap(errors.ErrORMInvalidArgument, "empty index key") + return errorsmod.Wrap(errors.ErrORMInvalidArgument, "empty index key") } if err := checkUniqueIndexKey(store, secondaryIndexKeyBytes); err != nil { @@ -160,7 +161,7 @@ func multiKeyAddFunc(store storetypes.KVStore, secondaryIndexKey interface{}, ro return err } if len(secondaryIndexKeyBytes) == 0 { - return sdkerrors.Wrap(errors.ErrORMInvalidArgument, "empty index key") + return errorsmod.Wrap(errors.ErrORMInvalidArgument, "empty index key") } encodedKey, err := buildKeyFromParts([]interface{}{secondaryIndexKey, []byte(rowID)}) @@ -168,7 +169,7 @@ func multiKeyAddFunc(store storetypes.KVStore, secondaryIndexKey interface{}, ro return err } if len(encodedKey) == 0 { - return sdkerrors.Wrap(errors.ErrORMInvalidArgument, "empty index key") + return errorsmod.Wrap(errors.ErrORMInvalidArgument, "empty index key") } store.Set(encodedKey, []byte{}) diff --git a/x/group/internal/orm/indexer_test.go b/x/group/internal/orm/indexer_test.go index d40b2a52ad..18138cc97f 100644 --- a/x/group/internal/orm/indexer_test.go +++ b/x/group/internal/orm/indexer_test.go @@ -10,7 +10,8 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/x/group/errors" ) @@ -376,7 +377,7 @@ func TestUniqueKeyAddFunc(t *testing.T) { specs := map[string]struct { srcKey []byte - expErr *sdkerrors.Error //nolint:staticcheck // SA1019: sdkerrors.Error is deprecated: the type has been moved to cosmossdk.io/errors module. Please use the above module instead of this package. + expErr *errorsmod.Error expExistingEntry []byte }{ "create when not exists": { @@ -419,7 +420,7 @@ func TestMultiKeyAddFunc(t *testing.T) { specs := map[string]struct { srcKey []byte - expErr *sdkerrors.Error //nolint:staticcheck // SA1019: sdkerrors.Error is deprecated: the type has been moved to cosmossdk.io/errors module. Please use the above module instead of this package. + expErr *errorsmod.Error expExistingEntry []byte }{ "create when not exists": { diff --git a/x/group/internal/orm/iterator.go b/x/group/internal/orm/iterator.go index 09214ab345..c83d588064 100644 --- a/x/group/internal/orm/iterator.go +++ b/x/group/internal/orm/iterator.go @@ -4,9 +4,9 @@ import ( "fmt" "reflect" + errorsmod "cosmossdk.io/errors" "github.com/cosmos/gogoproto/proto" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/types/query" "github.com/cosmos/cosmos-sdk/x/group/errors" ) @@ -34,7 +34,7 @@ func NewSingleValueIterator(rowID RowID, val []byte) Iterator { var closed bool return IteratorFunc(func(dest proto.Message) (RowID, error) { if dest == nil { - return nil, sdkerrors.Wrap(errors.ErrORMInvalidArgument, "destination object must not be nil") + return nil, errorsmod.Wrap(errors.ErrORMInvalidArgument, "destination object must not be nil") } if closed || val == nil { return nil, errors.ErrORMIteratorDone @@ -90,7 +90,7 @@ func (i LimitedIterator) Close() error { // When the iterator is closed or has no elements the according error is passed as return value. func First(it Iterator, dest proto.Message) (RowID, error) { if it == nil { - return nil, sdkerrors.Wrap(errors.ErrORMInvalidArgument, "iterator must not be nil") + return nil, errorsmod.Wrap(errors.ErrORMInvalidArgument, "iterator must not be nil") } defer it.Close() binKey, err := it.LoadNext(dest) @@ -146,7 +146,7 @@ func Paginate( } if it == nil { - return nil, sdkerrors.Wrap(errors.ErrORMInvalidArgument, "iterator must not be nil") + return nil, errorsmod.Wrap(errors.ErrORMInvalidArgument, "iterator must not be nil") } defer it.Close() @@ -176,7 +176,7 @@ func Paginate( modelProto, ok := model.Interface().(proto.Message) if !ok { - return nil, sdkerrors.Wrapf(errors.ErrORMInvalidArgument, "%s should implement codec.ProtoMarshaler", elemType) + return nil, errorsmod.Wrapf(errors.ErrORMInvalidArgument, "%s should implement codec.ProtoMarshaler", elemType) } binKey, err := it.LoadNext(modelProto) if err != nil { @@ -236,7 +236,7 @@ type ModelSlicePtr interface{} // require.NoError(t, err) func ReadAll(it Iterator, dest ModelSlicePtr) ([]RowID, error) { if it == nil { - return nil, sdkerrors.Wrap(errors.ErrORMInvalidArgument, "iterator must not be nil") + return nil, errorsmod.Wrap(errors.ErrORMInvalidArgument, "iterator must not be nil") } defer it.Close() @@ -275,14 +275,14 @@ func ReadAll(it Iterator, dest ModelSlicePtr) ([]RowID, error) { // It overwrites destRef and tmpSlice using reflection. func assertDest(dest ModelSlicePtr, destRef *reflect.Value, tmpSlice *reflect.Value) (reflect.Type, error) { if dest == nil { - return nil, sdkerrors.Wrap(errors.ErrORMInvalidArgument, "destination must not be nil") + return nil, errorsmod.Wrap(errors.ErrORMInvalidArgument, "destination must not be nil") } tp := reflect.ValueOf(dest) if tp.Kind() != reflect.Ptr { - return nil, sdkerrors.Wrap(errors.ErrORMInvalidArgument, "destination must be a pointer to a slice") + return nil, errorsmod.Wrap(errors.ErrORMInvalidArgument, "destination must be a pointer to a slice") } if tp.Elem().Kind() != reflect.Slice { - return nil, sdkerrors.Wrap(errors.ErrORMInvalidArgument, "destination must point to a slice") + return nil, errorsmod.Wrap(errors.ErrORMInvalidArgument, "destination must point to a slice") } // Since dest is just an interface{}, we overwrite destRef using reflection @@ -290,7 +290,7 @@ func assertDest(dest ModelSlicePtr, destRef *reflect.Value, tmpSlice *reflect.Va *destRef = tp.Elem() // We need to verify that we can call Set() on destRef. if !destRef.CanSet() { - return nil, sdkerrors.Wrap(errors.ErrORMInvalidArgument, "destination not assignable") + return nil, errorsmod.Wrap(errors.ErrORMInvalidArgument, "destination not assignable") } elemType := reflect.TypeOf(dest).Elem().Elem() @@ -298,7 +298,7 @@ func assertDest(dest ModelSlicePtr, destRef *reflect.Value, tmpSlice *reflect.Va protoMarshaler := reflect.TypeOf((*proto.Message)(nil)).Elem() if !elemType.Implements(protoMarshaler) && !reflect.PtrTo(elemType).Implements(protoMarshaler) { - return nil, sdkerrors.Wrapf(errors.ErrORMInvalidArgument, "unsupported type :%s", elemType) + return nil, errorsmod.Wrapf(errors.ErrORMInvalidArgument, "unsupported type :%s", elemType) } // tmpSlice is a slice value for the specified type diff --git a/x/group/internal/orm/iterator_property_test.go b/x/group/internal/orm/iterator_property_test.go index 618c918d88..8a1b473fea 100644 --- a/x/group/internal/orm/iterator_property_test.go +++ b/x/group/internal/orm/iterator_property_test.go @@ -7,8 +7,9 @@ import ( "github.com/stretchr/testify/require" "pgregory.net/rapid" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/testutil/testdata" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/types/query" "github.com/cosmos/cosmos-sdk/x/group/errors" ) @@ -97,7 +98,7 @@ func testTableModelIterator(tms []*testdata.TableModel, key RowID) Iterator { } return IteratorFunc(func(dest proto.Message) (RowID, error) { if dest == nil { - return nil, sdkerrors.Wrap(errors.ErrORMInvalidArgument, "destination object must not be nil") + return nil, errorsmod.Wrap(errors.ErrORMInvalidArgument, "destination object must not be nil") } if index == len(tms) { diff --git a/x/group/internal/orm/iterator_test.go b/x/group/internal/orm/iterator_test.go index 29a902cfe7..a7b4854dd1 100644 --- a/x/group/internal/orm/iterator_test.go +++ b/x/group/internal/orm/iterator_test.go @@ -7,13 +7,13 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + errorsmod "cosmossdk.io/errors" storetypes "cosmossdk.io/store/types" "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/codec/types" "github.com/cosmos/cosmos-sdk/testutil/testdata" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/types/query" "github.com/cosmos/cosmos-sdk/x/group/errors" ) @@ -22,7 +22,7 @@ func TestReadAll(t *testing.T) { specs := map[string]struct { srcIT Iterator destSlice func() ModelSlicePtr - expErr *sdkerrors.Error //nolint:staticcheck // SA1019: sdkerrors.Error is deprecated: the type has been moved to cosmossdk.io/errors module. Please use the above module instead of this package. + expErr *errorsmod.Error expIDs []RowID expResult ModelSlicePtr }{ diff --git a/x/group/internal/orm/key_codec.go b/x/group/internal/orm/key_codec.go index 2203491e8e..53c1dadc45 100644 --- a/x/group/internal/orm/key_codec.go +++ b/x/group/internal/orm/key_codec.go @@ -3,7 +3,8 @@ package orm import ( "fmt" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/x/group/errors" ) @@ -59,7 +60,7 @@ func keyPartBytes(part interface{}, last bool) ([]byte, error) { func AddLengthPrefix(bytes []byte) []byte { byteLen := len(bytes) if byteLen > MaxBytesLen { - panic(sdkerrors.Wrap(errors.ErrORMKeyMaxLength, "Cannot create key part with an []byte of length greater than 255 bytes. Try again with a smaller []byte.")) + panic(errorsmod.Wrap(errors.ErrORMKeyMaxLength, "Cannot create key part with an []byte of length greater than 255 bytes. Try again with a smaller []byte.")) } prefixedBytes := make([]byte, 1+len(bytes)) diff --git a/x/group/internal/orm/primary_key_property_test.go b/x/group/internal/orm/primary_key_property_test.go index be3a62afd5..7a40cf8c2d 100644 --- a/x/group/internal/orm/primary_key_property_test.go +++ b/x/group/internal/orm/primary_key_property_test.go @@ -1,4 +1,3 @@ -//nolint:unused // this file contains tests package orm import ( diff --git a/x/group/internal/orm/primary_key_test.go b/x/group/internal/orm/primary_key_test.go index cccc4bf2bc..f0fef3c142 100644 --- a/x/group/internal/orm/primary_key_test.go +++ b/x/group/internal/orm/primary_key_test.go @@ -3,6 +3,7 @@ package orm import ( "testing" + errorsmod "cosmossdk.io/errors" storetypes "cosmossdk.io/store/types" "github.com/stretchr/testify/assert" @@ -10,7 +11,6 @@ import ( "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/codec/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/group/errors" "github.com/cosmos/cosmos-sdk/testutil/testdata" @@ -51,7 +51,7 @@ func TestPrimaryKeyTablePrefixScan(t *testing.T) { start, end []byte expResult []testdata.TableModel expRowIDs []RowID - expError *sdkerrors.Error //nolint:staticcheck // SA1019: sdkerrors.Error is deprecated: the type has been moved to cosmossdk.io/errors module. Please use the above module instead of this package. + expError *errorsmod.Error method func(store storetypes.KVStore, start, end []byte) (Iterator, error) }{ "exact match with a single result": { diff --git a/x/group/internal/orm/sequence.go b/x/group/internal/orm/sequence.go index b7f94ead63..77d73ccc72 100644 --- a/x/group/internal/orm/sequence.go +++ b/x/group/internal/orm/sequence.go @@ -3,10 +3,10 @@ package orm import ( "encoding/binary" + errorsmod "cosmossdk.io/errors" "cosmossdk.io/store/prefix" storetypes "cosmossdk.io/store/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/group/errors" ) @@ -57,7 +57,7 @@ func (s Sequence) PeekNextVal(store storetypes.KVStore) uint64 { func (s Sequence) InitVal(store storetypes.KVStore, seq uint64) error { pStore := prefix.NewStore(store, []byte{s.prefix}) if pStore.Has(sequenceStorageKey) { - return sdkerrors.Wrap(errors.ErrORMUniqueConstraint, "already initialized") + return errorsmod.Wrap(errors.ErrORMUniqueConstraint, "already initialized") } pStore.Set(sequenceStorageKey, EncodeSequence(seq)) return nil diff --git a/x/group/internal/orm/sequence_property_test.go b/x/group/internal/orm/sequence_property_test.go index 8dce9054db..fad3bdae25 100644 --- a/x/group/internal/orm/sequence_property_test.go +++ b/x/group/internal/orm/sequence_property_test.go @@ -1,4 +1,3 @@ -//nolint:unused // contains tests package orm import ( diff --git a/x/group/internal/orm/table.go b/x/group/internal/orm/table.go index 9556a90668..b2024fad01 100644 --- a/x/group/internal/orm/table.go +++ b/x/group/internal/orm/table.go @@ -6,6 +6,7 @@ import ( "github.com/cosmos/gogoproto/proto" + errorsmod "cosmossdk.io/errors" "cosmossdk.io/store/prefix" "cosmossdk.io/store/types" @@ -121,13 +122,13 @@ func (a table) Set(store types.KVStore, rowID RowID, newValue proto.Message) err newValueEncoded, err := a.cdc.Marshal(newValue) if err != nil { - return sdkerrors.Wrapf(err, "failed to serialize %T", newValue) + return errorsmod.Wrapf(err, "failed to serialize %T", newValue) } pStore.Set(rowID, newValueEncoded) for i, itc := range a.afterSet { if err := itc(store, rowID, newValue, oldValue); err != nil { - return sdkerrors.Wrapf(err, "interceptor %d failed", i) + return errorsmod.Wrapf(err, "interceptor %d failed", i) } } return nil @@ -153,13 +154,13 @@ func (a table) Delete(store types.KVStore, rowID RowID) error { oldValue := reflect.New(a.model).Interface().(proto.Message) if err := a.GetOne(store, rowID, oldValue); err != nil { - return sdkerrors.Wrap(err, "load old value") + return errorsmod.Wrap(err, "load old value") } pStore.Delete(rowID) for i, itc := range a.afterDelete { if err := itc(store, rowID, oldValue); err != nil { - return sdkerrors.Wrapf(err, "delete interceptor %d failed", i) + return errorsmod.Wrapf(err, "delete interceptor %d failed", i) } } return nil @@ -205,7 +206,7 @@ func (a table) GetOne(store types.KVStore, rowID RowID, dest proto.Message) erro // CONTRACT: No writes may happen within a domain while an iterator exists over it. func (a table) PrefixScan(store types.KVStore, start, end RowID) (Iterator, error) { if start != nil && end != nil && bytes.Compare(start, end) >= 0 { - return NewInvalidIterator(), sdkerrors.Wrap(errors.ErrORMInvalidArgument, "start must be before end") + return NewInvalidIterator(), errorsmod.Wrap(errors.ErrORMInvalidArgument, "start must be before end") } pStore := prefix.NewStore(store, a.prefix[:]) return &typeSafeIterator{ @@ -226,7 +227,7 @@ func (a table) PrefixScan(store types.KVStore, start, end RowID) (Iterator, erro // CONTRACT: No writes may happen within a domain while an iterator exists over it. func (a table) ReversePrefixScan(store types.KVStore, start, end RowID) (Iterator, error) { if start != nil && end != nil && bytes.Compare(start, end) >= 0 { - return NewInvalidIterator(), sdkerrors.Wrap(errors.ErrORMInvalidArgument, "start must be before end") + return NewInvalidIterator(), errorsmod.Wrap(errors.ErrORMInvalidArgument, "start must be before end") } pStore := prefix.NewStore(store, a.prefix[:]) return &typeSafeIterator{ @@ -240,7 +241,7 @@ func (a table) ReversePrefixScan(store types.KVStore, start, end RowID) (Iterato func (a table) Export(store types.KVStore, dest ModelSlicePtr) (uint64, error) { it, err := a.PrefixScan(store, nil, nil) if err != nil { - return 0, sdkerrors.Wrap(err, "table Export failure when exporting table data") + return 0, errorsmod.Wrap(err, "table Export failure when exporting table data") } _, err = ReadAll(it, dest) if err != nil { @@ -263,14 +264,14 @@ func (a table) Import(store types.KVStore, data interface{}, _ uint64) error { // Provided data must be a slice modelSlice := reflect.ValueOf(data) if modelSlice.Kind() != reflect.Slice { - return sdkerrors.Wrap(errors.ErrORMInvalidArgument, "data must be a slice") + return errorsmod.Wrap(errors.ErrORMInvalidArgument, "data must be a slice") } // Import values from slice for i := 0; i < modelSlice.Len(); i++ { obj, ok := modelSlice.Index(i).Interface().(PrimaryKeyed) if !ok { - return sdkerrors.Wrapf(errors.ErrORMInvalidArgument, "unsupported type :%s", reflect.TypeOf(data).Elem().Elem()) + return errorsmod.Wrapf(errors.ErrORMInvalidArgument, "unsupported type :%s", reflect.TypeOf(data).Elem().Elem()) } err := a.Create(store, PrimaryKey(obj), obj) if err != nil { diff --git a/x/group/internal/orm/table_test.go b/x/group/internal/orm/table_test.go index 17638305e8..57789e3875 100644 --- a/x/group/internal/orm/table_test.go +++ b/x/group/internal/orm/table_test.go @@ -8,6 +8,7 @@ import ( "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + errorsmod "cosmossdk.io/errors" storetypes "cosmossdk.io/store/types" "github.com/cosmos/cosmos-sdk/codec" @@ -58,7 +59,7 @@ func TestCreate(t *testing.T) { specs := map[string]struct { rowID RowID src proto.Message - expErr *sdkerrors.Error //nolint:staticcheck // SA1019: sdkerrors.Error is deprecated: the type has been moved to cosmossdk.io/errors module. Please use the above module instead of this package. + expErr *errorsmod.Error }{ "empty rowID": { rowID: []byte{}, @@ -126,7 +127,7 @@ func TestCreate(t *testing.T) { func TestUpdate(t *testing.T) { specs := map[string]struct { src proto.Message - expErr *sdkerrors.Error //nolint:staticcheck // SA1019: sdkerrors.Error is deprecated: the type has been moved to cosmossdk.io/errors module. Please use the above module instead of this package. + expErr *errorsmod.Error }{ "happy path": { src: &testdata.TableModel{ @@ -188,7 +189,7 @@ func TestUpdate(t *testing.T) { func TestDelete(t *testing.T) { specs := map[string]struct { rowID []byte - expErr *sdkerrors.Error //nolint:staticcheck // SA1019: sdkerrors.Error is deprecated: the type has been moved to cosmossdk.io/errors module. Please use the above module instead of this package. + expErr *errorsmod.Error }{ "happy path": { rowID: EncodeSequence(1), diff --git a/x/group/internal/orm/types.go b/x/group/internal/orm/types.go index 1e5b60290c..c3f357a6a3 100644 --- a/x/group/internal/orm/types.go +++ b/x/group/internal/orm/types.go @@ -9,6 +9,7 @@ import ( "github.com/cosmos/gogoproto/proto" + errorsmod "cosmossdk.io/errors" "cosmossdk.io/store/prefix" storetypes "cosmossdk.io/store/types" @@ -109,7 +110,7 @@ type RowGetter func(store storetypes.KVStore, rowID RowID, dest proto.Message) e func NewTypeSafeRowGetter(prefixKey [2]byte, model reflect.Type, cdc codec.Codec) RowGetter { return func(store storetypes.KVStore, rowID RowID, dest proto.Message) error { if len(rowID) == 0 { - return sdkerrors.Wrap(errors.ErrORMEmptyKey, "key must not be nil") + return errorsmod.Wrap(errors.ErrORMEmptyKey, "key must not be nil") } if err := assertCorrectType(model, dest); err != nil { return err @@ -128,10 +129,10 @@ func NewTypeSafeRowGetter(prefixKey [2]byte, model reflect.Type, cdc codec.Codec func assertCorrectType(model reflect.Type, obj proto.Message) error { tp := reflect.TypeOf(obj) if tp.Kind() != reflect.Ptr { - return sdkerrors.Wrap(sdkerrors.ErrInvalidType, "model destination must be a pointer") + return errorsmod.Wrap(sdkerrors.ErrInvalidType, "model destination must be a pointer") } if model != tp.Elem() { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidType, "can not use %T with this bucket", obj) + return errorsmod.Wrapf(sdkerrors.ErrInvalidType, "can not use %T with this bucket", obj) } return nil } diff --git a/x/group/internal/orm/types_test.go b/x/group/internal/orm/types_test.go index e5f4dcba89..091dadc7eb 100644 --- a/x/group/internal/orm/types_test.go +++ b/x/group/internal/orm/types_test.go @@ -4,6 +4,7 @@ import ( "reflect" "testing" + errorsmod "cosmossdk.io/errors" "cosmossdk.io/store/prefix" storetypes "cosmossdk.io/store/types" "github.com/stretchr/testify/assert" @@ -33,7 +34,7 @@ func TestTypeSafeRowGetter(t *testing.T) { srcRowID RowID srcModelType reflect.Type expObj interface{} - expErr *sdkerrors.Error //nolint:staticcheck // SA1019: sdkerrors.Error is deprecated: the type has been moved to cosmossdk.io/errors module. Please use the above module instead of this package. + expErr *errorsmod.Error }{ "happy path": { srcRowID: EncodeSequence(1), diff --git a/x/group/keeper/genesis.go b/x/group/keeper/genesis.go index fd4eb13c00..26d016a1f1 100644 --- a/x/group/keeper/genesis.go +++ b/x/group/keeper/genesis.go @@ -5,9 +5,10 @@ import ( abci "github.com/cometbft/cometbft/abci/types" + "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/group" ) diff --git a/x/group/keeper/grpc_query.go b/x/group/keeper/grpc_query.go index e549622804..a54e3bedf2 100644 --- a/x/group/keeper/grpc_query.go +++ b/x/group/keeper/grpc_query.go @@ -7,8 +7,9 @@ import ( "google.golang.org/grpc/codes" "google.golang.org/grpc/status" + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/types/query" "github.com/cosmos/cosmos-sdk/x/group" "github.com/cosmos/cosmos-sdk/x/group/errors" @@ -23,7 +24,7 @@ func (k Keeper) GroupInfo(goCtx context.Context, request *group.QueryGroupInfoRe groupID := request.GroupId groupInfo, err := k.getGroupInfo(ctx, groupID) if err != nil { - return nil, sdkerrors.Wrap(err, "group") + return nil, errorsmod.Wrap(err, "group") } return &group.QueryGroupInfoResponse{Info: &groupInfo}, nil @@ -41,7 +42,7 @@ func (k Keeper) GroupPolicyInfo(goCtx context.Context, request *group.QueryGroup ctx := sdk.UnwrapSDKContext(goCtx) groupPolicyInfo, err := k.getGroupPolicyInfo(ctx, request.Address) if err != nil { - return nil, sdkerrors.Wrap(err, "group policy") + return nil, errorsmod.Wrap(err, "group policy") } return &group.QueryGroupPolicyInfoResponse{Info: &groupPolicyInfo}, nil @@ -209,7 +210,7 @@ func (k Keeper) getProposalsByGroupPolicy(ctx sdk.Context, account sdk.AccAddres func (k Keeper) getProposal(ctx sdk.Context, proposalID uint64) (group.Proposal, error) { var p group.Proposal if _, err := k.proposalTable.GetOne(ctx.KVStore(k.key), proposalID, &p); err != nil { - return group.Proposal{}, sdkerrors.Wrap(err, "load proposal") + return group.Proposal{}, errorsmod.Wrap(err, "load proposal") } return p, nil } @@ -341,12 +342,12 @@ func (k Keeper) TallyResult(goCtx context.Context, request *group.QueryTallyResu } if proposal.Status == group.PROPOSAL_STATUS_WITHDRAWN || proposal.Status == group.PROPOSAL_STATUS_ABORTED { - return nil, sdkerrors.Wrapf(errors.ErrInvalid, "can't get the tally of a proposal with status %s", proposal.Status) + return nil, errorsmod.Wrapf(errors.ErrInvalid, "can't get the tally of a proposal with status %s", proposal.Status) } var policyInfo group.GroupPolicyInfo if policyInfo, err = k.getGroupPolicyInfo(ctx, proposal.GroupPolicyAddress); err != nil { - return nil, sdkerrors.Wrap(err, "load group policy") + return nil, errorsmod.Wrap(err, "load group policy") } tallyResult, err := k.Tally(ctx, proposal, policyInfo.GroupId) diff --git a/x/group/keeper/keeper.go b/x/group/keeper/keeper.go index 702cfbc0f9..22a871f3de 100644 --- a/x/group/keeper/keeper.go +++ b/x/group/keeper/keeper.go @@ -8,10 +8,11 @@ import ( storetypes "cosmossdk.io/store/types" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/baseapp" "github.com/cosmos/cosmos-sdk/codec" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/group" "github.com/cosmos/cosmos-sdk/x/group/errors" "github.com/cosmos/cosmos-sdk/x/group/internal/orm" @@ -392,12 +393,12 @@ func (k Keeper) TallyProposalsAtVPEnd(ctx sdk.Context) error { for _, proposal := range proposals { policyInfo, err := k.getGroupPolicyInfo(ctx, proposal.GroupPolicyAddress) if err != nil { - return sdkerrors.Wrap(err, "group policy") + return errorsmod.Wrap(err, "group policy") } electorate, err := k.getGroupInfo(ctx, policyInfo.GroupId) if err != nil { - return sdkerrors.Wrap(err, "group") + return errorsmod.Wrap(err, "group") } proposalID := proposal.Id @@ -410,11 +411,11 @@ func (k Keeper) TallyProposalsAtVPEnd(ctx sdk.Context) error { } } else if proposal.Status == group.PROPOSAL_STATUS_SUBMITTED { if err := k.doTallyAndUpdate(ctx, &proposal, electorate, policyInfo); err != nil { - return sdkerrors.Wrap(err, "doTallyAndUpdate") + return errorsmod.Wrap(err, "doTallyAndUpdate") } if err := k.proposalTable.Update(ctx.KVStore(k.key), proposal.Id, &proposal); err != nil { - return sdkerrors.Wrap(err, "proposal update") + return errorsmod.Wrap(err, "proposal update") } } // Note: We do nothing if the proposal has been marked as ACCEPTED or diff --git a/x/group/keeper/msg_server.go b/x/group/keeper/msg_server.go index a35c602b81..94feeaed3e 100644 --- a/x/group/keeper/msg_server.go +++ b/x/group/keeper/msg_server.go @@ -5,6 +5,8 @@ import ( "encoding/binary" "fmt" + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" authtypes "github.com/cosmos/cosmos-sdk/x/auth/types" @@ -65,7 +67,7 @@ func (k Keeper) CreateGroup(goCtx context.Context, req *group.MsgCreateGroup) (* } groupID, err := k.groupTable.Create(ctx.KVStore(k.key), groupInfo) if err != nil { - return nil, sdkerrors.Wrap(err, "could not create group") + return nil, errorsmod.Wrap(err, "could not create group") } // Create new group members in the groupMemberTable. @@ -81,7 +83,7 @@ func (k Keeper) CreateGroup(goCtx context.Context, req *group.MsgCreateGroup) (* }, }) if err != nil { - return nil, sdkerrors.Wrapf(err, "could not store member %d", i) + return nil, errorsmod.Wrapf(err, "could not store member %d", i) } } @@ -98,7 +100,7 @@ func (k Keeper) UpdateGroupMembers(goCtx context.Context, req *group.MsgUpdateGr action := func(g *group.GroupInfo) error { totalWeight, err := math.NewNonNegativeDecFromString(g.TotalWeight) if err != nil { - return sdkerrors.Wrap(err, "group total weight") + return errorsmod.Wrap(err, "group total weight") } for i := range req.MemberUpdates { if err := k.assertMetadataLength(req.MemberUpdates[i].Metadata, "group member metadata"); err != nil { @@ -122,7 +124,7 @@ func (k Keeper) UpdateGroupMembers(goCtx context.Context, req *group.MsgUpdateGr case sdkerrors.ErrNotFound.Is(err): found = false default: - return sdkerrors.Wrap(err, "get group member") + return errorsmod.Wrap(err, "get group member") } newMemberWeight, err := math.NewNonNegativeDecFromString(groupMember.Member.Weight) @@ -134,7 +136,7 @@ func (k Keeper) UpdateGroupMembers(goCtx context.Context, req *group.MsgUpdateGr if newMemberWeight.IsZero() { // We can't delete a group member that doesn't already exist. if !found { - return sdkerrors.Wrap(sdkerrors.ErrNotFound, "unknown member") + return errorsmod.Wrap(sdkerrors.ErrNotFound, "unknown member") } previousMemberWeight, err := math.NewPositiveDecFromString(prevGroupMember.Member.Weight) @@ -150,7 +152,7 @@ func (k Keeper) UpdateGroupMembers(goCtx context.Context, req *group.MsgUpdateGr // Delete group member in the groupMemberTable. if err := k.groupMemberTable.Delete(ctx.KVStore(k.key), &groupMember); err != nil { - return sdkerrors.Wrap(err, "delete member") + return errorsmod.Wrap(err, "delete member") } continue } @@ -168,12 +170,12 @@ func (k Keeper) UpdateGroupMembers(goCtx context.Context, req *group.MsgUpdateGr // Save updated group member in the groupMemberTable. groupMember.Member.AddedAt = prevGroupMember.Member.AddedAt if err := k.groupMemberTable.Update(ctx.KVStore(k.key), &groupMember); err != nil { - return sdkerrors.Wrap(err, "add member") + return errorsmod.Wrap(err, "add member") } } else { // else handle create. groupMember.Member.AddedAt = ctx.BlockTime() if err := k.groupMemberTable.Create(ctx.KVStore(k.key), &groupMember); err != nil { - return sdkerrors.Wrap(err, "add member") + return errorsmod.Wrap(err, "add member") } } // In both cases (handle + update), we need to add the new member's weight to the group total weight. @@ -245,7 +247,7 @@ func (k Keeper) CreateGroupWithPolicy(goCtx context.Context, req *group.MsgCreat Metadata: req.GroupMetadata, }) if err != nil { - return nil, sdkerrors.Wrap(err, "group response") + return nil, errorsmod.Wrap(err, "group response") } groupID := groupRes.GroupId @@ -257,13 +259,13 @@ func (k Keeper) CreateGroupWithPolicy(goCtx context.Context, req *group.MsgCreat DecisionPolicy: req.DecisionPolicy, }) if err != nil { - return nil, sdkerrors.Wrap(err, "group policy response") + return nil, errorsmod.Wrap(err, "group policy response") } policyAddr := groupPolicyRes.Address groupPolicyAddr, err = sdk.AccAddressFromBech32(policyAddr) if err != nil { - return nil, sdkerrors.Wrap(err, "group policy address") + return nil, errorsmod.Wrap(err, "group policy address") } groupPolicyAddress := groupPolicyAddr.String() @@ -296,11 +298,11 @@ func (k Keeper) CreateGroupPolicy(goCtx context.Context, req *group.MsgCreateGro ctx := sdk.UnwrapSDKContext(goCtx) admin, err := sdk.AccAddressFromBech32(req.GetAdmin()) if err != nil { - return nil, sdkerrors.Wrap(err, "request admin") + return nil, errorsmod.Wrap(err, "request admin") } policy, err := req.GetDecisionPolicy() if err != nil { - return nil, sdkerrors.Wrap(err, "request decision policy") + return nil, errorsmod.Wrap(err, "request decision policy") } groupID := req.GetGroupID() metadata := req.GetMetadata() @@ -315,11 +317,11 @@ func (k Keeper) CreateGroupPolicy(goCtx context.Context, req *group.MsgCreateGro } groupAdmin, err := sdk.AccAddressFromBech32(g.Admin) if err != nil { - return nil, sdkerrors.Wrap(err, "group admin") + return nil, errorsmod.Wrap(err, "group admin") } // Only current group admin is authorized to create a group policy for this if !groupAdmin.Equals(admin) { - return nil, sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "not group admin") + return nil, errorsmod.Wrap(sdkerrors.ErrUnauthorized, "not group admin") } err = policy.Validate(g, k.config) @@ -350,7 +352,7 @@ func (k Keeper) CreateGroupPolicy(goCtx context.Context, req *group.MsgCreateGro // group policy accounts are unclaimable base accounts account, err := authtypes.NewBaseAccountWithPubKey(ac) if err != nil { - return nil, sdkerrors.Wrap(err, "could not create group policy account") + return nil, errorsmod.Wrap(err, "could not create group policy account") } acc := k.accKeeper.NewAccount(ctx, account) @@ -373,7 +375,7 @@ func (k Keeper) CreateGroupPolicy(goCtx context.Context, req *group.MsgCreateGro } if err := k.groupPolicyTable.Create(ctx.KVStore(k.key), &groupPolicy); err != nil { - return nil, sdkerrors.Wrap(err, "could not create group policy") + return nil, errorsmod.Wrap(err, "could not create group policy") } err = ctx.EventManager().EmitTypedEvent(&group.EventCreateGroupPolicy{Address: accountAddr.String()}) @@ -461,13 +463,13 @@ func (k Keeper) SubmitProposal(goCtx context.Context, req *group.MsgSubmitPropos ctx := sdk.UnwrapSDKContext(goCtx) groupPolicyAddr, err := sdk.AccAddressFromBech32(req.GroupPolicyAddress) if err != nil { - return nil, sdkerrors.Wrap(err, "request account address of group policy") + return nil, errorsmod.Wrap(err, "request account address of group policy") } metadata := req.Metadata proposers := req.Proposers msgs, err := req.GetMsgs() if err != nil { - return nil, sdkerrors.Wrap(err, "request msgs") + return nil, errorsmod.Wrap(err, "request msgs") } if err := k.assertMetadataLength(metadata, "metadata"); err != nil { @@ -484,18 +486,18 @@ func (k Keeper) SubmitProposal(goCtx context.Context, req *group.MsgSubmitPropos policyAcc, err := k.getGroupPolicyInfo(ctx, req.GroupPolicyAddress) if err != nil { - return nil, sdkerrors.Wrap(err, "load group policy") + return nil, errorsmod.Wrap(err, "load group policy") } g, err := k.getGroupInfo(ctx, policyAcc.GroupId) if err != nil { - return nil, sdkerrors.Wrap(err, "get group by groupId of group policy") + return nil, errorsmod.Wrap(err, "get group by groupId of group policy") } // Only members of the group can submit a new proposal. for i := range proposers { if !k.groupMemberTable.Has(ctx.KVStore(k.key), orm.PrimaryKey(&group.GroupMember{GroupId: g.Id, Member: &group.Member{Address: proposers[i]}})) { - return nil, sdkerrors.Wrapf(errors.ErrUnauthorized, "not in group: %s", proposers[i]) + return nil, errorsmod.Wrapf(errors.ErrUnauthorized, "not in group: %s", proposers[i]) } } @@ -506,7 +508,7 @@ func (k Keeper) SubmitProposal(goCtx context.Context, req *group.MsgSubmitPropos policy, err := policyAcc.GetDecisionPolicy() if err != nil { - return nil, sdkerrors.Wrap(err, "proposal group policy decision policy") + return nil, errorsmod.Wrap(err, "proposal group policy decision policy") } // Prevent proposal that can not succeed. @@ -532,12 +534,12 @@ func (k Keeper) SubmitProposal(goCtx context.Context, req *group.MsgSubmitPropos } if err := m.SetMsgs(msgs); err != nil { - return nil, sdkerrors.Wrap(err, "create proposal") + return nil, errorsmod.Wrap(err, "create proposal") } id, err := k.proposalTable.Create(ctx.KVStore(k.key), m) if err != nil { - return nil, sdkerrors.Wrap(err, "create proposal") + return nil, errorsmod.Wrap(err, "create proposal") } err = ctx.EventManager().EmitTypedEvent(&group.EventSubmitProposal{ProposalId: id}) @@ -556,7 +558,7 @@ func (k Keeper) SubmitProposal(goCtx context.Context, req *group.MsgSubmitPropos Option: group.VOTE_OPTION_YES, }) if err != nil { - return &group.MsgSubmitProposalResponse{ProposalId: id}, sdkerrors.Wrapf(err, "the proposal was created but failed on vote for voter %s", proposers[i]) + return &group.MsgSubmitProposalResponse{ProposalId: id}, errorsmod.Wrapf(err, "the proposal was created but failed on vote for voter %s", proposers[i]) } } @@ -568,7 +570,7 @@ func (k Keeper) SubmitProposal(goCtx context.Context, req *group.MsgSubmitPropos Executor: proposers[0], }) if err != nil { - return &group.MsgSubmitProposalResponse{ProposalId: id}, sdkerrors.Wrap(err, "the proposal was created but failed on exec") + return &group.MsgSubmitProposalResponse{ProposalId: id}, errorsmod.Wrap(err, "the proposal was created but failed on exec") } } @@ -587,17 +589,17 @@ func (k Keeper) WithdrawProposal(goCtx context.Context, req *group.MsgWithdrawPr // Ensure the proposal can be withdrawn. if proposal.Status != group.PROPOSAL_STATUS_SUBMITTED { - return nil, sdkerrors.Wrapf(errors.ErrInvalid, "cannot withdraw a proposal with the status of %s", proposal.Status.String()) + return nil, errorsmod.Wrapf(errors.ErrInvalid, "cannot withdraw a proposal with the status of %s", proposal.Status.String()) } var policyInfo group.GroupPolicyInfo if policyInfo, err = k.getGroupPolicyInfo(ctx, proposal.GroupPolicyAddress); err != nil { - return nil, sdkerrors.Wrap(err, "load group policy") + return nil, errorsmod.Wrap(err, "load group policy") } // check address is the group policy admin he is in proposers list.. if address != policyInfo.Admin && !isProposer(proposal, address) { - return nil, sdkerrors.Wrapf(errors.ErrUnauthorized, "given address is neither group policy admin nor in proposers: %s", address) + return nil, errorsmod.Wrapf(errors.ErrUnauthorized, "given address is neither group policy admin nor in proposers: %s", address) } proposal.Status = group.PROPOSAL_STATUS_WITHDRAWN @@ -629,15 +631,15 @@ func (k Keeper) Vote(goCtx context.Context, req *group.MsgVote) (*group.MsgVoteR } // Ensure that we can still accept votes for this proposal. if proposal.Status != group.PROPOSAL_STATUS_SUBMITTED { - return nil, sdkerrors.Wrap(errors.ErrInvalid, "proposal not open for voting") + return nil, errorsmod.Wrap(errors.ErrInvalid, "proposal not open for voting") } if ctx.BlockTime().After(proposal.VotingPeriodEnd) { - return nil, sdkerrors.Wrap(errors.ErrExpired, "voting period has ended already") + return nil, errorsmod.Wrap(errors.ErrExpired, "voting period has ended already") } policyInfo, err := k.getGroupPolicyInfo(ctx, proposal.GroupPolicyAddress) if err != nil { - return nil, sdkerrors.Wrap(err, "load group policy") + return nil, errorsmod.Wrap(err, "load group policy") } electorate, err := k.getGroupInfo(ctx, policyInfo.GroupId) @@ -649,7 +651,7 @@ func (k Keeper) Vote(goCtx context.Context, req *group.MsgVote) (*group.MsgVoteR voterAddr := req.Voter voter := group.GroupMember{GroupId: electorate.Id, Member: &group.Member{Address: voterAddr}} if err := k.groupMemberTable.GetOne(ctx.KVStore(k.key), orm.PrimaryKey(&voter), &voter); err != nil { - return nil, sdkerrors.Wrapf(err, "voter address: %s", voterAddr) + return nil, errorsmod.Wrapf(err, "voter address: %s", voterAddr) } newVote := group.Vote{ ProposalId: id, @@ -662,7 +664,7 @@ func (k Keeper) Vote(goCtx context.Context, req *group.MsgVote) (*group.MsgVoteR // The ORM will return an error if the vote already exists, // making sure than a voter hasn't already voted. if err := k.voteTable.Create(ctx.KVStore(k.key), &newVote); err != nil { - return nil, sdkerrors.Wrap(err, "store vote") + return nil, errorsmod.Wrap(err, "store vote") } err = ctx.EventManager().EmitTypedEvent(&group.EventVote{ProposalId: id}) @@ -700,7 +702,7 @@ func (k Keeper) doTallyAndUpdate(ctx sdk.Context, p *group.Proposal, electorate result, err := policy.Allow(tallyResult, electorate.TotalWeight) if err != nil { - return sdkerrors.Wrap(err, "policy allow") + return errorsmod.Wrap(err, "policy allow") } // If the result was final (i.e. enough votes to pass) or if the voting @@ -731,12 +733,12 @@ func (k Keeper) Exec(goCtx context.Context, req *group.MsgExec) (*group.MsgExecR } if proposal.Status != group.PROPOSAL_STATUS_SUBMITTED && proposal.Status != group.PROPOSAL_STATUS_ACCEPTED { - return nil, sdkerrors.Wrapf(errors.ErrInvalid, "not possible to exec with proposal status %s", proposal.Status.String()) + return nil, errorsmod.Wrapf(errors.ErrInvalid, "not possible to exec with proposal status %s", proposal.Status.String()) } policyInfo, err := k.getGroupPolicyInfo(ctx, proposal.GroupPolicyAddress) if err != nil { - return nil, sdkerrors.Wrap(err, "load group policy") + return nil, errorsmod.Wrap(err, "load group policy") } // If proposal is still in SUBMITTED phase, it means that the voting period @@ -745,7 +747,7 @@ func (k Keeper) Exec(goCtx context.Context, req *group.MsgExec) (*group.MsgExecR if proposal.Status == group.PROPOSAL_STATUS_SUBMITTED { electorate, err := k.getGroupInfo(ctx, policyInfo.GroupId) if err != nil { - return nil, sdkerrors.Wrap(err, "load group") + return nil, errorsmod.Wrap(err, "load group") } if err := k.doTallyAndUpdate(ctx, &proposal, electorate, policyInfo); err != nil { @@ -817,7 +819,7 @@ func (k Keeper) LeaveGroup(goCtx context.Context, req *group.MsgLeaveGroup) (*gr groupInfo, err := k.getGroupInfo(ctx, req.GroupId) if err != nil { - return nil, sdkerrors.Wrap(err, "group") + return nil, errorsmod.Wrap(err, "group") } groupWeight, err := math.NewNonNegativeDecFromString(groupInfo.TotalWeight) @@ -845,7 +847,7 @@ func (k Keeper) LeaveGroup(goCtx context.Context, req *group.MsgLeaveGroup) (*gr // delete group member in the groupMemberTable. if err := k.groupMemberTable.Delete(ctx.KVStore(k.key), gm); err != nil { - return nil, sdkerrors.Wrap(err, "group member") + return nil, errorsmod.Wrap(err, "group member") } // update group weight @@ -898,26 +900,26 @@ type ( func (k Keeper) doUpdateGroupPolicy(ctx sdk.Context, groupPolicy string, admin string, action groupPolicyActionFn, note string) error { groupPolicyInfo, err := k.getGroupPolicyInfo(ctx, groupPolicy) if err != nil { - return sdkerrors.Wrap(err, "load group policy") + return errorsmod.Wrap(err, "load group policy") } groupPolicyAddr, err := sdk.AccAddressFromBech32(groupPolicy) if err != nil { - return sdkerrors.Wrap(err, "group policy address") + return errorsmod.Wrap(err, "group policy address") } groupPolicyAdmin, err := sdk.AccAddressFromBech32(admin) if err != nil { - return sdkerrors.Wrap(err, "group policy admin") + return errorsmod.Wrap(err, "group policy admin") } // Only current group policy admin is authorized to update a group policy. if groupPolicyAdmin.String() != groupPolicyInfo.Admin { - return sdkerrors.Wrap(sdkerrors.ErrUnauthorized, "not group policy admin") + return errorsmod.Wrap(sdkerrors.ErrUnauthorized, "not group policy admin") } if err := action(&groupPolicyInfo); err != nil { - return sdkerrors.Wrap(err, note) + return errorsmod.Wrap(err, note) } if err = k.abortProposals(ctx, groupPolicyAddr); err != nil { @@ -956,17 +958,17 @@ func (k Keeper) doAuthenticated(ctx sdk.Context, req authNGroupReq, action actio } admin, err := sdk.AccAddressFromBech32(group.Admin) if err != nil { - return sdkerrors.Wrap(err, "group admin") + return errorsmod.Wrap(err, "group admin") } reqAdmin, err := sdk.AccAddressFromBech32(req.GetAdmin()) if err != nil { - return sdkerrors.Wrap(err, "request admin") + return errorsmod.Wrap(err, "request admin") } if !admin.Equals(reqAdmin) { - return sdkerrors.Wrapf(sdkerrors.ErrUnauthorized, "not group admin; got %s, expected %s", req.GetAdmin(), group.Admin) + return errorsmod.Wrapf(sdkerrors.ErrUnauthorized, "not group admin; got %s, expected %s", req.GetAdmin(), group.Admin) } if err := action(&group); err != nil { - return sdkerrors.Wrap(err, errNote) + return errorsmod.Wrap(err, errNote) } return nil } @@ -975,7 +977,7 @@ func (k Keeper) doAuthenticated(ctx sdk.Context, req authNGroupReq, action actio // is greater than a pre-defined maxMetadataLen. func (k Keeper) assertMetadataLength(metadata string, description string) error { if metadata != "" && uint64(len(metadata)) > k.config.MaxMetadataLen { - return sdkerrors.Wrapf(errors.ErrMaxLimit, description) + return errorsmod.Wrapf(errors.ErrMaxLimit, description) } return nil } diff --git a/x/group/keeper/proposal_executor.go b/x/group/keeper/proposal_executor.go index ca09065e1b..abc2d86d8b 100644 --- a/x/group/keeper/proposal_executor.go +++ b/x/group/keeper/proposal_executor.go @@ -3,6 +3,8 @@ package keeper import ( "fmt" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/baseapp" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" @@ -41,11 +43,11 @@ func (s Keeper) doExecuteMsgs(ctx sdk.Context, router baseapp.MessageRouter, pro for i, msg := range msgs { handler := s.router.Handler(msg) if handler == nil { - return nil, sdkerrors.Wrapf(errors.ErrInvalid, "no message handler found for %q", sdk.MsgTypeURL(msg)) + return nil, errorsmod.Wrapf(errors.ErrInvalid, "no message handler found for %q", sdk.MsgTypeURL(msg)) } r, err := handler(ctx, msg) if err != nil { - return nil, sdkerrors.Wrapf(err, "message %s at position %d", sdk.MsgTypeURL(msg), i) + return nil, errorsmod.Wrapf(err, "message %s at position %d", sdk.MsgTypeURL(msg), i) } // Handler should always return non-nil sdk.Result. if r == nil { @@ -67,7 +69,7 @@ func ensureMsgAuthZ(msgs []sdk.Msg, groupPolicyAcc sdk.AccAddress) error { // but we prefer to loop through all GetSigners just to be sure. for _, acct := range msgs[i].GetSigners() { if !groupPolicyAcc.Equals(acct) { - return sdkerrors.Wrapf(sdkerrors.ErrUnauthorized, "msg does not have group policy authorization; expected %s, got %s", groupPolicyAcc.String(), acct.String()) + return errorsmod.Wrapf(sdkerrors.ErrUnauthorized, "msg does not have group policy authorization; expected %s, got %s", groupPolicyAcc.String(), acct.String()) } } } diff --git a/x/group/keeper/tally.go b/x/group/keeper/tally.go index d3ffedfd5e..c390ea8c0d 100644 --- a/x/group/keeper/tally.go +++ b/x/group/keeper/tally.go @@ -1,6 +1,8 @@ package keeper import ( + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/group" @@ -55,7 +57,7 @@ func (k Keeper) Tally(ctx sdk.Context, p group.Proposal, groupID uint64) (group. } if err := tallyResult.Add(vote, member.Member.Weight); err != nil { - return group.TallyResult{}, sdkerrors.Wrap(err, "add new vote") + return group.TallyResult{}, errorsmod.Wrap(err, "add new vote") } } diff --git a/x/group/msgs.go b/x/group/msgs.go index 71d1e7482a..426105c113 100644 --- a/x/group/msgs.go +++ b/x/group/msgs.go @@ -3,6 +3,8 @@ package group import ( "github.com/cosmos/gogoproto/proto" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/codec/types" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" @@ -34,7 +36,7 @@ func (m MsgCreateGroup) GetSigners() []sdk.AccAddress { func (m MsgCreateGroup) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(m.Admin) if err != nil { - return sdkerrors.Wrap(err, "admin") + return errorsmod.Wrap(err, "admin") } return strictValidateMembers(m.Members) @@ -48,11 +50,11 @@ func (m MsgCreateGroup) ValidateBasic() error { func (m MemberRequest) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(m.Address) if err != nil { - return sdkerrors.Wrap(err, "address") + return errorsmod.Wrap(err, "address") } if _, err := math.NewNonNegativeDecFromString(m.Weight); err != nil { - return sdkerrors.Wrap(err, "weight") + return errorsmod.Wrap(err, "weight") } return nil @@ -78,21 +80,21 @@ func (m MsgUpdateGroupAdmin) GetSigners() []sdk.AccAddress { // ValidateBasic does a sanity check on the provided data. func (m MsgUpdateGroupAdmin) ValidateBasic() error { if m.GroupId == 0 { - return sdkerrors.Wrap(errors.ErrEmpty, "group id") + return errorsmod.Wrap(errors.ErrEmpty, "group id") } admin, err := sdk.AccAddressFromBech32(m.Admin) if err != nil { - return sdkerrors.Wrap(err, "admin") + return errorsmod.Wrap(err, "admin") } newAdmin, err := sdk.AccAddressFromBech32(m.NewAdmin) if err != nil { - return sdkerrors.Wrap(err, "new admin") + return errorsmod.Wrap(err, "new admin") } if admin.Equals(newAdmin) { - return sdkerrors.Wrap(errors.ErrInvalid, "new and old admin are the same") + return errorsmod.Wrap(errors.ErrInvalid, "new and old admin are the same") } return nil } @@ -122,11 +124,11 @@ func (m MsgUpdateGroupMetadata) GetSigners() []sdk.AccAddress { // ValidateBasic does a sanity check on the provided data func (m MsgUpdateGroupMetadata) ValidateBasic() error { if m.GroupId == 0 { - return sdkerrors.Wrap(errors.ErrEmpty, "group id") + return errorsmod.Wrap(errors.ErrEmpty, "group id") } _, err := sdk.AccAddressFromBech32(m.Admin) if err != nil { - return sdkerrors.Wrap(err, "admin") + return errorsmod.Wrap(err, "admin") } return nil @@ -159,19 +161,19 @@ func (m MsgUpdateGroupMembers) GetSigners() []sdk.AccAddress { // ValidateBasic does a sanity check on the provided data func (m MsgUpdateGroupMembers) ValidateBasic() error { if m.GroupId == 0 { - return sdkerrors.Wrap(errors.ErrEmpty, "group id") + return errorsmod.Wrap(errors.ErrEmpty, "group id") } _, err := sdk.AccAddressFromBech32(m.Admin) if err != nil { - return sdkerrors.Wrap(err, "admin") + return errorsmod.Wrap(err, "admin") } if len(m.MemberUpdates) == 0 { - return sdkerrors.Wrap(errors.ErrEmpty, "member updates") + return errorsmod.Wrap(errors.ErrEmpty, "member updates") } members := MemberRequests{Members: m.MemberUpdates} if err := members.ValidateBasic(); err != nil { - return sdkerrors.Wrap(err, "members") + return errorsmod.Wrap(err, "members") } return nil } @@ -244,14 +246,14 @@ func (m MsgCreateGroupWithPolicy) GetSigners() []sdk.AccAddress { func (m MsgCreateGroupWithPolicy) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(m.Admin) if err != nil { - return sdkerrors.Wrap(err, "admin") + return errorsmod.Wrap(err, "admin") } policy, err := m.GetDecisionPolicy() if err != nil { - return sdkerrors.Wrap(err, "decision policy") + return errorsmod.Wrap(err, "decision policy") } if err := policy.ValidateBasic(); err != nil { - return sdkerrors.Wrap(err, "decision policy") + return errorsmod.Wrap(err, "decision policy") } return strictValidateMembers(m.Members) @@ -277,19 +279,19 @@ func (m MsgCreateGroupPolicy) GetSigners() []sdk.AccAddress { func (m MsgCreateGroupPolicy) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(m.Admin) if err != nil { - return sdkerrors.Wrap(err, "admin") + return errorsmod.Wrap(err, "admin") } if m.GroupId == 0 { - return sdkerrors.Wrap(errors.ErrEmpty, "group id") + return errorsmod.Wrap(errors.ErrEmpty, "group id") } policy, err := m.GetDecisionPolicy() if err != nil { - return sdkerrors.Wrap(err, "decision policy") + return errorsmod.Wrap(err, "decision policy") } if err := policy.ValidateBasic(); err != nil { - return sdkerrors.Wrap(err, "decision policy") + return errorsmod.Wrap(err, "decision policy") } return nil } @@ -315,21 +317,21 @@ func (m MsgUpdateGroupPolicyAdmin) GetSigners() []sdk.AccAddress { func (m MsgUpdateGroupPolicyAdmin) ValidateBasic() error { admin, err := sdk.AccAddressFromBech32(m.Admin) if err != nil { - return sdkerrors.Wrap(err, "admin") + return errorsmod.Wrap(err, "admin") } newAdmin, err := sdk.AccAddressFromBech32(m.NewAdmin) if err != nil { - return sdkerrors.Wrap(err, "new admin") + return errorsmod.Wrap(err, "new admin") } _, err = sdk.AccAddressFromBech32(m.GroupPolicyAddress) if err != nil { - return sdkerrors.Wrap(err, "group policy") + return errorsmod.Wrap(err, "group policy") } if admin.Equals(newAdmin) { - return sdkerrors.Wrap(errors.ErrInvalid, "new and old admin are same") + return errorsmod.Wrap(errors.ErrInvalid, "new and old admin are same") } return nil } @@ -384,21 +386,21 @@ func (m MsgUpdateGroupPolicyDecisionPolicy) GetSigners() []sdk.AccAddress { func (m MsgUpdateGroupPolicyDecisionPolicy) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(m.Admin) if err != nil { - return sdkerrors.Wrap(err, "admin") + return errorsmod.Wrap(err, "admin") } _, err = sdk.AccAddressFromBech32(m.GroupPolicyAddress) if err != nil { - return sdkerrors.Wrap(err, "group policy") + return errorsmod.Wrap(err, "group policy") } policy, err := m.GetDecisionPolicy() if err != nil { - return sdkerrors.Wrap(err, "decision policy") + return errorsmod.Wrap(err, "decision policy") } if err := policy.ValidateBasic(); err != nil { - return sdkerrors.Wrap(err, "decision policy") + return errorsmod.Wrap(err, "decision policy") } return nil @@ -441,12 +443,12 @@ func (m MsgUpdateGroupPolicyMetadata) GetSigners() []sdk.AccAddress { func (m MsgUpdateGroupPolicyMetadata) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(m.Admin) if err != nil { - return sdkerrors.Wrap(err, "admin") + return errorsmod.Wrap(err, "admin") } _, err = sdk.AccAddressFromBech32(m.GroupPolicyAddress) if err != nil { - return sdkerrors.Wrap(err, "group policy") + return errorsmod.Wrap(err, "group policy") } return nil @@ -556,28 +558,28 @@ func (m MsgSubmitProposal) GetSigners() []sdk.AccAddress { func (m MsgSubmitProposal) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(m.GroupPolicyAddress) if err != nil { - return sdkerrors.Wrap(err, "group policy") + return errorsmod.Wrap(err, "group policy") } if m.Title == "" { - return sdkerrors.Wrap(errors.ErrEmpty, "title") + return errorsmod.Wrap(errors.ErrEmpty, "title") } if m.Summary == "" { - return sdkerrors.Wrap(errors.ErrEmpty, "summary") + return errorsmod.Wrap(errors.ErrEmpty, "summary") } if len(m.Proposers) == 0 { - return sdkerrors.Wrap(errors.ErrEmpty, "proposers") + return errorsmod.Wrap(errors.ErrEmpty, "proposers") } addrs, err := m.getProposerAccAddresses() if err != nil { - return sdkerrors.Wrap(err, "group proposers") + return errorsmod.Wrap(err, "group proposers") } if err := accAddresses(addrs).ValidateBasic(); err != nil { - return sdkerrors.Wrap(err, "proposers") + return errorsmod.Wrap(err, "proposers") } msgs, err := m.GetMsgs() @@ -587,7 +589,7 @@ func (m MsgSubmitProposal) ValidateBasic() error { for i, msg := range msgs { if err := msg.ValidateBasic(); err != nil { - return sdkerrors.Wrapf(err, "msg %d", i) + return errorsmod.Wrapf(err, "msg %d", i) } } return nil @@ -599,7 +601,7 @@ func (m *MsgSubmitProposal) getProposerAccAddresses() ([]sdk.AccAddress, error) for i, proposer := range m.Proposers { addr, err := sdk.AccAddressFromBech32(proposer) if err != nil { - return nil, sdkerrors.Wrap(err, "proposers") + return nil, errorsmod.Wrap(err, "proposers") } addrs[i] = addr } @@ -648,11 +650,11 @@ func (m MsgWithdrawProposal) GetSigners() []sdk.AccAddress { func (m MsgWithdrawProposal) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(m.Address) if err != nil { - return sdkerrors.Wrap(err, "admin") + return errorsmod.Wrap(err, "admin") } if m.ProposalId == 0 { - return sdkerrors.Wrap(errors.ErrEmpty, "proposal id") + return errorsmod.Wrap(errors.ErrEmpty, "proposal id") } return nil @@ -679,16 +681,16 @@ func (m MsgVote) GetSigners() []sdk.AccAddress { func (m MsgVote) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(m.Voter) if err != nil { - return sdkerrors.Wrap(err, "voter") + return errorsmod.Wrap(err, "voter") } if m.ProposalId == 0 { - return sdkerrors.Wrap(errors.ErrEmpty, "proposal id") + return errorsmod.Wrap(errors.ErrEmpty, "proposal id") } if m.Option == VOTE_OPTION_UNSPECIFIED { - return sdkerrors.Wrap(errors.ErrEmpty, "vote option") + return errorsmod.Wrap(errors.ErrEmpty, "vote option") } if _, ok := VoteOption_name[int32(m.Option)]; !ok { - return sdkerrors.Wrap(errors.ErrInvalid, "vote option") + return errorsmod.Wrap(errors.ErrInvalid, "vote option") } return nil } @@ -714,10 +716,10 @@ func (m MsgExec) GetSigners() []sdk.AccAddress { func (m MsgExec) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(m.Executor) if err != nil { - return sdkerrors.Wrap(err, "signer") + return errorsmod.Wrap(err, "signer") } if m.ProposalId == 0 { - return sdkerrors.Wrap(errors.ErrEmpty, "proposal id") + return errorsmod.Wrap(errors.ErrEmpty, "proposal id") } return nil } @@ -743,11 +745,11 @@ func (m MsgLeaveGroup) GetSigners() []sdk.AccAddress { func (m MsgLeaveGroup) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(m.Address) if err != nil { - return sdkerrors.Wrap(err, "group member") + return errorsmod.Wrap(err, "group member") } if m.GroupId == 0 { - return sdkerrors.Wrap(errors.ErrEmpty, "group-id") + return errorsmod.Wrap(errors.ErrEmpty, "group-id") } return nil } @@ -763,7 +765,7 @@ func strictValidateMembers(members []MemberRequest) error { for _, m := range members { if _, err := math.NewPositiveDecFromString(m.Weight); err != nil { - return sdkerrors.Wrap(err, "weight") + return errorsmod.Wrap(err, "weight") } } diff --git a/x/group/types.go b/x/group/types.go index 750921d8d5..9b0a84f359 100644 --- a/x/group/types.go +++ b/x/group/types.go @@ -6,6 +6,8 @@ import ( proto "github.com/cosmos/gogoproto/proto" + errorsmod "cosmossdk.io/errors" + codectypes "github.com/cosmos/cosmos-sdk/codec/types" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" @@ -66,11 +68,11 @@ func (p ThresholdDecisionPolicy) GetMinExecutionPeriod() time.Duration { // ValidateBasic does basic validation on ThresholdDecisionPolicy func (p ThresholdDecisionPolicy) ValidateBasic() error { if _, err := math.NewPositiveDecFromString(p.Threshold); err != nil { - return sdkerrors.Wrap(err, "threshold") + return errorsmod.Wrap(err, "threshold") } if p.Windows == nil || p.Windows.VotingPeriod == 0 { - return sdkerrors.Wrap(errors.ErrInvalid, "voting period cannot be zero") + return errorsmod.Wrap(errors.ErrInvalid, "voting period cannot be zero") } return nil @@ -80,16 +82,16 @@ func (p ThresholdDecisionPolicy) ValidateBasic() error { func (p ThresholdDecisionPolicy) Allow(tallyResult TallyResult, totalPower string) (DecisionPolicyResult, error) { threshold, err := math.NewPositiveDecFromString(p.Threshold) if err != nil { - return DecisionPolicyResult{}, sdkerrors.Wrap(err, "threshold") + return DecisionPolicyResult{}, errorsmod.Wrap(err, "threshold") } yesCount, err := math.NewNonNegativeDecFromString(tallyResult.YesCount) if err != nil { - return DecisionPolicyResult{}, sdkerrors.Wrap(err, "yes count") + return DecisionPolicyResult{}, errorsmod.Wrap(err, "yes count") } totalPowerDec, err := math.NewNonNegativeDecFromString(totalPower) if err != nil { - return DecisionPolicyResult{}, sdkerrors.Wrap(err, "total power") + return DecisionPolicyResult{}, errorsmod.Wrap(err, "total power") } // the real threshold of the policy is `min(threshold,total_weight)`. If @@ -137,15 +139,15 @@ func min(a, b math.Dec) math.Dec { func (p *ThresholdDecisionPolicy) Validate(g GroupInfo, config Config) error { _, err := math.NewPositiveDecFromString(p.Threshold) if err != nil { - return sdkerrors.Wrap(err, "threshold") + return errorsmod.Wrap(err, "threshold") } _, err = math.NewNonNegativeDecFromString(g.TotalWeight) if err != nil { - return sdkerrors.Wrap(err, "group total weight") + return errorsmod.Wrap(err, "group total weight") } if p.Windows.MinExecutionPeriod > p.Windows.VotingPeriod+config.MaxExecutionPeriod { - return sdkerrors.Wrap(errors.ErrInvalid, "min_execution_period should be smaller than voting_period + max_execution_period") + return errorsmod.Wrap(errors.ErrInvalid, "min_execution_period should be smaller than voting_period + max_execution_period") } return nil } @@ -172,14 +174,14 @@ func (p PercentageDecisionPolicy) GetMinExecutionPeriod() time.Duration { func (p PercentageDecisionPolicy) ValidateBasic() error { percentage, err := math.NewPositiveDecFromString(p.Percentage) if err != nil { - return sdkerrors.Wrap(err, "percentage threshold") + return errorsmod.Wrap(err, "percentage threshold") } if percentage.Cmp(math.NewDecFromInt64(1)) == 1 { - return sdkerrors.Wrap(errors.ErrInvalid, "percentage must be > 0 and <= 1") + return errorsmod.Wrap(errors.ErrInvalid, "percentage must be > 0 and <= 1") } if p.Windows == nil || p.Windows.VotingPeriod == 0 { - return sdkerrors.Wrap(errors.ErrInvalid, "voting period cannot be 0") + return errorsmod.Wrap(errors.ErrInvalid, "voting period cannot be 0") } return nil @@ -188,7 +190,7 @@ func (p PercentageDecisionPolicy) ValidateBasic() error { // Validate validates the policy against the group. func (p *PercentageDecisionPolicy) Validate(g GroupInfo, config Config) error { if p.Windows.MinExecutionPeriod > p.Windows.VotingPeriod+config.MaxExecutionPeriod { - return sdkerrors.Wrap(errors.ErrInvalid, "min_execution_period should be smaller than voting_period + max_execution_period") + return errorsmod.Wrap(errors.ErrInvalid, "min_execution_period should be smaller than voting_period + max_execution_period") } return nil } @@ -197,15 +199,15 @@ func (p *PercentageDecisionPolicy) Validate(g GroupInfo, config Config) error { func (p PercentageDecisionPolicy) Allow(tally TallyResult, totalPower string) (DecisionPolicyResult, error) { percentage, err := math.NewPositiveDecFromString(p.Percentage) if err != nil { - return DecisionPolicyResult{}, sdkerrors.Wrap(err, "percentage") + return DecisionPolicyResult{}, errorsmod.Wrap(err, "percentage") } yesCount, err := math.NewNonNegativeDecFromString(tally.YesCount) if err != nil { - return DecisionPolicyResult{}, sdkerrors.Wrap(err, "yes count") + return DecisionPolicyResult{}, errorsmod.Wrap(err, "yes count") } totalPowerDec, err := math.NewNonNegativeDecFromString(totalPower) if err != nil { - return DecisionPolicyResult{}, sdkerrors.Wrap(err, "total power") + return DecisionPolicyResult{}, errorsmod.Wrap(err, "total power") } yesPercentage, err := yesCount.Quo(totalPowerDec) @@ -295,19 +297,19 @@ func (g GroupInfo) PrimaryKeyFields() []interface{} { // ValidateBasic does basic validation on group info. func (g GroupInfo) ValidateBasic() error { if g.Id == 0 { - return sdkerrors.Wrap(errors.ErrEmpty, "group's GroupId") + return errorsmod.Wrap(errors.ErrEmpty, "group's GroupId") } _, err := sdk.AccAddressFromBech32(g.Admin) if err != nil { - return sdkerrors.Wrap(err, "admin") + return errorsmod.Wrap(err, "admin") } if _, err := math.NewNonNegativeDecFromString(g.TotalWeight); err != nil { - return sdkerrors.Wrap(err, "total weight") + return errorsmod.Wrap(err, "total weight") } if g.Version == 0 { - return sdkerrors.Wrap(errors.ErrEmpty, "version") + return errorsmod.Wrap(errors.ErrEmpty, "version") } return nil } @@ -326,26 +328,26 @@ func (g Proposal) PrimaryKeyFields() []interface{} { func (g GroupPolicyInfo) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(g.Admin) if err != nil { - return sdkerrors.Wrap(err, "group policy admin") + return errorsmod.Wrap(err, "group policy admin") } _, err = sdk.AccAddressFromBech32(g.Address) if err != nil { - return sdkerrors.Wrap(err, "group policy account address") + return errorsmod.Wrap(err, "group policy account address") } if g.GroupId == 0 { - return sdkerrors.Wrap(errors.ErrEmpty, "group policy's group id") + return errorsmod.Wrap(errors.ErrEmpty, "group policy's group id") } if g.Version == 0 { - return sdkerrors.Wrap(errors.ErrEmpty, "group policy version") + return errorsmod.Wrap(errors.ErrEmpty, "group policy version") } policy, err := g.GetDecisionPolicy() if err != nil { - return sdkerrors.Wrap(err, "group policy decision policy") + return errorsmod.Wrap(err, "group policy decision policy") } if err := policy.ValidateBasic(); err != nil { - return sdkerrors.Wrap(err, "group policy's decision policy") + return errorsmod.Wrap(err, "group policy's decision policy") } return nil } @@ -359,12 +361,12 @@ func (g GroupMember) PrimaryKeyFields() []interface{} { // ValidateBasic does basic validation on group member. func (g GroupMember) ValidateBasic() error { if g.GroupId == 0 { - return sdkerrors.Wrap(errors.ErrEmpty, "group member's group id") + return errorsmod.Wrap(errors.ErrEmpty, "group member's group id") } err := MemberToMemberRequest(g.Member).ValidateBasic() if err != nil { - return sdkerrors.Wrap(err, "group member") + return errorsmod.Wrap(err, "group member") } return nil } @@ -384,33 +386,33 @@ func MemberToMemberRequest(m *Member) MemberRequest { // ValidateBasic does basic validation on proposal. func (g Proposal) ValidateBasic() error { if g.Id == 0 { - return sdkerrors.Wrap(errors.ErrEmpty, "proposal id") + return errorsmod.Wrap(errors.ErrEmpty, "proposal id") } _, err := sdk.AccAddressFromBech32(g.GroupPolicyAddress) if err != nil { - return sdkerrors.Wrap(err, "proposal group policy address") + return errorsmod.Wrap(err, "proposal group policy address") } if g.GroupVersion == 0 { - return sdkerrors.Wrap(errors.ErrEmpty, "proposal group version") + return errorsmod.Wrap(errors.ErrEmpty, "proposal group version") } if g.GroupPolicyVersion == 0 { - return sdkerrors.Wrap(errors.ErrEmpty, "proposal group policy version") + return errorsmod.Wrap(errors.ErrEmpty, "proposal group policy version") } _, err = g.FinalTallyResult.GetYesCount() if err != nil { - return sdkerrors.Wrap(err, "proposal FinalTallyResult yes count") + return errorsmod.Wrap(err, "proposal FinalTallyResult yes count") } _, err = g.FinalTallyResult.GetNoCount() if err != nil { - return sdkerrors.Wrap(err, "proposal FinalTallyResult no count") + return errorsmod.Wrap(err, "proposal FinalTallyResult no count") } _, err = g.FinalTallyResult.GetAbstainCount() if err != nil { - return sdkerrors.Wrap(err, "proposal FinalTallyResult abstain count") + return errorsmod.Wrap(err, "proposal FinalTallyResult abstain count") } _, err = g.FinalTallyResult.GetNoWithVetoCount() if err != nil { - return sdkerrors.Wrap(err, "proposal FinalTallyResult veto count") + return errorsmod.Wrap(err, "proposal FinalTallyResult veto count") } return nil } @@ -427,16 +429,16 @@ var _ orm.Validateable = Vote{} func (v Vote) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(v.Voter) if err != nil { - return sdkerrors.Wrap(err, "voter") + return errorsmod.Wrap(err, "voter") } if v.ProposalId == 0 { - return sdkerrors.Wrap(errors.ErrEmpty, "voter ProposalId") + return errorsmod.Wrap(errors.ErrEmpty, "voter ProposalId") } if v.Option == VOTE_OPTION_UNSPECIFIED { - return sdkerrors.Wrap(errors.ErrEmpty, "voter vote option") + return errorsmod.Wrap(errors.ErrEmpty, "voter vote option") } if _, ok := VoteOption_name[int32(v.Option)]; !ok { - return sdkerrors.Wrap(errors.ErrInvalid, "vote option") + return errorsmod.Wrap(errors.ErrInvalid, "vote option") } return nil } @@ -472,48 +474,48 @@ func (t *TallyResult) operation(vote Vote, weight string, op operation) error { yesCount, err := t.GetYesCount() if err != nil { - return sdkerrors.Wrap(err, "yes count") + return errorsmod.Wrap(err, "yes count") } noCount, err := t.GetNoCount() if err != nil { - return sdkerrors.Wrap(err, "no count") + return errorsmod.Wrap(err, "no count") } abstainCount, err := t.GetAbstainCount() if err != nil { - return sdkerrors.Wrap(err, "abstain count") + return errorsmod.Wrap(err, "abstain count") } vetoCount, err := t.GetNoWithVetoCount() if err != nil { - return sdkerrors.Wrap(err, "veto count") + return errorsmod.Wrap(err, "veto count") } switch vote.Option { case VOTE_OPTION_YES: yesCount, err := op(yesCount, weightDec) if err != nil { - return sdkerrors.Wrap(err, "yes count") + return errorsmod.Wrap(err, "yes count") } t.YesCount = yesCount.String() case VOTE_OPTION_NO: noCount, err := op(noCount, weightDec) if err != nil { - return sdkerrors.Wrap(err, "no count") + return errorsmod.Wrap(err, "no count") } t.NoCount = noCount.String() case VOTE_OPTION_ABSTAIN: abstainCount, err := op(abstainCount, weightDec) if err != nil { - return sdkerrors.Wrap(err, "abstain count") + return errorsmod.Wrap(err, "abstain count") } t.AbstainCount = abstainCount.String() case VOTE_OPTION_NO_WITH_VETO: vetoCount, err := op(vetoCount, weightDec) if err != nil { - return sdkerrors.Wrap(err, "veto count") + return errorsmod.Wrap(err, "veto count") } t.NoWithVetoCount = vetoCount.String() default: - return sdkerrors.Wrapf(errors.ErrInvalid, "unknown vote option %s", vote.Option.String()) + return errorsmod.Wrapf(errors.ErrInvalid, "unknown vote option %s", vote.Option.String()) } return nil } @@ -565,19 +567,19 @@ func (t *TallyResult) Add(vote Vote, weight string) error { func (t TallyResult) TotalCounts() (math.Dec, error) { yesCount, err := t.GetYesCount() if err != nil { - return math.Dec{}, sdkerrors.Wrap(err, "yes count") + return math.Dec{}, errorsmod.Wrap(err, "yes count") } noCount, err := t.GetNoCount() if err != nil { - return math.Dec{}, sdkerrors.Wrap(err, "no count") + return math.Dec{}, errorsmod.Wrap(err, "no count") } abstainCount, err := t.GetAbstainCount() if err != nil { - return math.Dec{}, sdkerrors.Wrap(err, "abstain count") + return math.Dec{}, errorsmod.Wrap(err, "abstain count") } vetoCount, err := t.GetNoWithVetoCount() if err != nil { - return math.Dec{}, sdkerrors.Wrap(err, "veto count") + return math.Dec{}, errorsmod.Wrap(err, "veto count") } totalCounts := math.NewDecFromInt64(0) diff --git a/x/group/typesupport.go b/x/group/typesupport.go index 1b94a8b466..c1108606c9 100644 --- a/x/group/typesupport.go +++ b/x/group/typesupport.go @@ -1,8 +1,9 @@ package group import ( + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/group/errors" ) @@ -23,7 +24,7 @@ func (ms MemberRequests) ValidateBasic() error { } addr := member.Address if _, exists := index[addr]; exists { - return sdkerrors.Wrapf(errors.ErrDuplicate, "address: %s", addr) + return errorsmod.Wrapf(errors.ErrDuplicate, "address: %s", addr) } index[addr] = struct{}{} } @@ -40,7 +41,7 @@ func (a accAddresses) ValidateBasic() error { accAddr := a[i] addr := string(accAddr) if _, exists := index[addr]; exists { - return sdkerrors.Wrapf(errors.ErrDuplicate, "address: %s", accAddr.String()) + return errorsmod.Wrapf(errors.ErrDuplicate, "address: %s", accAddr.String()) } index[addr] = struct{}{} } diff --git a/x/mint/keeper/msg_server.go b/x/mint/keeper/msg_server.go index 472138cdf4..f65e21c519 100644 --- a/x/mint/keeper/msg_server.go +++ b/x/mint/keeper/msg_server.go @@ -3,8 +3,9 @@ package keeper import ( "context" + "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/types/errors" govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" "github.com/cosmos/cosmos-sdk/x/mint/types" ) diff --git a/x/mint/types/msgs.go b/x/mint/types/msgs.go index 366a0a02a4..8ee7ee78cb 100644 --- a/x/mint/types/msgs.go +++ b/x/mint/types/msgs.go @@ -1,8 +1,9 @@ package types import ( + "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/auth/migrations/legacytx" ) @@ -25,7 +26,7 @@ func (m MsgUpdateParams) GetSigners() []sdk.AccAddress { // ValidateBasic does a sanity check on the provided data. func (m MsgUpdateParams) ValidateBasic() error { if _, err := sdk.AccAddressFromBech32(m.Authority); err != nil { - return sdkerrors.Wrap(err, "invalid authority address") + return errors.Wrap(err, "invalid authority address") } if err := m.Params.Validate(); err != nil { diff --git a/x/nft/go.mod b/x/nft/go.mod index c7981caa24..e91fc89425 100644 --- a/x/nft/go.mod +++ b/x/nft/go.mod @@ -7,7 +7,7 @@ require ( cosmossdk.io/core v0.5.1 cosmossdk.io/depinject v1.0.0-alpha.3 cosmossdk.io/errors v1.0.0-beta.7 - cosmossdk.io/math v1.0.0-beta.6 + cosmossdk.io/math v1.0.0-beta.6.0.20230216172121-959ce49135e4 cosmossdk.io/store v0.0.0-20230206092147-e03195e4b8a7 github.com/cometbft/cometbft v0.0.0-20230203130311-387422ac220d github.com/cosmos/cosmos-proto v1.0.0-beta.1 diff --git a/x/nft/go.sum b/x/nft/go.sum index 8a1a453b95..6caf6f64a9 100644 --- a/x/nft/go.sum +++ b/x/nft/go.sum @@ -45,8 +45,8 @@ cosmossdk.io/depinject v1.0.0-alpha.3 h1:6evFIgj//Y3w09bqOUOzEpFj5tsxBqdc5CfkO7z cosmossdk.io/depinject v1.0.0-alpha.3/go.mod h1:eRbcdQ7MRpIPEM5YUJh8k97nxHpYbc3sMUnEtt8HPWU= cosmossdk.io/errors v1.0.0-beta.7 h1:gypHW76pTQGVnHKo6QBkb4yFOJjC+sUGRc5Al3Odj1w= cosmossdk.io/errors v1.0.0-beta.7/go.mod h1:mz6FQMJRku4bY7aqS/Gwfcmr/ue91roMEKAmDUDpBfE= -cosmossdk.io/math v1.0.0-beta.6 h1:WF29SiFYNde5eYvqO2kdOM9nYbDb44j3YW5B8M1m9KE= -cosmossdk.io/math v1.0.0-beta.6/go.mod h1:gUVtWwIzfSXqcOT+lBVz2jyjfua8DoBdzRsIyaUAT/8= +cosmossdk.io/math v1.0.0-beta.6.0.20230216172121-959ce49135e4 h1:/jnzJ9zFsL7qkV8LCQ1JH3dYHh2EsKZ3k8Mr6AqqiOA= +cosmossdk.io/math v1.0.0-beta.6.0.20230216172121-959ce49135e4/go.mod h1:gUVtWwIzfSXqcOT+lBVz2jyjfua8DoBdzRsIyaUAT/8= cosmossdk.io/store v0.0.0-20230206092147-e03195e4b8a7 h1:IwyDN/YaQmF+Pmuv8d7vRWMM/k2RjSmPBycMcmd3ICE= cosmossdk.io/store v0.0.0-20230206092147-e03195e4b8a7/go.mod h1:1XOtuYs7jsfQkn7G3VQXB6I+2tHXKHZw2U/AafNbnlk= cosmossdk.io/x/tx v0.2.0 h1:53f5TIXhpPYJGMm47SUslcV2i8JNBEN3eE08BmxE/Zg= diff --git a/x/nft/keeper/class.go b/x/nft/keeper/class.go index 25139f90de..1517961df0 100644 --- a/x/nft/keeper/class.go +++ b/x/nft/keeper/class.go @@ -1,21 +1,21 @@ package keeper import ( + "cosmossdk.io/errors" storetypes "cosmossdk.io/store/types" "cosmossdk.io/x/nft" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) // SaveClass defines a method for creating a new nft class func (k Keeper) SaveClass(ctx sdk.Context, class nft.Class) error { if k.HasClass(ctx, class.Id) { - return sdkerrors.Wrap(nft.ErrClassExists, class.Id) + return errors.Wrap(nft.ErrClassExists, class.Id) } bz, err := k.cdc.Marshal(&class) if err != nil { - return sdkerrors.Wrap(err, "Marshal nft.Class failed") + return errors.Wrap(err, "Marshal nft.Class failed") } store := ctx.KVStore(k.storeKey) store.Set(classStoreKey(class.Id), bz) @@ -25,11 +25,11 @@ func (k Keeper) SaveClass(ctx sdk.Context, class nft.Class) error { // UpdateClass defines a method for updating an exist nft class func (k Keeper) UpdateClass(ctx sdk.Context, class nft.Class) error { if !k.HasClass(ctx, class.Id) { - return sdkerrors.Wrap(nft.ErrClassNotExists, class.Id) + return errors.Wrap(nft.ErrClassNotExists, class.Id) } bz, err := k.cdc.Marshal(&class) if err != nil { - return sdkerrors.Wrap(err, "Marshal nft.Class failed") + return errors.Wrap(err, "Marshal nft.Class failed") } store := ctx.KVStore(k.storeKey) store.Set(classStoreKey(class.Id), bz) diff --git a/x/nft/keeper/msg_server.go b/x/nft/keeper/msg_server.go index dfea37dcaa..87e8dc270c 100644 --- a/x/nft/keeper/msg_server.go +++ b/x/nft/keeper/msg_server.go @@ -3,7 +3,9 @@ package keeper import ( "context" + errorsmod "cosmossdk.io/errors" "cosmossdk.io/x/nft" + sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) @@ -20,7 +22,7 @@ func (k Keeper) Send(goCtx context.Context, msg *nft.MsgSend) (*nft.MsgSendRespo owner := k.GetOwner(ctx, msg.ClassId, msg.Id) if !owner.Equals(sender) { - return nil, sdkerrors.Wrapf(sdkerrors.ErrUnauthorized, "%s is not the owner of nft %s", sender, msg.Id) + return nil, errorsmod.Wrapf(sdkerrors.ErrUnauthorized, "%s is not the owner of nft %s", sender, msg.Id) } receiver, err := sdk.AccAddressFromBech32(msg.Receiver) diff --git a/x/nft/keeper/nft.go b/x/nft/keeper/nft.go index 15bb82d359..2db46f54ef 100644 --- a/x/nft/keeper/nft.go +++ b/x/nft/keeper/nft.go @@ -1,21 +1,21 @@ package keeper import ( + "cosmossdk.io/errors" "cosmossdk.io/store/prefix" "cosmossdk.io/x/nft" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) // Mint defines a method for minting a new nft func (k Keeper) Mint(ctx sdk.Context, token nft.NFT, receiver sdk.AccAddress) error { if !k.HasClass(ctx, token.ClassId) { - return sdkerrors.Wrap(nft.ErrClassNotExists, token.ClassId) + return errors.Wrap(nft.ErrClassNotExists, token.ClassId) } if k.HasNFT(ctx, token.ClassId, token.Id) { - return sdkerrors.Wrap(nft.ErrNFTExists, token.Id) + return errors.Wrap(nft.ErrNFTExists, token.Id) } k.mintWithNoCheck(ctx, token, receiver) @@ -41,11 +41,11 @@ func (k Keeper) mintWithNoCheck(ctx sdk.Context, token nft.NFT, receiver sdk.Acc // Note: When the upper module uses this method, it needs to authenticate nft func (k Keeper) Burn(ctx sdk.Context, classID string, nftID string) error { if !k.HasClass(ctx, classID) { - return sdkerrors.Wrap(nft.ErrClassNotExists, classID) + return errors.Wrap(nft.ErrClassNotExists, classID) } if !k.HasNFT(ctx, classID, nftID) { - return sdkerrors.Wrap(nft.ErrNFTNotExists, nftID) + return errors.Wrap(nft.ErrNFTNotExists, nftID) } k.burnWithNoCheck(ctx, classID, nftID) @@ -74,11 +74,11 @@ func (k Keeper) burnWithNoCheck(ctx sdk.Context, classID string, nftID string) e // Note: When the upper module uses this method, it needs to authenticate nft func (k Keeper) Update(ctx sdk.Context, token nft.NFT) error { if !k.HasClass(ctx, token.ClassId) { - return sdkerrors.Wrap(nft.ErrClassNotExists, token.ClassId) + return errors.Wrap(nft.ErrClassNotExists, token.ClassId) } if !k.HasNFT(ctx, token.ClassId, token.Id) { - return sdkerrors.Wrap(nft.ErrNFTNotExists, token.Id) + return errors.Wrap(nft.ErrNFTNotExists, token.Id) } k.updateWithNoCheck(ctx, token) return nil @@ -99,11 +99,11 @@ func (k Keeper) Transfer(ctx sdk.Context, receiver sdk.AccAddress, ) error { if !k.HasClass(ctx, classID) { - return sdkerrors.Wrap(nft.ErrClassNotExists, classID) + return errors.Wrap(nft.ErrClassNotExists, classID) } if !k.HasNFT(ctx, classID, nftID) { - return sdkerrors.Wrap(nft.ErrNFTNotExists, nftID) + return errors.Wrap(nft.ErrNFTNotExists, nftID) } k.transferWithNoCheck(ctx, classID, nftID, receiver) diff --git a/x/nft/keeper/nft_batch.go b/x/nft/keeper/nft_batch.go index d22052e14f..345897d6b0 100644 --- a/x/nft/keeper/nft_batch.go +++ b/x/nft/keeper/nft_batch.go @@ -1,9 +1,10 @@ package keeper import ( + "cosmossdk.io/errors" "cosmossdk.io/x/nft" + sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) // BatchMint defines a method for minting a batch of nfts @@ -14,11 +15,11 @@ func (k Keeper) BatchMint(ctx sdk.Context, checked := make(map[string]bool, len(tokens)) for _, token := range tokens { if !checked[token.ClassId] && !k.HasClass(ctx, token.ClassId) { - return sdkerrors.Wrap(nft.ErrClassNotExists, token.ClassId) + return errors.Wrap(nft.ErrClassNotExists, token.ClassId) } if k.HasNFT(ctx, token.ClassId, token.Id) { - return sdkerrors.Wrap(nft.ErrNFTExists, token.Id) + return errors.Wrap(nft.ErrNFTExists, token.Id) } checked[token.ClassId] = true @@ -31,11 +32,11 @@ func (k Keeper) BatchMint(ctx sdk.Context, // Note: When the upper module uses this method, it needs to authenticate nft func (k Keeper) BatchBurn(ctx sdk.Context, classID string, nftIDs []string) error { if !k.HasClass(ctx, classID) { - return sdkerrors.Wrap(nft.ErrClassNotExists, classID) + return errors.Wrap(nft.ErrClassNotExists, classID) } for _, nftID := range nftIDs { if !k.HasNFT(ctx, classID, nftID) { - return sdkerrors.Wrap(nft.ErrNFTNotExists, nftID) + return errors.Wrap(nft.ErrNFTNotExists, nftID) } if err := k.burnWithNoCheck(ctx, classID, nftID); err != nil { return err @@ -50,11 +51,11 @@ func (k Keeper) BatchUpdate(ctx sdk.Context, tokens []nft.NFT) error { checked := make(map[string]bool, len(tokens)) for _, token := range tokens { if !checked[token.ClassId] && !k.HasClass(ctx, token.ClassId) { - return sdkerrors.Wrap(nft.ErrClassNotExists, token.ClassId) + return errors.Wrap(nft.ErrClassNotExists, token.ClassId) } if !k.HasNFT(ctx, token.ClassId, token.Id) { - return sdkerrors.Wrap(nft.ErrNFTNotExists, token.Id) + return errors.Wrap(nft.ErrNFTNotExists, token.Id) } checked[token.ClassId] = true k.updateWithNoCheck(ctx, token) @@ -70,14 +71,14 @@ func (k Keeper) BatchTransfer(ctx sdk.Context, receiver sdk.AccAddress, ) error { if !k.HasClass(ctx, classID) { - return sdkerrors.Wrap(nft.ErrClassNotExists, classID) + return errors.Wrap(nft.ErrClassNotExists, classID) } for _, nftID := range nftIDs { if !k.HasNFT(ctx, classID, nftID) { - return sdkerrors.Wrap(nft.ErrNFTNotExists, nftID) + return errors.Wrap(nft.ErrNFTNotExists, nftID) } if err := k.transferWithNoCheck(ctx, classID, nftID, receiver); err != nil { - return sdkerrors.Wrap(nft.ErrNFTNotExists, nftID) + return errors.Wrap(nft.ErrNFTNotExists, nftID) } } return nil diff --git a/x/nft/module/module.go b/x/nft/module/module.go index 4b1ab86b13..c3b14941e4 100644 --- a/x/nft/module/module.go +++ b/x/nft/module/module.go @@ -10,14 +10,13 @@ import ( "cosmossdk.io/core/appmodule" "cosmossdk.io/depinject" - + "cosmossdk.io/errors" store "cosmossdk.io/store/types" sdkclient "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/codec" cdctypes "github.com/cosmos/cosmos-sdk/codec/types" sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/types/module" simtypes "github.com/cosmos/cosmos-sdk/types/simulation" @@ -70,7 +69,7 @@ func (AppModuleBasic) DefaultGenesis(cdc codec.JSONCodec) json.RawMessage { func (AppModuleBasic) ValidateGenesis(cdc codec.JSONCodec, config sdkclient.TxEncodingConfig, bz json.RawMessage) error { var data nft.GenesisState if err := cdc.UnmarshalJSON(bz, &data); err != nil { - return sdkerrors.Wrapf(err, "failed to unmarshal %s genesis state", nft.ModuleName) + return errors.Wrapf(err, "failed to unmarshal %s genesis state", nft.ModuleName) } return nft.ValidateGenesis(data) diff --git a/x/nft/msgs.go b/x/nft/msgs.go index 0fdbd87495..c15b99cd8e 100644 --- a/x/nft/msgs.go +++ b/x/nft/msgs.go @@ -1,7 +1,7 @@ package nft import ( - "cosmossdk.io/errors" + errorsmod "cosmossdk.io/errors" sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" @@ -26,12 +26,12 @@ func (m MsgSend) ValidateBasic() error { _, err := sdk.AccAddressFromBech32(m.Sender) if err != nil { - return errors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid sender address (%s)", m.Sender) + return errorsmod.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid sender address (%s)", m.Sender) } _, err = sdk.AccAddressFromBech32(m.Receiver) if err != nil { - return errors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid receiver address (%s)", m.Receiver) + return errorsmod.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid receiver address (%s)", m.Receiver) } return nil } diff --git a/x/params/keeper/grpc_query.go b/x/params/keeper/grpc_query.go index 48fd9ec686..54d1c33a17 100644 --- a/x/params/keeper/grpc_query.go +++ b/x/params/keeper/grpc_query.go @@ -6,8 +6,9 @@ import ( "google.golang.org/grpc/codes" "google.golang.org/grpc/status" + "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/params/types/proposal" ) @@ -25,7 +26,7 @@ func (k Keeper) Params(c context.Context, req *proposal.QueryParamsRequest) (*pr ss, ok := k.GetSubspace(req.Subspace) if !ok { - return nil, sdkerrors.Wrap(proposal.ErrUnknownSubspace, req.Subspace) + return nil, errors.Wrap(proposal.ErrUnknownSubspace, req.Subspace) } ctx := sdk.UnwrapSDKContext(c) diff --git a/x/params/keeper/keeper_test.go b/x/params/keeper/keeper_test.go index 83d27cf255..e9863c7c5e 100644 --- a/x/params/keeper/keeper_test.go +++ b/x/params/keeper/keeper_test.go @@ -192,9 +192,9 @@ func TestSubspace(t *testing.T) { {"uint16", uint16(1), uint16(0), new(uint16)}, {"uint32", uint32(1), uint32(0), new(uint32)}, {"uint64", uint64(1), uint64(0), new(uint64)}, - {"int", sdk.NewInt(1), math.Int{}, new(math.Int)}, - {"uint", sdk.NewUint(1), sdk.Uint{}, new(sdk.Uint)}, - {"dec", math.LegacyNewDec(1), sdk.Dec{}, new(sdk.Dec)}, + {"int", math.NewInt(1), math.Int{}, new(math.Int)}, + {"uint", math.NewUint(1), math.Uint{}, new(math.Uint)}, + {"dec", math.LegacyNewDec(1), math.LegacyDec{}, new(math.LegacyDec)}, {"struct", s{1}, s{0}, new(s)}, } @@ -208,7 +208,7 @@ func TestSubspace(t *testing.T) { types.NewParamSetPair([]byte("uint32"), uint32(0), validateNoOp), types.NewParamSetPair([]byte("uint64"), uint64(0), validateNoOp), types.NewParamSetPair([]byte("int"), math.Int{}, validateNoOp), - types.NewParamSetPair([]byte("uint"), sdk.Uint{}, validateNoOp), + types.NewParamSetPair([]byte("uint"), math.Uint{}, validateNoOp), types.NewParamSetPair([]byte("dec"), sdk.Dec{}, validateNoOp), types.NewParamSetPair([]byte("struct"), s{}, validateNoOp), ) diff --git a/x/params/proposal_handler.go b/x/params/proposal_handler.go index a5c0166e43..cc24dd0109 100644 --- a/x/params/proposal_handler.go +++ b/x/params/proposal_handler.go @@ -3,6 +3,8 @@ package params import ( "fmt" + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" govtypes "github.com/cosmos/cosmos-sdk/x/gov/types/v1beta1" @@ -18,7 +20,7 @@ func NewParamChangeProposalHandler(k keeper.Keeper) govtypes.Handler { return handleParameterChangeProposal(ctx, k, c) default: - return sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "unrecognized param proposal content type: %T", c) + return errorsmod.Wrapf(sdkerrors.ErrUnknownRequest, "unrecognized param proposal content type: %T", c) } } } @@ -27,7 +29,7 @@ func handleParameterChangeProposal(ctx sdk.Context, k keeper.Keeper, p *proposal for _, c := range p.Changes { ss, ok := k.GetSubspace(c.Subspace) if !ok { - return sdkerrors.Wrap(proposal.ErrUnknownSubspace, c.Subspace) + return errorsmod.Wrap(proposal.ErrUnknownSubspace, c.Subspace) } k.Logger(ctx).Info( @@ -35,7 +37,7 @@ func handleParameterChangeProposal(ctx sdk.Context, k keeper.Keeper, p *proposal ) if err := ss.Update(ctx, []byte(c.Key), []byte(c.Value)); err != nil { - return sdkerrors.Wrapf(proposal.ErrSettingParameter, "key: %s, value: %s, err: %s", c.Key, c.Value, err.Error()) + return errorsmod.Wrapf(proposal.ErrSettingParameter, "key: %s, value: %s, err: %s", c.Key, c.Value, err.Error()) } } diff --git a/x/params/types/proposal/errors.go b/x/params/types/proposal/errors.go index a8c891af2c..880864b844 100644 --- a/x/params/types/proposal/errors.go +++ b/x/params/types/proposal/errors.go @@ -1,15 +1,13 @@ package proposal -import ( - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" -) +import "cosmossdk.io/errors" // x/params module sentinel errors var ( - ErrUnknownSubspace = sdkerrors.Register(ModuleName, 2, "unknown subspace") - ErrSettingParameter = sdkerrors.Register(ModuleName, 3, "failed to set parameter") - ErrEmptyChanges = sdkerrors.Register(ModuleName, 4, "submitted parameter changes are empty") - ErrEmptySubspace = sdkerrors.Register(ModuleName, 5, "parameter subspace is empty") - ErrEmptyKey = sdkerrors.Register(ModuleName, 6, "parameter key is empty") - ErrEmptyValue = sdkerrors.Register(ModuleName, 7, "parameter value is empty") + ErrUnknownSubspace = errors.Register(ModuleName, 2, "unknown subspace") + ErrSettingParameter = errors.Register(ModuleName, 3, "failed to set parameter") + ErrEmptyChanges = errors.Register(ModuleName, 4, "submitted parameter changes are empty") + ErrEmptySubspace = errors.Register(ModuleName, 5, "parameter subspace is empty") + ErrEmptyKey = errors.Register(ModuleName, 6, "parameter key is empty") + ErrEmptyValue = errors.Register(ModuleName, 7, "parameter value is empty") ) diff --git a/x/slashing/keeper/msg_server.go b/x/slashing/keeper/msg_server.go index d3852d30b6..d671e578fb 100644 --- a/x/slashing/keeper/msg_server.go +++ b/x/slashing/keeper/msg_server.go @@ -3,8 +3,9 @@ package keeper import ( "context" + "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/types/errors" govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" "github.com/cosmos/cosmos-sdk/x/slashing/types" ) diff --git a/x/slashing/keeper/unjail.go b/x/slashing/keeper/unjail.go index 23a9121e54..d34cf719de 100644 --- a/x/slashing/keeper/unjail.go +++ b/x/slashing/keeper/unjail.go @@ -1,8 +1,9 @@ package keeper import ( + "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/slashing/types" ) @@ -23,7 +24,7 @@ func (k Keeper) Unjail(ctx sdk.Context, validatorAddr sdk.ValAddress) error { tokens := validator.TokensFromShares(selfDel.GetShares()).TruncateInt() minSelfBond := validator.GetMinSelfDelegation() if tokens.LT(minSelfBond) { - return sdkerrors.Wrapf( + return errors.Wrapf( types.ErrSelfDelegationTooLowToUnjail, "%s less than %s", tokens, minSelfBond, ) } diff --git a/x/slashing/types/errors.go b/x/slashing/types/errors.go index daff6ecc04..8e71077988 100644 --- a/x/slashing/types/errors.go +++ b/x/slashing/types/errors.go @@ -1,16 +1,14 @@ package types -import ( - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" -) +import "cosmossdk.io/errors" // x/slashing module sentinel errors var ( - ErrNoValidatorForAddress = sdkerrors.Register(ModuleName, 2, "address is not associated with any known validator") - ErrBadValidatorAddr = sdkerrors.Register(ModuleName, 3, "validator does not exist for that address") - ErrValidatorJailed = sdkerrors.Register(ModuleName, 4, "validator still jailed; cannot be unjailed") - ErrValidatorNotJailed = sdkerrors.Register(ModuleName, 5, "validator not jailed; cannot be unjailed") - ErrMissingSelfDelegation = sdkerrors.Register(ModuleName, 6, "validator has no self-delegation; cannot be unjailed") - ErrSelfDelegationTooLowToUnjail = sdkerrors.Register(ModuleName, 7, "validator's self delegation less than minimum; cannot be unjailed") - ErrNoSigningInfoFound = sdkerrors.Register(ModuleName, 8, "no validator signing info found") + ErrNoValidatorForAddress = errors.Register(ModuleName, 2, "address is not associated with any known validator") + ErrBadValidatorAddr = errors.Register(ModuleName, 3, "validator does not exist for that address") + ErrValidatorJailed = errors.Register(ModuleName, 4, "validator still jailed; cannot be unjailed") + ErrValidatorNotJailed = errors.Register(ModuleName, 5, "validator not jailed; cannot be unjailed") + ErrMissingSelfDelegation = errors.Register(ModuleName, 6, "validator has no self-delegation; cannot be unjailed") + ErrSelfDelegationTooLowToUnjail = errors.Register(ModuleName, 7, "validator's self delegation less than minimum; cannot be unjailed") + ErrNoSigningInfoFound = errors.Register(ModuleName, 8, "no validator signing info found") ) diff --git a/x/slashing/types/msg.go b/x/slashing/types/msg.go index df9178fd3d..416e9b3077 100644 --- a/x/slashing/types/msg.go +++ b/x/slashing/types/msg.go @@ -1,6 +1,8 @@ package types import ( + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/auth/migrations/legacytx" @@ -58,7 +60,7 @@ func (msg MsgUpdateParams) GetSigners() []sdk.AccAddress { // ValidateBasic does a sanity check on the provided data. func (msg MsgUpdateParams) ValidateBasic() error { if _, err := sdk.AccAddressFromBech32(msg.Authority); err != nil { - return sdkerrors.Wrap(err, "invalid authority address") + return errorsmod.Wrap(err, "invalid authority address") } if err := msg.Params.Validate(); err != nil { diff --git a/x/staking/client/cli/tx.go b/x/staking/client/cli/tx.go index b70b0b1207..258a6c248f 100644 --- a/x/staking/client/cli/tx.go +++ b/x/staking/client/cli/tx.go @@ -11,6 +11,8 @@ import ( "github.com/spf13/cobra" flag "github.com/spf13/pflag" + errorsmod "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/client" "github.com/cosmos/cosmos-sdk/client/flags" "github.com/cosmos/cosmos-sdk/client/tx" @@ -129,7 +131,7 @@ func NewEditValidatorCmd() *cobra.Command { if minSelfDelegationString != "" { msb, ok := sdk.NewIntFromString(minSelfDelegationString) if !ok { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "minimum self delegation must be a positive integer") + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "minimum self delegation must be a positive integer") } newMinSelfDelegation = &msb @@ -323,7 +325,7 @@ $ %s tx staking cancel-unbond %s1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj 100stake creationHeight, err := strconv.ParseInt(args[2], 10, 64) if err != nil { - return sdkerrors.Wrap(fmt.Errorf("invalid height: %d", creationHeight), "invalid height") + return errorsmod.Wrap(fmt.Errorf("invalid height: %d", creationHeight), "invalid height") } msg := types.NewMsgCancelUnbondingDelegation(delAddr, valAddr, creationHeight, amount) @@ -383,7 +385,7 @@ func newBuildCreateValidatorMsg(clientCtx client.Context, txf tx.Factory, fs *fl minSelfDelegation, ok := sdk.NewIntFromString(msbStr) if !ok { - return txf, nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "minimum self delegation must be a positive integer") + return txf, nil, errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "minimum self delegation must be a positive integer") } msg, err := types.NewMsgCreateValidator( @@ -592,7 +594,7 @@ func BuildCreateValidatorMsg(clientCtx client.Context, config TxCreateValidatorC minSelfDelegation, ok := sdk.NewIntFromString(msbStr) if !ok { - return txBldr, nil, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "minimum self delegation must be a positive integer") + return txBldr, nil, errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "minimum self delegation must be a positive integer") } msg, err := types.NewMsgCreateValidator( diff --git a/x/staking/keeper/delegation.go b/x/staking/keeper/delegation.go index 50d81b8e31..5093688b5b 100644 --- a/x/staking/keeper/delegation.go +++ b/x/staking/keeper/delegation.go @@ -8,6 +8,8 @@ import ( "cosmossdk.io/math" storetypes "cosmossdk.io/store/types" + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/staking/types" @@ -731,7 +733,7 @@ func (k Keeper) Unbond( // ensure that we have enough shares to remove if delegation.Shares.LT(shares) { - return amount, sdkerrors.Wrap(types.ErrNotEnoughDelegationShares, delegation.Shares.String()) + return amount, errorsmod.Wrap(types.ErrNotEnoughDelegationShares, delegation.Shares.String()) } // get validator @@ -1018,7 +1020,7 @@ func (k Keeper) ValidateUnbondAmount( delShares := del.GetShares() if sharesTruncated.GT(delShares) { - return shares, sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "invalid shares amount") + return shares, errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "invalid shares amount") } // Cap the shares at the delegation's shares. Shares being greater could occur diff --git a/x/staking/keeper/delegation_test.go b/x/staking/keeper/delegation_test.go index de31f3312d..7a747aceaf 100644 --- a/x/staking/keeper/delegation_test.go +++ b/x/staking/keeper/delegation_test.go @@ -301,7 +301,7 @@ func (s *KeeperTestSuite) TestUndelegateFromUnbondingValidator() { validator, issuedShares = validator.AddTokensFromDel(delTokens) require.Equal(delTokens, issuedShares.RoundInt()) - validator = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true) + stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true) delegation := stakingtypes.NewDelegation(addrDels[1], addrVals[0], issuedShares) keeper.SetDelegation(ctx, delegation) @@ -690,7 +690,7 @@ func (s *KeeperTestSuite) TestRedelegateSelfDelegation() { delTokens := keeper.TokensFromConsensusPower(ctx, 10) validator, issuedShares = validator.AddTokensFromDel(delTokens) require.Equal(delTokens, issuedShares.RoundInt()) - validator = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true) + stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true) delegation := stakingtypes.NewDelegation(addrDels[0], addrVals[0], issuedShares) keeper.SetDelegation(ctx, delegation) @@ -732,7 +732,7 @@ func (s *KeeperTestSuite) TestRedelegateFromUnbondingValidator() { delTokens := keeper.TokensFromConsensusPower(ctx, 10) validator, issuedShares = validator.AddTokensFromDel(delTokens) require.Equal(delTokens, issuedShares.RoundInt()) - validator = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true) + stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true) delegation := stakingtypes.NewDelegation(addrDels[1], addrVals[0], issuedShares) keeper.SetDelegation(ctx, delegation) @@ -812,7 +812,7 @@ func (s *KeeperTestSuite) TestRedelegateFromUnbondedValidator() { delTokens := keeper.TokensFromConsensusPower(ctx, 10) validator, issuedShares = validator.AddTokensFromDel(delTokens) require.Equal(delTokens, issuedShares.RoundInt()) - validator = stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true) + stakingkeeper.TestingUpdateValidator(keeper, ctx, validator, true) delegation := stakingtypes.NewDelegation(addrDels[1], addrVals[0], issuedShares) keeper.SetDelegation(ctx, delegation) diff --git a/x/staking/keeper/msg_server.go b/x/staking/keeper/msg_server.go index 21cd788d45..9d7113113f 100644 --- a/x/staking/keeper/msg_server.go +++ b/x/staking/keeper/msg_server.go @@ -9,6 +9,8 @@ import ( "google.golang.org/grpc/codes" "google.golang.org/grpc/status" + errorsmod "cosmossdk.io/errors" + cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" "github.com/cosmos/cosmos-sdk/telemetry" sdk "github.com/cosmos/cosmos-sdk/types" @@ -39,7 +41,7 @@ func (k msgServer) CreateValidator(goCtx context.Context, msg *types.MsgCreateVa } if msg.Commission.Rate.LT(k.MinCommissionRate(ctx)) { - return nil, sdkerrors.Wrapf(types.ErrCommissionLTMinRate, "cannot set validator commission to less than minimum rate of %s", k.MinCommissionRate(ctx)) + return nil, errorsmod.Wrapf(types.ErrCommissionLTMinRate, "cannot set validator commission to less than minimum rate of %s", k.MinCommissionRate(ctx)) } // check to see if the pubkey or sender has been registered before @@ -49,7 +51,7 @@ func (k msgServer) CreateValidator(goCtx context.Context, msg *types.MsgCreateVa pk, ok := msg.Pubkey.GetCachedValue().(cryptotypes.PubKey) if !ok { - return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidType, "Expecting cryptotypes.PubKey, got %T", pk) + return nil, errorsmod.Wrapf(sdkerrors.ErrInvalidType, "Expecting cryptotypes.PubKey, got %T", pk) } if _, found := k.GetValidatorByConsAddr(ctx, sdk.GetConsAddress(pk)); found { @@ -58,7 +60,7 @@ func (k msgServer) CreateValidator(goCtx context.Context, msg *types.MsgCreateVa bondDenom := k.BondDenom(ctx) if msg.Value.Denom != bondDenom { - return nil, sdkerrors.Wrapf( + return nil, errorsmod.Wrapf( sdkerrors.ErrInvalidRequest, "invalid coin denomination: got %s, expected %s", msg.Value.Denom, bondDenom, ) } @@ -78,7 +80,7 @@ func (k msgServer) CreateValidator(goCtx context.Context, msg *types.MsgCreateVa } } if !hasKeyType { - return nil, sdkerrors.Wrapf( + return nil, errorsmod.Wrapf( types.ErrValidatorPubKeyTypeNotSupported, "got: %s, expected: %s", pk.Type(), cp.Validator.PubKeyTypes, ) @@ -210,7 +212,7 @@ func (k msgServer) Delegate(goCtx context.Context, msg *types.MsgDelegate) (*typ bondDenom := k.BondDenom(ctx) if msg.Amount.Denom != bondDenom { - return nil, sdkerrors.Wrapf( + return nil, errorsmod.Wrapf( sdkerrors.ErrInvalidRequest, "invalid coin denomination: got %s, expected %s", msg.Amount.Denom, bondDenom, ) } @@ -264,7 +266,7 @@ func (k msgServer) BeginRedelegate(goCtx context.Context, msg *types.MsgBeginRed bondDenom := k.BondDenom(ctx) if msg.Amount.Denom != bondDenom { - return nil, sdkerrors.Wrapf( + return nil, errorsmod.Wrapf( sdkerrors.ErrInvalidRequest, "invalid coin denomination: got %s, expected %s", msg.Amount.Denom, bondDenom, ) } @@ -328,7 +330,7 @@ func (k msgServer) Undelegate(goCtx context.Context, msg *types.MsgUndelegate) ( bondDenom := k.BondDenom(ctx) if msg.Amount.Denom != bondDenom { - return nil, sdkerrors.Wrapf( + return nil, errorsmod.Wrapf( sdkerrors.ErrInvalidRequest, "invalid coin denomination: got %s, expected %s", msg.Amount.Denom, bondDenom, ) } @@ -383,7 +385,7 @@ func (k msgServer) CancelUnbondingDelegation(goCtx context.Context, msg *types.M bondDenom := k.BondDenom(ctx) if msg.Amount.Denom != bondDenom { - return nil, sdkerrors.Wrapf( + return nil, errorsmod.Wrapf( sdkerrors.ErrInvalidRequest, "invalid coin denomination: got %s, expected %s", msg.Amount.Denom, bondDenom, ) } @@ -477,7 +479,7 @@ func (k msgServer) UpdateParams(goCtx context.Context, msg *types.MsgUpdateParam ctx := sdk.UnwrapSDKContext(goCtx) if k.authority != msg.Authority { - return nil, sdkerrors.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", k.authority, msg.Authority) + return nil, errorsmod.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", k.authority, msg.Authority) } // store params diff --git a/x/staking/keeper/unbonding.go b/x/staking/keeper/unbonding.go index 122ca4ef83..c1e8a9443f 100644 --- a/x/staking/keeper/unbonding.go +++ b/x/staking/keeper/unbonding.go @@ -3,8 +3,9 @@ package keeper import ( "encoding/binary" + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/staking/types" ) @@ -248,7 +249,7 @@ func (k Keeper) unbondingDelegationEntryCanComplete(ctx sdk.Context, id uint64) // The entry must be on hold if !ubd.Entries[i].OnHold() { - return sdkerrors.Wrapf( + return errorsmod.Wrapf( types.ErrUnbondingOnHoldRefCountNegative, "undelegation unbondingID(%d), expecting UnbondingOnHoldRefCount > 0, got %T", id, ubd.Entries[i].UnbondingOnHoldRefCount, @@ -306,7 +307,7 @@ func (k Keeper) redelegationEntryCanComplete(ctx sdk.Context, id uint64) error { // The entry must be on hold if !red.Entries[i].OnHold() { - return sdkerrors.Wrapf( + return errorsmod.Wrapf( types.ErrUnbondingOnHoldRefCountNegative, "redelegation unbondingID(%d), expecting UnbondingOnHoldRefCount > 0, got %T", id, red.Entries[i].UnbondingOnHoldRefCount, @@ -340,7 +341,7 @@ func (k Keeper) validatorUnbondingCanComplete(ctx sdk.Context, id uint64) error } if val.UnbondingOnHoldRefCount <= 0 { - return sdkerrors.Wrapf( + return errorsmod.Wrapf( types.ErrUnbondingOnHoldRefCountNegative, "val(%s), expecting UnbondingOnHoldRefCount > 0, got %T", val.OperatorAddress, val.UnbondingOnHoldRefCount, diff --git a/x/staking/types/authz.go b/x/staking/types/authz.go index 1f9016cdbb..ba5103acd4 100644 --- a/x/staking/types/authz.go +++ b/x/staking/types/authz.go @@ -1,6 +1,8 @@ package types import ( + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/authz" @@ -45,7 +47,7 @@ func (a StakeAuthorization) MsgTypeURL() string { func (a StakeAuthorization) ValidateBasic() error { if a.MaxTokens != nil && a.MaxTokens.IsNegative() { - return sdkerrors.Wrapf(authz.ErrNegativeMaxTokens, "negative coin amount: %v", a.MaxTokens) + return errorsmod.Wrapf(authz.ErrNegativeMaxTokens, "negative coin amount: %v", a.MaxTokens) } if a.AuthorizationType == AuthorizationType_AUTHORIZATION_TYPE_UNSPECIFIED { return authz.ErrUnknownAuthorizationType @@ -150,6 +152,6 @@ func normalizeAuthzType(authzType AuthorizationType) (string, error) { case AuthorizationType_AUTHORIZATION_TYPE_REDELEGATE: return sdk.MsgTypeURL(&MsgBeginRedelegate{}), nil default: - return "", sdkerrors.Wrapf(authz.ErrUnknownAuthorizationType, "cannot normalize authz type with %T", authzType) + return "", errorsmod.Wrapf(authz.ErrUnknownAuthorizationType, "cannot normalize authz type with %T", authzType) } } diff --git a/x/staking/types/errors.go b/x/staking/types/errors.go index 5cf482984d..ee1750c223 100644 --- a/x/staking/types/errors.go +++ b/x/staking/types/errors.go @@ -1,8 +1,6 @@ package types -import ( - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" -) +import "cosmossdk.io/errors" // x/staking module sentinel errors // @@ -11,45 +9,45 @@ import ( // // REF: https://github.com/cosmos/cosmos-sdk/issues/5450 var ( - ErrEmptyValidatorAddr = sdkerrors.Register(ModuleName, 2, "empty validator address") - ErrNoValidatorFound = sdkerrors.Register(ModuleName, 3, "validator does not exist") - ErrValidatorOwnerExists = sdkerrors.Register(ModuleName, 4, "validator already exist for this operator address; must use new validator operator address") - ErrValidatorPubKeyExists = sdkerrors.Register(ModuleName, 5, "validator already exist for this pubkey; must use new validator pubkey") - ErrValidatorPubKeyTypeNotSupported = sdkerrors.Register(ModuleName, 6, "validator pubkey type is not supported") - ErrValidatorJailed = sdkerrors.Register(ModuleName, 7, "validator for this address is currently jailed") - ErrBadRemoveValidator = sdkerrors.Register(ModuleName, 8, "failed to remove validator") - ErrCommissionNegative = sdkerrors.Register(ModuleName, 9, "commission must be positive") - ErrCommissionHuge = sdkerrors.Register(ModuleName, 10, "commission cannot be more than 100%") - ErrCommissionGTMaxRate = sdkerrors.Register(ModuleName, 11, "commission cannot be more than the max rate") - ErrCommissionUpdateTime = sdkerrors.Register(ModuleName, 12, "commission cannot be changed more than once in 24h") - ErrCommissionChangeRateNegative = sdkerrors.Register(ModuleName, 13, "commission change rate must be positive") - ErrCommissionChangeRateGTMaxRate = sdkerrors.Register(ModuleName, 14, "commission change rate cannot be more than the max rate") - ErrCommissionGTMaxChangeRate = sdkerrors.Register(ModuleName, 15, "commission cannot be changed more than max change rate") - ErrSelfDelegationBelowMinimum = sdkerrors.Register(ModuleName, 16, "validator's self delegation must be greater than their minimum self delegation") - ErrMinSelfDelegationDecreased = sdkerrors.Register(ModuleName, 17, "minimum self delegation cannot be decrease") - ErrEmptyDelegatorAddr = sdkerrors.Register(ModuleName, 18, "empty delegator address") - ErrNoDelegation = sdkerrors.Register(ModuleName, 19, "no delegation for (address, validator) tuple") - ErrBadDelegatorAddr = sdkerrors.Register(ModuleName, 20, "delegator does not exist with address") - ErrNoDelegatorForAddress = sdkerrors.Register(ModuleName, 21, "delegator does not contain delegation") - ErrInsufficientShares = sdkerrors.Register(ModuleName, 22, "insufficient delegation shares") - ErrDelegationValidatorEmpty = sdkerrors.Register(ModuleName, 23, "cannot delegate to an empty validator") - ErrNotEnoughDelegationShares = sdkerrors.Register(ModuleName, 24, "not enough delegation shares") - ErrNotMature = sdkerrors.Register(ModuleName, 25, "entry not mature") - ErrNoUnbondingDelegation = sdkerrors.Register(ModuleName, 26, "no unbonding delegation found") - ErrMaxUnbondingDelegationEntries = sdkerrors.Register(ModuleName, 27, "too many unbonding delegation entries for (delegator, validator) tuple") - ErrNoRedelegation = sdkerrors.Register(ModuleName, 28, "no redelegation found") - ErrSelfRedelegation = sdkerrors.Register(ModuleName, 29, "cannot redelegate to the same validator") - ErrTinyRedelegationAmount = sdkerrors.Register(ModuleName, 30, "too few tokens to redelegate (truncates to zero tokens)") - ErrBadRedelegationDst = sdkerrors.Register(ModuleName, 31, "redelegation destination validator not found") - ErrTransitiveRedelegation = sdkerrors.Register(ModuleName, 32, "redelegation to this validator already in progress; first redelegation to this validator must complete before next redelegation") - ErrMaxRedelegationEntries = sdkerrors.Register(ModuleName, 33, "too many redelegation entries for (delegator, src-validator, dst-validator) tuple") - ErrDelegatorShareExRateInvalid = sdkerrors.Register(ModuleName, 34, "cannot delegate to validators with invalid (zero) ex-rate") - ErrBothShareMsgsGiven = sdkerrors.Register(ModuleName, 35, "both shares amount and shares percent provided") - ErrNeitherShareMsgsGiven = sdkerrors.Register(ModuleName, 36, "neither shares amount nor shares percent provided") - ErrInvalidHistoricalInfo = sdkerrors.Register(ModuleName, 37, "invalid historical info") - ErrNoHistoricalInfo = sdkerrors.Register(ModuleName, 38, "no historical info found") - ErrEmptyValidatorPubKey = sdkerrors.Register(ModuleName, 39, "empty validator public key") - ErrCommissionLTMinRate = sdkerrors.Register(ModuleName, 40, "commission cannot be less than min rate") - ErrUnbondingNotFound = sdkerrors.Register(ModuleName, 41, "unbonding operation not found") - ErrUnbondingOnHoldRefCountNegative = sdkerrors.Register(ModuleName, 42, "cannot un-hold unbonding operation that is not on hold") + ErrEmptyValidatorAddr = errors.Register(ModuleName, 2, "empty validator address") + ErrNoValidatorFound = errors.Register(ModuleName, 3, "validator does not exist") + ErrValidatorOwnerExists = errors.Register(ModuleName, 4, "validator already exist for this operator address; must use new validator operator address") + ErrValidatorPubKeyExists = errors.Register(ModuleName, 5, "validator already exist for this pubkey; must use new validator pubkey") + ErrValidatorPubKeyTypeNotSupported = errors.Register(ModuleName, 6, "validator pubkey type is not supported") + ErrValidatorJailed = errors.Register(ModuleName, 7, "validator for this address is currently jailed") + ErrBadRemoveValidator = errors.Register(ModuleName, 8, "failed to remove validator") + ErrCommissionNegative = errors.Register(ModuleName, 9, "commission must be positive") + ErrCommissionHuge = errors.Register(ModuleName, 10, "commission cannot be more than 100%") + ErrCommissionGTMaxRate = errors.Register(ModuleName, 11, "commission cannot be more than the max rate") + ErrCommissionUpdateTime = errors.Register(ModuleName, 12, "commission cannot be changed more than once in 24h") + ErrCommissionChangeRateNegative = errors.Register(ModuleName, 13, "commission change rate must be positive") + ErrCommissionChangeRateGTMaxRate = errors.Register(ModuleName, 14, "commission change rate cannot be more than the max rate") + ErrCommissionGTMaxChangeRate = errors.Register(ModuleName, 15, "commission cannot be changed more than max change rate") + ErrSelfDelegationBelowMinimum = errors.Register(ModuleName, 16, "validator's self delegation must be greater than their minimum self delegation") + ErrMinSelfDelegationDecreased = errors.Register(ModuleName, 17, "minimum self delegation cannot be decrease") + ErrEmptyDelegatorAddr = errors.Register(ModuleName, 18, "empty delegator address") + ErrNoDelegation = errors.Register(ModuleName, 19, "no delegation for (address, validator) tuple") + ErrBadDelegatorAddr = errors.Register(ModuleName, 20, "delegator does not exist with address") + ErrNoDelegatorForAddress = errors.Register(ModuleName, 21, "delegator does not contain delegation") + ErrInsufficientShares = errors.Register(ModuleName, 22, "insufficient delegation shares") + ErrDelegationValidatorEmpty = errors.Register(ModuleName, 23, "cannot delegate to an empty validator") + ErrNotEnoughDelegationShares = errors.Register(ModuleName, 24, "not enough delegation shares") + ErrNotMature = errors.Register(ModuleName, 25, "entry not mature") + ErrNoUnbondingDelegation = errors.Register(ModuleName, 26, "no unbonding delegation found") + ErrMaxUnbondingDelegationEntries = errors.Register(ModuleName, 27, "too many unbonding delegation entries for (delegator, validator) tuple") + ErrNoRedelegation = errors.Register(ModuleName, 28, "no redelegation found") + ErrSelfRedelegation = errors.Register(ModuleName, 29, "cannot redelegate to the same validator") + ErrTinyRedelegationAmount = errors.Register(ModuleName, 30, "too few tokens to redelegate (truncates to zero tokens)") + ErrBadRedelegationDst = errors.Register(ModuleName, 31, "redelegation destination validator not found") + ErrTransitiveRedelegation = errors.Register(ModuleName, 32, "redelegation to this validator already in progress; first redelegation to this validator must complete before next redelegation") + ErrMaxRedelegationEntries = errors.Register(ModuleName, 33, "too many redelegation entries for (delegator, src-validator, dst-validator) tuple") + ErrDelegatorShareExRateInvalid = errors.Register(ModuleName, 34, "cannot delegate to validators with invalid (zero) ex-rate") + ErrBothShareMsgsGiven = errors.Register(ModuleName, 35, "both shares amount and shares percent provided") + ErrNeitherShareMsgsGiven = errors.Register(ModuleName, 36, "neither shares amount nor shares percent provided") + ErrInvalidHistoricalInfo = errors.Register(ModuleName, 37, "invalid historical info") + ErrNoHistoricalInfo = errors.Register(ModuleName, 38, "no historical info found") + ErrEmptyValidatorPubKey = errors.Register(ModuleName, 39, "empty validator public key") + ErrCommissionLTMinRate = errors.Register(ModuleName, 40, "commission cannot be less than min rate") + ErrUnbondingNotFound = errors.Register(ModuleName, 41, "unbonding operation not found") + ErrUnbondingOnHoldRefCountNegative = errors.Register(ModuleName, 42, "cannot un-hold unbonding operation that is not on hold") ) diff --git a/x/staking/types/historical_info.go b/x/staking/types/historical_info.go index 9abebdf866..bfdbf454fa 100644 --- a/x/staking/types/historical_info.go +++ b/x/staking/types/historical_info.go @@ -8,9 +8,10 @@ import ( cmtproto "github.com/cometbft/cometbft/proto/tendermint/types" "github.com/cosmos/gogoproto/proto" + "cosmossdk.io/errors" + "github.com/cosmos/cosmos-sdk/codec" codectypes "github.com/cosmos/cosmos-sdk/codec/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) // NewHistoricalInfo will create a historical information struct from header and valset @@ -46,11 +47,11 @@ func UnmarshalHistoricalInfo(cdc codec.BinaryCodec, value []byte) (hi Historical // ValidateBasic will ensure HistoricalInfo is not nil and sorted func ValidateBasic(hi HistoricalInfo) error { if len(hi.Valset) == 0 { - return sdkerrors.Wrap(ErrInvalidHistoricalInfo, "validator set is empty") + return errors.Wrap(ErrInvalidHistoricalInfo, "validator set is empty") } if !sort.IsSorted(Validators(hi.Valset)) { - return sdkerrors.Wrap(ErrInvalidHistoricalInfo, "validator set is not sorted by address") + return errors.Wrap(ErrInvalidHistoricalInfo, "validator set is not sorted by address") } return nil diff --git a/x/staking/types/msg.go b/x/staking/types/msg.go index 4542f3b821..1cd7767266 100644 --- a/x/staking/types/msg.go +++ b/x/staking/types/msg.go @@ -1,7 +1,9 @@ package types import ( + errorsmod "cosmossdk.io/errors" "cosmossdk.io/math" + codectypes "github.com/cosmos/cosmos-sdk/codec/types" cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types" sdk "github.com/cosmos/cosmos-sdk/types" @@ -82,15 +84,15 @@ func (msg MsgCreateValidator) ValidateBasic() error { } if !msg.Value.IsValid() || !msg.Value.Amount.IsPositive() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "invalid delegation amount") + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "invalid delegation amount") } if msg.Description == (Description{}) { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "empty description") + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "empty description") } if msg.Commission == (CommissionRates{}) { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "empty commission") + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "empty commission") } if err := msg.Commission.Validate(); err != nil { @@ -98,7 +100,7 @@ func (msg MsgCreateValidator) ValidateBasic() error { } if !msg.MinSelfDelegation.IsPositive() { - return sdkerrors.Wrap( + return errorsmod.Wrap( sdkerrors.ErrInvalidRequest, "minimum self delegation must be a positive integer", ) @@ -148,11 +150,11 @@ func (msg MsgEditValidator) ValidateBasic() error { } if msg.Description == (Description{}) { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "empty description") + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "empty description") } if msg.MinSelfDelegation != nil && !msg.MinSelfDelegation.IsPositive() { - return sdkerrors.Wrap( + return errorsmod.Wrap( sdkerrors.ErrInvalidRequest, "minimum self delegation must be a positive integer", ) @@ -160,7 +162,7 @@ func (msg MsgEditValidator) ValidateBasic() error { if msg.CommissionRate != nil { if msg.CommissionRate.GT(math.LegacyOneDec()) || msg.CommissionRate.IsNegative() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "commission rate must be between 0 and 1 (inclusive)") + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "commission rate must be between 0 and 1 (inclusive)") } } @@ -200,7 +202,7 @@ func (msg MsgDelegate) ValidateBasic() error { } if !msg.Amount.IsValid() || !msg.Amount.Amount.IsPositive() { - return sdkerrors.Wrap( + return errorsmod.Wrap( sdkerrors.ErrInvalidRequest, "invalid delegation amount", ) @@ -248,7 +250,7 @@ func (msg MsgBeginRedelegate) ValidateBasic() error { } if !msg.Amount.IsValid() || !msg.Amount.Amount.IsPositive() { - return sdkerrors.Wrap( + return errorsmod.Wrap( sdkerrors.ErrInvalidRequest, "invalid shares amount", ) @@ -290,7 +292,7 @@ func (msg MsgUndelegate) ValidateBasic() error { } if !msg.Amount.IsValid() || !msg.Amount.Amount.IsPositive() { - return sdkerrors.Wrap( + return errorsmod.Wrap( sdkerrors.ErrInvalidRequest, "invalid shares amount", ) @@ -332,14 +334,14 @@ func (msg MsgCancelUnbondingDelegation) ValidateBasic() error { } if !msg.Amount.IsValid() || !msg.Amount.Amount.IsPositive() { - return sdkerrors.Wrap( + return errorsmod.Wrap( sdkerrors.ErrInvalidRequest, "invalid amount", ) } if msg.CreationHeight <= 0 { - return sdkerrors.Wrap( + return errorsmod.Wrap( sdkerrors.ErrInvalidRequest, "invalid height", ) @@ -358,7 +360,7 @@ func (m MsgUpdateParams) GetSignBytes() []byte { // ValidateBasic executes sanity validation on the provided data func (m MsgUpdateParams) ValidateBasic() error { if _, err := sdk.AccAddressFromBech32(m.Authority); err != nil { - return sdkerrors.Wrap(err, "invalid authority address") + return errorsmod.Wrap(err, "invalid authority address") } return m.Params.Validate() } diff --git a/x/staking/types/validator.go b/x/staking/types/validator.go index 9a87595e49..c763998dc7 100644 --- a/x/staking/types/validator.go +++ b/x/staking/types/validator.go @@ -222,23 +222,23 @@ func (d Description) UpdateDescription(d2 Description) (Description, error) { // EnsureLength ensures the length of a validator's description. func (d Description) EnsureLength() (Description, error) { if len(d.Moniker) > MaxMonikerLength { - return d, sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "invalid moniker length; got: %d, max: %d", len(d.Moniker), MaxMonikerLength) + return d, errors.Wrapf(sdkerrors.ErrInvalidRequest, "invalid moniker length; got: %d, max: %d", len(d.Moniker), MaxMonikerLength) } if len(d.Identity) > MaxIdentityLength { - return d, sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "invalid identity length; got: %d, max: %d", len(d.Identity), MaxIdentityLength) + return d, errors.Wrapf(sdkerrors.ErrInvalidRequest, "invalid identity length; got: %d, max: %d", len(d.Identity), MaxIdentityLength) } if len(d.Website) > MaxWebsiteLength { - return d, sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "invalid website length; got: %d, max: %d", len(d.Website), MaxWebsiteLength) + return d, errors.Wrapf(sdkerrors.ErrInvalidRequest, "invalid website length; got: %d, max: %d", len(d.Website), MaxWebsiteLength) } if len(d.SecurityContact) > MaxSecurityContactLength { - return d, sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "invalid security contact length; got: %d, max: %d", len(d.SecurityContact), MaxSecurityContactLength) + return d, errors.Wrapf(sdkerrors.ErrInvalidRequest, "invalid security contact length; got: %d, max: %d", len(d.SecurityContact), MaxSecurityContactLength) } if len(d.Details) > MaxDetailsLength { - return d, sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "invalid details length; got: %d, max: %d", len(d.Details), MaxDetailsLength) + return d, errors.Wrapf(sdkerrors.ErrInvalidRequest, "invalid details length; got: %d, max: %d", len(d.Details), MaxDetailsLength) } return d, nil @@ -492,7 +492,7 @@ func (v Validator) CmtConsPublicKey() (cmtprotocrypto.PublicKey, error) { func (v Validator) GetConsAddr() (sdk.ConsAddress, error) { pk, ok := v.ConsensusPubkey.GetCachedValue().(cryptotypes.PubKey) if !ok { - return nil, sdkerrors.Wrapf(sdkerrors.ErrInvalidType, "expecting cryptotypes.PubKey, got %T", pk) + return nil, errors.Wrapf(sdkerrors.ErrInvalidType, "expecting cryptotypes.PubKey, got %T", pk) } return sdk.ConsAddress(pk.Address()), nil diff --git a/x/tx/textual/coins_test.go b/x/tx/textual/coins_test.go index a4febb3946..96c13a9651 100644 --- a/x/tx/textual/coins_test.go +++ b/x/tx/textual/coins_test.go @@ -66,7 +66,7 @@ func TestCoinsJsonTestcases(t *testing.T) { // set equality using a map. func checkCoinsEqual(t *testing.T, l1, l2 protoreflect.List) { require.Equal(t, l1.Len(), l2.Len()) - var coinsMap = make(map[string]*basev1beta1.Coin, l1.Len()) + coinsMap := make(map[string]*basev1beta1.Coin, l1.Len()) for i := 0; i < l1.Len(); i++ { coin, ok := l1.Get(i).Message().Interface().(*basev1beta1.Coin) diff --git a/x/tx/textual/e2e_test.go b/x/tx/textual/e2e_test.go index 620ca90c63..8d57bcd2eb 100644 --- a/x/tx/textual/e2e_test.go +++ b/x/tx/textual/e2e_test.go @@ -72,7 +72,6 @@ func TestE2EJsonTestcases(t *testing.T) { }) require.NoError(t, err) require.Equal(t, tc.Cbor, hex.EncodeToString(signDoc)) - }) } } diff --git a/x/tx/textual/enum.go b/x/tx/textual/enum.go index 849e74f11e..bfc207024d 100644 --- a/x/tx/textual/enum.go +++ b/x/tx/textual/enum.go @@ -23,7 +23,6 @@ func NewEnumValueRenderer(fd protoreflect.FieldDescriptor) ValueRenderer { var _ ValueRenderer = (*enumValueRenderer)(nil) func (er enumValueRenderer) Format(_ context.Context, v protoreflect.Value) ([]Screen, error) { - // Get the full name of the enum variant. evd := er.ed.Values().ByNumber(v.Enum()) if evd == nil { @@ -31,7 +30,6 @@ func (er enumValueRenderer) Format(_ context.Context, v protoreflect.Value) ([]S } return []Screen{{Content: string(evd.Name())}}, nil - } func (er enumValueRenderer) Parse(_ context.Context, screens []Screen) (protoreflect.Value, error) { diff --git a/x/tx/textual/message.go b/x/tx/textual/message.go index f6e5ed1cd2..f45c8ac7d9 100644 --- a/x/tx/textual/message.go +++ b/x/tx/textual/message.go @@ -242,7 +242,7 @@ func (mr *messageValueRenderer) Parse(ctx context.Context, screens []Screen) (pr } else { err = mr.parseRepeated(ctx, subscreens, nf.List(), vr) - //Skip List Terminator + // Skip List Terminator idx++ } if err != nil { @@ -272,7 +272,6 @@ func (mr *messageValueRenderer) parseRepeated(ctx context.Context, screens []Scr lengthStr := res[0][1] length, err := strconv.Atoi(lengthStr) - if err != nil { return fmt.Errorf("malformed length: %q with error: %w", lengthStr, err) } diff --git a/x/upgrade/go.mod b/x/upgrade/go.mod index a817ee685d..1da4c3d0b7 100644 --- a/x/upgrade/go.mod +++ b/x/upgrade/go.mod @@ -6,6 +6,7 @@ require ( cosmossdk.io/api v0.3.0 cosmossdk.io/core v0.5.1 cosmossdk.io/depinject v1.0.0-alpha.3 + cosmossdk.io/errors v1.0.0-beta.7 cosmossdk.io/store v0.0.0-20230206092147-e03195e4b8a7 github.com/cometbft/cometbft v0.0.0-20230203130311-387422ac220d github.com/cosmos/cosmos-db v1.0.0-rc.1 @@ -31,9 +32,8 @@ require ( cloud.google.com/go/iam v0.11.0 // indirect cloud.google.com/go/storage v1.29.0 // indirect cosmossdk.io/collections v0.0.0-20230204135315-697871069999 // indirect - cosmossdk.io/errors v1.0.0-beta.7 // indirect cosmossdk.io/log v0.0.0-00010101000000-000000000000 // indirect - cosmossdk.io/math v1.0.0-beta.6 // indirect + cosmossdk.io/math v1.0.0-beta.6.0.20230216172121-959ce49135e4 // indirect cosmossdk.io/x/tx v0.2.0 // indirect filippo.io/edwards25519 v1.0.0-rc.1 // indirect github.com/99designs/go-keychain v0.0.0-20191008050251-8e49817e8af4 // indirect diff --git a/x/upgrade/go.sum b/x/upgrade/go.sum index 05fdc9fc78..51be641a8c 100644 --- a/x/upgrade/go.sum +++ b/x/upgrade/go.sum @@ -198,8 +198,8 @@ cosmossdk.io/depinject v1.0.0-alpha.3 h1:6evFIgj//Y3w09bqOUOzEpFj5tsxBqdc5CfkO7z cosmossdk.io/depinject v1.0.0-alpha.3/go.mod h1:eRbcdQ7MRpIPEM5YUJh8k97nxHpYbc3sMUnEtt8HPWU= cosmossdk.io/errors v1.0.0-beta.7 h1:gypHW76pTQGVnHKo6QBkb4yFOJjC+sUGRc5Al3Odj1w= cosmossdk.io/errors v1.0.0-beta.7/go.mod h1:mz6FQMJRku4bY7aqS/Gwfcmr/ue91roMEKAmDUDpBfE= -cosmossdk.io/math v1.0.0-beta.6 h1:WF29SiFYNde5eYvqO2kdOM9nYbDb44j3YW5B8M1m9KE= -cosmossdk.io/math v1.0.0-beta.6/go.mod h1:gUVtWwIzfSXqcOT+lBVz2jyjfua8DoBdzRsIyaUAT/8= +cosmossdk.io/math v1.0.0-beta.6.0.20230216172121-959ce49135e4 h1:/jnzJ9zFsL7qkV8LCQ1JH3dYHh2EsKZ3k8Mr6AqqiOA= +cosmossdk.io/math v1.0.0-beta.6.0.20230216172121-959ce49135e4/go.mod h1:gUVtWwIzfSXqcOT+lBVz2jyjfua8DoBdzRsIyaUAT/8= cosmossdk.io/store v0.0.0-20230206092147-e03195e4b8a7 h1:IwyDN/YaQmF+Pmuv8d7vRWMM/k2RjSmPBycMcmd3ICE= cosmossdk.io/store v0.0.0-20230206092147-e03195e4b8a7/go.mod h1:1XOtuYs7jsfQkn7G3VQXB6I+2tHXKHZw2U/AafNbnlk= cosmossdk.io/x/tx v0.2.0 h1:53f5TIXhpPYJGMm47SUslcV2i8JNBEN3eE08BmxE/Zg= diff --git a/x/upgrade/handler.go b/x/upgrade/handler.go index e43230262b..3c5511c9d8 100644 --- a/x/upgrade/handler.go +++ b/x/upgrade/handler.go @@ -4,6 +4,8 @@ import ( "cosmossdk.io/x/upgrade/keeper" "cosmossdk.io/x/upgrade/types" + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" govtypes "github.com/cosmos/cosmos-sdk/x/gov/types/v1beta1" @@ -24,7 +26,7 @@ func NewSoftwareUpgradeProposalHandler(k *keeper.Keeper) govtypes.Handler { return handleCancelSoftwareUpgradeProposal(ctx, k, c) default: - return sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "unrecognized software upgrade proposal content type: %T", c) + return errorsmod.Wrapf(sdkerrors.ErrUnknownRequest, "unrecognized software upgrade proposal content type: %T", c) } } } diff --git a/x/upgrade/keeper/grpc_query.go b/x/upgrade/keeper/grpc_query.go index b2b2edff87..ba042693d9 100644 --- a/x/upgrade/keeper/grpc_query.go +++ b/x/upgrade/keeper/grpc_query.go @@ -3,6 +3,7 @@ package keeper import ( "context" + errorsmod "cosmossdk.io/errors" "cosmossdk.io/x/upgrade/types" sdk "github.com/cosmos/cosmos-sdk/types" @@ -63,7 +64,7 @@ func (k Keeper) ModuleVersions(c context.Context, req *types.QueryModuleVersions return &types.QueryModuleVersionsResponse{ModuleVersions: res}, nil } // module requested, but not found - return nil, errors.Wrapf(errors.ErrNotFound, "x/upgrade: QueryModuleVersions module %s not found", req.ModuleName) + return nil, errorsmod.Wrapf(errors.ErrNotFound, "x/upgrade: QueryModuleVersions module %s not found", req.ModuleName) } // if no module requested return all module versions from state diff --git a/x/upgrade/keeper/keeper.go b/x/upgrade/keeper/keeper.go index f8102c2a7a..ed3ccf1ccb 100644 --- a/x/upgrade/keeper/keeper.go +++ b/x/upgrade/keeper/keeper.go @@ -11,6 +11,7 @@ import ( "github.com/cometbft/cometbft/libs/log" + errorsmod "cosmossdk.io/errors" "cosmossdk.io/store/prefix" storetypes "cosmossdk.io/store/types" xp "cosmossdk.io/x/upgrade/exported" @@ -199,11 +200,11 @@ func (k Keeper) ScheduleUpgrade(ctx sdk.Context, plan types.Plan) error { // NOTE: allow for the possibility of chains to schedule upgrades in begin block of the same block // as a strategy for emergency hard fork recoveries if plan.Height < ctx.BlockHeight() { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "upgrade cannot be scheduled in the past") + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "upgrade cannot be scheduled in the past") } if k.GetDoneHeight(ctx, plan.Name) != 0 { - return sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "upgrade with name %s has already been completed", plan.Name) + return errorsmod.Wrapf(sdkerrors.ErrInvalidRequest, "upgrade with name %s has already been completed", plan.Name) } store := ctx.KVStore(k.storeKey) diff --git a/x/upgrade/keeper/msg_server.go b/x/upgrade/keeper/msg_server.go index e9468ccf86..ade16ce586 100644 --- a/x/upgrade/keeper/msg_server.go +++ b/x/upgrade/keeper/msg_server.go @@ -3,10 +3,10 @@ package keeper import ( "context" + "cosmossdk.io/errors" "cosmossdk.io/x/upgrade/types" sdk "github.com/cosmos/cosmos-sdk/types" - "github.com/cosmos/cosmos-sdk/types/errors" gov "github.com/cosmos/cosmos-sdk/x/gov/types" ) diff --git a/x/upgrade/types/msgs.go b/x/upgrade/types/msgs.go index b142554338..8a8c92c7a8 100644 --- a/x/upgrade/types/msgs.go +++ b/x/upgrade/types/msgs.go @@ -1,8 +1,9 @@ package types import ( + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" "github.com/cosmos/cosmos-sdk/x/auth/migrations/legacytx" ) @@ -19,11 +20,11 @@ func (m MsgSoftwareUpgrade) GetSignBytes() []byte { // ValidateBasic does a sanity check on the provided data. func (m *MsgSoftwareUpgrade) ValidateBasic() error { if _, err := sdk.AccAddressFromBech32(m.Authority); err != nil { - return sdkerrors.Wrap(err, "authority") + return errorsmod.Wrap(err, "authority") } if err := m.Plan.ValidateBasic(); err != nil { - return sdkerrors.Wrap(err, "plan") + return errorsmod.Wrap(err, "plan") } return nil @@ -43,7 +44,7 @@ func (m MsgCancelUpgrade) GetSignBytes() []byte { // ValidateBasic does a sanity check on the provided data. func (m *MsgCancelUpgrade) ValidateBasic() error { if _, err := sdk.AccAddressFromBech32(m.Authority); err != nil { - return sdkerrors.Wrap(err, "authority") + return errorsmod.Wrap(err, "authority") } return nil diff --git a/x/upgrade/types/plan.go b/x/upgrade/types/plan.go index f304fff544..7f0659ba4e 100644 --- a/x/upgrade/types/plan.go +++ b/x/upgrade/types/plan.go @@ -3,6 +3,8 @@ package types import ( "fmt" + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" ) @@ -19,10 +21,10 @@ func (p Plan) ValidateBasic() error { return sdkerrors.ErrInvalidRequest.Wrap("upgrade logic for IBC has been moved to the IBC module") } if len(p.Name) == 0 { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "name cannot be empty") + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "name cannot be empty") } if p.Height <= 0 { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "height must be greater than 0") + return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "height must be greater than 0") } return nil