mirror of
				https://github.com/0glabs/0g-chain.git
				synced 2025-11-04 03:07:28 +00:00 
			
		
		
		
	
		
			
				
	
	
		
			704 lines
		
	
	
		
			16 KiB
		
	
	
	
		
			Go
		
	
	
	
	
	
			
		
		
	
	
			704 lines
		
	
	
		
			16 KiB
		
	
	
	
		
			Go
		
	
	
	
	
	
package keeper_test
 | 
						|
 | 
						|
import (
 | 
						|
	"strings"
 | 
						|
	"testing"
 | 
						|
	"time"
 | 
						|
 | 
						|
	"github.com/stretchr/testify/suite"
 | 
						|
 | 
						|
	sdkmath "cosmossdk.io/math"
 | 
						|
	sdk "github.com/cosmos/cosmos-sdk/types"
 | 
						|
 | 
						|
	tmproto "github.com/cometbft/cometbft/proto/tendermint/types"
 | 
						|
	tmtime "github.com/cometbft/cometbft/types/time"
 | 
						|
 | 
						|
	"github.com/0glabs/0g-chain/app"
 | 
						|
	"github.com/0glabs/0g-chain/chaincfg"
 | 
						|
	"github.com/0glabs/0g-chain/x/bep3/keeper"
 | 
						|
	"github.com/0glabs/0g-chain/x/bep3/types"
 | 
						|
)
 | 
						|
 | 
						|
type AssetTestSuite struct {
 | 
						|
	suite.Suite
 | 
						|
 | 
						|
	keeper keeper.Keeper
 | 
						|
	app    app.TestApp
 | 
						|
	ctx    sdk.Context
 | 
						|
}
 | 
						|
 | 
						|
func (suite *AssetTestSuite) SetupTest() {
 | 
						|
	chaincfg.SetSDKConfig()
 | 
						|
 | 
						|
	// Initialize test app and set context
 | 
						|
	tApp := app.NewTestApp()
 | 
						|
	ctx := tApp.NewContext(true, tmproto.Header{Height: 1, Time: tmtime.Now()})
 | 
						|
 | 
						|
	// Initialize genesis state
 | 
						|
	deputy, _ := sdk.AccAddressFromBech32(TestDeputy)
 | 
						|
	tApp.InitializeFromGenesisStates(NewBep3GenStateMulti(tApp.AppCodec(), deputy))
 | 
						|
 | 
						|
	keeper := tApp.GetBep3Keeper()
 | 
						|
	params := keeper.GetParams(ctx)
 | 
						|
	params.AssetParams[0].SupplyLimit.Limit = sdkmath.NewInt(50)
 | 
						|
	params.AssetParams[1].SupplyLimit.Limit = sdkmath.NewInt(100)
 | 
						|
	params.AssetParams[1].SupplyLimit.TimeBasedLimit = sdkmath.NewInt(15)
 | 
						|
	keeper.SetParams(ctx, params)
 | 
						|
	// Set asset supply with standard value for testing
 | 
						|
	supply := types.NewAssetSupply(c("bnb", 5), c("bnb", 5), c("bnb", 40), c("bnb", 0), time.Duration(0))
 | 
						|
	keeper.SetAssetSupply(ctx, supply, supply.IncomingSupply.Denom)
 | 
						|
 | 
						|
	supply = types.NewAssetSupply(c("inc", 10), c("inc", 5), c("inc", 5), c("inc", 0), time.Duration(0))
 | 
						|
	keeper.SetAssetSupply(ctx, supply, supply.IncomingSupply.Denom)
 | 
						|
	keeper.SetPreviousBlockTime(ctx, ctx.BlockTime())
 | 
						|
 | 
						|
	suite.app = tApp
 | 
						|
	suite.ctx = ctx
 | 
						|
	suite.keeper = keeper
 | 
						|
}
 | 
						|
 | 
						|
func (suite *AssetTestSuite) TestIncrementCurrentAssetSupply() {
 | 
						|
	type args struct {
 | 
						|
		coin sdk.Coin
 | 
						|
	}
 | 
						|
	testCases := []struct {
 | 
						|
		name       string
 | 
						|
		args       args
 | 
						|
		expectPass bool
 | 
						|
	}{
 | 
						|
		{
 | 
						|
			"normal",
 | 
						|
			args{
 | 
						|
				coin: c("bnb", 5),
 | 
						|
			},
 | 
						|
			true,
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"equal limit",
 | 
						|
			args{
 | 
						|
				coin: c("bnb", 10),
 | 
						|
			},
 | 
						|
			true,
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"exceeds limit",
 | 
						|
			args{
 | 
						|
				coin: c("bnb", 11),
 | 
						|
			},
 | 
						|
			false,
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"unsupported asset",
 | 
						|
			args{
 | 
						|
				coin: c("xyz", 5),
 | 
						|
			},
 | 
						|
			false,
 | 
						|
		},
 | 
						|
	}
 | 
						|
 | 
						|
	for _, tc := range testCases {
 | 
						|
		suite.SetupTest()
 | 
						|
		suite.Run(tc.name, func() {
 | 
						|
			preSupply, found := suite.keeper.GetAssetSupply(suite.ctx, tc.args.coin.Denom)
 | 
						|
			err := suite.keeper.IncrementCurrentAssetSupply(suite.ctx, tc.args.coin)
 | 
						|
			postSupply, _ := suite.keeper.GetAssetSupply(suite.ctx, tc.args.coin.Denom)
 | 
						|
 | 
						|
			if tc.expectPass {
 | 
						|
				suite.True(found)
 | 
						|
				suite.NoError(err)
 | 
						|
				suite.Equal(preSupply.CurrentSupply.Add(tc.args.coin), postSupply.CurrentSupply)
 | 
						|
			} else {
 | 
						|
				suite.Error(err)
 | 
						|
				suite.Equal(preSupply.CurrentSupply, postSupply.CurrentSupply)
 | 
						|
			}
 | 
						|
		})
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func (suite *AssetTestSuite) TestIncrementTimeLimitedCurrentAssetSupply() {
 | 
						|
	type args struct {
 | 
						|
		coin           sdk.Coin
 | 
						|
		expectedSupply types.AssetSupply
 | 
						|
	}
 | 
						|
	type errArgs struct {
 | 
						|
		expectPass bool
 | 
						|
		contains   string
 | 
						|
	}
 | 
						|
	testCases := []struct {
 | 
						|
		name    string
 | 
						|
		args    args
 | 
						|
		errArgs errArgs
 | 
						|
	}{
 | 
						|
		{
 | 
						|
			"normal",
 | 
						|
			args{
 | 
						|
				coin: c("inc", 5),
 | 
						|
				expectedSupply: types.AssetSupply{
 | 
						|
					IncomingSupply:           c("inc", 10),
 | 
						|
					OutgoingSupply:           c("inc", 5),
 | 
						|
					CurrentSupply:            c("inc", 10),
 | 
						|
					TimeLimitedCurrentSupply: c("inc", 5),
 | 
						|
					TimeElapsed:              time.Duration(0),
 | 
						|
				},
 | 
						|
			},
 | 
						|
			errArgs{
 | 
						|
				expectPass: true,
 | 
						|
				contains:   "",
 | 
						|
			},
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"over limit",
 | 
						|
			args{
 | 
						|
				coin:           c("inc", 16),
 | 
						|
				expectedSupply: types.AssetSupply{},
 | 
						|
			},
 | 
						|
			errArgs{
 | 
						|
				expectPass: false,
 | 
						|
				contains:   "asset supply over limit for current time period",
 | 
						|
			},
 | 
						|
		},
 | 
						|
	}
 | 
						|
	for _, tc := range testCases {
 | 
						|
		suite.SetupTest()
 | 
						|
		suite.Run(tc.name, func() {
 | 
						|
			err := suite.keeper.IncrementCurrentAssetSupply(suite.ctx, tc.args.coin)
 | 
						|
			if tc.errArgs.expectPass {
 | 
						|
				suite.Require().NoError(err)
 | 
						|
				supply, _ := suite.keeper.GetAssetSupply(suite.ctx, tc.args.coin.Denom)
 | 
						|
				suite.Require().Equal(tc.args.expectedSupply, supply)
 | 
						|
			} else {
 | 
						|
				suite.Require().Error(err)
 | 
						|
				suite.Require().True(strings.Contains(err.Error(), tc.errArgs.contains))
 | 
						|
			}
 | 
						|
		})
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func (suite *AssetTestSuite) TestDecrementCurrentAssetSupply() {
 | 
						|
	type args struct {
 | 
						|
		coin sdk.Coin
 | 
						|
	}
 | 
						|
	testCases := []struct {
 | 
						|
		name       string
 | 
						|
		args       args
 | 
						|
		expectPass bool
 | 
						|
	}{
 | 
						|
		{
 | 
						|
			"normal",
 | 
						|
			args{
 | 
						|
				coin: c("bnb", 30),
 | 
						|
			},
 | 
						|
			true,
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"equal current",
 | 
						|
			args{
 | 
						|
				coin: c("bnb", 40),
 | 
						|
			},
 | 
						|
			true,
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"exceeds current",
 | 
						|
			args{
 | 
						|
				coin: c("bnb", 41),
 | 
						|
			},
 | 
						|
			false,
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"unsupported asset",
 | 
						|
			args{
 | 
						|
				coin: c("xyz", 30),
 | 
						|
			},
 | 
						|
			false,
 | 
						|
		},
 | 
						|
	}
 | 
						|
 | 
						|
	for _, tc := range testCases {
 | 
						|
		suite.SetupTest()
 | 
						|
		suite.Run(tc.name, func() {
 | 
						|
			preSupply, found := suite.keeper.GetAssetSupply(suite.ctx, tc.args.coin.Denom)
 | 
						|
			err := suite.keeper.DecrementCurrentAssetSupply(suite.ctx, tc.args.coin)
 | 
						|
			postSupply, _ := suite.keeper.GetAssetSupply(suite.ctx, tc.args.coin.Denom)
 | 
						|
 | 
						|
			if tc.expectPass {
 | 
						|
				suite.True(found)
 | 
						|
				suite.NoError(err)
 | 
						|
				suite.True(preSupply.CurrentSupply.Sub(tc.args.coin).IsEqual(postSupply.CurrentSupply))
 | 
						|
			} else {
 | 
						|
				suite.Error(err)
 | 
						|
				suite.Equal(preSupply.CurrentSupply, postSupply.CurrentSupply)
 | 
						|
			}
 | 
						|
		})
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func (suite *AssetTestSuite) TestIncrementIncomingAssetSupply() {
 | 
						|
	type args struct {
 | 
						|
		coin sdk.Coin
 | 
						|
	}
 | 
						|
	testCases := []struct {
 | 
						|
		name       string
 | 
						|
		args       args
 | 
						|
		expectPass bool
 | 
						|
	}{
 | 
						|
		{
 | 
						|
			"normal",
 | 
						|
			args{
 | 
						|
				coin: c("bnb", 2),
 | 
						|
			},
 | 
						|
			true,
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"incoming + current = limit",
 | 
						|
			args{
 | 
						|
				coin: c("bnb", 5),
 | 
						|
			},
 | 
						|
			true,
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"incoming + current > limit",
 | 
						|
			args{
 | 
						|
				coin: c("bnb", 6),
 | 
						|
			},
 | 
						|
			false,
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"unsupported asset",
 | 
						|
			args{
 | 
						|
				coin: c("xyz", 2),
 | 
						|
			},
 | 
						|
			false,
 | 
						|
		},
 | 
						|
	}
 | 
						|
 | 
						|
	for _, tc := range testCases {
 | 
						|
		suite.SetupTest()
 | 
						|
		suite.Run(tc.name, func() {
 | 
						|
			preSupply, found := suite.keeper.GetAssetSupply(suite.ctx, tc.args.coin.Denom)
 | 
						|
			err := suite.keeper.IncrementIncomingAssetSupply(suite.ctx, tc.args.coin)
 | 
						|
			postSupply, _ := suite.keeper.GetAssetSupply(suite.ctx, tc.args.coin.Denom)
 | 
						|
 | 
						|
			if tc.expectPass {
 | 
						|
				suite.True(found)
 | 
						|
				suite.NoError(err)
 | 
						|
				suite.Equal(preSupply.IncomingSupply.Add(tc.args.coin), postSupply.IncomingSupply)
 | 
						|
			} else {
 | 
						|
				suite.Error(err)
 | 
						|
				suite.Equal(preSupply.IncomingSupply, postSupply.IncomingSupply)
 | 
						|
			}
 | 
						|
		})
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func (suite *AssetTestSuite) TestIncrementTimeLimitedIncomingAssetSupply() {
 | 
						|
	type args struct {
 | 
						|
		coin           sdk.Coin
 | 
						|
		expectedSupply types.AssetSupply
 | 
						|
	}
 | 
						|
	type errArgs struct {
 | 
						|
		expectPass bool
 | 
						|
		contains   string
 | 
						|
	}
 | 
						|
	testCases := []struct {
 | 
						|
		name    string
 | 
						|
		args    args
 | 
						|
		errArgs errArgs
 | 
						|
	}{
 | 
						|
		{
 | 
						|
			"normal",
 | 
						|
			args{
 | 
						|
				coin: c("inc", 5),
 | 
						|
				expectedSupply: types.AssetSupply{
 | 
						|
					IncomingSupply:           c("inc", 15),
 | 
						|
					OutgoingSupply:           c("inc", 5),
 | 
						|
					CurrentSupply:            c("inc", 5),
 | 
						|
					TimeLimitedCurrentSupply: c("inc", 0),
 | 
						|
					TimeElapsed:              time.Duration(0),
 | 
						|
				},
 | 
						|
			},
 | 
						|
			errArgs{
 | 
						|
				expectPass: true,
 | 
						|
				contains:   "",
 | 
						|
			},
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"over limit",
 | 
						|
			args{
 | 
						|
				coin:           c("inc", 6),
 | 
						|
				expectedSupply: types.AssetSupply{},
 | 
						|
			},
 | 
						|
			errArgs{
 | 
						|
				expectPass: false,
 | 
						|
				contains:   "asset supply over limit for current time period",
 | 
						|
			},
 | 
						|
		},
 | 
						|
	}
 | 
						|
	for _, tc := range testCases {
 | 
						|
		suite.SetupTest()
 | 
						|
		suite.Run(tc.name, func() {
 | 
						|
			err := suite.keeper.IncrementIncomingAssetSupply(suite.ctx, tc.args.coin)
 | 
						|
			if tc.errArgs.expectPass {
 | 
						|
				suite.Require().NoError(err)
 | 
						|
				supply, _ := suite.keeper.GetAssetSupply(suite.ctx, tc.args.coin.Denom)
 | 
						|
				suite.Require().Equal(tc.args.expectedSupply, supply)
 | 
						|
			} else {
 | 
						|
				suite.Require().Error(err)
 | 
						|
				suite.Require().True(strings.Contains(err.Error(), tc.errArgs.contains))
 | 
						|
			}
 | 
						|
		})
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func (suite *AssetTestSuite) TestDecrementIncomingAssetSupply() {
 | 
						|
	type args struct {
 | 
						|
		coin sdk.Coin
 | 
						|
	}
 | 
						|
	testCases := []struct {
 | 
						|
		name       string
 | 
						|
		args       args
 | 
						|
		expectPass bool
 | 
						|
	}{
 | 
						|
		{
 | 
						|
			"normal",
 | 
						|
			args{
 | 
						|
				coin: c("bnb", 4),
 | 
						|
			},
 | 
						|
			true,
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"equal incoming",
 | 
						|
			args{
 | 
						|
				coin: c("bnb", 5),
 | 
						|
			},
 | 
						|
			true,
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"exceeds incoming",
 | 
						|
			args{
 | 
						|
				coin: c("bnb", 6),
 | 
						|
			},
 | 
						|
			false,
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"unsupported asset",
 | 
						|
			args{
 | 
						|
				coin: c("xyz", 4),
 | 
						|
			},
 | 
						|
			false,
 | 
						|
		},
 | 
						|
	}
 | 
						|
 | 
						|
	for _, tc := range testCases {
 | 
						|
		suite.SetupTest()
 | 
						|
		suite.Run(tc.name, func() {
 | 
						|
			preSupply, found := suite.keeper.GetAssetSupply(suite.ctx, tc.args.coin.Denom)
 | 
						|
			err := suite.keeper.DecrementIncomingAssetSupply(suite.ctx, tc.args.coin)
 | 
						|
			postSupply, _ := suite.keeper.GetAssetSupply(suite.ctx, tc.args.coin.Denom)
 | 
						|
 | 
						|
			if tc.expectPass {
 | 
						|
				suite.True(found)
 | 
						|
				suite.NoError(err)
 | 
						|
				suite.True(preSupply.IncomingSupply.Sub(tc.args.coin).IsEqual(postSupply.IncomingSupply))
 | 
						|
			} else {
 | 
						|
				suite.Error(err)
 | 
						|
				suite.Equal(preSupply.IncomingSupply, postSupply.IncomingSupply)
 | 
						|
			}
 | 
						|
		})
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func (suite *AssetTestSuite) TestIncrementOutgoingAssetSupply() {
 | 
						|
	type args struct {
 | 
						|
		coin sdk.Coin
 | 
						|
	}
 | 
						|
	testCases := []struct {
 | 
						|
		name       string
 | 
						|
		args       args
 | 
						|
		expectPass bool
 | 
						|
	}{
 | 
						|
		{
 | 
						|
			"normal",
 | 
						|
			args{
 | 
						|
				coin: c("bnb", 30),
 | 
						|
			},
 | 
						|
			true,
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"outgoing + amount = current",
 | 
						|
			args{
 | 
						|
				coin: c("bnb", 35),
 | 
						|
			},
 | 
						|
			true,
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"outgoing + amount > current",
 | 
						|
			args{
 | 
						|
				coin: c("bnb", 36),
 | 
						|
			},
 | 
						|
			false,
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"unsupported asset",
 | 
						|
			args{
 | 
						|
				coin: c("xyz", 30),
 | 
						|
			},
 | 
						|
			false,
 | 
						|
		},
 | 
						|
	}
 | 
						|
 | 
						|
	for _, tc := range testCases {
 | 
						|
		suite.SetupTest()
 | 
						|
		suite.Run(tc.name, func() {
 | 
						|
			preSupply, found := suite.keeper.GetAssetSupply(suite.ctx, tc.args.coin.Denom)
 | 
						|
			err := suite.keeper.IncrementOutgoingAssetSupply(suite.ctx, tc.args.coin)
 | 
						|
			postSupply, _ := suite.keeper.GetAssetSupply(suite.ctx, tc.args.coin.Denom)
 | 
						|
 | 
						|
			if tc.expectPass {
 | 
						|
				suite.True(found)
 | 
						|
				suite.NoError(err)
 | 
						|
				suite.Equal(preSupply.OutgoingSupply.Add(tc.args.coin), postSupply.OutgoingSupply)
 | 
						|
			} else {
 | 
						|
				suite.Error(err)
 | 
						|
				suite.Equal(preSupply.OutgoingSupply, postSupply.OutgoingSupply)
 | 
						|
			}
 | 
						|
		})
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func (suite *AssetTestSuite) TestDecrementOutgoingAssetSupply() {
 | 
						|
	type args struct {
 | 
						|
		coin sdk.Coin
 | 
						|
	}
 | 
						|
	testCases := []struct {
 | 
						|
		name       string
 | 
						|
		args       args
 | 
						|
		expectPass bool
 | 
						|
	}{
 | 
						|
		{
 | 
						|
			"normal",
 | 
						|
			args{
 | 
						|
				coin: c("bnb", 4),
 | 
						|
			},
 | 
						|
			true,
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"equal outgoing",
 | 
						|
			args{
 | 
						|
				coin: c("bnb", 5),
 | 
						|
			},
 | 
						|
			true,
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"exceeds outgoing",
 | 
						|
			args{
 | 
						|
				coin: c("bnb", 6),
 | 
						|
			},
 | 
						|
			false,
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"unsupported asset",
 | 
						|
			args{
 | 
						|
				coin: c("xyz", 4),
 | 
						|
			},
 | 
						|
			false,
 | 
						|
		},
 | 
						|
	}
 | 
						|
 | 
						|
	for _, tc := range testCases {
 | 
						|
		suite.SetupTest()
 | 
						|
		suite.Run(tc.name, func() {
 | 
						|
			preSupply, found := suite.keeper.GetAssetSupply(suite.ctx, tc.args.coin.Denom)
 | 
						|
			err := suite.keeper.DecrementOutgoingAssetSupply(suite.ctx, tc.args.coin)
 | 
						|
			postSupply, _ := suite.keeper.GetAssetSupply(suite.ctx, tc.args.coin.Denom)
 | 
						|
 | 
						|
			if tc.expectPass {
 | 
						|
				suite.True(found)
 | 
						|
				suite.NoError(err)
 | 
						|
				suite.True(preSupply.OutgoingSupply.Sub(tc.args.coin).IsEqual(postSupply.OutgoingSupply))
 | 
						|
			} else {
 | 
						|
				suite.Error(err)
 | 
						|
				suite.Equal(preSupply.OutgoingSupply, postSupply.OutgoingSupply)
 | 
						|
			}
 | 
						|
		})
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func (suite *AssetTestSuite) TestUpdateTimeBasedSupplyLimits() {
 | 
						|
	type args struct {
 | 
						|
		asset          string
 | 
						|
		duration       time.Duration
 | 
						|
		expectedSupply types.AssetSupply
 | 
						|
	}
 | 
						|
	type errArgs struct {
 | 
						|
		expectPanic bool
 | 
						|
		contains    string
 | 
						|
	}
 | 
						|
	testCases := []struct {
 | 
						|
		name    string
 | 
						|
		args    args
 | 
						|
		errArgs errArgs
 | 
						|
	}{
 | 
						|
		{
 | 
						|
			"rate-limited increment time",
 | 
						|
			args{
 | 
						|
				asset:          "inc",
 | 
						|
				duration:       time.Second,
 | 
						|
				expectedSupply: types.NewAssetSupply(c("inc", 10), c("inc", 5), c("inc", 5), c("inc", 0), time.Second),
 | 
						|
			},
 | 
						|
			errArgs{
 | 
						|
				expectPanic: false,
 | 
						|
				contains:    "",
 | 
						|
			},
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"rate-limited increment time half",
 | 
						|
			args{
 | 
						|
				asset:          "inc",
 | 
						|
				duration:       time.Minute * 30,
 | 
						|
				expectedSupply: types.NewAssetSupply(c("inc", 10), c("inc", 5), c("inc", 5), c("inc", 0), time.Minute*30),
 | 
						|
			},
 | 
						|
			errArgs{
 | 
						|
				expectPanic: false,
 | 
						|
				contains:    "",
 | 
						|
			},
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"rate-limited period change",
 | 
						|
			args{
 | 
						|
				asset:          "inc",
 | 
						|
				duration:       time.Hour + time.Second,
 | 
						|
				expectedSupply: types.NewAssetSupply(c("inc", 10), c("inc", 5), c("inc", 5), c("inc", 0), time.Duration(0)),
 | 
						|
			},
 | 
						|
			errArgs{
 | 
						|
				expectPanic: false,
 | 
						|
				contains:    "",
 | 
						|
			},
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"rate-limited period change exact",
 | 
						|
			args{
 | 
						|
				asset:          "inc",
 | 
						|
				duration:       time.Hour,
 | 
						|
				expectedSupply: types.NewAssetSupply(c("inc", 10), c("inc", 5), c("inc", 5), c("inc", 0), time.Duration(0)),
 | 
						|
			},
 | 
						|
			errArgs{
 | 
						|
				expectPanic: false,
 | 
						|
				contains:    "",
 | 
						|
			},
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"rate-limited period change big",
 | 
						|
			args{
 | 
						|
				asset:          "inc",
 | 
						|
				duration:       time.Hour * 4,
 | 
						|
				expectedSupply: types.NewAssetSupply(c("inc", 10), c("inc", 5), c("inc", 5), c("inc", 0), time.Duration(0)),
 | 
						|
			},
 | 
						|
			errArgs{
 | 
						|
				expectPanic: false,
 | 
						|
				contains:    "",
 | 
						|
			},
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"non rate-limited increment time",
 | 
						|
			args{
 | 
						|
				asset:          "bnb",
 | 
						|
				duration:       time.Second,
 | 
						|
				expectedSupply: types.NewAssetSupply(c("bnb", 5), c("bnb", 5), c("bnb", 40), c("bnb", 0), time.Duration(0)),
 | 
						|
			},
 | 
						|
			errArgs{
 | 
						|
				expectPanic: false,
 | 
						|
				contains:    "",
 | 
						|
			},
 | 
						|
		},
 | 
						|
		{
 | 
						|
			"new asset increment time",
 | 
						|
			args{
 | 
						|
				asset:          "lol",
 | 
						|
				duration:       time.Second,
 | 
						|
				expectedSupply: types.NewAssetSupply(c("lol", 0), c("lol", 0), c("lol", 0), c("lol", 0), time.Second),
 | 
						|
			},
 | 
						|
			errArgs{
 | 
						|
				expectPanic: false,
 | 
						|
				contains:    "",
 | 
						|
			},
 | 
						|
		},
 | 
						|
	}
 | 
						|
	for _, tc := range testCases {
 | 
						|
		suite.SetupTest()
 | 
						|
		suite.Run(tc.name, func() {
 | 
						|
			deputy, _ := sdk.AccAddressFromBech32(TestDeputy)
 | 
						|
			newParams := types.Params{
 | 
						|
				AssetParams: types.AssetParams{
 | 
						|
					{
 | 
						|
						Denom:  "bnb",
 | 
						|
						CoinID: 714,
 | 
						|
						SupplyLimit: types.SupplyLimit{
 | 
						|
							Limit:          sdkmath.NewInt(350000000000000),
 | 
						|
							TimeLimited:    false,
 | 
						|
							TimeBasedLimit: sdk.ZeroInt(),
 | 
						|
							TimePeriod:     time.Hour,
 | 
						|
						},
 | 
						|
						Active:        true,
 | 
						|
						DeputyAddress: deputy,
 | 
						|
						FixedFee:      sdkmath.NewInt(1000),
 | 
						|
						MinSwapAmount: sdk.OneInt(),
 | 
						|
						MaxSwapAmount: sdkmath.NewInt(1000000000000),
 | 
						|
						MinBlockLock:  types.DefaultMinBlockLock,
 | 
						|
						MaxBlockLock:  types.DefaultMaxBlockLock,
 | 
						|
					},
 | 
						|
					{
 | 
						|
						Denom:  "inc",
 | 
						|
						CoinID: 9999,
 | 
						|
						SupplyLimit: types.SupplyLimit{
 | 
						|
							Limit:          sdkmath.NewInt(100),
 | 
						|
							TimeLimited:    true,
 | 
						|
							TimeBasedLimit: sdkmath.NewInt(10),
 | 
						|
							TimePeriod:     time.Hour,
 | 
						|
						},
 | 
						|
						Active:        false,
 | 
						|
						DeputyAddress: deputy,
 | 
						|
						FixedFee:      sdkmath.NewInt(1000),
 | 
						|
						MinSwapAmount: sdk.OneInt(),
 | 
						|
						MaxSwapAmount: sdkmath.NewInt(1000000000000),
 | 
						|
						MinBlockLock:  types.DefaultMinBlockLock,
 | 
						|
						MaxBlockLock:  types.DefaultMaxBlockLock,
 | 
						|
					},
 | 
						|
					{
 | 
						|
						Denom:  "lol",
 | 
						|
						CoinID: 9999,
 | 
						|
						SupplyLimit: types.SupplyLimit{
 | 
						|
							Limit:          sdkmath.NewInt(100),
 | 
						|
							TimeLimited:    true,
 | 
						|
							TimeBasedLimit: sdkmath.NewInt(10),
 | 
						|
							TimePeriod:     time.Hour,
 | 
						|
						},
 | 
						|
						Active:        false,
 | 
						|
						DeputyAddress: deputy,
 | 
						|
						FixedFee:      sdkmath.NewInt(1000),
 | 
						|
						MinSwapAmount: sdk.OneInt(),
 | 
						|
						MaxSwapAmount: sdkmath.NewInt(1000000000000),
 | 
						|
						MinBlockLock:  types.DefaultMinBlockLock,
 | 
						|
						MaxBlockLock:  types.DefaultMaxBlockLock,
 | 
						|
					},
 | 
						|
				},
 | 
						|
			}
 | 
						|
			suite.keeper.SetParams(suite.ctx, newParams)
 | 
						|
			suite.ctx = suite.ctx.WithBlockTime(suite.ctx.BlockTime().Add(tc.args.duration))
 | 
						|
			suite.NotPanics(
 | 
						|
				func() {
 | 
						|
					suite.keeper.UpdateTimeBasedSupplyLimits(suite.ctx)
 | 
						|
				},
 | 
						|
			)
 | 
						|
			if !tc.errArgs.expectPanic {
 | 
						|
				supply, found := suite.keeper.GetAssetSupply(suite.ctx, tc.args.asset)
 | 
						|
				suite.Require().True(found)
 | 
						|
				suite.Require().Equal(tc.args.expectedSupply, supply)
 | 
						|
			}
 | 
						|
		})
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
func TestAssetTestSuite(t *testing.T) {
 | 
						|
	suite.Run(t, new(AssetTestSuite))
 | 
						|
}
 |