x.beacon - PR5421 - cosmos/cosmos-sdk#5421 - standard error interface

app/app.go

@@ -257,7 +257,6 @@ func NewMainchainApp(
 	app.beaconKeeper = beacon.NewKeeper(
 		keys[beacon.StoreKey],
 		app.subspaces[beacon.ModuleName],
-		beacon.DefaultCodespace,
 		app.cdc,
 	)
 

simapp/app.go

@@ -256,7 +256,6 @@ func NewUndSimApp(
 	app.BeaconKeeper = beacon.NewKeeper(
 		keys[beacon.StoreKey],
 		app.subspaces[beacon.ModuleName],
-		beacon.DefaultCodespace,
 		app.cdc,
 	)
 

simapp/test_helpers.go

@@ -180,7 +180,7 @@ func CheckBalance(t *testing.T, app *UndSimApp, addr sdk.AccAddress, exp sdk.Coi
 func SignCheckDeliver(
 	t *testing.T, cdc *codec.Codec, app *bam.BaseApp, header abci.Header, msgs []sdk.Msg,
 	accNums, seq []uint64, expSimPass, expPass bool, priv ...crypto.PrivKey,
-) sdk.Result {
+) (sdk.GasInfo, *sdk.Result, error) {
 
 	tx := helpers.GenTx(
 		msgs,
@@ -195,28 +195,32 @@ func SignCheckDeliver(
 	require.Nil(t, err)
 
 	// Must simulate now as CheckTx doesn't run Msgs anymore
-	res := app.Simulate(txBytes, tx)
+	_, res, err := app.Simulate(txBytes, tx)
 
 	if expSimPass {
-		require.Equal(t, sdk.CodeOK, res.Code, res.Log)
+		require.NoError(t, err)
+		require.NotNil(t, res)
 	} else {
-		require.NotEqual(t, sdk.CodeOK, res.Code, res.Log)
+		require.Error(t, err)
+		require.Nil(t, res)
 	}
 
 	// Simulate a sending a transaction and committing a block
 	app.BeginBlock(abci.RequestBeginBlock{Header: header})
-	res = app.Deliver(tx)
+	gInfo, res, err := app.Deliver(tx)
 
 	if expPass {
-		require.Equal(t, sdk.CodeOK, res.Code, res.Log)
+		require.NoError(t, err)
+		require.NotNil(t, res)
 	} else {
-		require.NotEqual(t, sdk.CodeOK, res.Code, res.Log)
+		require.Error(t, err)
+		require.Nil(t, res)
 	}
 
 	app.EndBlock(abci.RequestEndBlock{})
 	app.Commit()
 
-	return res
+	return gInfo, res, err
 }
 
 // GenSequenceOfTxs generates a set of signed transactions of messages, such

x/beacon/alias.go

@@ -14,8 +14,6 @@ const (
 
 	DefaultParamspace = types.DefaultParamspace
 
-	DefaultCodespace = types.DefaultCodespace
-
 	QueryParameters = keeper.QueryParameters
 	QuerierRoute    = types.QuerierRoute
 	QueryBeacons    = keeper.QueryBeacons
@@ -42,14 +40,10 @@ var (
 	NewParamsRetriever = keeper.NewParamsRetriever
 
 	// Errors
-	ErrInvalidGenesis                 = types.ErrInvalidGenesis
 	ErrBeaconAlreadyRegistered        = types.ErrBeaconAlreadyRegistered
 	ErrBeaconDoesNotExist             = types.ErrBeaconDoesNotExist
 	ErrNotBeaconOwner                 = types.ErrNotBeaconOwner
 	ErrBeaconTimestampAlreadyRecorded = types.ErrBeaconTimestampAlreadyRecorded
-	ErrInsufficientBeaconFee          = types.ErrInsufficientBeaconFee
-	ErrTooMuchBeaconFee               = types.ErrTooMuchBeaconFee
-	ErrFeePayerNotOwner               = types.ErrFeePayerNotOwner
 
 	// Events
 	EventTypeRegisterBeacon         = types.EventTypeRegisterBeacon

x/beacon/client/cli/tx.go

@@ -13,6 +13,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/client/context"
 	"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/version"
 	"github.com/cosmos/cosmos-sdk/x/auth"
 	"github.com/cosmos/cosmos-sdk/x/auth/client/utils"
@@ -93,7 +94,7 @@ $ %s tx %s register --moniker=MyBeacon --name="My WRKChain" --from mykey
 			// the Tx and therefore charging reg fees
 			if (len(matchingBeacons)) > 0 {
 				errMsg := fmt.Sprintf("beacon already registered with moniker '%s' - beacon id: %d, owner: %s", moniker, matchingBeacons[0].BeaconID, matchingBeacons[0].Owner)
-				return types.ErrBeaconAlreadyRegistered(types.DefaultCodespace, errMsg)
+				return sdkerrors.Wrap(types.ErrBeaconAlreadyRegistered, errMsg)
 			}
 
 			txBldr := auth.NewTxBuilderFromCLI(inBuf).WithTxEncoder(utils.GetTxEncoder(cdc))
@@ -143,7 +144,7 @@ $ %s tx %s record 1 --hash=d04b98f48e8 --subtime=1234356 --from mykey
 			submitTime := viper.GetUint64(FlagSubmitTime)
 
 			if len(hash) == 0 {
-				return sdk.ErrInternal("BEACON timestamp must have a Hash submitted")
+				return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "BEACON timestamp must have a Hash submitted")
 			}
 
 			txBldr := auth.NewTxBuilderFromCLI(inBuf).WithTxEncoder(utils.GetTxEncoder(cdc))
@@ -158,7 +159,7 @@ $ %s tx %s record 1 --hash=d04b98f48e8 --subtime=1234356 --from mykey
 			}
 
 			if beaconID == 0 {
-				return sdk.ErrInternal("BEACON id must be > 0")
+				return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "BEACON id must be > 0")
 			}
 
 			if submitTime == 0 {

x/beacon/handler.go

@@ -3,39 +3,39 @@ package beacon
 import (
 	"fmt"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	"strconv"
 )
 
 // NewHandler returns a handler for "beacon" type messages.
 func NewHandler(keeper Keeper) sdk.Handler {
-	return func(ctx sdk.Context, msg sdk.Msg) sdk.Result {
+	return func(ctx sdk.Context, msg sdk.Msg) (*sdk.Result, error) {
 		switch msg := msg.(type) {
 		case MsgRegisterBeacon:
 			return handleMsgRegisterBeacon(ctx, keeper, msg)
 		case MsgRecordBeaconTimestamp:
 			return handleMsgRecordBeaconTimestamp(ctx, keeper, msg)
 		default:
-			errMsg := fmt.Sprintf("Unrecognised beacon Msg type: %v", msg.Type())
-			return sdk.ErrUnknownRequest(errMsg).Result()
+			return nil, sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "unrecognized %s message type: %T", ModuleName, msg)
 		}
 	}
 }
 
 // Handle a message to register a new BEACON
-func handleMsgRegisterBeacon(ctx sdk.Context, keeper Keeper, msg MsgRegisterBeacon) sdk.Result {
+func handleMsgRegisterBeacon(ctx sdk.Context, keeper Keeper, msg MsgRegisterBeacon) (*sdk.Result, error) {
 
 	params := NewQueryBeaconParams(1, 1, msg.Moniker, sdk.AccAddress{})
 	beacons := keeper.GetBeaconsFiltered(ctx, params)
 
 	if (len(beacons)) > 0 {
 		errMsg := fmt.Sprintf("beacon already registered with moniker '%s' - id: %d, owner: %s", msg.Moniker, beacons[0].BeaconID, beacons[0].Owner)
-		return ErrBeaconAlreadyRegistered(keeper.Codespace(), errMsg).Result()
+		return nil, sdkerrors.Wrap(ErrBeaconAlreadyRegistered, errMsg)
 	}
 
 	beaconID, err := keeper.RegisterBeacon(ctx, msg.Moniker, msg.BeaconName, msg.Owner) // register the BEACON
 
 	if err != nil {
-		return err.Result()
+		return nil, err
 	}
 
 	ctx.EventManager().EmitEvents(sdk.Events{
@@ -48,30 +48,30 @@ func handleMsgRegisterBeacon(ctx sdk.Context, keeper Keeper, msg MsgRegisterBeac
 		),
 	})
 
-	return sdk.Result{
+	return &sdk.Result{
 		Events: ctx.EventManager().Events(),
 		Data:   GetBeaconIDBytes(beaconID),
-	}
+	}, nil
 }
 
 // Handle a message to record a new BEACON timestamp
-func handleMsgRecordBeaconTimestamp(ctx sdk.Context, keeper Keeper, msg MsgRecordBeaconTimestamp) sdk.Result {
+func handleMsgRecordBeaconTimestamp(ctx sdk.Context, keeper Keeper, msg MsgRecordBeaconTimestamp) (*sdk.Result, error) {
 	if !keeper.IsBeaconRegistered(ctx, msg.BeaconID) { // Checks if the BEACON is registered
-		return ErrBeaconDoesNotExist(keeper.Codespace(), "beacon has not been registered yet").Result() // If not, throw an error
+		return nil, sdkerrors.Wrap(ErrBeaconDoesNotExist, "beacon has not been registered yet") // If not, throw an error
 	}
 
 	if !keeper.IsAuthorisedToRecord(ctx, msg.BeaconID, msg.Owner) {
-		return ErrNotBeaconOwner(keeper.Codespace(), "you are not the owner of this beacon").Result()
+		return nil, sdkerrors.Wrap(ErrNotBeaconOwner, "you are not the owner of this beacon")
 	}
 
 	if keeper.IsBeaconTimestampRecordedByHashTime(ctx, msg.BeaconID, msg.Hash, msg.SubmitTime) {
-		return ErrBeaconTimestampAlreadyRecorded(keeper.Codespace(), fmt.Sprintf("timestamp hash %s already recorded at time %d", msg.Hash, msg.SubmitTime)).Result()
+		return nil, sdkerrors.Wrap(ErrBeaconTimestampAlreadyRecorded, fmt.Sprintf("timestamp hash %s already recorded at time %d", msg.Hash, msg.SubmitTime))
 	}
 
 	tsID, err := keeper.RecordBeaconTimestamp(ctx, msg.BeaconID, msg.Hash, msg.SubmitTime, msg.Owner)
 
 	if err != nil {
-		return err.Result()
+		return nil, err
 	}
 
 	ctx.EventManager().EmitEvents(sdk.Events{
@@ -84,8 +84,8 @@ func handleMsgRecordBeaconTimestamp(ctx sdk.Context, keeper Keeper, msg MsgRecor
 			sdk.NewAttribute(AttributeKeyOwner, msg.Owner.String()),
 		),
 	})
-	return sdk.Result{
+	return &sdk.Result{
 		Events: ctx.EventManager().Events(),
 		Data:   GetTimestampIDBytes(tsID),
-	}
+	}, nil
 }

x/beacon/internal/ante/ante.go

@@ -91,7 +91,7 @@ func checkBeaconFees(ctx sdk.Context, tx FeeTx, bk keeper.Keeper) error {
 
 	if !hasFeeDenom {
 		errMsg := fmt.Sprintf("incorrect fee denomination. expected %s", expectedFeeDenom)
-		return types.ErrIncorrectFeeDenomination(types.DefaultCodespace, errMsg)
+		return sdkerrors.Wrap(types.ErrIncorrectFeeDenomination, errMsg)
 	}
 
 	// go through Msgs wrapped in the Tx, and check for BEACON messages
@@ -109,12 +109,12 @@ func checkBeaconFees(ctx sdk.Context, tx FeeTx, bk keeper.Keeper) error {
 	totalFees := sdk.Coins{expectedFees}
 	if tx.GetFee().IsAllLT(totalFees) {
 		errMsg := fmt.Sprintf("insufficient fee to pay for beacon tx. numMsgs in tx: %v, expected fees: %v, sent fees: %v", numMsgs, totalFees.String(), tx.GetFee())
-		return types.ErrInsufficientBeaconFee(types.DefaultCodespace, errMsg)
+		return sdkerrors.Wrap(types.ErrInsufficientBeaconFee, errMsg)
 	}
 
 	if tx.GetFee().IsAllGT(totalFees) {
 		errMsg := fmt.Sprintf("too much fee sent to pay for beacon tx. numMsgs in tx: %v, expected fees: %v, sent fees: %v", numMsgs, totalFees.String(), tx.GetFee())
-		return types.ErrTooMuchBeaconFee(types.DefaultCodespace, errMsg)
+		return sdkerrors.Wrap(types.ErrTooMuchBeaconFee, errMsg)
 	}
 
 	return nil

x/beacon/internal/ante/ante_test.go

@@ -104,7 +104,7 @@ func TestCorrectBeaconFeeDecoratorRejectTooLittleFeeInTx(t *testing.T) {
 	_, err := antehandler(ctx, tx, false)
 
 	errMsg := fmt.Sprintf("insufficient fee to pay for beacon tx. numMsgs in tx: 1, expected fees: %d%s, sent fees: %d%s", actualRegFeeAmt, actualFeeDenom, feeInt, feeDenom)
-	expectedErr := types.ErrInsufficientBeaconFee(types.DefaultCodespace, errMsg)
+	expectedErr := sdkerrors.Wrap(types.ErrInsufficientBeaconFee, errMsg)
 
 	require.NotNil(t, err, "Did not error on invalid tx")
 	require.Equal(t, expectedErr, err, "unexpected type of error: %s", err)
@@ -126,7 +126,7 @@ func TestCorrectBeaconFeeDecoratorRejectTooLittleFeeInTx(t *testing.T) {
 	_, err1 := antehandler(ctx, tx1, false)
 
 	errMsg1 := fmt.Sprintf("insufficient fee to pay for beacon tx. numMsgs in tx: 1, expected fees: %d%s, sent fees: %d%s", actualRecFeeAmt, actualFeeDenom, feeInt, feeDenom)
-	expectedErr1 := types.ErrInsufficientBeaconFee(types.DefaultCodespace, errMsg1)
+	expectedErr1 := sdkerrors.Wrap(types.ErrInsufficientBeaconFee, errMsg1)
 
 	require.NotNil(t, err1, "Did not error on invalid tx")
 	require.Equal(t, expectedErr1, err1, "unexpected type of error: %s", err1)
@@ -165,7 +165,7 @@ func TestCorrectBeaconFeeDecoratorRejectTooMuchFeeInTx(t *testing.T) {
 	_, err := antehandler(ctx, tx, false)
 
 	errMsg := fmt.Sprintf("too much fee sent to pay for beacon tx. numMsgs in tx: 1, expected fees: %d%s, sent fees: %d%s", actualRegFeeAmt, actualFeeDenom, feeInt, feeDenom)
-	expectedErr := types.ErrTooMuchBeaconFee(types.DefaultCodespace, errMsg)
+	expectedErr := sdkerrors.Wrap(types.ErrTooMuchBeaconFee, errMsg)
 
 	require.NotNil(t, err, "Did not error on invalid tx")
 	require.Equal(t, expectedErr, err, "unexpected type of error: %s", err)
@@ -187,7 +187,7 @@ func TestCorrectBeaconFeeDecoratorRejectTooMuchFeeInTx(t *testing.T) {
 	_, err1 := antehandler(ctx, tx1, false)
 
 	errMsg1 := fmt.Sprintf("too much fee sent to pay for beacon tx. numMsgs in tx: 1, expected fees: %d%s, sent fees: %d%s", actualRecFeeAmt, actualFeeDenom, feeInt, feeDenom)
-	expectedErr1 := types.ErrTooMuchBeaconFee(types.DefaultCodespace, errMsg1)
+	expectedErr1 := sdkerrors.Wrap(types.ErrTooMuchBeaconFee, errMsg1)
 
 	require.NotNil(t, err1, "Did not error on invalid tx")
 	require.Equal(t, expectedErr1, err1, "unexpected type of error: %s", err1)
@@ -226,7 +226,7 @@ func TestCorrectBeaconFeeDecoratorRejectIncorrectDenomFeeInTx(t *testing.T) {
 	_, err := antehandler(ctx, tx, false)
 
 	errMsg := fmt.Sprintf("incorrect fee denomination. expected %s", actualFeeDenom)
-	expectedErr := types.ErrIncorrectFeeDenomination(types.DefaultCodespace, errMsg)
+	expectedErr := sdkerrors.Wrap(types.ErrIncorrectFeeDenomination, errMsg)
 
 	require.NotNil(t, err, "Did not error on invalid tx1")
 	require.Equal(t, expectedErr, err, "unexpected type of error: %s", err)

x/beacon/internal/keeper/keeper.go

@@ -13,16 +13,14 @@ import (
 type Keeper struct {
 	storeKey   sdk.StoreKey // Unexposed key to access store from sdk.Context
 	paramSpace params.Subspace
-	codespace  sdk.CodespaceType
 	cdc        *codec.Codec // The wire codec for binary encoding/decoding.
 }
 
 // NewKeeper creates new instances of the beacon Keeper
-func NewKeeper(storeKey sdk.StoreKey, paramSpace params.Subspace, codespace sdk.CodespaceType, cdc *codec.Codec) Keeper {
+func NewKeeper(storeKey sdk.StoreKey, paramSpace params.Subspace, cdc *codec.Codec) Keeper {
 	return Keeper{
 		storeKey:   storeKey,
 		paramSpace: paramSpace.WithKeyTable(types.ParamKeyTable()),
-		codespace:  codespace,
 		cdc:        cdc,
 	}
 }
@@ -32,10 +30,6 @@ func (k Keeper) Logger(ctx sdk.Context) log.Logger {
 	return ctx.Logger().With("module", fmt.Sprintf("x/%s", types.ModuleName))
 }
 
-func (k Keeper) Codespace() sdk.CodespaceType {
-	return k.codespace
-}
-
 func (k Keeper) Cdc() *codec.Codec {
 	return k.cdc
 }