feat: implement burn-consumption

Signed-off-by: Lorenz Herzberger <lorenzherzberger@gmail.com>

app/ante/check_machine_decorator.go

@@ -31,16 +31,21 @@ func (cm CheckMachineDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate
 			if ok {
 				ctx, err = cm.handleAttestMachine(ctx, attestMsg)
 			}
-		case "planetmintgo.dao.MsgReportPoPResult":
+		case "/planetmintgo.dao.MsgReportPoPResult":
 			popMsg, ok := msg.(*daotypes.MsgReportPopResult)
 			if ok {
 				ctx, err = cm.handlePopResult(ctx, popMsg)
 			}
-		case "planetmintgo.machine.MsgMintProduction":
+		case "/planetmintgo.machine.MsgMintProduction":
 			mintProdMsg, ok := msg.(*machinetypes.MsgMintProduction)
 			if ok {
 				ctx, err = cm.handleMintProduction(ctx, mintProdMsg)
 			}
+		case "/planetmintgo.machine.MsgBurnConsumption":
+			burnConsMsg, ok := msg.(*machinetypes.MsgBurnConsumption)
+			if ok {
+				ctx, err = cm.handleBurnConsumption(ctx, burnConsMsg)
+			}
 		default:
 			continue
 		}
@@ -90,3 +95,11 @@ func (cm CheckMachineDecorator) handleMintProduction(ctx sdk.Context, mintProdMs
 	}
 	return ctx, nil
 }
+
+func (cm CheckMachineDecorator) handleBurnConsumption(ctx sdk.Context, burnConsMsg *machinetypes.MsgBurnConsumption) (sdk.Context, error) {
+	_, found := cm.mk.GetMachineIndexByAddress(ctx, burnConsMsg.GetCreator())
+	if !found {
+		return ctx, errorsmod.Wrapf(machinetypes.ErrMachineNotFound, ErrorAnteContext)
+	}
+	return ctx, nil
+}

x/machine/keeper/msg_server_burn_consumption.go

@@ -3,6 +3,7 @@ package keeper
 import (
 	"context"
 
+	errorsmod "cosmossdk.io/errors"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/planetmint/planetmint-go/x/machine/types"
 )
@@ -10,8 +11,20 @@ import (
 func (k msgServer) BurnConsumption(goCtx context.Context, msg *types.MsgBurnConsumption) (*types.MsgBurnConsumptionResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 
-	// TODO: Handling the message
+	addr, err := sdk.AccAddressFromBech32(msg.GetCreator())
-	_ = ctx
+	if err != nil {
+		return nil, errorsmod.Wrapf(types.ErrInvalidAddress, "invalid address: %s", msg.GetCreator())
+	}
+
+	err = k.bankKeeper.SendCoinsFromAccountToModule(ctx, addr, types.ModuleName, msg.GetConsumption())
+	if err != nil {
+		return nil, errorsmod.Wrapf(types.ErrTransferFailed, "error while transferring %v consumption from address %s", msg.GetConsumption(), msg.GetCreator())
+	}
+
+	err = k.bankKeeper.BurnCoins(ctx, types.ModuleName, msg.GetConsumption())
+	if err != nil {
+		return nil, errorsmod.Wrapf(types.ErrBurnFailed, "error while burning consumption %v for address %s", msg.GetConsumption(), msg.GetCreator())
+	}
 
 	return &types.MsgBurnConsumptionResponse{}, nil
 }

x/machine/testutil/expected_keepers_mocks.go

@@ -100,6 +100,20 @@ func (mr *MockBankKeeperMockRecorder) MintCoins(ctx, moduleName, amt interface{}
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MintCoins", reflect.TypeOf((*MockBankKeeper)(nil).MintCoins), ctx, moduleName, amt)
 }
 
+// SendCoinsFromAccountToModule mocks base method.
+func (m *MockBankKeeper) SendCoinsFromAccountToModule(ctx types.Context, senderAddr types.AccAddress, recipientModule string, amt types.Coins) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SendCoinsFromAccountToModule", ctx, senderAddr, recipientModule, amt)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SendCoinsFromAccountToModule indicates an expected call of SendCoinsFromAccountToModule.
+func (mr *MockBankKeeperMockRecorder) SendCoinsFromAccountToModule(ctx, senderAddr, recipientModule, amt interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCoinsFromAccountToModule", reflect.TypeOf((*MockBankKeeper)(nil).SendCoinsFromAccountToModule), ctx, senderAddr, recipientModule, amt)
+}
+
 // SendCoinsFromModuleToAccount mocks base method.
 func (m *MockBankKeeper) SendCoinsFromModuleToAccount(ctx types.Context, senderModule string, recipientAddr types.AccAddress, amt types.Coins) error {
 	m.ctrl.T.Helper()

x/machine/types/errors.go

@@ -24,4 +24,5 @@ var (
 	ErrInvalidAddress               = errorsmod.Register(ModuleName, 16, "invalid address")
 	ErrTransferFailed               = errorsmod.Register(ModuleName, 17, "transfer failed")
 	ErrMintFailed                   = errorsmod.Register(ModuleName, 18, "minting failed")
+	ErrBurnFailed                   = errorsmod.Register(ModuleName, 19, "burning failed")
 )

x/machine/types/expected_keepers.go

@@ -17,5 +17,6 @@ type BankKeeper interface {
 	MintCoins(ctx sdk.Context, moduleName string, amt sdk.Coins) error
 	BurnCoins(ctx sdk.Context, moduleName string, amt sdk.Coins) error
 	SendCoinsFromModuleToAccount(ctx sdk.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) error
+	SendCoinsFromAccountToModule(ctx sdk.Context, senderAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) error
 	// Methods imported from bank should be defined here
 }