feat: add put into basket sim

app/app.go

@@ -94,6 +94,7 @@ import (
 
 	"github.com/regen-network/regen-ledger/types/module/server"
 	"github.com/regen-network/regen-ledger/x/ecocredit"
+	baskettypes "github.com/regen-network/regen-ledger/x/ecocredit/basket"
 	ecocreditmodule "github.com/regen-network/regen-ledger/x/ecocredit/module"
 
 	// unnamed import of statik for swagger UI support
@@ -139,14 +140,15 @@ var (
 
 	// module account permissions
 	maccPerms = map[string][]string{
-		authtypes.FeeCollectorName:     nil,
-		distrtypes.ModuleName:          nil,
-		minttypes.ModuleName:           {authtypes.Minter},
-		stakingtypes.BondedPoolName:    {authtypes.Burner, authtypes.Staking},
-		stakingtypes.NotBondedPoolName: {authtypes.Burner, authtypes.Staking},
-		govtypes.ModuleName:            {authtypes.Burner},
-		ibctransfertypes.ModuleName:    {authtypes.Minter, authtypes.Burner},
-		ecocredit.ModuleName:           {authtypes.Burner},
+		authtypes.FeeCollectorName:      nil,
+		distrtypes.ModuleName:           nil,
+		minttypes.ModuleName:            {authtypes.Minter},
+		stakingtypes.BondedPoolName:     {authtypes.Burner, authtypes.Staking},
+		stakingtypes.NotBondedPoolName:  {authtypes.Burner, authtypes.Staking},
+		govtypes.ModuleName:             {authtypes.Burner},
+		ibctransfertypes.ModuleName:     {authtypes.Minter, authtypes.Burner},
+		ecocredit.ModuleName:            {authtypes.Burner},
+		baskettypes.BasketSubModuleName: {authtypes.Minter, authtypes.Burner},
 	}
 )
 

x/ecocredit/server/basket/put.go

@@ -126,7 +126,7 @@ func (k Keeper) canBasketAcceptCredit(ctx context.Context, basket *basketv1.Bask
 	if err != nil {
 		return err
 	}
-	gotCreditType := res2.Info.CreditType.Name
+	gotCreditType := res2.Info.CreditType.Abbreviation
 	if requiredCreditType != gotCreditType {
 		return errInvalidReq.Wrapf("cannot use credit of type %s in a basket that requires credit type %s", gotCreditType, requiredCreditType)
 	}

x/ecocredit/simulation/basket/operations.go

@@ -1,19 +1,23 @@
 package basketsims
 
 import (
+	"fmt"
 	"math/rand"
+	"strings"
 	"time"
 
 	gogotypes "github.com/gogo/protobuf/types"
 
 	"github.com/cosmos/cosmos-sdk/baseapp"
 	"github.com/cosmos/cosmos-sdk/codec"
+	"github.com/cosmos/cosmos-sdk/simapp/helpers"
 	simappparams "github.com/cosmos/cosmos-sdk/simapp/params"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
 	"github.com/cosmos/cosmos-sdk/x/simulation"
 
 	regentypes "github.com/regen-network/regen-ledger/types"
+	"github.com/regen-network/regen-ledger/types/math"
 	"github.com/regen-network/regen-ledger/x/ecocredit"
 	"github.com/regen-network/regen-ledger/x/ecocredit/basket"
 )
@@ -122,23 +126,21 @@ func SimulateMsgCreate(ak ecocredit.AccountKeeper, bk ecocredit.BankKeeper,
 			return simtypes.NoOpMsg(ecocredit.ModuleName, TypeMsgCreate, "credit type not found"), nil, nil
 		}
 
-		var exponent uint32
-		if creditType.Precision <= 1 {
-			exponent = creditType.Precision
-		} else {
-			exponent = uint32(simtypes.RandIntBetween(r, 1, int(creditType.Precision)))
-		}
+		precision := int(creditType.Precision)
+		exponent := uint32(simtypes.RandIntBetween(r, precision, precision+5))
 
+		dateCriteria := randomDateCriteria(r)
+		dateCriteria = nil
 		msg := &basket.MsgCreate{
-			Name:              simtypes.RandStringOfLength(r, simtypes.RandIntBetween(r, 2, 10)),
-			DisplayName:       simtypes.RandStringOfLength(r, simtypes.RandIntBetween(r, 2, 10)),
-			Fee:               sdk.NewCoins(sdk.NewInt64Coin(sdk.DefaultBondDenom, int64(simtypes.RandIntBetween(r, 0, 5)))),
+			Name:              simtypes.RandStringOfLength(r, simtypes.RandIntBetween(r, 3, 32)),
+			DisplayName:       simtypes.RandStringOfLength(r, simtypes.RandIntBetween(r, 3, 32)),
+			Fee:               params.BasketCreationFee,
 			DisableAutoRetire: r.Float32() < 0.5,
 			Curator:           curator.Address.String(),
 			Exponent:          exponent,
 			AllowedClasses:    classIds,
-			CreditTypeName:    creditType.Name,
-			DateCriteria:      randomDateCriteria(r),
+			CreditTypeName:    creditType.Abbreviation,
+			DateCriteria:      dateCriteria,
 		}
 
 		txCtx := simulation.OperationInput{
@@ -190,8 +192,135 @@ func SimulateMsgPut(ak ecocredit.AccountKeeper, bk ecocredit.BankKeeper,
 	return func(
 		r *rand.Rand, app *baseapp.BaseApp, sdkCtx sdk.Context, accs []simtypes.Account, chainID string,
 	) (simtypes.OperationMsg, []simtypes.FutureOperation, error) {
+		owner, _ := simtypes.RandomAcc(r, accs)
+
+		ctx := regentypes.Context{Context: sdkCtx}
+		res, err := bsktQryClient.Baskets(ctx, &basket.QueryBasketsRequest{})
+		if err != nil {
+			return simtypes.NoOpMsg(ecocredit.ModuleName, TypeMsgPut, err.Error()), nil, err
+		}
+
+		baskets := res.Baskets
+		if len(baskets) == 0 {
+			return simtypes.NoOpMsg(ecocredit.ModuleName, TypeMsgPut, "no baskets"), nil, nil
+		}
 
-		return simtypes.NoOpMsg(ecocredit.ModuleName, TypeMsgPut, ""), nil, nil
+		classesRes, err := qryClient.Classes(ctx, &ecocredit.QueryClassesRequest{})
+		if err != nil {
+			return simtypes.NoOpMsg(ecocredit.ModuleName, TypeMsgPut, err.Error()), nil, err
+		}
+
+		classes := classesRes.Classes
+		if len(classes) == 0 {
+			return simtypes.NoOpMsg(ecocredit.ModuleName, TypeMsgPut, "no classes"), nil, nil
+		}
+
+		rBasket := baskets[r.Intn(len(baskets))]
+		var classInfoList []ecocredit.ClassInfo
+		max := 0
+
+		r.Shuffle(len(classes), func(i, j int) { classes[i], classes[j] = classes[j], classes[i] })
+		for _, class := range classes {
+			if class.CreditType.Abbreviation == rBasket.CreditTypeName {
+				classInfoList = append(classInfoList, *class)
+				if max == 2 {
+					break
+				}
+				max++
+			}
+		}
+
+		if len(classInfoList) == 0 {
+			return simtypes.NoOpMsg(ecocredit.ModuleName, TypeMsgPut, "different credit type"), nil, nil
+		}
+
+		var credits []*basket.BasketCredit
+		for _, info := range classInfoList {
+			batchesRes, err := qryClient.Batches(ctx, &ecocredit.QueryBatchesRequest{ClassId: info.ClassId})
+			if err != nil {
+				return simtypes.NoOpMsg(ecocredit.ModuleName, TypeMsgPut, err.Error()), nil, err
+			}
+
+			batches := batchesRes.Batches
+			if len(batches) != 0 {
+				for _, item := range batches {
+					balanceRes, err := qryClient.Balance(ctx, &ecocredit.QueryBalanceRequest{Account: owner.Address.String(), BatchDenom: item.BatchDenom})
+					if err != nil {
+						return simtypes.NoOpMsg(ecocredit.ModuleName, TypeMsgPut, err.Error()), nil, err
+					}
+
+					tradableAmount := balanceRes.TradableAmount
+					if tradableAmount != "0" {
+						d, err := math.NewPositiveDecFromString(tradableAmount)
+						if err != nil {
+							return simtypes.NoOpMsg(ecocredit.ModuleName, TypeMsgPut, err.Error()), nil, err
+						}
+
+						dInt, err := d.Int64()
+						if err != nil {
+							return simtypes.NoOpMsg(ecocredit.ModuleName, TypeMsgPut, err.Error()), nil, err
+						}
+
+						if dInt == 1 {
+							credits = append(credits, &basket.BasketCredit{
+								BatchDenom: item.BatchDenom,
+								Amount:     "1",
+							})
+						} else {
+							amt := simtypes.RandIntBetween(r, 1, int(dInt))
+							credits = append(credits, &basket.BasketCredit{
+								BatchDenom: item.BatchDenom,
+								Amount:     fmt.Sprintf("%d", amt),
+							})
+
+						}
+					}
+				}
+			}
+
+		}
+
+		if len(credits) == 0 {
+			return simtypes.NoOpMsg(ecocredit.ModuleName, TypeMsgPut, "no basket credits"), nil, nil
+		}
+
+		msg := &basket.MsgPut{
+			Owner:       owner.Address.String(),
+			BasketDenom: rBasket.BasketDenom,
+			Credits:     credits,
+		}
+		spendable := bk.SpendableCoins(sdkCtx, owner.Address)
+		fees, err := simtypes.RandomFees(r, sdkCtx, spendable)
+		if err != nil {
+			return simtypes.NoOpMsg(ecocredit.ModuleName, TypeMsgPut, "fee error"), nil, err
+		}
+
+		account := ak.GetAccount(sdkCtx, owner.Address)
+		txGen := simappparams.MakeTestEncodingConfig().TxConfig
+		tx, err := helpers.GenTx(
+			txGen,
+			[]sdk.Msg{msg},
+			fees,
+			helpers.DefaultGenTxGas,
+			chainID,
+			[]uint64{account.GetAccountNumber()},
+			[]uint64{account.GetSequence()},
+			owner.PrivKey,
+		)
+		if err != nil {
+			return simtypes.NoOpMsg(ecocredit.ModuleName, TypeMsgPut, "unable to generate mock tx"), nil, err
+		}
+
+		_, _, err = app.Deliver(txGen.TxEncoder(), tx)
+		if err != nil {
+			if strings.Contains(err.Error(), "is not allowed in this basket") {
+				return simtypes.NoOpMsg(ecocredit.ModuleName, msg.Type(), "class is not allowed"), nil, nil
+			}
+
+			return simtypes.NoOpMsg(ecocredit.ModuleName, msg.Type(), "unable to deliver tx"), nil, err
+		}
+
+		return simtypes.NewOperationMsg(msg, true, "", nil), nil, nil
 	}
 }
 
@@ -215,10 +344,13 @@ func randomClasses(r *rand.Rand, ctx regentypes.Context, qryClient ecocredit.Que
 	classes := res.GetClasses()
 	if len(classes) == 0 {
 		return []string{}, nil
+	} else if len(classes) == 1 {
+		return []string{classes[0].ClassId}, nil
 	}
 
 	max := simtypes.RandIntBetween(r, 1, len(classes))
 
+	r.Shuffle(len(classes), func(i, j int) { classes[i], classes[j] = classes[j], classes[i] })
 	classIds := make([]string, max)
 	for i := 0; i < max; i++ {
 		classIds[i] = classes[i].ClassId
@@ -240,3 +372,51 @@ func randomCreditType(r *rand.Rand, ctx regentypes.Context, qryClient ecocredit.
 
 	return creditTypes[r.Intn(len(creditTypes))], nil
 }
+
+// GenAndDeliverTxWithRandFees generates a transaction with a random fee and delivers it.
+func GenAndDeliverTxWithRandFees(txCtx simulation.OperationInput) (simtypes.OperationMsg, []simtypes.FutureOperation, error) {
+	account := txCtx.AccountKeeper.GetAccount(txCtx.Context, txCtx.SimAccount.Address)
+	spendable := txCtx.Bankkeeper.SpendableCoins(txCtx.Context, account.GetAddress())
+
+	var fees sdk.Coins
+	var err error
+
+	coins, hasNeg := spendable.SafeSub(txCtx.CoinsSpentInMsg)
+	if hasNeg {
+		return simtypes.NoOpMsg(txCtx.ModuleName, txCtx.MsgType, "message doesn't leave room for fees"), nil, err
+	}
+
+	fees, err = simtypes.RandomFees(txCtx.R, txCtx.Context, coins)
+	if err != nil {
+		return simtypes.NoOpMsg(txCtx.ModuleName, txCtx.MsgType, "unable to generate fees"), nil, err
+	}
+	return GenAndDeliverTx(txCtx, fees)
+}
+
+// GenAndDeliverTx generates a transactions and delivers it.
+func GenAndDeliverTx(txCtx simulation.OperationInput, fees sdk.Coins) (simtypes.OperationMsg, []simtypes.FutureOperation, error) {
+	account := txCtx.AccountKeeper.GetAccount(txCtx.Context, txCtx.SimAccount.Address)
+	tx, err := helpers.GenTx(
+		txCtx.TxGen,
+		[]sdk.Msg{txCtx.Msg},
+		fees,
+		helpers.DefaultGenTxGas,
+		txCtx.Context.ChainID(),
+		[]uint64{account.GetAccountNumber()},
+		[]uint64{account.GetSequence()},
+		txCtx.SimAccount.PrivKey,
+	)
+
+	if err != nil {
+		return simtypes.NoOpMsg(txCtx.ModuleName, txCtx.MsgType, "unable to generate mock tx"), nil, err
+	}
+
+	_, r1, err := txCtx.App.Deliver(txCtx.TxGen.TxEncoder(), tx)
+	fmt.Println(r1)
+	if err != nil {
+		return simtypes.NoOpMsg(txCtx.ModuleName, txCtx.MsgType, "unable to deliver tx"), nil, err
+	}
+
+	return simtypes.NewOperationMsg(txCtx.Msg, true, "", txCtx.Cdc), nil, nil
+
+}