github.com/fibonacci-chain/fbc@v0.0.0-20231124064014-c7636198c1e9/libs/cosmos-sdk/x/mint/internal/keeper/keeper_fbchain_test.go (about)

     1  package keeper_test
     2  
     3  import (
     4  	"testing"
     5  	"time"
     6  
     7  	"github.com/fibonacci-chain/fbc/app"
     8  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/codec"
     9  	sdk "github.com/fibonacci-chain/fbc/libs/cosmos-sdk/types"
    10  	"github.com/fibonacci-chain/fbc/libs/cosmos-sdk/x/mint/internal/types"
    11  	abci "github.com/fibonacci-chain/fbc/libs/tendermint/abci/types"
    12  	evm_types "github.com/fibonacci-chain/fbc/x/evm/types"
    13  	"github.com/stretchr/testify/suite"
    14  )
    15  
    16  type TreasuresTestSuite struct {
    17  	suite.Suite
    18  
    19  	ctx     sdk.Context
    20  	app     *app.FBChainApp
    21  	stateDB *evm_types.CommitStateDB
    22  	codec   *codec.Codec
    23  
    24  	handler sdk.Handler
    25  }
    26  
    27  func (suite *TreasuresTestSuite) SetupTest() {
    28  	checkTx := false
    29  
    30  	suite.app = app.Setup(checkTx)
    31  	suite.ctx = suite.app.BaseApp.NewContext(checkTx, abci.Header{Height: 1, ChainID: "ethermint-3", Time: time.Now().UTC()})
    32  	suite.codec = codec.New()
    33  
    34  	suite.app.MintKeeper.SetParams(suite.ctx, types.DefaultParams())
    35  	suite.app.MintKeeper.SetMinter(suite.ctx, types.InitialMinterCustom())
    36  }
    37  
    38  var (
    39  	treasure1 = types.NewTreasure(sdk.AccAddress([]byte{0x01}), sdk.NewDecWithPrec(4, 2))
    40  	treasure2 = types.NewTreasure(sdk.AccAddress([]byte{0x02}), sdk.NewDecWithPrec(3, 2))
    41  	treasure3 = types.NewTreasure(sdk.AccAddress([]byte{0x03}), sdk.NewDecWithPrec(2, 2))
    42  	treasure4 = types.NewTreasure(sdk.AccAddress([]byte{0x04}), sdk.NewDecWithPrec(1, 2))
    43  	treasure5 = types.NewTreasure(sdk.AccAddress([]byte{0x05}), sdk.NewDecWithPrec(1, 1))
    44  	treasures = []types.Treasure{*treasure1, *treasure2, *treasure3, *treasure4, *treasure5}
    45  )
    46  
    47  func TestTreasuresTestSuite(t *testing.T) {
    48  	suite.Run(t, new(TreasuresTestSuite))
    49  }
    50  
    51  func (suite *TreasuresTestSuite) TestGetSetTreasures() {
    52  	input := []types.Treasure{}
    53  	testCases := []struct {
    54  		msg      string
    55  		prepare  func()
    56  		expected []types.Treasure
    57  	}{
    58  		{
    59  			msg: "set one treasure into empty db",
    60  			prepare: func() {
    61  				input = []types.Treasure{treasures[1]}
    62  			},
    63  			expected: []types.Treasure{treasures[1]},
    64  		},
    65  		{
    66  			msg: "set one treasure into db which has one",
    67  			prepare: func() {
    68  				input = []types.Treasure{treasures[0]}
    69  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[1]})
    70  			},
    71  			expected: []types.Treasure{treasures[0]},
    72  		},
    73  		{
    74  			msg: "set one treasure(exist) into db which has one",
    75  			prepare: func() {
    76  				input = []types.Treasure{types.Treasure{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(4, 1)}}
    77  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
    78  			},
    79  			expected: []types.Treasure{types.Treasure{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(4, 1)}},
    80  		},
    81  		{
    82  			msg: "set one treasure into db which has multi",
    83  			prepare: func() {
    84  				input = []types.Treasure{treasures[0]}
    85  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[1], treasures[2]})
    86  			},
    87  			expected: []types.Treasure{treasures[0]},
    88  		},
    89  		{
    90  			msg: "set one treasure(exist) into db which has multi",
    91  			prepare: func() {
    92  				input = []types.Treasure{types.Treasure{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(4, 1)}}
    93  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[1], treasures[2], treasures[0]})
    94  			},
    95  			expected: []types.Treasure{types.Treasure{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(4, 1)}},
    96  		},
    97  		{
    98  			msg: "set multi treasure into empty db",
    99  			prepare: func() {
   100  				input = []types.Treasure{treasures[1], treasures[2], treasures[0], treasures[3], treasures[4]}
   101  			},
   102  			expected: []types.Treasure{treasures[4], treasures[3], treasures[2], treasures[1], treasures[0]},
   103  		},
   104  		{
   105  			msg: "set multi treasure into db which has one",
   106  			prepare: func() {
   107  				input = []types.Treasure{treasures[1], treasures[2], treasures[3], treasures[4]}
   108  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   109  			},
   110  			expected: []types.Treasure{treasures[4], treasures[3], treasures[2], treasures[1]},
   111  		},
   112  		{
   113  			msg: "set multi treasure(part exist) into db which has one",
   114  			prepare: func() {
   115  				input = []types.Treasure{treasures[1], treasures[2], types.Treasure{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(4, 1)}, treasures[3], treasures[4]}
   116  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   117  			},
   118  			expected: []types.Treasure{treasures[4], treasures[3], treasures[2], treasures[1], types.Treasure{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(4, 1)}},
   119  		}, {
   120  			msg: "set multi treasure into db which has multi",
   121  			prepare: func() {
   122  				input = []types.Treasure{treasures[0], treasures[3]}
   123  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[1], treasures[2]})
   124  			},
   125  			expected: []types.Treasure{treasures[3], treasures[0]},
   126  		},
   127  		{
   128  			msg: "set multi treasure(part exist) into db which has multi",
   129  			prepare: func() {
   130  				input = []types.Treasure{types.Treasure{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(4, 1)}, treasures[1], treasures[3]}
   131  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[1], treasures[2], treasures[0]})
   132  			},
   133  			expected: []types.Treasure{treasures[3], treasures[1], types.Treasure{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(4, 1)}},
   134  		},
   135  		{
   136  			msg: "set multi treasure(all exist) into db which has multi",
   137  			prepare: func() {
   138  				input = []types.Treasure{types.Treasure{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(4, 1)}, treasures[1], treasures[3]}
   139  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[1], treasures[3], treasures[0]})
   140  			},
   141  			expected: []types.Treasure{treasures[3], treasures[1], types.Treasure{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(4, 1)}},
   142  		},
   143  	}
   144  
   145  	for _, tc := range testCases {
   146  		tc.prepare()
   147  		suite.app.MintKeeper.SetTreasures(suite.ctx, input)
   148  		actual := suite.app.MintKeeper.GetTreasures(suite.ctx)
   149  		suite.Require().Equal(tc.expected, actual, tc.msg)
   150  		suite.app.MintKeeper.SetTreasures(suite.ctx, make([]types.Treasure, 0))
   151  	}
   152  }
   153  
   154  func (suite *TreasuresTestSuite) TestAllocateTokenToTreasure() {
   155  	input := sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewDecWithPrec(5, 1)))
   156  	testCases := []struct {
   157  		msg        string
   158  		treasures  func() []types.Treasure
   159  		prepare    func(trs []types.Treasure)
   160  		expectfunc func(trs []types.Treasure, remain sdk.Coins, err error, msg string)
   161  	}{
   162  		{
   163  			msg: "0.5 coin allocate 0%(one)",
   164  			treasures: func() []types.Treasure {
   165  				return []types.Treasure{{Address: sdk.AccAddress([]byte{0x01}), Proportion: sdk.NewDecWithPrec(0, 2)}}
   166  			},
   167  			prepare: func(trs []types.Treasure) {
   168  				err := suite.app.MintKeeper.MintCoins(suite.ctx, input)
   169  				suite.Require().NoError(err)
   170  				suite.app.MintKeeper.SetTreasures(suite.ctx, trs)
   171  			},
   172  			expectfunc: func(trs []types.Treasure, remain sdk.Coins, err error, msg string) {
   173  				suite.Require().NoError(err, msg)
   174  				suite.Require().Equal(sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewDecWithPrec(50, 2))), remain, msg)
   175  				for i, _ := range trs {
   176  					acc := suite.app.AccountKeeper.GetAccount(suite.ctx, trs[i].Address)
   177  					suite.Require().Equal(sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewDecWithPrec(50, 2).MulTruncate(trs[i].Proportion))).String(), acc.GetCoins().String(), msg)
   178  					err := acc.SetCoins(sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.ZeroDec())))
   179  					suite.Require().NoError(err, msg)
   180  					suite.app.AccountKeeper.SetAccount(suite.ctx, acc)
   181  				}
   182  			},
   183  		},
   184  		{
   185  			msg: "0.5 coin allocate 50%(one)",
   186  			treasures: func() []types.Treasure {
   187  				return []types.Treasure{{Address: sdk.AccAddress([]byte{0x01}), Proportion: sdk.NewDecWithPrec(50, 2)}}
   188  			},
   189  			prepare: func(trs []types.Treasure) {
   190  				err := suite.app.MintKeeper.MintCoins(suite.ctx, input)
   191  				suite.Require().NoError(err)
   192  				suite.app.MintKeeper.SetTreasures(suite.ctx, trs)
   193  			},
   194  			expectfunc: func(trs []types.Treasure, remain sdk.Coins, err error, msg string) {
   195  				suite.Require().NoError(err, msg)
   196  				suite.Require().Equal(sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewDecWithPrec(25, 2))), remain, msg)
   197  				for i, _ := range trs {
   198  					acc := suite.app.AccountKeeper.GetAccount(suite.ctx, trs[i].Address)
   199  					suite.Require().Equal(sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewDecWithPrec(25, 2))), acc.GetCoins(), msg)
   200  					err := acc.SetCoins(sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.ZeroDec())))
   201  					suite.Require().NoError(err, msg)
   202  					suite.app.AccountKeeper.SetAccount(suite.ctx, acc)
   203  				}
   204  			},
   205  		},
   206  		{
   207  			msg: "0.5 coin allocate 50%(multi)",
   208  			treasures: func() []types.Treasure {
   209  				return []types.Treasure{
   210  					{Address: sdk.AccAddress([]byte{0x01}), Proportion: sdk.NewDecWithPrec(30, 2)},
   211  					{Address: sdk.AccAddress([]byte{0x02}), Proportion: sdk.NewDecWithPrec(20, 2)},
   212  				}
   213  			},
   214  			prepare: func(trs []types.Treasure) {
   215  				err := suite.app.MintKeeper.MintCoins(suite.ctx, input)
   216  				suite.Require().NoError(err)
   217  				suite.app.MintKeeper.SetTreasures(suite.ctx, trs)
   218  			},
   219  			expectfunc: func(trs []types.Treasure, remain sdk.Coins, err error, msg string) {
   220  				suite.Require().NoError(err, msg)
   221  				suite.Require().Equal(sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewDecWithPrec(25, 2))), remain, msg)
   222  				for i, _ := range trs {
   223  					acc := suite.app.AccountKeeper.GetAccount(suite.ctx, trs[i].Address)
   224  					suite.Require().Equal(sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewDecWithPrec(50, 2).MulTruncate(trs[i].Proportion))), acc.GetCoins(), msg)
   225  					err := acc.SetCoins(sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.ZeroDec())))
   226  					suite.Require().NoError(err, msg)
   227  					suite.app.AccountKeeper.SetAccount(suite.ctx, acc)
   228  				}
   229  			},
   230  		},
   231  		{
   232  			msg: "0.5 coin allocate 60%(multi)",
   233  			treasures: func() []types.Treasure {
   234  				return []types.Treasure{
   235  					{Address: sdk.AccAddress([]byte{0x01}), Proportion: sdk.NewDecWithPrec(30, 2)},
   236  					{Address: sdk.AccAddress([]byte{0x02}), Proportion: sdk.NewDecWithPrec(30, 2)},
   237  				}
   238  			},
   239  			prepare: func(trs []types.Treasure) {
   240  				err := suite.app.MintKeeper.MintCoins(suite.ctx, input)
   241  				suite.Require().NoError(err)
   242  				suite.app.MintKeeper.SetTreasures(suite.ctx, trs)
   243  			},
   244  			expectfunc: func(trs []types.Treasure, remain sdk.Coins, err error, msg string) {
   245  				suite.Require().NoError(err, msg)
   246  				suite.Require().Equal(sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewDecWithPrec(20, 2))), remain, msg)
   247  				for i, _ := range trs {
   248  					acc := suite.app.AccountKeeper.GetAccount(suite.ctx, trs[i].Address)
   249  					suite.Require().Equal(sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewDecWithPrec(50, 2).MulTruncate(trs[i].Proportion))), acc.GetCoins(), msg)
   250  					err := acc.SetCoins(sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.ZeroDec())))
   251  					suite.Require().NoError(err, msg)
   252  					suite.app.AccountKeeper.SetAccount(suite.ctx, acc)
   253  				}
   254  			},
   255  		},
   256  		{
   257  			msg: "0.5 coin allocate 100%(multi)",
   258  			treasures: func() []types.Treasure {
   259  				return []types.Treasure{
   260  					{Address: sdk.AccAddress([]byte{0x01}), Proportion: sdk.NewDecWithPrec(60, 2)},
   261  					{Address: sdk.AccAddress([]byte{0x02}), Proportion: sdk.NewDecWithPrec(40, 2)},
   262  				}
   263  			},
   264  			prepare: func(trs []types.Treasure) {
   265  				err := suite.app.MintKeeper.MintCoins(suite.ctx, input)
   266  				suite.Require().NoError(err)
   267  				suite.app.MintKeeper.SetTreasures(suite.ctx, trs)
   268  			},
   269  			expectfunc: func(trs []types.Treasure, remain sdk.Coins, err error, msg string) {
   270  				suite.Require().NoError(err, msg)
   271  				suite.Require().Equal(sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewDecWithPrec(0, 2))).String(), remain.String(), msg)
   272  				for i, _ := range trs {
   273  					acc := suite.app.AccountKeeper.GetAccount(suite.ctx, trs[i].Address)
   274  					suite.Require().Equal(sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewDecWithPrec(50, 2).MulTruncate(trs[i].Proportion))), acc.GetCoins(), msg)
   275  					err := acc.SetCoins(sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.ZeroDec())))
   276  					suite.Require().NoError(err, msg)
   277  					suite.app.AccountKeeper.SetAccount(suite.ctx, acc)
   278  				}
   279  			},
   280  		},
   281  		{
   282  			msg: "0.7 coin allocate 60%(multi)",
   283  			treasures: func() []types.Treasure {
   284  				return []types.Treasure{
   285  					{Address: sdk.AccAddress([]byte{0x01}), Proportion: sdk.NewDecWithPrec(30, 2)},
   286  					{Address: sdk.AccAddress([]byte{0x02}), Proportion: sdk.NewDecWithPrec(30, 2)},
   287  				}
   288  			},
   289  			prepare: func(trs []types.Treasure) {
   290  				input = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewDecWithPrec(7, 1)))
   291  				err := suite.app.MintKeeper.MintCoins(suite.ctx, input)
   292  				suite.Require().NoError(err)
   293  				suite.app.MintKeeper.SetTreasures(suite.ctx, trs)
   294  			},
   295  			expectfunc: func(trs []types.Treasure, remain sdk.Coins, err error, msg string) {
   296  				suite.Require().NoError(err, msg)
   297  				suite.Require().Equal(sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewDecWithPrec(28, 2))), remain, msg)
   298  				for i, _ := range trs {
   299  					acc := suite.app.AccountKeeper.GetAccount(suite.ctx, trs[i].Address)
   300  					suite.Require().Equal(sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewDecWithPrec(70, 2).MulTruncate(trs[i].Proportion))), acc.GetCoins(), msg)
   301  					err := acc.SetCoins(sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.ZeroDec())))
   302  					suite.Require().NoError(err, msg)
   303  					suite.app.AccountKeeper.SetAccount(suite.ctx, acc)
   304  				}
   305  			},
   306  		},
   307  	}
   308  
   309  	for _, tc := range testCases {
   310  		input = sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewDecWithPrec(5, 1)))
   311  		//prepare environment
   312  		treasuresInput := tc.treasures()
   313  		tc.prepare(treasuresInput)
   314  
   315  		// handler test case
   316  		remain, err := suite.app.MintKeeper.AllocateTokenToTreasure(suite.ctx, input)
   317  
   318  		// verify
   319  		tc.expectfunc(treasuresInput, remain, err, tc.msg)
   320  
   321  		// reset environment
   322  		suite.app.MintKeeper.SetTreasures(suite.ctx, make([]types.Treasure, 0))
   323  	}
   324  }
   325  
   326  func (suite *TreasuresTestSuite) TestUpdateTreasures() {
   327  	input := []types.Treasure{}
   328  	normal := func(isPass bool, expected []types.Treasure, msg string, err error) {
   329  		if isPass {
   330  			suite.Require().NoError(err, msg)
   331  			actual := suite.app.MintKeeper.GetTreasures(suite.ctx)
   332  			suite.Require().Equal(expected, actual, msg)
   333  		} else {
   334  			suite.Require().Error(err, msg)
   335  		}
   336  	}
   337  	treasureError := func(isPass bool, expected []types.Treasure, msg string, err error) {
   338  		suite.Require().False(isPass, msg)
   339  		suite.Require().Error(err, msg)
   340  		suite.Require().Contains(err.Error(), "treasure proportion should non-negative and less than one", msg)
   341  	}
   342  	sumProportionError := func(isPass bool, expected []types.Treasure, msg string, err error) {
   343  		suite.Require().False(isPass, msg)
   344  		suite.Require().Error(err, msg)
   345  		suite.Require().Contains(err.Error(), "the sum of treasure proportion should non-negative and less than one", msg)
   346  	}
   347  	testCases := []struct {
   348  		msg        string
   349  		prepare    func()
   350  		isPass     bool
   351  		expected   []types.Treasure
   352  		expectFunc func(isPass bool, expected []types.Treasure, msg string, err error)
   353  	}{
   354  		{
   355  			msg: "insert one treasure into empty db",
   356  			prepare: func() {
   357  				input = []types.Treasure{treasures[1]}
   358  			},
   359  			isPass:     true,
   360  			expected:   []types.Treasure{treasures[1]},
   361  			expectFunc: normal,
   362  		},
   363  		{
   364  			msg: "insert one treasure(proportion is negative) into empty db",
   365  			prepare: func() {
   366  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDec(-1)}}
   367  			},
   368  			isPass:     false,
   369  			expected:   []types.Treasure{},
   370  			expectFunc: treasureError,
   371  		},
   372  		{
   373  			msg: "insert one treasure(proportion is more than one) into empty db",
   374  			prepare: func() {
   375  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDec(2)}}
   376  			},
   377  			isPass:     false,
   378  			expected:   []types.Treasure{},
   379  			expectFunc: treasureError,
   380  		},
   381  		{
   382  			msg: "insert one treasure into db which has one",
   383  			prepare: func() {
   384  				input = []types.Treasure{treasures[1]}
   385  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   386  			},
   387  			isPass:     true,
   388  			expected:   []types.Treasure{treasures[1], treasures[0]},
   389  			expectFunc: normal,
   390  		},
   391  		{
   392  			msg: "insert one treasure(proportion is negative) into db which has one",
   393  			prepare: func() {
   394  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDec(-1)}}
   395  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   396  			},
   397  			isPass:     false,
   398  			expected:   []types.Treasure{},
   399  			expectFunc: treasureError,
   400  		},
   401  		{
   402  			msg: "insert one treasure(proportion is more than one) into db which has one",
   403  			prepare: func() {
   404  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDec(2)}}
   405  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   406  			},
   407  			isPass:     false,
   408  			expected:   []types.Treasure{},
   409  			expectFunc: treasureError,
   410  		},
   411  		{
   412  			msg: "insert one treasure(sum proportion is more than one) into db which has one",
   413  			prepare: func() {
   414  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDec(1)}}
   415  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   416  			},
   417  			isPass:     false,
   418  			expected:   []types.Treasure{},
   419  			expectFunc: sumProportionError,
   420  		},
   421  		{
   422  			msg: "insert one treasure into db which has multi",
   423  			prepare: func() {
   424  				input = []types.Treasure{treasures[1]}
   425  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
   426  			},
   427  			isPass:     true,
   428  			expected:   []types.Treasure{treasures[2], treasures[1], treasures[0]},
   429  			expectFunc: normal,
   430  		},
   431  		{
   432  			msg: "insert one treasure(proportion is negative) into db which has multi",
   433  			prepare: func() {
   434  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDec(-1)}}
   435  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
   436  			},
   437  			isPass:     false,
   438  			expected:   []types.Treasure{},
   439  			expectFunc: treasureError,
   440  		},
   441  		{
   442  			msg: "insert one treasure(proportion is more than one) into db which has multi",
   443  			prepare: func() {
   444  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDec(2)}}
   445  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
   446  			},
   447  			isPass:     false,
   448  			expected:   []types.Treasure{},
   449  			expectFunc: treasureError,
   450  		},
   451  		{
   452  			msg: "insert one treasure(sum proportion is more than one) into db which has multi",
   453  			prepare: func() {
   454  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDec(1)}}
   455  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
   456  			},
   457  			isPass:     false,
   458  			expected:   []types.Treasure{},
   459  			expectFunc: sumProportionError,
   460  		},
   461  		{
   462  			msg: "insert multi treasure into empty db",
   463  			prepare: func() {
   464  				input = []types.Treasure{treasures[1], treasures[3], treasures[4], treasures[2], treasures[0]}
   465  			},
   466  			isPass:     true,
   467  			expected:   []types.Treasure{treasures[4], treasures[3], treasures[2], treasures[1], treasures[0]},
   468  			expectFunc: normal,
   469  		},
   470  		{
   471  			msg: "insert multi treasure(part negative) into empty db",
   472  			prepare: func() {
   473  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDec(-1)}, treasures[3], treasures[4], treasures[2], treasures[0]}
   474  			},
   475  			isPass:     false,
   476  			expected:   []types.Treasure{},
   477  			expectFunc: treasureError,
   478  		},
   479  		{
   480  			msg: "insert multi treasure(all negative) into empty db",
   481  			prepare: func() {
   482  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDec(-1)}, {Address: treasures[3].Address, Proportion: sdk.NewDec(-1)}, {Address: treasures[4].Address, Proportion: sdk.NewDec(-1)}}
   483  			},
   484  			isPass:     false,
   485  			expected:   []types.Treasure{},
   486  			expectFunc: treasureError,
   487  		},
   488  		{
   489  			msg: "insert multi treasure(more than one) into empty db",
   490  			prepare: func() {
   491  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDec(2)}, treasures[2]}
   492  			},
   493  			isPass:     false,
   494  			expected:   []types.Treasure{},
   495  			expectFunc: treasureError,
   496  		},
   497  		{
   498  			msg: "insert multi treasure(all more than one) into empty db",
   499  			prepare: func() {
   500  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDec(2)}, {Address: treasures[2].Address, Proportion: sdk.NewDec(2)}}
   501  			},
   502  			isPass:     false,
   503  			expected:   []types.Treasure{},
   504  			expectFunc: treasureError,
   505  		},
   506  		{
   507  			msg: "insert multi treasure(the sum proportion more than one) into empty db",
   508  			prepare: func() {
   509  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDecWithPrec(5, 1)}, {Address: treasures[2].Address, Proportion: sdk.NewDecWithPrec(6, 1)}}
   510  			},
   511  			isPass:     false,
   512  			expected:   []types.Treasure{},
   513  			expectFunc: sumProportionError,
   514  		},
   515  		{
   516  			msg: "insert multi treasure into db which has one",
   517  			prepare: func() {
   518  				input = []types.Treasure{treasures[1], treasures[3], treasures[4], treasures[2]}
   519  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   520  			},
   521  			isPass:     true,
   522  			expected:   []types.Treasure{treasures[4], treasures[3], treasures[2], treasures[1], treasures[0]},
   523  			expectFunc: normal,
   524  		},
   525  		{
   526  			msg: "insert multi treasure(negative) into db which has one",
   527  			prepare: func() {
   528  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDec(-1)}, treasures[3], treasures[4], treasures[2]}
   529  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   530  			},
   531  			isPass:     false,
   532  			expected:   []types.Treasure{},
   533  			expectFunc: treasureError,
   534  		},
   535  		{
   536  			msg: "insert multi treasure(part negative) into db which has one",
   537  			prepare: func() {
   538  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDec(-1)}, {Address: treasures[3].Address, Proportion: sdk.NewDec(-1)}, treasures[4], treasures[2]}
   539  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   540  			},
   541  			isPass:     false,
   542  			expected:   []types.Treasure{},
   543  			expectFunc: treasureError,
   544  		},
   545  		{
   546  			msg: "insert multi treasure(all negative) into db which has one",
   547  			prepare: func() {
   548  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDec(-1)}, {Address: treasures[3].Address, Proportion: sdk.NewDec(-1)}, {Address: treasures[4].Address, Proportion: sdk.NewDec(-1)}}
   549  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   550  			},
   551  			isPass:     false,
   552  			expected:   []types.Treasure{},
   553  			expectFunc: treasureError,
   554  		},
   555  		{
   556  			msg: "insert multi treasure(more than one) into db which has one",
   557  			prepare: func() {
   558  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDecWithPrec(2, 0)}, treasures[3], treasures[4], treasures[2]}
   559  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   560  			},
   561  			isPass:     false,
   562  			expected:   []types.Treasure{},
   563  			expectFunc: treasureError,
   564  		},
   565  		{
   566  			msg: "insert multi treasure(part more than one) into db which has one",
   567  			prepare: func() {
   568  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDecWithPrec(2, 0)}, {Address: treasures[3].Address, Proportion: sdk.NewDecWithPrec(2, 0)}, treasures[4], treasures[2]}
   569  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   570  			},
   571  			isPass:     false,
   572  			expected:   []types.Treasure{},
   573  			expectFunc: treasureError,
   574  		},
   575  		{
   576  			msg: "insert multi treasure(all more than one) into db which has one",
   577  			prepare: func() {
   578  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDecWithPrec(2, 0)}, {Address: treasures[3].Address, Proportion: sdk.NewDecWithPrec(2, 0)}, {Address: treasures[4].Address, Proportion: sdk.NewDecWithPrec(2, 0)}}
   579  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   580  			},
   581  			isPass:     false,
   582  			expected:   []types.Treasure{},
   583  			expectFunc: treasureError,
   584  		},
   585  		{
   586  			msg: "insert multi treasure(the sum proportion more than one) into db which has one",
   587  			prepare: func() {
   588  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDecWithPrec(2, 1)}, {Address: treasures[3].Address, Proportion: sdk.NewDecWithPrec(8, 1)}, {Address: treasures[4].Address, Proportion: sdk.NewDecWithPrec(2, 2)}}
   589  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   590  			},
   591  			isPass:     false,
   592  			expected:   []types.Treasure{},
   593  			expectFunc: sumProportionError,
   594  		},
   595  		{
   596  			msg: "insert multi treasure into db which has one (the result treasures's sum proportion more than one)",
   597  			prepare: func() {
   598  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDecWithPrec(2, 1)}, {Address: treasures[3].Address, Proportion: sdk.NewDecWithPrec(8, 1)}}
   599  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   600  			},
   601  			isPass:     false,
   602  			expected:   []types.Treasure{},
   603  			expectFunc: sumProportionError,
   604  		},
   605  		{
   606  			msg: "insert multi treasure into db which has multi",
   607  			prepare: func() {
   608  				input = []types.Treasure{treasures[1], treasures[3], treasures[4]}
   609  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
   610  			},
   611  			isPass:     true,
   612  			expected:   []types.Treasure{treasures[4], treasures[3], treasures[2], treasures[1], treasures[0]},
   613  			expectFunc: normal,
   614  		},
   615  		{
   616  			msg: "insert multi treasure(negative) into db which has multi",
   617  			prepare: func() {
   618  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDec(-1)}, treasures[3], treasures[4], treasures[2]}
   619  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
   620  			},
   621  			isPass:     false,
   622  			expected:   []types.Treasure{},
   623  			expectFunc: treasureError,
   624  		},
   625  		{
   626  			msg: "insert multi treasure(part negative) into db which has multi",
   627  			prepare: func() {
   628  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDec(-1)}, {Address: treasures[3].Address, Proportion: sdk.NewDec(-1)}, treasures[4]}
   629  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
   630  			},
   631  			isPass:     false,
   632  			expected:   []types.Treasure{},
   633  			expectFunc: treasureError,
   634  		},
   635  		{
   636  			msg: "insert multi treasure(all negative) into db which has multi",
   637  			prepare: func() {
   638  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDec(-1)}, {Address: treasures[3].Address, Proportion: sdk.NewDec(-1)}, {Address: treasures[4].Address, Proportion: sdk.NewDec(-1)}}
   639  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
   640  			},
   641  			isPass:     false,
   642  			expected:   []types.Treasure{},
   643  			expectFunc: treasureError,
   644  		},
   645  		{
   646  			msg: "insert multi treasure(more than one) into db which has multi",
   647  			prepare: func() {
   648  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDecWithPrec(2, 0)}, treasures[3], treasures[4]}
   649  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
   650  			},
   651  			isPass:     false,
   652  			expected:   []types.Treasure{},
   653  			expectFunc: treasureError,
   654  		},
   655  		{
   656  			msg: "insert multi treasure(part more than one) into db which has multi",
   657  			prepare: func() {
   658  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDecWithPrec(2, 0)}, {Address: treasures[3].Address, Proportion: sdk.NewDecWithPrec(2, 0)}, treasures[4]}
   659  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
   660  			},
   661  			isPass:     false,
   662  			expected:   []types.Treasure{},
   663  			expectFunc: treasureError,
   664  		},
   665  		{
   666  			msg: "insert multi treasure(all more than one) into db which has multi",
   667  			prepare: func() {
   668  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDecWithPrec(2, 0)}, {Address: treasures[3].Address, Proportion: sdk.NewDecWithPrec(2, 0)}, {Address: treasures[4].Address, Proportion: sdk.NewDecWithPrec(2, 0)}}
   669  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
   670  			},
   671  			isPass:     false,
   672  			expected:   []types.Treasure{},
   673  			expectFunc: treasureError,
   674  		},
   675  		{
   676  			msg: "insert multi treasure(the sum proportion more than one) into db which has multi",
   677  			prepare: func() {
   678  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDecWithPrec(2, 1)}, {Address: treasures[3].Address, Proportion: sdk.NewDecWithPrec(8, 1)}, {Address: treasures[4].Address, Proportion: sdk.NewDecWithPrec(2, 2)}}
   679  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
   680  			},
   681  			isPass:     false,
   682  			expected:   []types.Treasure{},
   683  			expectFunc: sumProportionError,
   684  		},
   685  		{
   686  			msg: "insert multi treasure into db which has one (the result treasures's sum proportion more than multi)",
   687  			prepare: func() {
   688  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDecWithPrec(2, 1)}, {Address: treasures[3].Address, Proportion: sdk.NewDecWithPrec(8, 1)}}
   689  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
   690  			},
   691  			isPass:     false,
   692  			expected:   []types.Treasure{},
   693  			expectFunc: sumProportionError,
   694  		},
   695  		{
   696  			msg: "update one treasure with one db",
   697  			prepare: func() {
   698  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(8, 2)}}
   699  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   700  			},
   701  			isPass:     true,
   702  			expected:   []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(8, 2)}},
   703  			expectFunc: normal,
   704  		},
   705  		{
   706  			msg: "update one treasure(negative) with one db",
   707  			prepare: func() {
   708  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDec(-1)}}
   709  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   710  			},
   711  			isPass:     false,
   712  			expected:   []types.Treasure{},
   713  			expectFunc: treasureError,
   714  		},
   715  		{
   716  			msg: "update one treasure(more than one) with one db",
   717  			prepare: func() {
   718  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDec(3)}}
   719  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   720  			},
   721  			isPass:     false,
   722  			expected:   []types.Treasure{},
   723  			expectFunc: treasureError,
   724  		},
   725  		{
   726  			msg: "update one treasure with multi db",
   727  			prepare: func() {
   728  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(8, 2)}}
   729  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
   730  			},
   731  			isPass:     true,
   732  			expected:   []types.Treasure{treasures[2], {Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(8, 2)}},
   733  			expectFunc: normal,
   734  		},
   735  		{
   736  			msg: "update one treasure(negative) with multi db",
   737  			prepare: func() {
   738  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDec(-1)}}
   739  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
   740  			},
   741  			isPass:     false,
   742  			expected:   []types.Treasure{},
   743  			expectFunc: treasureError,
   744  		},
   745  		{
   746  			msg: "update one treasure(more than one) with multi db",
   747  			prepare: func() {
   748  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDec(5)}}
   749  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
   750  			},
   751  			isPass:     false,
   752  			expected:   []types.Treasure{},
   753  			expectFunc: treasureError,
   754  		},
   755  		{
   756  			msg: "update one treasure(the sum proportion more than one) with multi db",
   757  			prepare: func() {
   758  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(1, 0)}}
   759  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
   760  			},
   761  			isPass:     false,
   762  			expected:   []types.Treasure{},
   763  			expectFunc: sumProportionError,
   764  		},
   765  		{
   766  			msg: "update multi treasure with one db",
   767  			prepare: func() {
   768  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(8, 2)}, treasures[2]}
   769  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   770  			},
   771  			isPass:     true,
   772  			expected:   []types.Treasure{treasures[2], {Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(8, 2)}},
   773  			expectFunc: normal,
   774  		},
   775  		{
   776  			msg: "update multi treasure(negative) with one db",
   777  			prepare: func() {
   778  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(-8, 2)}, treasures[2]}
   779  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   780  			},
   781  			isPass:     false,
   782  			expected:   []types.Treasure{},
   783  			expectFunc: treasureError,
   784  		},
   785  		{
   786  			msg: "update multi treasure(more than one) with one db",
   787  			prepare: func() {
   788  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(8, 0)}, treasures[2]}
   789  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   790  			},
   791  			isPass:     false,
   792  			expected:   []types.Treasure{},
   793  			expectFunc: treasureError,
   794  		},
   795  		{
   796  			msg: "update multi treasure(the sum proportion more than one) with one db",
   797  			prepare: func() {
   798  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(1, 0)}, treasures[2]}
   799  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   800  			},
   801  			isPass:     false,
   802  			expected:   []types.Treasure{},
   803  			expectFunc: sumProportionError,
   804  		},
   805  		{
   806  			msg: "update multi treasure(part) with multi db",
   807  			prepare: func() {
   808  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(8, 2)}, {Address: treasures[2].Address, Proportion: sdk.NewDecWithPrec(10, 2)}}
   809  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[3]})
   810  			},
   811  			isPass:     true,
   812  			expected:   []types.Treasure{treasures[3], {Address: treasures[2].Address, Proportion: sdk.NewDecWithPrec(10, 2)}, {Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(8, 2)}},
   813  			expectFunc: normal,
   814  		},
   815  		{
   816  			msg: "update multi treasure(part negtive) with multi db",
   817  			prepare: func() {
   818  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(-8, 2)}, {Address: treasures[2].Address, Proportion: sdk.NewDecWithPrec(-10, 2)}}
   819  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[3]})
   820  			},
   821  			isPass:     false,
   822  			expected:   []types.Treasure{},
   823  			expectFunc: treasureError,
   824  		},
   825  		{
   826  			msg: "update multi treasure(part more than one) with multi db",
   827  			prepare: func() {
   828  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(8, 0)}, {Address: treasures[2].Address, Proportion: sdk.NewDecWithPrec(10, 0)}}
   829  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[3]})
   830  			},
   831  			isPass:     false,
   832  			expected:   []types.Treasure{},
   833  			expectFunc: treasureError,
   834  		},
   835  		{
   836  			msg: "update multi treasure(part the sum proportion more than one) with multi db",
   837  			prepare: func() {
   838  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(8, 1)}, {Address: treasures[2].Address, Proportion: sdk.NewDecWithPrec(2, 1)}}
   839  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[3]})
   840  			},
   841  			isPass:     false,
   842  			expected:   []types.Treasure{},
   843  			expectFunc: sumProportionError,
   844  		},
   845  		{
   846  			msg: "update multi treasure(all) with multi db",
   847  			prepare: func() {
   848  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(8, 2)}, {Address: treasures[2].Address, Proportion: sdk.NewDecWithPrec(10, 2)}}
   849  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
   850  			},
   851  			isPass:     true,
   852  			expected:   []types.Treasure{{Address: treasures[2].Address, Proportion: sdk.NewDecWithPrec(10, 2)}, {Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(8, 2)}},
   853  			expectFunc: normal,
   854  		},
   855  		{
   856  			msg: "update multi treasure(all negative1) with multi db",
   857  			prepare: func() {
   858  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(-8, 2)}, {Address: treasures[2].Address, Proportion: sdk.NewDecWithPrec(-10, 2)}}
   859  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
   860  			},
   861  			isPass:     false,
   862  			expected:   []types.Treasure{},
   863  			expectFunc: treasureError,
   864  		},
   865  		{
   866  			msg: "update multi treasure(all negative2) with multi db",
   867  			prepare: func() {
   868  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(-8, 2)}, {Address: treasures[2].Address, Proportion: sdk.NewDecWithPrec(10, 2)}}
   869  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
   870  			},
   871  			isPass:     false,
   872  			expected:   []types.Treasure{},
   873  			expectFunc: treasureError,
   874  		},
   875  		{
   876  			msg: "update multi treasure(all more than one 1) with multi db",
   877  			prepare: func() {
   878  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(8, 0)}, {Address: treasures[2].Address, Proportion: sdk.NewDecWithPrec(10, 2)}}
   879  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
   880  			},
   881  			isPass:     false,
   882  			expected:   []types.Treasure{},
   883  			expectFunc: treasureError,
   884  		},
   885  		{
   886  			msg: "update multi treasure(all more than one 2) with multi db",
   887  			prepare: func() {
   888  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(8, 0)}, {Address: treasures[2].Address, Proportion: sdk.NewDecWithPrec(10, 0)}}
   889  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
   890  			},
   891  			isPass:     false,
   892  			expected:   []types.Treasure{},
   893  			expectFunc: treasureError,
   894  		},
   895  		{
   896  			msg: "update multi treasure(all the sum proportion more than one) with multi db",
   897  			prepare: func() {
   898  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(8, 1)}, {Address: treasures[2].Address, Proportion: sdk.NewDecWithPrec(23, 2)}}
   899  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
   900  			},
   901  			isPass:     false,
   902  			expected:   []types.Treasure{},
   903  			expectFunc: sumProportionError,
   904  		},
   905  	}
   906  
   907  	for _, tc := range testCases {
   908  		//prepare environment
   909  		tc.prepare()
   910  
   911  		// handler test case
   912  		err := suite.app.MintKeeper.UpdateTreasures(suite.ctx, input)
   913  		//verify test case expect
   914  		tc.expectFunc(tc.isPass, tc.expected, tc.msg, err)
   915  
   916  		// reset environment
   917  		suite.app.MintKeeper.SetTreasures(suite.ctx, make([]types.Treasure, 0))
   918  	}
   919  }
   920  
   921  func (suite *TreasuresTestSuite) TestDeleteTreasures() {
   922  	input := []types.Treasure{}
   923  	normal := func(isPass bool, expected []types.Treasure, msg string, err error) {
   924  		if isPass {
   925  			suite.Require().NoError(err)
   926  			actual := suite.app.MintKeeper.GetTreasures(suite.ctx)
   927  			suite.Require().Equal(expected, actual, msg)
   928  		} else {
   929  			suite.Require().Error(err)
   930  		}
   931  	}
   932  	unexistError := func(isPass bool, expected []types.Treasure, msg string, err error) {
   933  		suite.Require().False(isPass, msg)
   934  		suite.Require().Error(err, msg)
   935  		suite.Require().Contains(err.Error(), "because it's not exist from treasures", msg)
   936  	}
   937  	testCases := []struct {
   938  		msg        string
   939  		prepare    func()
   940  		isPass     bool
   941  		expected   []types.Treasure
   942  		expectFunc func(isPass bool, expected []types.Treasure, msg string, err error)
   943  	}{
   944  		{
   945  			msg: "delete one treasure from empty db",
   946  			prepare: func() {
   947  				input = []types.Treasure{treasures[1]}
   948  			},
   949  			isPass:     false,
   950  			expected:   nil,
   951  			expectFunc: unexistError,
   952  		},
   953  		{
   954  			msg: "delete multi treasure from empty db",
   955  			prepare: func() {
   956  				input = []types.Treasure{treasures[1], treasures[0]}
   957  			},
   958  			isPass:     false,
   959  			expectFunc: unexistError,
   960  		},
   961  		{
   962  			msg: "delete one treasure from one db",
   963  			prepare: func() {
   964  				input = []types.Treasure{treasures[1]}
   965  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[1]})
   966  			},
   967  			isPass:     true,
   968  			expected:   nil,
   969  			expectFunc: normal,
   970  		},
   971  		{
   972  			msg: "delete one treasure(not exist) from one db",
   973  			prepare: func() {
   974  				input = []types.Treasure{treasures[1]}
   975  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   976  			},
   977  			isPass:     false,
   978  			expected:   []types.Treasure{},
   979  			expectFunc: unexistError,
   980  		},
   981  		{
   982  			msg: "delete one treasure(negative) from one db",
   983  			prepare: func() {
   984  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(-1, 0)}}
   985  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   986  			},
   987  			isPass:     true,
   988  			expected:   nil,
   989  			expectFunc: normal,
   990  		},
   991  		{
   992  			msg: "delete one treasure(negative,not exist) from one db",
   993  			prepare: func() {
   994  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDecWithPrec(-1, 0)}}
   995  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
   996  			},
   997  			isPass:     false,
   998  			expected:   []types.Treasure{},
   999  			expectFunc: unexistError,
  1000  		},
  1001  		{
  1002  			msg: "delete one treasure(more than one) from one db",
  1003  			prepare: func() {
  1004  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(2, 0)}}
  1005  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
  1006  			},
  1007  			isPass:     true,
  1008  			expected:   nil,
  1009  			expectFunc: normal,
  1010  		},
  1011  		{
  1012  			msg: "delete one treasure(more than one,not exist) from one db",
  1013  			prepare: func() {
  1014  				input = []types.Treasure{{Address: treasures[1].Address, Proportion: sdk.NewDecWithPrec(2, 0)}}
  1015  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0]})
  1016  			},
  1017  			isPass:     false,
  1018  			expected:   []types.Treasure{},
  1019  			expectFunc: unexistError,
  1020  		},
  1021  		{
  1022  			msg: "delete one treasures from multi",
  1023  			prepare: func() {
  1024  				input = []types.Treasure{treasures[0]}
  1025  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[1], treasures[0]})
  1026  			},
  1027  			isPass:     true,
  1028  			expected:   []types.Treasure{treasures[1]},
  1029  			expectFunc: normal,
  1030  		},
  1031  		{
  1032  			msg: "delete one treasures(no exist) from multi",
  1033  			prepare: func() {
  1034  				input = []types.Treasure{treasures[2]}
  1035  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[1], treasures[0]})
  1036  			},
  1037  			isPass:     false,
  1038  			expected:   []types.Treasure{},
  1039  			expectFunc: unexistError,
  1040  		},
  1041  		{
  1042  			msg: "delete one treasures(negative) from multi",
  1043  			prepare: func() {
  1044  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(-1, 0)}}
  1045  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[1], treasures[0]})
  1046  			},
  1047  			isPass:     true,
  1048  			expected:   []types.Treasure{treasures[1]},
  1049  			expectFunc: normal,
  1050  		},
  1051  		{
  1052  			msg: "delete one treasures(negative,not exist) from multi",
  1053  			prepare: func() {
  1054  				input = []types.Treasure{{Address: treasures[2].Address, Proportion: sdk.NewDecWithPrec(-1, 0)}}
  1055  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[1], treasures[0]})
  1056  			},
  1057  			isPass:     false,
  1058  			expected:   []types.Treasure{},
  1059  			expectFunc: unexistError,
  1060  		},
  1061  		{
  1062  			msg: "delete one treasures(more than one) from multi",
  1063  			prepare: func() {
  1064  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(2, 0)}}
  1065  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[1], treasures[0]})
  1066  			},
  1067  			isPass:     true,
  1068  			expected:   []types.Treasure{treasures[1]},
  1069  			expectFunc: normal,
  1070  		},
  1071  		{
  1072  			msg: "delete one treasures(more than one,not exist) from multi",
  1073  			prepare: func() {
  1074  				input = []types.Treasure{{Address: treasures[2].Address, Proportion: sdk.NewDecWithPrec(2, 0)}}
  1075  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[1], treasures[0]})
  1076  			},
  1077  			isPass:     false,
  1078  			expected:   []types.Treasure{},
  1079  			expectFunc: unexistError,
  1080  		},
  1081  		{
  1082  			msg: "delete multi treasures from multi",
  1083  			prepare: func() {
  1084  				input = []types.Treasure{treasures[0], treasures[1]}
  1085  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[1], treasures[0]})
  1086  			},
  1087  			isPass:     true,
  1088  			expected:   nil,
  1089  			expectFunc: normal,
  1090  		},
  1091  		{
  1092  			msg: "delete multi treasures(part) from multi",
  1093  			prepare: func() {
  1094  				input = []types.Treasure{treasures[0], treasures[1]}
  1095  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[1], treasures[0], treasures[2]})
  1096  			},
  1097  			isPass:     true,
  1098  			expected:   []types.Treasure{treasures[2]},
  1099  			expectFunc: normal,
  1100  		},
  1101  		{
  1102  			msg: "delete multi treasures(part,part negative) from multi",
  1103  			prepare: func() {
  1104  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(-1, 0)}, treasures[1]}
  1105  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[1], treasures[0], treasures[2]})
  1106  			},
  1107  			isPass:     true,
  1108  			expected:   []types.Treasure{treasures[2]},
  1109  			expectFunc: normal,
  1110  		},
  1111  		{
  1112  			msg: "delete multi treasures(part,all negative) from multi",
  1113  			prepare: func() {
  1114  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(-1, 0)}, {Address: treasures[1].Address, Proportion: sdk.NewDecWithPrec(-1, 0)}}
  1115  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[1], treasures[0], treasures[2]})
  1116  			},
  1117  			isPass:     true,
  1118  			expected:   []types.Treasure{treasures[2]},
  1119  			expectFunc: normal,
  1120  		},
  1121  		{
  1122  			msg: "delete multi treasures(part,part more than one) from multi",
  1123  			prepare: func() {
  1124  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(8, 0)}, treasures[1]}
  1125  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[1], treasures[0], treasures[2]})
  1126  			},
  1127  			isPass:     true,
  1128  			expected:   []types.Treasure{treasures[2]},
  1129  			expectFunc: normal,
  1130  		},
  1131  		{
  1132  			msg: "delete multi treasures(part,all more than one) from multi",
  1133  			prepare: func() {
  1134  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(8, 0)}, {Address: treasures[1].Address, Proportion: sdk.NewDecWithPrec(8, 0)}}
  1135  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[1], treasures[0], treasures[2]})
  1136  			},
  1137  			isPass:     true,
  1138  			expected:   []types.Treasure{treasures[2]},
  1139  			expectFunc: normal,
  1140  		},
  1141  		{
  1142  			msg: "delete multi treasures(part,the sum proportion more than one) from multi",
  1143  			prepare: func() {
  1144  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(2, 1)}, {Address: treasures[1].Address, Proportion: sdk.NewDecWithPrec(83, 2)}}
  1145  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[1], treasures[0], treasures[2]})
  1146  			},
  1147  			isPass:     true,
  1148  			expected:   []types.Treasure{treasures[2]},
  1149  			expectFunc: normal,
  1150  		},
  1151  		{
  1152  			msg: "delete multi treasures(part,part not exist) from multi",
  1153  			prepare: func() {
  1154  				input = []types.Treasure{treasures[0], treasures[1]}
  1155  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
  1156  			},
  1157  			isPass:     false,
  1158  			expected:   nil,
  1159  			expectFunc: unexistError,
  1160  		},
  1161  		{
  1162  			msg: "delete multi treasures(part,negative part not exist) from multi",
  1163  			prepare: func() {
  1164  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(-1, 0)}, treasures[1]}
  1165  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
  1166  			},
  1167  			isPass:     false,
  1168  			expected:   nil,
  1169  			expectFunc: unexistError,
  1170  		},
  1171  		{
  1172  			msg: "delete multi treasures(part,more than one part not exist) from multi",
  1173  			prepare: func() {
  1174  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(2, 0)}, treasures[1]}
  1175  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
  1176  			},
  1177  			isPass:     false,
  1178  			expected:   nil,
  1179  			expectFunc: unexistError,
  1180  		},
  1181  		{
  1182  			msg: "delete multi treasures(part,the sumproportion more than one, part not exist) from multi",
  1183  			prepare: func() {
  1184  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(2, 1)}, {Address: treasures[1].Address, Proportion: sdk.NewDecWithPrec(83, 2)}}
  1185  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[0], treasures[2]})
  1186  			},
  1187  			isPass:     false,
  1188  			expected:   nil,
  1189  			expectFunc: unexistError,
  1190  		},
  1191  		{
  1192  			msg: "delete multi treasures(part,all not exist) from multi",
  1193  			prepare: func() {
  1194  				input = []types.Treasure{treasures[0], treasures[1]}
  1195  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[3], treasures[2]})
  1196  			},
  1197  			isPass:     false,
  1198  			expected:   nil,
  1199  			expectFunc: unexistError,
  1200  		},
  1201  		{
  1202  			msg: "delete multi treasures(part,negative,all not exist) from multi",
  1203  			prepare: func() {
  1204  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(-1, 0)}, treasures[1]}
  1205  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[3], treasures[2]})
  1206  			},
  1207  			isPass:     false,
  1208  			expected:   nil,
  1209  			expectFunc: unexistError,
  1210  		},
  1211  		{
  1212  			msg: "delete multi treasures(part,more than one all not exist) from multi",
  1213  			prepare: func() {
  1214  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(2, 0)}, treasures[1]}
  1215  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[3], treasures[2]})
  1216  			},
  1217  			isPass:     false,
  1218  			expected:   nil,
  1219  			expectFunc: unexistError,
  1220  		},
  1221  		{
  1222  			msg: "delete multi treasures(part,the sumproportion more than one, all not exist) from multi",
  1223  			prepare: func() {
  1224  				input = []types.Treasure{{Address: treasures[0].Address, Proportion: sdk.NewDecWithPrec(2, 1)}, {Address: treasures[1].Address, Proportion: sdk.NewDecWithPrec(83, 2)}}
  1225  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[3], treasures[2]})
  1226  			},
  1227  			isPass:     false,
  1228  			expected:   nil,
  1229  			expectFunc: unexistError,
  1230  		},
  1231  		{
  1232  			msg: "delete multi treasures from one",
  1233  			prepare: func() {
  1234  				input = []types.Treasure{treasures[0], treasures[1]}
  1235  				suite.app.MintKeeper.SetTreasures(suite.ctx, []types.Treasure{treasures[1]})
  1236  			},
  1237  			isPass:     false,
  1238  			expected:   nil,
  1239  			expectFunc: unexistError,
  1240  		},
  1241  	}
  1242  
  1243  	for _, tc := range testCases {
  1244  		//prepare environment
  1245  		tc.prepare()
  1246  
  1247  		// handler test case
  1248  		err := suite.app.MintKeeper.DeleteTreasures(suite.ctx, input)
  1249  		//verify test case expect
  1250  		tc.expectFunc(tc.isPass, tc.expected, tc.msg, err)
  1251  
  1252  		// reset environment
  1253  		suite.app.MintKeeper.SetTreasures(suite.ctx, make([]types.Treasure, 0))
  1254  	}
  1255  }