feat: add versioned parameters to payment module (bnb-chain#281)

deployment/localup/localup.sh

@@ -147,7 +147,7 @@ function generate_genesis() {
         sed -i -e "s/\"challenge_keep_alive_period\": \"300\"/\"challenge_keep_alive_period\": \"50\"/g" ${workspace}/.local/validator${i}/config/genesis.json
         sed -i -e "s/\"heartbeat_interval\": \"1000\"/\"heartbeat_interval\": \"100\"/g" ${workspace}/.local/validator${i}/config/genesis.json
         sed -i -e "s/\"attestation_inturn_interval\": \"120\"/\"attestation_inturn_interval\": \"10\"/g" ${workspace}/.local/validator${i}/config/genesis.json
-        sed -i -e "s/\"discontinue_confirm_period\": \"604800\"/\"discontinue_confirm_period\": \"15\"/g" ${workspace}/.local/validator${i}/config/genesis.json
+        sed -i -e "s/\"discontinue_confirm_period\": \"604800\"/\"discontinue_confirm_period\": \"5\"/g" ${workspace}/.local/validator${i}/config/genesis.json
         sed -i -e "s/\"discontinue_deletion_max\": \"10000\"/\"discontinue_deletion_max\": \"1\"/g" ${workspace}/.local/validator${i}/config/genesis.json
         sed -i -e "s/\"voting_period\": \"30s\"/\"voting_period\": \"10s\"/g" ${workspace}/.local/validator${i}/config/genesis.json
     done

e2e/tests/sp_test.go

@@ -129,6 +129,7 @@ func (s *StorageProviderTestSuite) TestCreateStorageProvider() {
 	// 5. wait a voting period and confirm that the proposal success.
 	s.T().Logf("voting period %s", *queryVoteParamsResp.Params.VotingPeriod)
 	time.Sleep(*queryVoteParamsResp.Params.VotingPeriod)
+	time.Sleep(1 * time.Second)
 	proposalRes, err := s.Client.GovQueryClientV1.Proposal(ctx, queryProposal)
 	s.Require().NoError(err)
 	s.Require().Equal(proposalRes.Proposal.Status, govtypesv1.ProposalStatus_PROPOSAL_STATUS_PASSED)

e2e/tests/storage_test.go

@@ -492,7 +492,7 @@ func (s *StorageTestSuite) TestPayment_Smoke() {
 	readPrice := queryGetSpStoragePriceByTimeResp.SpStoragePrice.ReadPrice
 	readChargeRate := readPrice.MulInt(sdk.NewIntFromUint64(queryHeadBucketResponse.BucketInfo.ChargedReadQuota)).TruncateInt()
 	s.T().Logf("readPrice: %s, readChargeRate: %s", readPrice, readChargeRate)
-	userTaxRate := paymentParams.Params.ValidatorTaxRate.MulInt(readChargeRate).TruncateInt()
+	userTaxRate := paymentParams.Params.VersionedParams.ValidatorTaxRate.MulInt(readChargeRate).TruncateInt()
 	userTotalRate := readChargeRate.Add(userTaxRate)
 	s.Require().Equal(usr.NetflowRate.Abs(), userTotalRate)
 	expectedOutFlows := []paymenttypes.OutFlow{
@@ -560,7 +560,7 @@ func (s *StorageTestSuite) TestPayment_Smoke() {
 	secondaryStorePrice := queryGetSecondarySpStorePriceByTime.SecondarySpStorePrice.StorePrice
 	chargeSize := s.GetChargeSize(queryHeadObjectResponse.ObjectInfo.PayloadSize)
 	expectedChargeRate := primaryStorePrice.Add(secondaryStorePrice.MulInt64(6)).MulInt(sdk.NewIntFromUint64(chargeSize)).TruncateInt()
-	expectedLockedBalance := expectedChargeRate.Mul(sdkmath.NewIntFromUint64(paymentParams.Params.ReserveTime))
+	expectedLockedBalance := expectedChargeRate.Mul(sdkmath.NewIntFromUint64(paymentParams.Params.VersionedParams.ReserveTime))
 	s.Require().Equal(expectedLockedBalance.String(), userStreamAccountAfterCreateObj.LockBalance.String())
 
 	// seal object
@@ -672,7 +672,7 @@ func (s *StorageTestSuite) TestPayment_AutoSettle() {
 	paymentParams, err := s.Client.PaymentQueryClient.Params(ctx, &paymenttypes.QueryParamsRequest{})
 	s.T().Logf("paymentParams %s, err: %v", paymentParams, err)
 	s.Require().NoError(err)
-	reserveTime := paymentParams.Params.ReserveTime
+	reserveTime := paymentParams.Params.VersionedParams.ReserveTime
 	forcedSettleTime := paymentParams.Params.ForcedSettleTime
 	queryGetSpStoragePriceByTimeResp, err := s.Client.QueryGetSpStoragePriceByTime(ctx, &sptypes.QueryGetSpStoragePriceByTimeRequest{
 		SpAddr: sp.OperatorKey.GetAddr().String(),
@@ -681,7 +681,7 @@ func (s *StorageTestSuite) TestPayment_AutoSettle() {
 	s.Require().NoError(err)
 	readPrice := queryGetSpStoragePriceByTimeResp.SpStoragePrice.ReadPrice
 	totalUserRate := readPrice.MulInt(sdkmath.NewIntFromUint64(bucketChargedReadQuota)).TruncateInt()
-	taxRateParam := paymentParams.Params.ValidatorTaxRate
+	taxRateParam := paymentParams.Params.VersionedParams.ValidatorTaxRate
 	taxStreamRate := taxRateParam.MulInt(totalUserRate).TruncateInt()
 	expectedRate := totalUserRate.Add(taxStreamRate)
 	paymentAccountBNBNeeded := expectedRate.Mul(sdkmath.NewIntFromUint64(reserveTime))
@@ -1772,6 +1772,7 @@ func (s *StorageTestSuite) TestUpdateParams() {
 	// 5. wait a voting period and confirm that the proposal success.
 	s.T().Logf("voting period %s", *queryVoteParamsResp.Params.VotingPeriod)
 	time.Sleep(*queryVoteParamsResp.Params.VotingPeriod)
+	time.Sleep(1 * time.Second)
 	proposalRes, err := s.Client.GovQueryClientV1.Proposal(ctx, queryProposal)
 	s.Require().NoError(err)
 	s.Require().Equal(proposalRes.Proposal.Status, govtypesv1.ProposalStatus_PROPOSAL_STATUS_PASSED)

proto/greenfield/payment/params.proto

@@ -8,8 +8,7 @@ option go_package = "github.com/bnb-chain/greenfield/x/payment/types";
 
 // Params defines the parameters for the module.
 message Params {
-  // Time duration which the buffer balance need to be reserved for NetOutFlow e.g. 6 month
-  uint64 reserve_time = 1 [(gogoproto.moretags) = "yaml:\"reserve_time\""];
+  VersionedParams versioned_params = 1 [(gogoproto.nullable) = false];
   // The maximum number of payment accounts that can be created by one user
   uint64 payment_account_count_limit = 2 [(gogoproto.moretags) = "yaml:\"payment_account_count_limit\""];
   // Time duration threshold of forced settlement.
@@ -19,8 +18,14 @@ message Params {
   uint64 max_auto_force_settle_num = 4 [(gogoproto.moretags) = "yaml:\"max_auto_force_settle_num\""];
   // The denom of fee charged in payment module
   string fee_denom = 5 [(gogoproto.moretags) = "yaml:\"fee_denom\""];
+}
+
+// VersionedParams defines the parameters with multiple versions, each version is stored with different timestamp.
+message VersionedParams {
+  // Time duration which the buffer balance need to be reserved for NetOutFlow e.g. 6 month
+  uint64 reserve_time = 1 [(gogoproto.moretags) = "yaml:\"reserve_time\""];
   // The tax rate to pay for validators in storage payment. The default value is 1%(0.01)
-  string validator_tax_rate = 6 [
+  string validator_tax_rate = 2 [
     (cosmos_proto.scalar) = "cosmos.Dec",
     (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec",
     (gogoproto.nullable) = false

proto/greenfield/payment/query.proto

@@ -23,6 +23,11 @@ service Query {
     option (google.api.http).get = "/greenfield/payment/params";
   }
 
+  // ParamsByTimestamp queries the parameters of the module.
+  rpc ParamsByTimestamp(QueryParamsByTimestampRequest) returns (QueryParamsByTimestampResponse) {
+    option (google.api.http).get = "/greenfield/payment/params/{timestamp}";
+  }
+
   // Queries a StreamRecord by index.
   rpc StreamRecord(QueryGetStreamRecordRequest) returns (QueryGetStreamRecordResponse) {
     option (google.api.http).get = "/greenfield/payment/stream_record/{account}";
@@ -78,6 +83,18 @@ message QueryParamsResponse {
   Params params = 1 [(gogoproto.nullable) = false];
 }
 
+// QueryParamsByTimestampRequest is request type for the Query/ParamsByTimestamp RPC method with timestamp.
+message QueryParamsByTimestampRequest {
+  // the timestamp of the block time you want to query
+  int64 timestamp = 1;
+}
+
+// QueryParamsByTimestampResponse is response type for the Query/ParamsByTimestamp RPC method with timestamp.
+message QueryParamsByTimestampResponse {
+  // params holds all the parameters of this module.
+  Params params = 1 [(gogoproto.nullable) = false];
+}
+
 message QueryGetStreamRecordRequest {
   string account = 1;
 }

sdk/client/tx.go

@@ -3,8 +3,6 @@ package client
 import (
 	"context"
 
-	"github.com/bnb-chain/greenfield/sdk/keys"
-
 	"github.com/cosmos/cosmos-sdk/client"
 	clitx "github.com/cosmos/cosmos-sdk/client/tx"
 	sdk "github.com/cosmos/cosmos-sdk/types"
@@ -15,6 +13,7 @@ import (
 	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
 	"google.golang.org/grpc"
 
+	"github.com/bnb-chain/greenfield/sdk/keys"
 	"github.com/bnb-chain/greenfield/sdk/types"
 )
 

x/payment/keeper/grpc_query_params_by_timestamp.go

@@ -0,0 +1,32 @@
+package keeper
+
+import (
+	"context"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+
+	"github.com/bnb-chain/greenfield/x/payment/types"
+)
+
+func (k Keeper) ParamsByTimestamp(c context.Context, req *types.QueryParamsByTimestampRequest) (*types.QueryParamsByTimestampResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "invalid request")
+	}
+	ctx := sdk.UnwrapSDKContext(c)
+
+	ts := req.GetTimestamp()
+	if ts == 0 {
+		ts = ctx.BlockTime().Unix()
+	}
+
+	params := k.GetParams(ctx)
+	versionedParams, err := k.GetVersionedParamsWithTs(ctx, ts)
+	if err != nil {
+		return nil, status.Error(codes.Internal, err.Error())
+	}
+	params.VersionedParams = versionedParams
+
+	return &types.QueryParamsByTimestampResponse{Params: params}, nil
+}

x/payment/keeper/params.go

@@ -1,6 +1,9 @@
 package keeper
 
 import (
+	"fmt"
+
+	"github.com/cosmos/cosmos-sdk/store/prefix"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	"github.com/bnb-chain/greenfield/x/payment/types"
@@ -22,9 +25,43 @@ func (k Keeper) SetParams(ctx sdk.Context, params types.Params) error {
 	if err := params.Validate(); err != nil {
 		return err
 	}
+
 	store := ctx.KVStore(k.storeKey)
 	bz := k.cdc.MustMarshal(&params)
 	store.Set(types.ParamsKey, bz)
 
+	// store versioned params
+	err := k.SetVersionedParamsWithTs(ctx, params.VersionedParams)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (k Keeper) SetVersionedParamsWithTs(ctx sdk.Context, verParams types.VersionedParams) error {
+	store := prefix.NewStore(ctx.KVStore(k.storeKey), types.VersionedParamsKeyPrefix)
+	key := types.VersionedParamsKey(ctx.BlockTime().Unix())
+
+	b := k.cdc.MustMarshal(&verParams)
+	store.Set(key, b)
+
 	return nil
 }
+
+// GetVersionedParamsWithTs find the latest params before and equal than the specific timestamp
+func (k Keeper) GetVersionedParamsWithTs(ctx sdk.Context, ts int64) (verParams types.VersionedParams, err error) {
+	store := prefix.NewStore(ctx.KVStore(k.storeKey), types.VersionedParamsKeyPrefix)
+
+	// ReverseIterator will exclusive end, so we increment ts by 1
+	startKey := types.VersionedParamsKey(ts + 1)
+	iterator := store.ReverseIterator(nil, startKey)
+	defer iterator.Close()
+	if !iterator.Valid() {
+		return verParams, fmt.Errorf("no versioned params found")
+	}
+
+	k.cdc.MustUnmarshal(iterator.Value(), &verParams)
+
+	return verParams, nil
+}

x/payment/keeper/storage_fee_charge.go

@@ -70,7 +70,7 @@ func (k Keeper) ApplyUserFlowsList(ctx sdk.Context, userFlowsList []types.UserFl
 		streamRecordChange := types.NewDefaultStreamRecordChangeWithAddr(from).WithRateChange(totalRate.Neg())
 		// storage fee preview
 		if ctx.IsCheckTx() {
-			reserveTime := k.GetParams(ctx).ReserveTime
+			reserveTime := k.GetParams(ctx).VersionedParams.ReserveTime
 			changeRate := totalRate.Neg()
 			event := &types.EventFeePreview{
 				Account: from.String(),

x/payment/keeper/storage_fee_charge_test.go

@@ -107,7 +107,7 @@ func TestAutoForceSettle(t *testing.T) {
 	user := sample.RandAccAddress()
 	rate := sdkmath.NewInt(100)
 	sp := sample.RandAccAddress()
-	userInitBalance := sdkmath.NewInt(int64(100*params.ReserveTime) + 1) // just enough for reserve
+	userInitBalance := sdkmath.NewInt(int64(100*params.VersionedParams.ReserveTime) + 1) // just enough for reserve
 	// init balance
 	streamRecordChanges := []types.StreamRecordChange{
 		*types.NewDefaultStreamRecordChangeWithAddr(user).WithStaticBalanceChange(userInitBalance),
@@ -139,7 +139,7 @@ func TestAutoForceSettle(t *testing.T) {
 	t.Logf("auto settle queue: %+v", autoSettleQueue)
 	require.Equal(t, len(autoSettleQueue), 1)
 	require.Equal(t, autoSettleQueue[0].Addr, user.String())
-	require.Equal(t, autoSettleQueue[0].Timestamp, startTime+int64(params.ReserveTime)-int64(params.ForcedSettleTime))
+	require.Equal(t, autoSettleQueue[0].Timestamp, startTime+int64(params.VersionedParams.ReserveTime)-int64(params.ForcedSettleTime))
 	// 1 day pass
 	ctx = ctx.WithBlockTime(ctx.BlockTime().Add(time.Duration(86400) * time.Second))
 	// update and deposit to user for extra 100s
@@ -161,7 +161,7 @@ func TestAutoForceSettle(t *testing.T) {
 	t.Logf("auto settle queue: %+v", autoSettleQueue2)
 	require.Equal(t, autoSettleQueue[0].Timestamp+100, autoSettleQueue2[0].Timestamp)
 	// reverve time - forced settle time - 1 day + 101s pass
-	ctx = ctx.WithBlockTime(ctx.BlockTime().Add(time.Duration(params.ReserveTime-params.ForcedSettleTime-86400+101) * time.Second))
+	ctx = ctx.WithBlockTime(ctx.BlockTime().Add(time.Duration(params.VersionedParams.ReserveTime-params.ForcedSettleTime-86400+101) * time.Second))
 	change = types.NewDefaultStreamRecordChangeWithAddr(user)
 	usrBeforeForceSettle, _ := keeper.GetStreamRecord(ctx, user)
 	t.Logf("usrBeforeForceSettle: %s", usrBeforeForceSettle)

x/payment/keeper/stream_record.go

@@ -150,7 +150,7 @@ func (k Keeper) UpdateStreamRecord(ctx sdk.Context, streamRecord *types.StreamRe
 		streamRecord.NetflowRate = streamRecord.NetflowRate.Add(change.RateChange)
 		newBufferBalance := sdkmath.ZeroInt()
 		if streamRecord.NetflowRate.IsNegative() {
-			newBufferBalance = streamRecord.NetflowRate.Abs().Mul(sdkmath.NewIntFromUint64(params.ReserveTime))
+			newBufferBalance = streamRecord.NetflowRate.Abs().Mul(sdkmath.NewIntFromUint64(params.VersionedParams.ReserveTime))
 		}
 		if !newBufferBalance.Equal(streamRecord.BufferBalance) {
 			streamRecord.StaticBalance = streamRecord.StaticBalance.Sub(newBufferBalance).Add(streamRecord.BufferBalance)
@@ -282,7 +282,7 @@ func (k Keeper) TryResumeStreamRecord(ctx sdk.Context, streamRecord *types.Strea
 	}
 	streamRecord.StaticBalance = streamRecord.StaticBalance.Add(depositBalance)
 	params := k.GetParams(ctx)
-	reserveTime := params.ReserveTime
+	reserveTime := params.VersionedParams.ReserveTime
 	forcedSettleTime := params.ForcedSettleTime
 	totalRates := sdkmath.ZeroInt()
 	for _, flow := range streamRecord.OutFlows {

x/payment/types/keys.go

@@ -26,6 +26,7 @@ var (
 	PaymentAccountCountKeyPrefix = []byte{0x03}
 	PaymentAccountKeyPrefix      = []byte{0x04}
 	ParamsKey                    = []byte{0x05}
+	VersionedParamsKeyPrefix     = []byte{0x06}
 )
 
 // AutoSettleRecordKey returns the store key to retrieve a AutoSettleRecord from the index fields
@@ -71,3 +72,10 @@ func StreamRecordKey(
 ) []byte {
 	return account
 }
+
+// VersionedParamsKey return multi-version params store key
+func VersionedParamsKey(timestamp int64) []byte {
+	bz := make([]byte, 8)
+	binary.BigEndian.PutUint64(bz, uint64(timestamp))
+	return append(ParamsKey, bz...)
+}

x/payment/types/params.go

@@ -17,12 +17,13 @@ var (
 	KeyFeeDenom                 = []byte("FeeDenom")
 	KeyValidatorTaxRate         = []byte("ValidatorTaxRate")
 
-	DefaultReserveTime              uint64  = 180 * 24 * 60 * 60 // 180 days
-	DefaultForcedSettleTime         uint64  = 24 * 60 * 60       // 1 day
-	DefaultPaymentAccountCountLimit uint64  = 200
-	DefaultMaxAutoForceSettleNum    uint64  = 100
-	DefaultFeeDenom                 string  = "BNB"
-	DefaultValidatorTaxRate         sdk.Dec = sdk.NewDecWithPrec(1, 2) // 1%
+	DefaultReserveTime      uint64  = 180 * 24 * 60 * 60       // 180 days
+	DefaultValidatorTaxRate sdk.Dec = sdk.NewDecWithPrec(1, 2) // 1%
+
+	DefaultForcedSettleTime         uint64 = 24 * 60 * 60 // 1 day
+	DefaultPaymentAccountCountLimit uint64 = 200
+	DefaultMaxAutoForceSettleNum    uint64 = 100
+	DefaultFeeDenom                 string = "BNB"
 )
 
 // ParamKeyTable the param key table for launch module
@@ -33,49 +34,52 @@ func ParamKeyTable() paramtypes.KeyTable {
 // NewParams creates a new Params instance
 func NewParams(
 	reserveTime uint64,
+	validatorTaxRate sdk.Dec,
 	forcedSettleTime uint64,
 	paymentAccountCountLimit uint64,
 	maxAutoForceSettleNum uint64,
 	feeDenom string,
-	validatorTaxRate sdk.Dec,
 ) Params {
 	return Params{
-		ReserveTime:              reserveTime,
+		VersionedParams:          VersionedParams{ReserveTime: reserveTime, ValidatorTaxRate: validatorTaxRate},
 		ForcedSettleTime:         forcedSettleTime,
 		PaymentAccountCountLimit: paymentAccountCountLimit,
 		MaxAutoForceSettleNum:    maxAutoForceSettleNum,
 		FeeDenom:                 feeDenom,
-		ValidatorTaxRate:         validatorTaxRate,
 	}
 }
 
 // DefaultParams returns a default set of parameters
 func DefaultParams() Params {
 	return NewParams(
 		DefaultReserveTime,
+		DefaultValidatorTaxRate,
 		DefaultForcedSettleTime,
 		DefaultPaymentAccountCountLimit,
 		DefaultMaxAutoForceSettleNum,
 		DefaultFeeDenom,
-		DefaultValidatorTaxRate,
 	)
 }
 
 // ParamSetPairs get the params.ParamSet
 func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs {
 	return paramtypes.ParamSetPairs{
-		paramtypes.NewParamSetPair(KeyReserveTime, &p.ReserveTime, validateReserveTime),
+		paramtypes.NewParamSetPair(KeyReserveTime, &p.VersionedParams.ReserveTime, validateReserveTime),
+		paramtypes.NewParamSetPair(KeyValidatorTaxRate, &p.VersionedParams.ValidatorTaxRate, validateValidatorTaxRate),
 		paramtypes.NewParamSetPair(KeyForcedSettleTime, &p.ForcedSettleTime, validateForcedSettleTime),
 		paramtypes.NewParamSetPair(KeyPaymentAccountCountLimit, &p.PaymentAccountCountLimit, validatePaymentAccountCountLimit),
 		paramtypes.NewParamSetPair(KeyMaxAutoForceSettleNum, &p.MaxAutoForceSettleNum, validateMaxAutoForceSettleNum),
 		paramtypes.NewParamSetPair(KeyFeeDenom, &p.FeeDenom, validateFeeDenom),
-		paramtypes.NewParamSetPair(KeyValidatorTaxRate, &p.ValidatorTaxRate, validateValidatorTaxRate),
 	}
 }
 
 // Validate validates the set of params
 func (p Params) Validate() error {
-	if err := validateReserveTime(p.ReserveTime); err != nil {
+	if err := validateReserveTime(p.VersionedParams.ReserveTime); err != nil {
+		return err
+	}
+
+	if err := validateValidatorTaxRate(p.VersionedParams.ValidatorTaxRate); err != nil {
 		return err
 	}
 
@@ -95,9 +99,6 @@ func (p Params) Validate() error {
 		return err
 	}
 
-	if err := validateValidatorTaxRate(p.ValidatorTaxRate); err != nil {
-		return err
-	}
 	return nil
 }