Mirroristas/planetmint-go
2
0
Fork 0
mirror of https://github.com/planetmint/planetmint-go.git synced 2025-03-30 15:08:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

relocate redeem claim and reissuance proposal ante decorator to respe… (#331)

Browse Source 
* relocate redeem claim and reissuance proposal ante decorator to respective msg servers

---------

Signed-off-by: Lorenz Herzberger <lorenzherzberger@gmail.com>
This commit is contained in:
Lorenz Herzberger 2024-03-05 15:03:27 +01:00 committed by GitHub
parent 4f5b1e5777
commit caa795e5f7
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
7 changed files with 58 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
app/ante/ante.go
View File

@ -60,8 +60,6 @@ func NewAnteHandler(options HandlerOptions) (sdk.AnteHandler, error) {
NewCheckValidatorDecorator(options.StakingKeeper),
NewCheckMachineDecorator(options.MachineKeeper),
NewCheckMintAddressDecorator(options.DaoKeeper),
NewCheckReissuanceDecorator(options.DaoKeeper),
NewRedeemClaimDecorator(options.DaoKeeper, options.BankKeeper),
ante.NewConsumeGasForTxSizeDecorator(options.AccountKeeper),
NewDeductFeeDecorator(options.AccountKeeper, options.BankKeeper, options.FeegrantKeeper, options.TxFeeChecker),
ante.NewSetPubKeyDecorator(options.AccountKeeper), // SetPubKeyDecorator must be called before all signature verification decorators

41
app/ante/check_reissuance_decorator.go
View File

@ -1,41 +0,0 @@
package ante
import (
errorsmod "cosmossdk.io/errors"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/planetmint/planetmint-go/util"
daotypes "github.com/planetmint/planetmint-go/x/dao/types"
)
var (
anteHandlerTag = "ante handler: "
)
type CheckReissuanceDecorator struct {
dk DaoKeeper
}
func NewCheckReissuanceDecorator(dk DaoKeeper) CheckReissuanceDecorator {
return CheckReissuanceDecorator{
dk: dk,
}
}
func (cmad CheckReissuanceDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (sdk.Context, error) {
for _, msg := range tx.GetMsgs() {
if sdk.MsgTypeURL(msg) == "/planetmintgo.dao.MsgReissueRDDLProposal" {
MsgProposal, ok := msg.(*daotypes.MsgReissueRDDLProposal)
if ok {
util.GetAppLogger().Debug(ctx, anteHandlerTag+"received reissuance proposal: "+MsgProposal.String())
isValid := cmad.dk.IsValidReissuanceProposal(ctx, MsgProposal)
if !isValid {
util.GetAppLogger().Info(ctx, anteHandlerTag+"rejected reissuance proposal")
return ctx, errorsmod.Wrapf(daotypes.ErrReissuanceProposal, ErrorAnteContext)
}
util.GetAppLogger().Debug(ctx, anteHandlerTag+"accepted reissuance proposal: "+MsgProposal.String())
}
}
}
return next(ctx, tx, simulate)
}

90
app/ante/redeem_claim_decorator.go
View File

@ -1,90 +0,0 @@
package ante
import (
errorsmod "cosmossdk.io/errors"
sdk "github.com/cosmos/cosmos-sdk/types"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
daotypes "github.com/planetmint/planetmint-go/x/dao/types"
)
type RedeemClaimDecorator struct {
dk DaoKeeper
bk BankKeeper
}
func NewRedeemClaimDecorator(dk DaoKeeper, bk BankKeeper) RedeemClaimDecorator {
return RedeemClaimDecorator{
dk: dk,
bk: bk,
}
}
func (rcd RedeemClaimDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate bool, next sdk.AnteHandler) (_ sdk.Context, err error) {
for _, msg := range tx.GetMsgs() {
switch sdk.MsgTypeURL(msg) {
case "/planetmintgo.dao.MsgCreateRedeemClaim":
ctx, err = rcd.handleCreateRedeemClaim(ctx, msg)
case "/planetmintgo.dao.MsgUpdateRedeemClaim":
ctx, err = rcd.handleUpdateRedeemClaim(ctx, msg)
case "/planetmintgo.dao.MsgConfirmRedeemClaim":
ctx, err = rcd.handleConfirmRedeemClaim(ctx, msg)
default:
continue
}
}
if err != nil {
return ctx, err
}
return next(ctx, tx, simulate)
}
func (rcd RedeemClaimDecorator) handleCreateRedeemClaim(ctx sdk.Context, msg sdk.Msg) (sdk.Context, error) {
createRedeemClaimMsg, ok := msg.(*daotypes.MsgCreateRedeemClaim)
if !ok {
return ctx, errorsmod.Wrapf(sdkerrors.ErrLogic, "could not cast to MsgCreateRedeemClaim")
}
addr := sdk.MustAccAddressFromBech32(createRedeemClaimMsg.Creator)
params := rcd.dk.GetParams(ctx)
balance := rcd.bk.GetBalance(ctx, addr, params.ClaimDenom)
if !balance.Amount.GTE(sdk.NewIntFromUint64(createRedeemClaimMsg.Amount)) {
return ctx, errorsmod.Wrap(sdkerrors.ErrInsufficientFunds, ErrorAnteContext)
}
return ctx, nil
}
func (rcd RedeemClaimDecorator) handleUpdateRedeemClaim(ctx sdk.Context, msg sdk.Msg) (sdk.Context, error) {
updateClaimMsg, ok := msg.(*daotypes.MsgUpdateRedeemClaim)
if !ok {
return ctx, errorsmod.Wrapf(sdkerrors.ErrLogic, "could not cast to MsgUpdateRedeemClaim")
}
_, found := rcd.dk.GetRedeemClaim(ctx, updateClaimMsg.Beneficiary, updateClaimMsg.Id)
if !found {
return ctx, errorsmod.Wrapf(sdkerrors.ErrNotFound, "no redeem claim found for beneficiary: %s; id: %d", updateClaimMsg.Beneficiary, updateClaimMsg.Id)
}
return ctx, nil
}
func (rcd RedeemClaimDecorator) handleConfirmRedeemClaim(ctx sdk.Context, msg sdk.Msg) (sdk.Context, error) {
confirmClaimMsg, ok := msg.(*daotypes.MsgConfirmRedeemClaim)
if !ok {
return ctx, errorsmod.Wrapf(sdkerrors.ErrLogic, "could not cast to MsgConfirmRedeemClaim")
}
if confirmClaimMsg.Creator != rcd.dk.GetClaimAddress(ctx) {
return ctx, errorsmod.Wrapf(daotypes.ErrInvalidClaimAddress, "expected: %s; got: %s", rcd.dk.GetClaimAddress(ctx), confirmClaimMsg.Creator)
}
_, found := rcd.dk.GetRedeemClaim(ctx, confirmClaimMsg.Beneficiary, confirmClaimMsg.Id)
if !found {
return ctx, errorsmod.Wrapf(sdkerrors.ErrNotFound, "no redeem claim found for beneficiary: %s; id: %d", confirmClaimMsg.Beneficiary, confirmClaimMsg.Id)
}
return ctx, nil
}

6
tests/e2e/dao/pop_participant_selection_suite.go
View File

@ -280,9 +280,9 @@ func (s *PopSelectionE2ETestSuite) TestTokenRedeemClaim() {
out, err = lib.BroadcastTxWithFileLock(addr, confirmMsg)
s.Require().NoError(err)
txResponse, err = lib.GetTxResponseFromOut(out)
s.Require().NoError(err)
s.Require().Equal(int(21), int(txResponse.Code))
s.Require().NoError(s.network.WaitForNextBlock())
_, err = clitestutil.GetRawLogFromTxOut(val, out)
s.Require().ErrorContains(err, "failed to execute message; message index: 0: expected: plmnt19cl05ztgt8ey6v86hjjjn3thfmpu6q2xtveehc; got: plmnt1kp93kns6hs2066d8qw0uz84fw3vlthewt2ck6p: invalid claim address")
// Validator with Claim Address sends ConfirmRedeemClaim => accepted
valConfirmMsg := daotypes.NewMsgConfirmRedeemClaim(val.Address.String(), 0, "liquidAddress")

1
testutil/keeper/dao.go
View File

@ -58,6 +58,7 @@ func DaoKeeper(t testing.TB) (*keeper.Keeper, sdk.Context) {
bk.EXPECT().BurnCoins(gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
bk.EXPECT().SendCoinsFromModuleToAccount(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
bk.EXPECT().SendCoinsFromAccountToModule(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil).AnyTimes()
bk.EXPECT().GetBalance(gomock.Any(), gomock.Any(), gomock.Any()).Return(sdk.NewCoin("crddl", sdk.NewInt(10000))).AnyTimes()
k := keeper.NewKeeper(
cdc,

38
x/dao/keeper/msg_server_redeem_claim.go
View File

@ -12,6 +12,7 @@ import (
)
var (
redeemClaimContext = "redeem claim: "
createRedeemClaimTag = "create redeem claim: "
)
@ -19,13 +20,18 @@ func (k msgServer) CreateRedeemClaim(goCtx context.Context, msg *types.MsgCreate
ctx := sdk.UnwrapSDKContext(goCtx)
params := k.GetParams(ctx)
err := k.validateCreateRedeemClaim(ctx, msg)
if err != nil {
return nil, err
}
var redeemClaim = types.RedeemClaim{
Creator: msg.Creator,
Beneficiary: msg.Beneficiary,
Amount: msg.Amount,
}
err := k.burnClaimAmount(ctx, sdk.MustAccAddressFromBech32(msg.Creator), msg.Amount)
err = k.burnClaimAmount(ctx, sdk.MustAccAddressFromBech32(msg.Creator), msg.Amount)
if err != nil {
util.GetAppLogger().Error(ctx, createRedeemClaimTag+"could not burn claim")
}
@ -47,6 +53,19 @@ func (k msgServer) CreateRedeemClaim(goCtx context.Context, msg *types.MsgCreate
return &types.MsgCreateRedeemClaimResponse{}, nil
}
func (k msgServer) validateCreateRedeemClaim(ctx sdk.Context, msg *types.MsgCreateRedeemClaim) (err error) {
addr := sdk.MustAccAddressFromBech32(msg.Creator)
params := k.GetParams(ctx)
balance := k.bankKeeper.GetBalance(ctx, addr, params.ClaimDenom)
if !balance.Amount.GTE(sdk.NewIntFromUint64(msg.Amount)) {
return errorsmod.Wrap(sdkerrors.ErrInsufficientFunds, redeemClaimContext)
}
return nil
}
func (k msgServer) UpdateRedeemClaim(goCtx context.Context, msg *types.MsgUpdateRedeemClaim) (*types.MsgUpdateRedeemClaimResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
@ -75,6 +94,11 @@ func (k msgServer) UpdateRedeemClaim(goCtx context.Context, msg *types.MsgUpdate
func (k msgServer) ConfirmRedeemClaim(goCtx context.Context, msg *types.MsgConfirmRedeemClaim) (*types.MsgConfirmRedeemClaimResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
err := k.validateConfirmRedeemClaim(ctx, msg)
if err != nil {
return nil, err
}
valFound, isFound := k.GetRedeemClaim(
ctx,
msg.Beneficiary,
@ -98,6 +122,18 @@ func (k msgServer) ConfirmRedeemClaim(goCtx context.Context, msg *types.MsgConfi
return &types.MsgConfirmRedeemClaimResponse{}, nil
}
func (k msgServer) validateConfirmRedeemClaim(ctx sdk.Context, msg *types.MsgConfirmRedeemClaim) (err error) {
if msg.Creator != k.GetClaimAddress(ctx) {
return errorsmod.Wrapf(types.ErrInvalidClaimAddress, "expected: %s; got: %s", k.GetClaimAddress(ctx), msg.Creator)
}
_, found := k.GetRedeemClaim(ctx, msg.Beneficiary, msg.Id)
if !found {
return errorsmod.Wrapf(sdkerrors.ErrNotFound, "no redeem claim found for beneficiary: %s; id: %d", msg.Beneficiary, msg.Id)
}
return nil
}
func (k msgServer) burnClaimAmount(ctx sdk.Context, addr sdk.AccAddress, amount uint64) (err error) {
params := k.GetParams(ctx)
burnCoins := sdk.NewCoins(sdk.NewCoin(params.ClaimDenom, sdk.NewIntFromUint64(amount)))

17
x/dao/keeper/msg_server_reissue_rddl_proposal.go
View File

@ -3,6 +3,7 @@ package keeper
import (
"context"
errorsmod "cosmossdk.io/errors"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/planetmint/planetmint-go/util"
"github.com/planetmint/planetmint-go/x/dao/types"
@ -15,6 +16,11 @@ var (
func (k msgServer) ReissueRDDLProposal(goCtx context.Context, msg *types.MsgReissueRDDLProposal) (*types.MsgReissueRDDLProposalResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
err := k.validateReissuanceProposal(ctx, msg)
if err != nil {
return nil, err
}
var reissuance types.Reissuance
reissuance.BlockHeight = msg.GetBlockHeight()
reissuance.Proposer = msg.GetProposer()
@ -38,3 +44,14 @@ func (k msgServer) ReissueRDDLProposal(goCtx context.Context, msg *types.MsgReis
return &types.MsgReissueRDDLProposalResponse{}, nil
}
func (k msgServer) validateReissuanceProposal(ctx sdk.Context, msg *types.MsgReissueRDDLProposal) (err error) {
util.GetAppLogger().Debug(ctx, reissueTag+"received reissuance proposal: "+msg.String())
isValid := k.IsValidReissuanceProposal(ctx, msg)
if !isValid {
util.GetAppLogger().Info(ctx, reissueTag+"rejected reissuance proposal")
return errorsmod.Wrapf(types.ErrReissuanceProposal, reissueTag)
}
util.GetAppLogger().Debug(ctx, reissueTag+"accepted reissuance proposal: "+msg.String())
return
}