merge develop branch

deployment/localup/localup.sh

@@ -147,7 +147,7 @@ function generate_genesis() {
         sed -i -e "s/\"challenge_keep_alive_period\": \"300\"/\"challenge_keep_alive_period\": \"10\"/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/challenge_test.go

@@ -113,8 +113,6 @@ func (s *ChallengeTestSuite) createObject() (string, string, sdk.AccAddress, []s
 	err = storagetypes.VerifySignature(sp.ApprovalKey.GetAddr(), sdk.Keccak256(sr.GetSignBytes()), secondarySig)
 	s.Require().NoError(err)
 
-	s.Require().NoError(err)
-
 	secondarySigs := [][]byte{secondarySig, secondarySig, secondarySig, secondarySig, secondarySig, secondarySig}
 	msgSealObject.SecondarySpSignatures = secondarySigs
 	s.SendTxBlock(sp.SealKey, msgSealObject)

e2e/tests/sp_test.go

@@ -2,6 +2,7 @@ package tests
 
 import (
 	"context"
+	"sort"
 	"strconv"
 	"testing"
 	"time"
@@ -129,6 +130,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)
@@ -285,19 +287,27 @@ func (s *StorageProviderTestSuite) CheckSecondarySpPrice() {
 	s.Require().NoError(err)
 	s.T().Logf("sps: %s", sps)
 	spNum := int64(sps.Pagination.Total)
-	total := sdk.ZeroDec()
+	prices := make([]sdk.Dec, 0)
 	for _, sp := range sps.Sps {
 		spStoragePrice, err := s.Client.QueryGetSpStoragePriceByTime(ctx, &sptypes.QueryGetSpStoragePriceByTimeRequest{
 			SpAddr:    sp.OperatorAddress,
 			Timestamp: 0,
 		})
 		s.Require().NoError(err)
 		s.T().Logf("sp: %s, storage price: %s", sp.OperatorAddress, core.YamlString(spStoragePrice.SpStoragePrice))
-		total = total.Add(spStoragePrice.SpStoragePrice.StorePrice)
+		prices = append(prices, spStoragePrice.SpStoragePrice.StorePrice)
 	}
+	sort.Slice(prices, func(i, j int) bool { return prices[i].LT(prices[j]) })
+	var median sdk.Dec
+	if spNum%2 == 0 {
+		median = prices[spNum/2-1].Add(prices[spNum/2]).QuoInt64(2)
+	} else {
+		median = prices[spNum/2]
+	}
+
 	params, err := s.Client.SpQueryClient.Params(ctx, &sptypes.QueryParamsRequest{})
 	s.Require().NoError(err)
-	expectedSecondarySpStorePrice := params.Params.SecondarySpStorePriceRatio.Mul(total).QuoInt64(spNum)
+	expectedSecondarySpStorePrice := params.Params.SecondarySpStorePriceRatio.Mul(median)
 	s.Require().Equal(expectedSecondarySpStorePrice, queryGetSecondarySpStorePriceByTimeResp.SecondarySpStorePrice.StorePrice)
 }
 

e2e/tests/storage_test.go

@@ -496,7 +496,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(userStreamRecord.NetflowRate.Abs(), userTotalRate)
 	expectedOutFlows := []paymenttypes.OutFlow{
@@ -564,11 +564,12 @@ 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))
 
 	streamRecordsAfterCreateObject := s.GetStreamRecords(streamAddresses)
 	s.T().Logf("streamRecordsAfterCreateObject %s", core.YamlString(streamRecordsAfterCreateObject))
 	userStreamAccountAfterCreateObj := streamRecordsAfterCreateObject.User
+
 	s.Require().Equal(expectedLockedBalance.String(), userStreamAccountAfterCreateObj.LockBalance.String())
 
 	// seal object
@@ -693,7 +694,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(),
@@ -702,7 +703,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))
@@ -1799,6 +1800,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.
@@ -21,8 +20,14 @@ message Params {
   uint64 max_auto_resume_flow_count = 5 [(gogoproto.moretags) = "yaml:\"max_auto_resume_flow_count\""];
   // The denom of fee charged in payment module
   string fee_denom = 6 [(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 = 7 [
+  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

@@ -24,6 +24,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 OutFlows(QueryOutFlowsRequest) returns (QueryOutFlowsResponse) {
     option (google.api.http).get = "/greenfield/payment/out_flows/{account}";
@@ -84,6 +89,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 QueryOutFlowsRequest {
   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

@@ -72,7 +72,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

@@ -149,7 +149,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)
@@ -346,7 +346,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
 
 	expectedBalanceToResume := streamRecord.FrozenNetflowRate.Mul(sdkmath.NewIntFromUint64(reserveTime))

x/payment/types/keys.go

@@ -30,6 +30,7 @@ var (
 	PaymentAccountKeyPrefix      = []byte{0x05}
 	OutFlowKeyPrefix             = []byte{0x06}
 	ParamsKey                    = []byte{0x07}
+	VersionedParamsKeyPrefix     = []byte{0x08}
 )
 
 // AutoSettleRecordKey returns the store key to retrieve a AutoSettleRecord from the index fields
@@ -133,3 +134,10 @@ func ParseOutFlowValue(value []byte) sdkmath.Int {
 	}
 	return rate
 }
+
+// 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...)
+}