Feat/txfees

proto/cosmwasm/txfees/v1/epoch.proto

@@ -0,0 +1,68 @@
+syntax = "proto3";
+package cosmwasm.txfees.v1;
+
+import "gogoproto/gogo.proto";
+import "cosmos_proto/cosmos.proto";
+import "google/protobuf/duration.proto";
+import "google/protobuf/timestamp.proto";
+import "cosmwasm/txfees/v1/params.proto";
+
+option go_package = "github.com/CosmWasm/wasmd/x/txfees/types";
+
+// EpochInfo defines information of a epoch
+message EpochInfo {
+    // identifier is a unique reference to this particular timer.
+    string identifier = 1;
+    // start_time is the time at which the timer first ever ticks.
+    // If start_time is in the future, the epoch will not begin until the start
+    // time.
+    google.protobuf.Timestamp start_time = 2 [
+      (gogoproto.stdtime) = true,
+      (gogoproto.nullable) = false,
+      (gogoproto.moretags) = "yaml:\"start_time\""
+    ];
+    // duration is the time in between epoch ticks.
+    // In order for intended behavior to be met, duration should
+    // be greater than the chains expected block time.
+    // Duration must be non-zero.
+    google.protobuf.Duration duration = 3 [
+      (gogoproto.nullable) = false,
+      (gogoproto.stdduration) = true,
+      (gogoproto.jsontag) = "duration,omitempty",
+      (gogoproto.moretags) = "yaml:\"duration\""
+    ];
+    // current_epoch is the current epoch number, or in other words,
+    // how many times has the timer 'ticked'.
+    // The first tick (current_epoch=1) is defined as
+    // the first block whose blocktime is greater than the EpochInfo start_time.
+    int64 current_epoch = 4;
+    // current_epoch_start_time describes the start time of the current timer
+    // interval. The interval is (current_epoch_start_time,
+    // current_epoch_start_time + duration] When the timer ticks, this is set to
+    // current_epoch_start_time = last_epoch_start_time + duration only one timer
+    // tick for a given identifier can occur per block.
+    //
+    // NOTE! The current_epoch_start_time may diverge significantly from the
+    // wall-clock time the epoch began at. Wall-clock time of epoch start may be
+    // >> current_epoch_start_time. Suppose current_epoch_start_time = 10,
+    // duration = 5. Suppose the chain goes offline at t=14, and comes back online
+    // at t=30, and produces blocks at every successive time. (t=31, 32, etc.)
+    // * The t=30 block will start the epoch for (10, 15]
+    // * The t=31 block will start the epoch for (15, 20]
+    // * The t=32 block will start the epoch for (20, 25]
+    // * The t=33 block will start the epoch for (25, 30]
+    // * The t=34 block will start the epoch for (30, 35]
+    // * The **t=36** block will start the epoch for (35, 40]
+    google.protobuf.Timestamp current_epoch_start_time = 5 [
+      (gogoproto.stdtime) = true,
+      (gogoproto.nullable) = false,
+      (gogoproto.moretags) = "yaml:\"current_epoch_start_time\""
+    ];
+    // epoch_counting_started is a boolean, that indicates whether this
+    // epoch timer has began yet.
+    bool epoch_counting_started = 6;
+    reserved 7;
+    // current_epoch_start_height is the block height at which the current epoch
+    // started. (The block height at which the timer last ticked)
+    int64 current_epoch_start_height = 8;
+  }

proto/cosmwasm/txfees/v1/fee_token.proto

@@ -0,0 +1,20 @@
+syntax = "proto3";
+package cosmwasm.txfees.v1;
+
+import "gogoproto/gogo.proto";
+import "cosmos_proto/cosmos.proto";
+import "cosmwasm/txfees/v1/params.proto";
+
+option go_package = "github.com/CosmWasm/wasmd/x/txfees/types";
+
+enum FeeTokenStatus {
+    UPDATED = 0;
+    OUTDATED = 1;
+    FROZEN = 2;
+  }
+
+message FeeTokenConfiguration {
+    string denom = 1;
+    string pool_id = 2;
+    FeeTokenStatus status = 3;
+}

proto/cosmwasm/txfees/v1/genesis.proto

@@ -0,0 +1,13 @@
+syntax = "proto3";
+package cosmwasm.txfees.v1;
+
+import "gogoproto/gogo.proto";
+import "cosmwasm/txfees/v1/params.proto";
+
+option go_package = "github.com/CosmWasm/wasmd/x/txfees/types";
+
+// GenesisState defines the txfees module's genesis state.
+message GenesisState {
+  // params defines the paramaters of the module.
+  Params params = 1 [ (gogoproto.nullable) = false ];
+}

proto/cosmwasm/txfees/v1/params.proto

@@ -0,0 +1,13 @@
+syntax = "proto3";
+package cosmwasm.txfees.v1;
+
+import "gogoproto/gogo.proto";
+import "cosmos_proto/cosmos.proto";
+import "cosmos/base/v1beta1/coin.proto";
+
+option go_package = "github.com/CosmWasm/wasmd/x/txfees/types";
+
+// Params defines the parameters for the txfees module.
+message Params {
+    string price_contract_address = 1;
+}

proto/cosmwasm/txfees/v1/query.proto

@@ -0,0 +1,28 @@
+syntax = "proto3";
+package cosmwasm.txfees.v1;
+
+import "gogoproto/gogo.proto";
+import "google/api/annotations.proto";
+import "cosmos/base/query/v1beta1/pagination.proto";
+import "cosmwasm/txfees/v1/params.proto";
+
+option go_package = "github.com/CosmWasm/wasmd/x/txfees/types";
+
+// Query defines the gRPC querier service.
+service Query {
+  // Params defines a gRPC query method that returns the txfees module's
+  // parameters.
+  rpc Params(QueryParamsRequest) returns (QueryParamsResponse) {
+    option (google.api.http).get = "/cosmwasm/txfees/v1/params";
+  }
+
+}
+
+// QueryParamsRequest is the request type for the Query/Params RPC method.
+message QueryParamsRequest {}
+
+// QueryParamsResponse is the response type for the Query/Params RPC method.
+message QueryParamsResponse {
+  // params defines the parameters of the module.
+  Params params = 1 [ (gogoproto.nullable) = false ];
+}

proto/cosmwasm/txfees/v1/tx.proto

@@ -0,0 +1,62 @@
+syntax = "proto3";
+package cosmwasm.txfees.v1;
+
+import "cosmos/msg/v1/msg.proto";
+import "gogoproto/gogo.proto";
+import "cosmos_proto/cosmos.proto";
+import "amino/amino.proto";
+import "cosmos/base/v1beta1/coin.proto";
+import "cosmos/bank/v1beta1/bank.proto";
+import "cosmwasm/txfees/v1/params.proto";
+import "cosmwasm/txfees/v1/fee_token.proto";
+
+option go_package = "github.com/CosmWasm/wasmd/x/txfees/types";
+
+// Msg defines the tokefactory module's gRPC message service.
+service Msg {
+  option (cosmos.msg.v1.service) = true;
+
+  // Update module params
+  rpc UpdateParams(MsgUpdateParams) returns (MsgUpdateParamsResponse);
+
+  rpc AddFeeToken(MsgAddFeeToken) returns (MsgAddFeeTokenResponse);
+
+  rpc RemoveFeeToken(MsgRemoveFeeToken) returns (MsgRemoveFeeTokenResponse);
+}
+
+message MsgUpdateParams{
+  option (cosmos.msg.v1.signer) = "authority";
+
+  // authority is the address that controls the module (defaults to x/gov unless overwritten).
+  string authority    = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"];
+  option (amino.name) = "cosmwasm/x/txfees/MsgUpdateParams";
+
+  // params defines the x/fees parameters to update.
+  //
+  // NOTE: All parameters must be supplied.
+  Params params = 2 [(gogoproto.nullable) = false, (amino.dont_omitempty) = true];
+}
+
+message MsgUpdateParamsResponse {}
+
+message MsgAddFeeToken{
+  option (cosmos.msg.v1.signer) = "authority";
+
+  // authority is the address that controls the module (defaults to x/gov unless overwritten).
+  string authority    = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"];
+
+  FeeTokenConfiguration config = 2 [ (gogoproto.nullable)     = false ];
+}
+
+message MsgAddFeeTokenResponse {}
+
+message MsgRemoveFeeToken{
+  option (cosmos.msg.v1.signer) = "authority";
+
+  // authority is the address that controls the module (defaults to x/gov unless overwritten).
+  string authority    = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"];
+
+  string denom = 2;
+}
+
+message MsgRemoveFeeTokenResponse {}

x/txfees/keeper/abci.go

@@ -0,0 +1,60 @@
+package keeper
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/CosmWasm/wasmd/x/txfees/types"
+	"github.com/cosmos/cosmos-sdk/telemetry"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+func (k Keeper) BeginBlock(ctx sdk.Context) error {
+	defer telemetry.ModuleMeasureSince(types.ModuleName, time.Now(), telemetry.MetricKeyBeginBlocker)
+	k.IterateEpochInfo(ctx, func(index int64, epochInfo types.EpochInfo) (stop bool) {
+		logger := k.Logger(ctx)
+
+		// If blocktime < initial epoch start time, return
+		if ctx.BlockTime().Before(epochInfo.StartTime) {
+			return false
+		}
+		// if epoch counting hasn't started, signal we need to start.
+		shouldInitialEpochStart := !epochInfo.EpochCountingStarted
+
+		epochEndTime := epochInfo.CurrentEpochStartTime.Add(epochInfo.Duration)
+		shouldEpochStart := (ctx.BlockTime().After(epochEndTime)) || shouldInitialEpochStart
+
+		if !shouldEpochStart {
+			logger.Info(fmt.Sprintf("Epoch with identifier %s has not ended yet", epochInfo.Identifier))
+			return false
+		}
+		epochInfo.CurrentEpochStartHeight = ctx.BlockHeight()
+
+		if shouldInitialEpochStart {
+			epochInfo.EpochCountingStarted = true
+			epochInfo.CurrentEpoch = 1
+			epochInfo.CurrentEpochStartTime = epochInfo.StartTime
+			logger.Info(fmt.Sprintf("Starting new epoch with identifier %s epoch number %d", epochInfo.Identifier, epochInfo.CurrentEpoch))
+		} else {
+			k.AfterEpochEnd(ctx, epochInfo.Identifier)
+			epochInfo.CurrentEpoch++
+			epochInfo.CurrentEpochStartTime = epochInfo.CurrentEpochStartTime.Add(epochInfo.Duration)
+			logger.Info(fmt.Sprintf("Starting epoch with identifier %s epoch number %d", epochInfo.Identifier, epochInfo.CurrentEpoch))
+		}
+
+		// emit new epoch start event, set epoch info, and run BeforeEpochStart hook
+		ctx.EventManager().EmitEvent(
+			sdk.NewEvent(
+				types.EventTypeEpochStart,
+				sdk.NewAttribute(types.AttributeEpochNumber, fmt.Sprintf("%d", epochInfo.CurrentEpoch)),
+				sdk.NewAttribute(types.AttributeEpochStartTime, fmt.Sprintf("%d", epochInfo.CurrentEpochStartTime.Unix())),
+			),
+		)
+		if err := k.SetEpochInfo(ctx, epochInfo); err != nil {
+			k.Logger(ctx).Error(fmt.Sprintf("error setting epoch info: %s", err.Error()))
+			return true
+		}
+		return false
+	})
+	return nil
+}

x/txfees/keeper/epoch.go

@@ -0,0 +1,116 @@
+package keeper
+
+import (
+	"fmt"
+	"time"
+
+	storetypes "cosmossdk.io/store/types"
+	"github.com/CosmWasm/wasmd/x/txfees/types"
+	"github.com/cosmos/cosmos-sdk/runtime"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+func (k Keeper) HasEpochInfo(ctx sdk.Context, identifier string) (bool, error) {
+	store := k.storeService.OpenKVStore(ctx)
+	key := types.GetEpochKey(identifier)
+
+	has, err := store.Has(key)
+	if err != nil {
+		return false, err
+	}
+
+	return has, nil
+}
+
+func (k Keeper) SetEpochInfo(ctx sdk.Context, epoch types.EpochInfo) error {
+	store := k.storeService.OpenKVStore(ctx)
+	key := types.GetEpochKey(epoch.Identifier)
+
+	bz, err := k.cdc.Marshal(&epoch)
+	if err != nil {
+		return err
+	}
+
+	return store.Set(key, bz)
+}
+
+func (k Keeper) GetEpochInfo(ctx sdk.Context, identifier string) (types.EpochInfo, bool) {
+	store := k.storeService.OpenKVStore(ctx)
+	key := types.GetEpochKey(identifier)
+
+	bz, err := store.Get(key)
+	if bz == nil || err != nil {
+		return types.EpochInfo{}, false
+	}
+
+	epoch := types.EpochInfo{}
+	err = k.cdc.Unmarshal(bz, &epoch)
+	if err != nil {
+		panic(err)
+	}
+
+	return epoch, true
+}
+
+func (k Keeper) AddEpochInfo(ctx sdk.Context, epoch types.EpochInfo) error {
+	err := epoch.Validate()
+	if err != nil {
+		return err
+	}
+	// Check if identifier already exists
+	if has, _ := k.HasEpochInfo(ctx, epoch.Identifier); !has {
+		return fmt.Errorf("epoch with identifier %s already exists", epoch.Identifier)
+	}
+
+	// Initialize empty and default epoch values
+	if epoch.StartTime.Equal(time.Time{}) {
+		epoch.StartTime = ctx.BlockTime()
+	}
+	epoch.CurrentEpochStartHeight = ctx.BlockHeight()
+	return k.SetEpochInfo(ctx, epoch)
+}
+
+func (k Keeper) IterateEpochInfo(ctx sdk.Context, cb func(index int64, epochInfo types.EpochInfo) (stop bool)) {
+	store := k.storeService.OpenKVStore(ctx)
+
+	iterator := storetypes.KVStorePrefixIterator(runtime.KVStoreAdapter(store), types.EpochKeyPrefix)
+	defer iterator.Close()
+
+	i := int64(0)
+
+	for ; iterator.Valid(); iterator.Next() {
+		epoch := types.EpochInfo{}
+		err := k.cdc.Unmarshal(iterator.Value(), &epoch)
+		if err != nil {
+			panic(err)
+		}
+
+		stop := cb(i, epoch)
+		if stop {
+			break
+		}
+		i++
+	}
+}
+
+func (k Keeper) AllEpochInfos(ctx sdk.Context) []types.EpochInfo {
+	epochs := []types.EpochInfo{}
+	k.IterateEpochInfo(ctx, func(index int64, epoch types.EpochInfo) (stop bool) {
+		epochs = append(epochs, epoch)
+		return false
+	})
+
+	return epochs
+}
+
+func (k Keeper) AfterEpochEnd(ctx sdk.Context, identifier string) {
+	switch identifier {
+	case types.DefaultQueryEpochIdentifier:
+		k.IterateAllowedTokenList(ctx, func(denom string) (stop bool) {
+			k.QueryOraiDexTokenExchangeRate(ctx, denom)
+			return false
+		})
+	default:
+		k.Logger(ctx).Error((fmt.Sprintf("unknown epoch %s", identifier)))
+	}
+}