0g-chain/x/issuance/simulation/operations.go

package simulation

import (
	"fmt"
	"math/rand"

	"github.com/cosmos/cosmos-sdk/baseapp"
	"github.com/cosmos/cosmos-sdk/codec"
	"github.com/cosmos/cosmos-sdk/simapp/helpers"
	sdk "github.com/cosmos/cosmos-sdk/types"
	"github.com/cosmos/cosmos-sdk/x/simulation"
	simappparams "github.com/kava-labs/kava/app/params"

	"github.com/kava-labs/kava/x/issuance/keeper"
	"github.com/kava-labs/kava/x/issuance/types"
)

// Simulation operation weights constants
const (
	OpWeightMsgIssue  = "op_weight_msg_issue"
	OpWeightMsgRedeem = "op_weight_msg_redeem"
	OpWeightMsgBlock  = "op_weight_msg_block"
	OpWeightMsgPause  = "op_weight_msg_pause"
)

// WeightedOperations returns all the operations from the module with their respective weights
func WeightedOperations(
	appParams simulation.AppParams, cdc *codec.Codec, ak types.AccountKeeper, k keeper.Keeper,
) simulation.WeightedOperations {
	var (
		weightMsgIssue  int
		weightMsgReedem int
		weightMsgBlock  int
		weightMsgPause  int
	)

	appParams.GetOrGenerate(cdc, OpWeightMsgIssue, &weightMsgIssue, nil,
		func(_ *rand.Rand) {
			weightMsgIssue = simappparams.DefaultWeightMsgIssue
		},
	)

	appParams.GetOrGenerate(cdc, OpWeightMsgRedeem, &weightMsgReedem, nil,
		func(_ *rand.Rand) {
			weightMsgReedem = simappparams.DefaultWeightMsgRedeem
		},
	)

	appParams.GetOrGenerate(cdc, OpWeightMsgBlock, &weightMsgBlock, nil,
		func(_ *rand.Rand) {
			weightMsgBlock = simappparams.DefaultWeightMsgBlock
		},
	)

	appParams.GetOrGenerate(cdc, OpWeightMsgPause, &weightMsgPause, nil,
		func(_ *rand.Rand) {
			weightMsgPause = simappparams.DefaultWeightMsgPause
		},
	)

	return simulation.WeightedOperations{
		simulation.NewWeightedOperation(
			weightMsgIssue,
			SimulateMsgIssueTokens(ak, k),
		),
		simulation.NewWeightedOperation(
			weightMsgReedem,
			SimulateMsgRedeemTokens(ak, k),
		),
		simulation.NewWeightedOperation(
			weightMsgBlock,
			SimulateMsgBlockAddress(ak, k),
		),
		simulation.NewWeightedOperation(
			weightMsgPause,
			SimulateMsgPause(ak, k),
		),
	}
}

// SimulateMsgIssueTokens generates a MsgIssueTokens with random values
func SimulateMsgIssueTokens(ak types.AccountKeeper, k keeper.Keeper) simulation.Operation {
	return func(
		r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, chainID string,
	) (simulation.OperationMsg, []simulation.FutureOperation, error) {
		// shuffle the assets and get a random one
		assets := k.GetParams(ctx).Assets
		r.Shuffle(len(assets), func(i, j int) {
			assets[i], assets[j] = assets[j], assets[i]
		})
		asset := assets[0]

		if asset.Paused {
			return simulation.NoOpMsg(types.ModuleName), nil, nil
		}

		// make sure owner account exists
		ownerSimAcc, found := simulation.FindAccount(accs, asset.Owner)
		if !found {
			return simulation.NoOpMsg(types.ModuleName), nil, fmt.Errorf("asset owner not found: %s", asset)
		}

		// issue new tokens to the owner 50% of the time so we have funds to redeem
		ownerAcc := ak.GetAccount(ctx, asset.Owner)
		recipient := ownerAcc
		if r.Intn(2) == 0 {
			simAccount, _ := simulation.RandomAcc(r, accs)
			recipient = ak.GetAccount(ctx, simAccount.Address)
		}
		if recipient == nil {
			return simulation.NoOpMsg(types.ModuleName), nil, nil
		}
		for _, blockedAddr := range asset.BlockedAddresses {
			if recipient.GetAddress().Equals(blockedAddr) {
				return simulation.NoOpMsg(types.ModuleName), nil, nil
			}
		}
		randomAmount := simulation.RandIntBetween(r, 10000000, 1000000000000)
		if asset.RateLimit.Active {
			supply, found := k.GetAssetSupply(ctx, asset.Denom)
			if !found {
				return simulation.NoOpMsg(types.ModuleName), nil, fmt.Errorf("issuance - no asset supply for %s", asset.Denom)
			}
			if asset.RateLimit.Limit.LT(supply.CurrentSupply.Amount.Add(sdk.NewInt(int64(randomAmount)))) {
				maxAmount := asset.RateLimit.Limit.Sub(supply.CurrentSupply.Amount)
				if maxAmount.IsPositive() && maxAmount.GT(sdk.OneInt()) {
					randomAmount = simulation.RandIntBetween(r, 1, int(maxAmount.Int64()))
				} else {
					randomAmount = 1
				}
			}

		}
		msg := types.NewMsgIssueTokens(asset.Owner, sdk.NewCoin(asset.Denom, sdk.NewInt(int64(randomAmount))), recipient.GetAddress())
		spendableCoins := ownerAcc.SpendableCoins(ctx.BlockTime())
		fees, err := simulation.RandomFees(r, ctx, spendableCoins)
		if err != nil {
			return simulation.NoOpMsg(types.ModuleName), nil, err
		}
		tx := helpers.GenTx(
			[]sdk.Msg{msg},
			fees,
			helpers.DefaultGenTxGas,
			chainID,
			[]uint64{ownerAcc.GetAccountNumber()},
			[]uint64{ownerAcc.GetSequence()},
			ownerSimAcc.PrivKey,
		)

		_, _, err = app.Deliver(tx)
		if err != nil {
			fmt.Printf("error on issue %s\n%s\n", msg, asset)
			return simulation.NoOpMsg(types.ModuleName), nil, err
		}
		return simulation.NewOperationMsg(msg, true, ""), nil, nil
	}
}

// SimulateMsgRedeemTokens generates a MsgRedeemTokens with random values
func SimulateMsgRedeemTokens(ak types.AccountKeeper, k keeper.Keeper) simulation.Operation {
	return func(
		r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, chainID string,
	) (simulation.OperationMsg, []simulation.FutureOperation, error) {
		// shuffle the assets and get a random one
		assets := k.GetParams(ctx).Assets
		r.Shuffle(len(assets), func(i, j int) {
			assets[i], assets[j] = assets[j], assets[i]
		})
		asset := assets[0]
		if asset.Paused {
			return simulation.NoOpMsg(types.ModuleName), nil, nil
		}

		// make sure owner account exists
		ownerSimAcc, found := simulation.FindAccount(accs, asset.Owner)
		if !found {
			return simulation.NoOpMsg(types.ModuleName), nil, fmt.Errorf("asset owner not found: %s", asset)
		}

		ownerAcc := ak.GetAccount(ctx, asset.Owner)

		spendableCoinAmount := ownerAcc.SpendableCoins(ctx.BlockTime()).AmountOf(asset.Denom)
		if spendableCoinAmount.IsZero() {
			return simulation.NoOpMsg(types.ModuleName), nil, nil
		}
		var redeemAmount sdk.Int
		if spendableCoinAmount.Equal(sdk.OneInt()) {
			redeemAmount = sdk.OneInt()
		} else {
			redeemAmount = sdk.NewInt(int64(simulation.RandIntBetween(r, 1, int(spendableCoinAmount.Int64()))))
		}

		msg := types.NewMsgRedeemTokens(asset.Owner, sdk.NewCoin(asset.Denom, redeemAmount))
		spendableCoins := ownerAcc.SpendableCoins(ctx.BlockTime()).Sub(sdk.NewCoins(sdk.NewCoin(asset.Denom, redeemAmount)))
		fees, err := simulation.RandomFees(r, ctx, spendableCoins)
		if err != nil {
			fmt.Printf("%s\n", msg)
			return simulation.NoOpMsg(types.ModuleName), nil, err
		}
		tx := helpers.GenTx(
			[]sdk.Msg{msg},
			fees,
			helpers.DefaultGenTxGas,
			chainID,
			[]uint64{ownerAcc.GetAccountNumber()},
			[]uint64{ownerAcc.GetSequence()},
			ownerSimAcc.PrivKey,
		)

		_, _, err = app.Deliver(tx)
		if err != nil {
			fmt.Printf("error on redeem %s\n%s\n", msg, asset)
			return simulation.NoOpMsg(types.ModuleName), nil, err
		}
		return simulation.NewOperationMsg(msg, true, ""), nil, nil
	}
}

// SimulateMsgBlockAddress generates a MsgBlockAddress with random values
func SimulateMsgBlockAddress(ak types.AccountKeeper, k keeper.Keeper) simulation.Operation {
	return func(
		r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, chainID string,
	) (simulation.OperationMsg, []simulation.FutureOperation, error) {
		// shuffle the assets and get a random one
		assets := k.GetParams(ctx).Assets
		r.Shuffle(len(assets), func(i, j int) {
			assets[i], assets[j] = assets[j], assets[i]
		})
		asset := assets[0]

		// make sure owner account exists
		ownerSimAcc, found := simulation.FindAccount(accs, asset.Owner)
		if !found {
			return simulation.NoOpMsg(types.ModuleName), nil, fmt.Errorf("asset owner not found: %s", asset)
		}
		ownerAcc := ak.GetAccount(ctx, asset.Owner)

		// find an account to block
		simAccount, _ := simulation.RandomAcc(r, accs)
		blockedAccount := ak.GetAccount(ctx, simAccount.Address)
		if blockedAccount.GetAddress().Equals(asset.Owner) {
			return simulation.NoOpMsg(types.ModuleName), nil, nil
		}
		for _, blockedAddr := range asset.BlockedAddresses {
			if blockedAccount.GetAddress().Equals(blockedAddr) {
				return simulation.NoOpMsg(types.ModuleName), nil, nil
			}
		}

		msg := types.NewMsgBlockAddress(asset.Owner, asset.Denom, blockedAccount.GetAddress())
		spendableCoins := ownerAcc.SpendableCoins(ctx.BlockTime())
		fees, err := simulation.RandomFees(r, ctx, spendableCoins)
		if err != nil {
			return simulation.NoOpMsg(types.ModuleName), nil, err
		}
		tx := helpers.GenTx(
			[]sdk.Msg{msg},
			fees,
			helpers.DefaultGenTxGas*2,
			chainID,
			[]uint64{ownerAcc.GetAccountNumber()},
			[]uint64{ownerAcc.GetSequence()},
			ownerSimAcc.PrivKey,
		)

		_, _, err = app.Deliver(tx)
		if err != nil {
			fmt.Printf("error on block %s\n%s\n", msg, asset)
			return simulation.NoOpMsg(types.ModuleName), nil, err
		}
		return simulation.NewOperationMsg(msg, true, ""), nil, nil
	}
}

// SimulateMsgPause generates a MsgChangePauseStatus with random values
func SimulateMsgPause(ak types.AccountKeeper, k keeper.Keeper) simulation.Operation {
	return func(
		r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simulation.Account, chainID string,
	) (simulation.OperationMsg, []simulation.FutureOperation, error) {
		// shuffle the assets and get a random one
		assets := k.GetParams(ctx).Assets
		r.Shuffle(len(assets), func(i, j int) {
			assets[i], assets[j] = assets[j], assets[i]
		})
		asset := assets[0]

		// make sure owner account exists
		ownerSimAcc, found := simulation.FindAccount(accs, asset.Owner)
		if !found {
			return simulation.NoOpMsg(types.ModuleName), nil, fmt.Errorf("asset owner not found: %s", asset)
		}
		ownerAcc := ak.GetAccount(ctx, asset.Owner)

		// set status to paused/un-paused
		status := r.Intn(2) == 0

		msg := types.NewMsgSetPauseStatus(asset.Owner, asset.Denom, status)
		spendableCoins := ownerAcc.SpendableCoins(ctx.BlockTime())
		fees, err := simulation.RandomFees(r, ctx, spendableCoins)
		if err != nil {
			return simulation.NoOpMsg(types.ModuleName), nil, err
		}
		tx := helpers.GenTx(
			[]sdk.Msg{msg},
			fees,
			helpers.DefaultGenTxGas*2,
			chainID,
			[]uint64{ownerAcc.GetAccountNumber()},
			[]uint64{ownerAcc.GetSequence()},
			ownerSimAcc.PrivKey,
		)

		_, _, err = app.Deliver(tx)
		if err != nil {
			fmt.Printf("error on pause %s\n%s\n", msg, asset)
			return simulation.NoOpMsg(types.ModuleName), nil, err
		}
		return simulation.NewOperationMsg(msg, true, ""), nil, nil
	}
}