diff --git a/app/app.go b/app/app.go index 958601aba..daa38a486 100644 --- a/app/app.go +++ b/app/app.go @@ -1046,6 +1046,7 @@ func NewElysApp( appCodec, keys[tradeshieldmoduletypes.StoreKey], keys[tradeshieldmoduletypes.MemStoreKey], + authtypes.NewModuleAddress(govtypes.ModuleName).String(), ) tradeshieldModule := tradeshieldmodule.NewAppModule(appCodec, app.TradeshieldKeeper, app.AccountKeeper, app.BankKeeper) diff --git a/docs/static/openapi.yml b/docs/static/openapi.yml index dcce36706..169289b3d 100644 --- a/docs/static/openapi.yml +++ b/docs/static/openapi.yml @@ -46095,6 +46095,32 @@ paths: params: description: params holds all the parameters of this module. type: object + properties: + market_order_enabled: + type: boolean + title: 'TODO: Add gov proposal message to set this values' + stake_enabled: + type: boolean + process_orders_enabled: + type: boolean + swap_enabled: + type: boolean + perpetual_enabled: + type: boolean + reward_enabled: + type: boolean + leverage_enabled: + type: boolean + limit_process_order: + type: string + format: uint64 + reward_percentage: + type: string + title: For incentive system v2 + margin_error: + type: string + minimum_deposit: + type: string description: >- QueryParamsResponse is response type for the Query/Params RPC method. @@ -46132,13 +46158,68 @@ paths: items: type: object properties: - id: + order_id: type: string format: uint64 - order: + owner_address: type: string - creator: + perpetual_order_type: + type: string + enum: + - LIMITOPEN + - LIMITCLOSE + - MARKETOPEN + - MARKETCLOSE + - STOPLOSSPERP + default: LIMITOPEN + title: Perpetual Order + position: type: string + enum: + - UNSPECIFIED + - LONG + - SHORT + default: UNSPECIFIED + trigger_price: + type: object + properties: + base_denom: + type: string + quote_denom: + type: string + rate: + type: string + collateral: + type: object + properties: + denom: + type: string + amount: + type: string + description: >- + Coin defines a token with a denomination and an amount. + + + NOTE: The amount field is an Int which implements the + custom method + + signatures required by gogoproto. + trading_asset: + type: string + leverage: + type: string + take_profit_price: + type: string + position_id: + type: string + format: uint64 + status: + type: string + enum: + - PENDING + - EXECUTED + - CANCLED + default: PENDING pagination: type: object properties: @@ -46257,13 +46338,68 @@ paths: PendingPerpetualOrder: type: object properties: - id: + order_id: type: string format: uint64 - order: + owner_address: type: string - creator: + perpetual_order_type: + type: string + enum: + - LIMITOPEN + - LIMITCLOSE + - MARKETOPEN + - MARKETCLOSE + - STOPLOSSPERP + default: LIMITOPEN + title: Perpetual Order + position: type: string + enum: + - UNSPECIFIED + - LONG + - SHORT + default: UNSPECIFIED + trigger_price: + type: object + properties: + base_denom: + type: string + quote_denom: + type: string + rate: + type: string + collateral: + type: object + properties: + denom: + type: string + amount: + type: string + description: >- + Coin defines a token with a denomination and an amount. + + + NOTE: The amount field is an Int which implements the + custom method + + signatures required by gogoproto. + trading_asset: + type: string + leverage: + type: string + take_profit_price: + type: string + position_id: + type: string + format: uint64 + status: + type: string + enum: + - PENDING + - EXECUTED + - CANCLED + default: PENDING default: description: An unexpected error response. schema: @@ -91209,6 +91345,8 @@ definitions: type: object elys.tradeshield.MsgDeletePendingSpotOrderResponse: type: object + elys.tradeshield.MsgUpdateParamsResponse: + type: object elys.tradeshield.MsgUpdatePendingPerpetualOrderResponse: type: object elys.tradeshield.MsgUpdatePendingSpotOrderResponse: @@ -91224,17 +91362,112 @@ definitions: type: string elys.tradeshield.Params: type: object + properties: + market_order_enabled: + type: boolean + title: 'TODO: Add gov proposal message to set this values' + stake_enabled: + type: boolean + process_orders_enabled: + type: boolean + swap_enabled: + type: boolean + perpetual_enabled: + type: boolean + reward_enabled: + type: boolean + leverage_enabled: + type: boolean + limit_process_order: + type: string + format: uint64 + reward_percentage: + type: string + title: For incentive system v2 + margin_error: + type: string + minimum_deposit: + type: string description: Params defines the parameters for the module. - elys.tradeshield.PendingPerpetualOrder: + elys.tradeshield.PerpetualOrder: type: object properties: - id: + order_id: type: string format: uint64 - order: + owner_address: type: string - creator: + perpetual_order_type: + type: string + enum: + - LIMITOPEN + - LIMITCLOSE + - MARKETOPEN + - MARKETCLOSE + - STOPLOSSPERP + default: LIMITOPEN + title: Perpetual Order + position: + type: string + enum: + - UNSPECIFIED + - LONG + - SHORT + default: UNSPECIFIED + trigger_price: + type: object + properties: + base_denom: + type: string + quote_denom: + type: string + rate: + type: string + collateral: + type: object + properties: + denom: + type: string + amount: + type: string + description: |- + Coin defines a token with a denomination and an amount. + + NOTE: The amount field is an Int which implements the custom method + signatures required by gogoproto. + trading_asset: + type: string + leverage: + type: string + take_profit_price: + type: string + position_id: type: string + format: uint64 + status: + type: string + enum: + - PENDING + - EXECUTED + - CANCLED + default: PENDING + elys.tradeshield.PerpetualOrderType: + type: string + enum: + - LIMITOPEN + - LIMITCLOSE + - MARKETOPEN + - MARKETCLOSE + - STOPLOSSPERP + default: LIMITOPEN + title: Perpetual Order + elys.tradeshield.PerpetualPosition: + type: string + enum: + - UNSPECIFIED + - LONG + - SHORT + default: UNSPECIFIED elys.tradeshield.QueryAllPendingPerpetualOrderResponse: type: object properties: @@ -91243,13 +91476,68 @@ definitions: items: type: object properties: - id: + order_id: type: string format: uint64 - order: + owner_address: type: string - creator: + perpetual_order_type: type: string + enum: + - LIMITOPEN + - LIMITCLOSE + - MARKETOPEN + - MARKETCLOSE + - STOPLOSSPERP + default: LIMITOPEN + title: Perpetual Order + position: + type: string + enum: + - UNSPECIFIED + - LONG + - SHORT + default: UNSPECIFIED + trigger_price: + type: object + properties: + base_denom: + type: string + quote_denom: + type: string + rate: + type: string + collateral: + type: object + properties: + denom: + type: string + amount: + type: string + description: >- + Coin defines a token with a denomination and an amount. + + + NOTE: The amount field is an Int which implements the custom + method + + signatures required by gogoproto. + trading_asset: + type: string + leverage: + type: string + take_profit_price: + type: string + position_id: + type: string + format: uint64 + status: + type: string + enum: + - PENDING + - EXECUTED + - CANCLED + default: PENDING pagination: type: object properties: @@ -91372,13 +91660,68 @@ definitions: PendingPerpetualOrder: type: object properties: - id: + order_id: type: string format: uint64 - order: + owner_address: type: string - creator: + perpetual_order_type: + type: string + enum: + - LIMITOPEN + - LIMITCLOSE + - MARKETOPEN + - MARKETCLOSE + - STOPLOSSPERP + default: LIMITOPEN + title: Perpetual Order + position: + type: string + enum: + - UNSPECIFIED + - LONG + - SHORT + default: UNSPECIFIED + trigger_price: + type: object + properties: + base_denom: + type: string + quote_denom: + type: string + rate: + type: string + collateral: + type: object + properties: + denom: + type: string + amount: + type: string + description: >- + Coin defines a token with a denomination and an amount. + + + NOTE: The amount field is an Int which implements the custom + method + + signatures required by gogoproto. + trading_asset: + type: string + leverage: + type: string + take_profit_price: + type: string + position_id: + type: string + format: uint64 + status: type: string + enum: + - PENDING + - EXECUTED + - CANCLED + default: PENDING elys.tradeshield.QueryGetPendingSpotOrderResponse: type: object properties: @@ -91447,6 +91790,32 @@ definitions: params: description: params holds all the parameters of this module. type: object + properties: + market_order_enabled: + type: boolean + title: 'TODO: Add gov proposal message to set this values' + stake_enabled: + type: boolean + process_orders_enabled: + type: boolean + swap_enabled: + type: boolean + perpetual_enabled: + type: boolean + reward_enabled: + type: boolean + leverage_enabled: + type: boolean + limit_process_order: + type: string + format: uint64 + reward_percentage: + type: string + title: For incentive system v2 + margin_error: + type: string + minimum_deposit: + type: string description: QueryParamsResponse is response type for the Query/Params RPC method. elys.tradeshield.SpotOrder: type: object diff --git a/proto/elys/tradeshield/params.proto b/proto/elys/tradeshield/params.proto index 7ef231178..75ceae6f3 100644 --- a/proto/elys/tradeshield/params.proto +++ b/proto/elys/tradeshield/params.proto @@ -8,5 +8,27 @@ option go_package = "github.com/elys-network/elys/x/tradeshield/types"; // Params defines the parameters for the module. message Params { option (gogoproto.goproto_stringer) = false; - + + bool market_order_enabled = 1; + bool stake_enabled = 2; + bool process_orders_enabled = 3; + bool swap_enabled = 4; + bool perpetual_enabled = 5; + bool reward_enabled = 6; + bool leverage_enabled = 7; + uint64 limit_process_order = 8; + + // For incentive system v2 + string reward_percentage = 9 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", + (gogoproto.nullable) = false + ]; + string margin_error = 10 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec", + (gogoproto.nullable) = false + ]; + string minimum_deposit = 11 [ + (gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Int", + (gogoproto.nullable) = false + ]; } diff --git a/proto/elys/tradeshield/tx.proto b/proto/elys/tradeshield/tx.proto index a97caec44..960faeaca 100644 --- a/proto/elys/tradeshield/tx.proto +++ b/proto/elys/tradeshield/tx.proto @@ -3,6 +3,7 @@ syntax = "proto3"; package elys.tradeshield; import "elys/tradeshield/types.proto"; +import "elys/tradeshield/params.proto"; import "cosmos/base/v1beta1/coin.proto"; option go_package = "github.com/elys-network/elys/x/tradeshield/types"; @@ -15,6 +16,7 @@ service Msg { rpc CreatePendingPerpetualOrder (MsgCreatePendingPerpetualOrder) returns (MsgCreatePendingPerpetualOrderResponse); rpc UpdatePendingPerpetualOrder (MsgUpdatePendingPerpetualOrder) returns (MsgUpdatePendingPerpetualOrderResponse); rpc DeletePendingPerpetualOrder (MsgDeletePendingPerpetualOrder) returns (MsgDeletePendingPerpetualOrderResponse); + rpc UpdateParams (MsgUpdateParams ) returns (MsgUpdateParamsResponse ); } message MsgCreatePendingSpotOrder { SpotOrderType order_type = 1; @@ -69,3 +71,13 @@ message MsgDeletePendingPerpetualOrder { message MsgDeletePendingPerpetualOrderResponse {} +message MsgUpdateParams { + // authority is the address that controls the module (defaults to x/gov unless overwritten). + string authority = 1; + + // NOTE: All parameters must be supplied. + Params params = 2; +} + +message MsgUpdateParamsResponse {} + diff --git a/testutil/keeper/tradeshield.go b/testutil/keeper/tradeshield.go index a331c7916..034a40c00 100644 --- a/testutil/keeper/tradeshield.go +++ b/testutil/keeper/tradeshield.go @@ -11,6 +11,7 @@ import ( "github.com/cosmos/cosmos-sdk/store" storetypes "github.com/cosmos/cosmos-sdk/store/types" sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/address" "github.com/elys-network/elys/x/tradeshield/keeper" "github.com/elys-network/elys/x/tradeshield/types" "github.com/stretchr/testify/require" @@ -28,11 +29,13 @@ func TradeshieldKeeper(t testing.TB) (*keeper.Keeper, sdk.Context) { registry := codectypes.NewInterfaceRegistry() cdc := codec.NewProtoCodec(registry) + govAddress := sdk.AccAddress(address.Module("gov")) k := keeper.NewKeeper( cdc, storeKey, memStoreKey, + govAddress.String(), ) ctx := sdk.NewContext(stateStore, tmproto.Header{}, false, log.NewNopLogger()) diff --git a/x/tradeshield/client/cli/tx.go b/x/tradeshield/client/cli/tx.go index d92d7b72d..b76225a9b 100644 --- a/x/tradeshield/client/cli/tx.go +++ b/x/tradeshield/client/cli/tx.go @@ -36,6 +36,7 @@ func GetTxCmd() *cobra.Command { cmd.AddCommand(CmdCreatePendingPerpetualOrder()) cmd.AddCommand(CmdUpdatePendingPerpetualOrder()) cmd.AddCommand(CmdDeletePendingPerpetualOrder()) + cmd.AddCommand(CmdUpdateParams()) // this line is used by starport scaffolding # 1 return cmd diff --git a/x/tradeshield/client/cli/tx_update_params.go b/x/tradeshield/client/cli/tx_update_params.go new file mode 100644 index 000000000..9fd3be64c --- /dev/null +++ b/x/tradeshield/client/cli/tx_update_params.go @@ -0,0 +1,196 @@ +package cli + +import ( + "errors" + + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/cosmos/cosmos-sdk/client/tx" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/address" + "github.com/cosmos/cosmos-sdk/x/gov/client/cli" + v1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1" + "github.com/elys-network/elys/x/tradeshield/types" + "github.com/spf13/cobra" +) + +const ( + FlagMarketOrderEnabled = "market-order-enabled" + FlagStakeEnabled = "stake-enabled" + FlagProcessOrdersEnabled = "process-orders-enabled" + FlagSwapEnabled = "swap-enabled" + FlagPerpetualEnabled = "perpetual-enabled" + FlagRewardEnabled = "reward-enabled" + FlagLeverageEnabled = "leverage-enabled" + FlagLimitProcessOrder = "limit-process-order" + FlagRewardPercentage = "reward-percentage" + FlagMarginError = "margin-error" + FlagMinimumDeposit = "minimum-deposit" +) + +// Governance command +func CmdUpdateParams() *cobra.Command { + cmd := &cobra.Command{ + Use: "update-params", + Short: "Update tradeshield params", + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + title, err := cmd.Flags().GetString(cli.FlagTitle) + if err != nil { + return err + } + + summary, err := cmd.Flags().GetString(cli.FlagSummary) + if err != nil { + return err + } + + metadata, err := cmd.Flags().GetString(cli.FlagMetadata) + if err != nil { + return err + } + + marketOrderEnabled, err := cmd.Flags().GetBool(FlagMarketOrderEnabled) + if err != nil { + return err + } + + stakeEnabled, err := cmd.Flags().GetBool(FlagStakeEnabled) + if err != nil { + return err + } + + processOrdersEnabled, err := cmd.Flags().GetBool(FlagProcessOrdersEnabled) + if err != nil { + return err + } + + swapEnabled, err := cmd.Flags().GetBool(FlagSwapEnabled) + if err != nil { + return err + } + + perpetualEnabled, err := cmd.Flags().GetBool(FlagPerpetualEnabled) + if err != nil { + return err + } + + rewardEnabled, err := cmd.Flags().GetBool(FlagRewardEnabled) + if err != nil { + return err + } + + leverageEnabled, err := cmd.Flags().GetBool(FlagLeverageEnabled) + if err != nil { + return err + } + + limitProcessOrder, err := cmd.Flags().GetUint64(FlagLimitProcessOrder) + if err != nil { + return err + } + + rewardPercentage, err := cmd.Flags().GetString(FlagRewardPercentage) + if err != nil { + return err + } + + marginError, err := cmd.Flags().GetString(FlagMarginError) + if err != nil { + return err + } + + minDeposit, err := cmd.Flags().GetString(FlagMinimumDeposit) + if err != nil { + return err + } + + minimumDeposit, ok := sdk.NewIntFromString(minDeposit) + if !ok { + return errors.New("invalid minimum deposit amount") + } + + params := types.Params{ + MarketOrderEnabled: marketOrderEnabled, + StakeEnabled: stakeEnabled, + ProcessOrdersEnabled: processOrdersEnabled, + SwapEnabled: swapEnabled, + PerpetualEnabled: perpetualEnabled, + RewardEnabled: rewardEnabled, + LeverageEnabled: leverageEnabled, + LimitProcessOrder: limitProcessOrder, + RewardPercentage: sdk.MustNewDecFromStr(rewardPercentage), + MarginError: sdk.MustNewDecFromStr(marginError), + MinimumDeposit: minimumDeposit, + } + + signer := clientCtx.GetFromAddress() + if signer == nil { + return errors.New("signer address is missing") + } + + govAddress := sdk.AccAddress(address.Module("gov")) + msg := types.NewMsgUpdateParams( + govAddress.String(), + params, + ) + + if err := msg.ValidateBasic(); err != nil { + return err + } + + depositStr, err := cmd.Flags().GetString(cli.FlagDeposit) + if err != nil { + return err + } + + deposit, err := sdk.ParseCoinsNormalized(depositStr) + if err != nil { + return err + } + + govMsg, err := v1.NewMsgSubmitProposal([]sdk.Msg{msg}, deposit, signer.String(), metadata, title, summary) + if err != nil { + return err + } + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), govMsg) + }, + } + + cmd.Flags().Bool(FlagMarketOrderEnabled, false, "market order enabled") + cmd.Flags().Bool(FlagStakeEnabled, false, "stake enabled") + cmd.Flags().Bool(FlagProcessOrdersEnabled, false, "process order enabled") + cmd.Flags().Bool(FlagSwapEnabled, false, "swap enabled") + cmd.Flags().Bool(FlagPerpetualEnabled, false, "perpetual enabled") + cmd.Flags().Bool(FlagRewardEnabled, false, "reward enabled") + cmd.Flags().Bool(FlagLeverageEnabled, false, "leverage enabled") + cmd.Flags().Uint64(FlagLimitProcessOrder, 10000000, "max limit order processed") + cmd.Flags().String(FlagRewardPercentage, "", "percentage of rewards given to watchers (decimal range 0-1)") + cmd.Flags().String(FlagMarginError, "", "percentage of margin error on orders triggered by price (decimal range 0-1)") + cmd.Flags().String(FlagMinimumDeposit, "", "minimum deposit amount for watchers") + cmd.Flags().String(cli.FlagTitle, "", "title of proposal") + cmd.Flags().String(cli.FlagSummary, "", "summary of proposal") + cmd.Flags().String(cli.FlagMetadata, "", "metadata of proposal") + cmd.Flags().String(cli.FlagDeposit, "", "deposit of proposal") + _ = cmd.MarkFlagRequired(FlagMarketOrderEnabled) + _ = cmd.MarkFlagRequired(FlagStakeEnabled) + _ = cmd.MarkFlagRequired(FlagProcessOrdersEnabled) + _ = cmd.MarkFlagRequired(FlagSwapEnabled) + _ = cmd.MarkFlagRequired(FlagPerpetualEnabled) + _ = cmd.MarkFlagRequired(FlagRewardEnabled) + _ = cmd.MarkFlagRequired(FlagLeverageEnabled) + _ = cmd.MarkFlagRequired(FlagLimitProcessOrder) + _ = cmd.MarkFlagRequired(FlagRewardPercentage) + _ = cmd.MarkFlagRequired(FlagMarginError) + _ = cmd.MarkFlagRequired(FlagMinimumDeposit) + _ = cmd.MarkFlagRequired(cli.FlagTitle) + _ = cmd.MarkFlagRequired(cli.FlagSummary) + _ = cmd.MarkFlagRequired(cli.FlagMetadata) + _ = cmd.MarkFlagRequired(cli.FlagDeposit) + flags.AddTxFlagsToCmd(cmd) + return cmd +} diff --git a/x/tradeshield/client/cli/tx_update_params_test.go b/x/tradeshield/client/cli/tx_update_params_test.go new file mode 100644 index 000000000..9b7d0577b --- /dev/null +++ b/x/tradeshield/client/cli/tx_update_params_test.go @@ -0,0 +1,51 @@ +package cli_test + +import ( + "testing" + + clitestutil "github.com/cosmos/cosmos-sdk/testutil/cli" + "github.com/stretchr/testify/require" + + "github.com/elys-network/elys/testutil/network" + "github.com/elys-network/elys/x/tradeshield/client/cli" +) + +func setupNetwork(t *testing.T) *network.Network { + t.Helper() + + cfg := network.DefaultConfig() + return network.New(t, cfg) +} + +func TestGovUpdateParams(t *testing.T) { + net := setupNetwork(t) + ctx := net.Validators[0].ClientCtx + val := net.Validators[0] + + // Use baseURL to make API HTTP requests or use val.RPCClient to make direct + // Tendermint RPC calls. + // ... + + args := []string{ + "--title=test", + "--summary=test", + "--metadata=test", + "--deposit=1000000uelys", + "--market-order-enabled=true", + "--stake-enabled=true", + "--process-orders-enabled=true", + "--swap-enabled=true", + "--perpetual-enabled=true", + "--reward-enabled=true", + "--leverage-enabled=true", + "--limit-process-order=10000", + "--reward-percentage=0.1", + "--margin-error=0.1", + "--minimum-deposit=1000000", + "--from=" + val.Address.String(), + "-y", + } + + _, err := clitestutil.ExecTestCLICmd(ctx, cli.CmdUpdateParams(), args) + require.NoError(t, err) +} diff --git a/x/tradeshield/keeper/keeper.go b/x/tradeshield/keeper/keeper.go index c443100c3..c0276165a 100644 --- a/x/tradeshield/keeper/keeper.go +++ b/x/tradeshield/keeper/keeper.go @@ -13,9 +13,10 @@ import ( type ( Keeper struct { - cdc codec.BinaryCodec - storeKey storetypes.StoreKey - memKey storetypes.StoreKey + cdc codec.BinaryCodec + storeKey storetypes.StoreKey + memKey storetypes.StoreKey + authority string } ) @@ -23,11 +24,13 @@ func NewKeeper( cdc codec.BinaryCodec, storeKey, memKey storetypes.StoreKey, + authority string, ) *Keeper { return &Keeper{ - cdc: cdc, - storeKey: storeKey, - memKey: memKey, + cdc: cdc, + storeKey: storeKey, + memKey: memKey, + authority: authority, } } diff --git a/x/tradeshield/keeper/msg_server_update_params.go b/x/tradeshield/keeper/msg_server_update_params.go new file mode 100644 index 000000000..03abf9606 --- /dev/null +++ b/x/tradeshield/keeper/msg_server_update_params.go @@ -0,0 +1,25 @@ +package keeper + +import ( + "context" + + errorsmod "cosmossdk.io/errors" + sdk "github.com/cosmos/cosmos-sdk/types" + govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" + "github.com/elys-network/elys/x/tradeshield/types" +) + +func (k msgServer) UpdateParams(goCtx context.Context, msg *types.MsgUpdateParams) (*types.MsgUpdateParamsResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + if k.authority != msg.Authority { + return nil, errorsmod.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", k.authority, msg.Authority) + } + + // store params + if err := k.SetParams(ctx, msg.Params); err != nil { + return nil, err + } + + return &types.MsgUpdateParamsResponse{}, nil +} diff --git a/x/tradeshield/migrations/new_migrator.go b/x/tradeshield/migrations/new_migrator.go new file mode 100644 index 000000000..2892a2c4e --- /dev/null +++ b/x/tradeshield/migrations/new_migrator.go @@ -0,0 +1,13 @@ +package migrations + +import ( + "github.com/elys-network/elys/x/tradeshield/keeper" +) + +type Migrator struct { + keeper keeper.Keeper +} + +func NewMigrator(keeper keeper.Keeper) Migrator { + return Migrator{keeper: keeper} +} diff --git a/x/tradeshield/migrations/v2_migrator.go b/x/tradeshield/migrations/v2_migrator.go new file mode 100644 index 000000000..656f022e5 --- /dev/null +++ b/x/tradeshield/migrations/v2_migrator.go @@ -0,0 +1,14 @@ +package migrations + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/elys-network/elys/x/tradeshield/types" +) + +func (m Migrator) V2Migration(ctx sdk.Context) error { + + params := types.DefaultParams() + m.keeper.SetParams(ctx, ¶ms) + + return nil +} diff --git a/x/tradeshield/module.go b/x/tradeshield/module.go index 5003f7c9f..54d5123fd 100644 --- a/x/tradeshield/module.go +++ b/x/tradeshield/module.go @@ -4,6 +4,7 @@ import ( "context" "encoding/json" "fmt" + // this line is used by starport scaffolding # 1 "github.com/grpc-ecosystem/grpc-gateway/runtime" @@ -18,6 +19,7 @@ import ( "github.com/cosmos/cosmos-sdk/types/module" "github.com/elys-network/elys/x/tradeshield/client/cli" "github.com/elys-network/elys/x/tradeshield/keeper" + "github.com/elys-network/elys/x/tradeshield/migrations" "github.com/elys-network/elys/x/tradeshield/types" ) @@ -114,6 +116,11 @@ func NewAppModule( func (am AppModule) RegisterServices(cfg module.Configurator) { types.RegisterMsgServer(cfg.MsgServer(), keeper.NewMsgServerImpl(am.keeper)) types.RegisterQueryServer(cfg.QueryServer(), am.keeper) + m := migrations.NewMigrator(am.keeper) + err := cfg.RegisterMigration(types.ModuleName, 1, m.V2Migration) + if err != nil { + panic(err) + } } // RegisterInvariants registers the invariants of the module. If an invariant deviates from its predicted value, the InvariantRegistry triggers appropriate logic (most often the chain will be halted) @@ -137,7 +144,7 @@ func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.Raw } // ConsensusVersion is a sequence number for state-breaking change of the module. It should be incremented on each consensus-breaking change introduced by the module. To avoid wrong/empty versions, the initial version should be set to 1 -func (AppModule) ConsensusVersion() uint64 { return 1 } +func (AppModule) ConsensusVersion() uint64 { return 2 } // BeginBlock contains the logic that is automatically triggered at the beginning of each block func (am AppModule) BeginBlock(_ sdk.Context, _ abci.RequestBeginBlock) {} diff --git a/x/tradeshield/module_simulation.go b/x/tradeshield/module_simulation.go index 9892c15e0..edc53cf34 100644 --- a/x/tradeshield/module_simulation.go +++ b/x/tradeshield/module_simulation.go @@ -47,6 +47,10 @@ const ( // TODO: Determine the simulation weight value defaultWeightMsgDeletePendingPerpetualOrder int = 100 + opWeightMsgUpdateParams = "op_weight_msg_update_params" + // TODO: Determine the simulation weight value + defaultWeightMsgUpdateParams int = 100 + // this line is used by starport scaffolding # simapp/module/const ) @@ -163,6 +167,17 @@ func (am AppModule) WeightedOperations(simState module.SimulationState) []simtyp tradeshieldsimulation.SimulateMsgDeletePendingPerpetualOrder(am.accountKeeper, am.bankKeeper, am.keeper), )) + var weightMsgUpdateParams int + simState.AppParams.GetOrGenerate(simState.Cdc, opWeightMsgUpdateParams, &weightMsgUpdateParams, nil, + func(_ *rand.Rand) { + weightMsgUpdateParams = defaultWeightMsgUpdateParams + }, + ) + operations = append(operations, simulation.NewWeightedOperation( + weightMsgUpdateParams, + tradeshieldsimulation.SimulateMsgUpdateParams(am.accountKeeper, am.bankKeeper, am.keeper), + )) + // this line is used by starport scaffolding # simapp/module/operation return operations @@ -219,6 +234,14 @@ func (am AppModule) ProposalMsgs(simState module.SimulationState) []simtypes.Wei return nil }, ), + simulation.NewWeightedProposalMsg( + opWeightMsgUpdateParams, + defaultWeightMsgUpdateParams, + func(r *rand.Rand, ctx sdk.Context, accs []simtypes.Account) sdk.Msg { + tradeshieldsimulation.SimulateMsgUpdateParams(am.accountKeeper, am.bankKeeper, am.keeper) + return nil + }, + ), // this line is used by starport scaffolding # simapp/module/OpMsg } } diff --git a/x/tradeshield/simulation/update_params.go b/x/tradeshield/simulation/update_params.go new file mode 100644 index 000000000..4b6041e1d --- /dev/null +++ b/x/tradeshield/simulation/update_params.go @@ -0,0 +1,29 @@ +package simulation + +import ( + "math/rand" + + "github.com/cosmos/cosmos-sdk/baseapp" + sdk "github.com/cosmos/cosmos-sdk/types" + simtypes "github.com/cosmos/cosmos-sdk/types/simulation" + "github.com/elys-network/elys/x/tradeshield/keeper" + "github.com/elys-network/elys/x/tradeshield/types" +) + +func SimulateMsgUpdateParams( + ak types.AccountKeeper, + bk types.BankKeeper, + k keeper.Keeper, +) simtypes.Operation { + return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simtypes.Account, chainID string, + ) (simtypes.OperationMsg, []simtypes.FutureOperation, error) { + simAccount, _ := simtypes.RandomAcc(r, accs) + msg := &types.MsgUpdateParams{ + Authority: simAccount.Address.String(), + } + + // TODO: Handling the UpdateParams simulation + + return simtypes.NoOpMsg(types.ModuleName, msg.Type(), "UpdateParams simulation not implemented"), nil, nil + } +} diff --git a/x/tradeshield/types/codec.go b/x/tradeshield/types/codec.go index 9aa46d8d8..b9f25627c 100644 --- a/x/tradeshield/types/codec.go +++ b/x/tradeshield/types/codec.go @@ -2,18 +2,20 @@ package types import ( "github.com/cosmos/cosmos-sdk/codec" + "github.com/cosmos/cosmos-sdk/codec/legacy" cdctypes "github.com/cosmos/cosmos-sdk/codec/types" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/types/msgservice" ) func RegisterCodec(cdc *codec.LegacyAmino) { - cdc.RegisterConcrete(&MsgCreatePendingSpotOrder{}, "tradeshield/CreatePendingSpotOrder", nil) - cdc.RegisterConcrete(&MsgUpdatePendingSpotOrder{}, "tradeshield/UpdatePendingSpotOrder", nil) - cdc.RegisterConcrete(&MsgDeletePendingSpotOrder{}, "tradeshield/DeletePendingSpotOrder", nil) - cdc.RegisterConcrete(&MsgCreatePendingPerpetualOrder{}, "tradeshield/CreatePendingPerpetualOrder", nil) - cdc.RegisterConcrete(&MsgUpdatePendingPerpetualOrder{}, "tradeshield/UpdatePendingPerpetualOrder", nil) - cdc.RegisterConcrete(&MsgDeletePendingPerpetualOrder{}, "tradeshield/DeletePendingPerpetualOrder", nil) + legacy.RegisterAminoMsg(cdc, &MsgCreatePendingSpotOrder{}, "tradeshield/CreatePendingSpotOrder") + legacy.RegisterAminoMsg(cdc, &MsgUpdatePendingSpotOrder{}, "tradeshield/UpdatePendingSpotOrder") + legacy.RegisterAminoMsg(cdc, &MsgDeletePendingSpotOrder{}, "tradeshield/DeletePendingSpotOrder") + legacy.RegisterAminoMsg(cdc, &MsgCreatePendingPerpetualOrder{}, "tradeshield/CreatePendingPerpetualOrder") + legacy.RegisterAminoMsg(cdc, &MsgUpdatePendingPerpetualOrder{}, "tradeshield/UpdatePendingPerpetualOrder") + legacy.RegisterAminoMsg(cdc, &MsgDeletePendingPerpetualOrder{}, "tradeshield/DeletePendingPerpetualOrder") + legacy.RegisterAminoMsg(cdc, &MsgUpdateParams{}, "tradeshield/UpdateParams") // this line is used by starport scaffolding # 2 } @@ -27,6 +29,7 @@ func RegisterInterfaces(registry cdctypes.InterfaceRegistry) { &MsgCreatePendingPerpetualOrder{}, &MsgUpdatePendingPerpetualOrder{}, &MsgDeletePendingPerpetualOrder{}, + &MsgUpdateParams{}, ) // this line is used by starport scaffolding # 3 diff --git a/x/tradeshield/types/message_update_params.go b/x/tradeshield/types/message_update_params.go new file mode 100644 index 000000000..37e0d8918 --- /dev/null +++ b/x/tradeshield/types/message_update_params.go @@ -0,0 +1,61 @@ +package types + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" +) + +const TypeMsgUpdateParams = "update_params" + +var _ sdk.Msg = &MsgUpdateParams{} + +func NewMsgUpdateParams(authority string, params Params) *MsgUpdateParams { + return &MsgUpdateParams{ + Authority: authority, + Params: ¶ms, + } +} + +func (msg *MsgUpdateParams) Route() string { + return RouterKey +} + +func (msg *MsgUpdateParams) Type() string { + return TypeMsgUpdateParams +} + +func (msg *MsgUpdateParams) GetSigners() []sdk.AccAddress { + creator, err := sdk.AccAddressFromBech32(msg.Authority) + if err != nil { + panic(err) + } + return []sdk.AccAddress{creator} +} + +func (msg *MsgUpdateParams) GetSignBytes() []byte { + bz := ModuleCdc.MustMarshalJSON(msg) + return sdk.MustSortJSON(bz) +} + +func (msg *MsgUpdateParams) ValidateBasic() error { + _, err := sdk.AccAddressFromBech32(msg.Authority) + if err != nil { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) + } + + // Validate params + if msg.Params.LimitProcessOrder <= 0 { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "LimitProcessOrder must be greater than 0") + } + if msg.Params.RewardPercentage.IsNegative() { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "RewardPercentage must be non-negative") + } + if msg.Params.MarginError.IsNegative() { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "MarginError must be non-negative") + } + if msg.Params.MinimumDeposit.IsNegative() { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidRequest, "MinimumDeposit must be non-negative") + } + + return nil +} diff --git a/x/tradeshield/types/message_update_params_test.go b/x/tradeshield/types/message_update_params_test.go new file mode 100644 index 000000000..ae86e12b6 --- /dev/null +++ b/x/tradeshield/types/message_update_params_test.go @@ -0,0 +1,87 @@ +package types + +import ( + "testing" + + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/elys-network/elys/testutil/sample" + "github.com/stretchr/testify/require" +) + +func TestMsgUpdateParams_ValidateBasic(t *testing.T) { + tests := []struct { + name string + msg MsgUpdateParams + err error + }{ + { + name: "invalid address", + msg: MsgUpdateParams{ + Authority: "invalid_address", + Params: &Params{ + MarketOrderEnabled: true, + StakeEnabled: true, + ProcessOrdersEnabled: true, + SwapEnabled: true, + PerpetualEnabled: true, + RewardEnabled: true, + LeverageEnabled: true, + LimitProcessOrder: 1, + RewardPercentage: sdk.MustNewDecFromStr("0.5"), + MarginError: sdk.MustNewDecFromStr("0.1"), + MinimumDeposit: sdk.NewInt(100), + }, + }, + err: sdkerrors.ErrInvalidAddress, + }, { + name: "valid address", + msg: MsgUpdateParams{ + Authority: sample.AccAddress(), + Params: &Params{ + MarketOrderEnabled: true, + StakeEnabled: true, + ProcessOrdersEnabled: true, + SwapEnabled: true, + PerpetualEnabled: true, + RewardEnabled: true, + LeverageEnabled: true, + LimitProcessOrder: 1, + RewardPercentage: sdk.MustNewDecFromStr("0.5"), + MarginError: sdk.MustNewDecFromStr("0.1"), + MinimumDeposit: sdk.NewInt(100), + }, + }, + }, + { + name: "negative RewardPercentage", + msg: MsgUpdateParams{ + Authority: sample.AccAddress(), + Params: &Params{ + MarketOrderEnabled: true, + StakeEnabled: true, + ProcessOrdersEnabled: true, + SwapEnabled: true, + PerpetualEnabled: true, + RewardEnabled: true, + LeverageEnabled: true, + LimitProcessOrder: 1, + RewardPercentage: sdk.MustNewDecFromStr("-0.5"), + MarginError: sdk.MustNewDecFromStr("0.1"), + MinimumDeposit: sdk.NewInt(100), + }, + }, + err: sdkerrors.ErrInvalidRequest, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := tt.msg.ValidateBasic() + if tt.err != nil { + require.ErrorIs(t, err, tt.err) + return + } + require.NoError(t, err) + }) + } +} diff --git a/x/tradeshield/types/params.go b/x/tradeshield/types/params.go index 357196ad6..65ca57b29 100644 --- a/x/tradeshield/types/params.go +++ b/x/tradeshield/types/params.go @@ -1,6 +1,7 @@ package types import ( + sdk "github.com/cosmos/cosmos-sdk/types" paramtypes "github.com/cosmos/cosmos-sdk/x/params/types" "gopkg.in/yaml.v2" ) @@ -14,7 +15,19 @@ func ParamKeyTable() paramtypes.KeyTable { // NewParams creates a new Params instance func NewParams() Params { - return Params{} + return Params{ + MarketOrderEnabled: true, + StakeEnabled: true, + ProcessOrdersEnabled: true, + SwapEnabled: true, + PerpetualEnabled: true, + RewardEnabled: true, + LeverageEnabled: true, + LimitProcessOrder: 1000000, + RewardPercentage: sdk.ZeroDec(), + MarginError: sdk.ZeroDec(), + MinimumDeposit: sdk.ZeroInt(), + } } // DefaultParams returns a default set of parameters diff --git a/x/tradeshield/types/params.pb.go b/x/tradeshield/types/params.pb.go index 4dccd45da..a99cfefa9 100644 --- a/x/tradeshield/types/params.pb.go +++ b/x/tradeshield/types/params.pb.go @@ -5,6 +5,7 @@ package types import ( fmt "fmt" + github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" _ "github.com/cosmos/gogoproto/gogoproto" proto "github.com/cosmos/gogoproto/proto" io "io" @@ -25,6 +26,18 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // Params defines the parameters for the module. type Params struct { + MarketOrderEnabled bool `protobuf:"varint,1,opt,name=market_order_enabled,json=marketOrderEnabled,proto3" json:"market_order_enabled,omitempty"` + StakeEnabled bool `protobuf:"varint,2,opt,name=stake_enabled,json=stakeEnabled,proto3" json:"stake_enabled,omitempty"` + ProcessOrdersEnabled bool `protobuf:"varint,3,opt,name=process_orders_enabled,json=processOrdersEnabled,proto3" json:"process_orders_enabled,omitempty"` + SwapEnabled bool `protobuf:"varint,4,opt,name=swap_enabled,json=swapEnabled,proto3" json:"swap_enabled,omitempty"` + PerpetualEnabled bool `protobuf:"varint,5,opt,name=perpetual_enabled,json=perpetualEnabled,proto3" json:"perpetual_enabled,omitempty"` + RewardEnabled bool `protobuf:"varint,6,opt,name=reward_enabled,json=rewardEnabled,proto3" json:"reward_enabled,omitempty"` + LeverageEnabled bool `protobuf:"varint,7,opt,name=leverage_enabled,json=leverageEnabled,proto3" json:"leverage_enabled,omitempty"` + LimitProcessOrder uint64 `protobuf:"varint,8,opt,name=limit_process_order,json=limitProcessOrder,proto3" json:"limit_process_order,omitempty"` + // For incentive system v2 + RewardPercentage github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,9,opt,name=reward_percentage,json=rewardPercentage,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"reward_percentage"` + MarginError github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,10,opt,name=margin_error,json=marginError,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"margin_error"` + MinimumDeposit github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,11,opt,name=minimum_deposit,json=minimumDeposit,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"minimum_deposit"` } func (m *Params) Reset() { *m = Params{} } @@ -59,6 +72,62 @@ func (m *Params) XXX_DiscardUnknown() { var xxx_messageInfo_Params proto.InternalMessageInfo +func (m *Params) GetMarketOrderEnabled() bool { + if m != nil { + return m.MarketOrderEnabled + } + return false +} + +func (m *Params) GetStakeEnabled() bool { + if m != nil { + return m.StakeEnabled + } + return false +} + +func (m *Params) GetProcessOrdersEnabled() bool { + if m != nil { + return m.ProcessOrdersEnabled + } + return false +} + +func (m *Params) GetSwapEnabled() bool { + if m != nil { + return m.SwapEnabled + } + return false +} + +func (m *Params) GetPerpetualEnabled() bool { + if m != nil { + return m.PerpetualEnabled + } + return false +} + +func (m *Params) GetRewardEnabled() bool { + if m != nil { + return m.RewardEnabled + } + return false +} + +func (m *Params) GetLeverageEnabled() bool { + if m != nil { + return m.LeverageEnabled + } + return false +} + +func (m *Params) GetLimitProcessOrder() uint64 { + if m != nil { + return m.LimitProcessOrder + } + return 0 +} + func init() { proto.RegisterType((*Params)(nil), "elys.tradeshield.Params") } @@ -66,17 +135,35 @@ func init() { func init() { proto.RegisterFile("elys/tradeshield/params.proto", fileDescriptor_01646d3b2ec43fec) } var fileDescriptor_01646d3b2ec43fec = []byte{ - // 155 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4d, 0xcd, 0xa9, 0x2c, - 0xd6, 0x2f, 0x29, 0x4a, 0x4c, 0x49, 0x2d, 0xce, 0xc8, 0x4c, 0xcd, 0x49, 0xd1, 0x2f, 0x48, 0x2c, - 0x4a, 0xcc, 0x2d, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x12, 0x00, 0x49, 0xeb, 0x21, 0x49, - 0x4b, 0x89, 0xa4, 0xe7, 0xa7, 0xe7, 0x83, 0x25, 0xf5, 0x41, 0x2c, 0x88, 0x3a, 0x25, 0x3e, 0x2e, - 0xb6, 0x00, 0xb0, 0x3e, 0x2b, 0x96, 0x19, 0x0b, 0xe4, 0x19, 0x9c, 0xbc, 0x4e, 0x3c, 0x92, 0x63, - 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x09, 0x8f, 0xe5, 0x18, 0x2e, 0x3c, 0x96, - 0x63, 0xb8, 0xf1, 0x58, 0x8e, 0x21, 0xca, 0x20, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, - 0x3f, 0x57, 0x1f, 0x64, 0xb8, 0x6e, 0x5e, 0x6a, 0x49, 0x79, 0x7e, 0x51, 0x36, 0x98, 0xa3, 0x5f, - 0x81, 0xe2, 0x94, 0x92, 0xca, 0x82, 0xd4, 0xe2, 0x24, 0x36, 0xb0, 0x15, 0xc6, 0x80, 0x00, 0x00, - 0x00, 0xff, 0xff, 0x5a, 0x1d, 0x07, 0xbb, 0xab, 0x00, 0x00, 0x00, + // 440 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x92, 0x31, 0x6f, 0xd3, 0x40, + 0x14, 0xc7, 0x6d, 0x08, 0xa1, 0xbd, 0xa4, 0x6d, 0x62, 0x22, 0x64, 0x21, 0xe1, 0x04, 0x10, 0x28, + 0x08, 0xd5, 0xae, 0x04, 0x13, 0x63, 0xd5, 0x0e, 0xb0, 0x10, 0xb2, 0x20, 0xc1, 0x60, 0x5d, 0xec, + 0x27, 0xf7, 0x64, 0x9f, 0xef, 0xf4, 0xee, 0x42, 0xe8, 0xb7, 0x60, 0x64, 0xe4, 0xe3, 0x74, 0xec, + 0x88, 0x18, 0x2a, 0x94, 0x7c, 0x07, 0x66, 0xe4, 0x3b, 0xdb, 0x24, 0x23, 0x4c, 0xb6, 0xff, 0xff, + 0xdf, 0xfd, 0x7c, 0x4f, 0x7a, 0xe4, 0x21, 0x14, 0x97, 0x2a, 0xd2, 0x48, 0x53, 0x50, 0x17, 0x0c, + 0x8a, 0x34, 0x92, 0x14, 0x29, 0x57, 0xa1, 0x44, 0xa1, 0x85, 0x37, 0xa8, 0xea, 0x70, 0xab, 0x7e, + 0x30, 0xca, 0x44, 0x26, 0x4c, 0x19, 0x55, 0x6f, 0x96, 0x7b, 0xfc, 0xbb, 0x43, 0xba, 0x33, 0x73, + 0xd0, 0x3b, 0x21, 0x23, 0x4e, 0x31, 0x07, 0x1d, 0x0b, 0x4c, 0x01, 0x63, 0x28, 0xe9, 0xa2, 0x80, + 0xd4, 0x77, 0x27, 0xee, 0x74, 0x6f, 0xee, 0xd9, 0xee, 0x5d, 0x55, 0x9d, 0xdb, 0xc6, 0x7b, 0x42, + 0x0e, 0x94, 0xa6, 0x39, 0xb4, 0xe8, 0x2d, 0x83, 0xf6, 0x4d, 0xd8, 0x40, 0xaf, 0xc8, 0x7d, 0x89, + 0x22, 0x01, 0xa5, 0xac, 0x57, 0xb5, 0xf4, 0x6d, 0x43, 0x8f, 0xea, 0xd6, 0x98, 0x55, 0x73, 0xea, + 0x11, 0xe9, 0xab, 0x15, 0x95, 0x2d, 0xdb, 0x31, 0x6c, 0xaf, 0xca, 0x1a, 0xe4, 0x05, 0x19, 0x4a, + 0x40, 0x09, 0x7a, 0x49, 0x8b, 0x96, 0xbb, 0x63, 0xb8, 0x41, 0x5b, 0x34, 0xf0, 0x53, 0x72, 0x88, + 0xb0, 0xa2, 0x98, 0xb6, 0x64, 0xd7, 0x90, 0x07, 0x36, 0x6d, 0xb0, 0xe7, 0x64, 0x50, 0xc0, 0x67, + 0x40, 0x9a, 0xfd, 0x1d, 0xea, 0xae, 0x01, 0x8f, 0x9a, 0xbc, 0x41, 0x43, 0x72, 0xaf, 0x60, 0x9c, + 0xe9, 0x78, 0x67, 0x3a, 0x7f, 0x6f, 0xe2, 0x4e, 0x3b, 0xf3, 0xa1, 0xa9, 0x66, 0x5b, 0x93, 0x79, + 0x9f, 0xc8, 0xb0, 0xbe, 0x81, 0x04, 0x4c, 0xa0, 0xd4, 0x34, 0x03, 0x7f, 0x7f, 0xe2, 0x4e, 0xf7, + 0x4f, 0xc3, 0xab, 0x9b, 0xb1, 0xf3, 0xf3, 0x66, 0xfc, 0x2c, 0x63, 0xfa, 0x62, 0xb9, 0x08, 0x13, + 0xc1, 0xa3, 0x44, 0x28, 0x2e, 0x54, 0xfd, 0x38, 0x56, 0x69, 0x1e, 0xe9, 0x4b, 0x09, 0x2a, 0x3c, + 0x83, 0x64, 0x3e, 0xb0, 0xa2, 0x59, 0xeb, 0xf1, 0xde, 0x93, 0x3e, 0xa7, 0x98, 0xb1, 0x32, 0x06, + 0x44, 0x81, 0x3e, 0xf9, 0x2f, 0x6f, 0xcf, 0x3a, 0xce, 0x2b, 0x85, 0xf7, 0x81, 0x1c, 0x71, 0x56, + 0x32, 0xbe, 0xe4, 0x71, 0x0a, 0x52, 0x28, 0xa6, 0xfd, 0xde, 0x3f, 0x5b, 0xdf, 0x94, 0x7a, 0x7e, + 0x58, 0x6b, 0xce, 0xac, 0xe5, 0x75, 0xe7, 0xdb, 0xf7, 0xb1, 0x73, 0xfa, 0xf6, 0x6a, 0x1d, 0xb8, + 0xd7, 0xeb, 0xc0, 0xfd, 0xb5, 0x0e, 0xdc, 0xaf, 0x9b, 0xc0, 0xb9, 0xde, 0x04, 0xce, 0x8f, 0x4d, + 0xe0, 0x7c, 0x3c, 0xd9, 0xf2, 0x56, 0x5b, 0x7c, 0x5c, 0x82, 0x5e, 0x09, 0xcc, 0xcd, 0x47, 0xf4, + 0x65, 0x67, 0xe7, 0xcd, 0x5f, 0x16, 0x5d, 0xb3, 0xcb, 0x2f, 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, + 0xdf, 0x8e, 0xeb, 0x4f, 0x14, 0x03, 0x00, 0x00, } func (m *Params) Marshal() (dAtA []byte, err error) { @@ -99,6 +186,111 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + { + size := m.MinimumDeposit.Size() + i -= size + if _, err := m.MinimumDeposit.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintParams(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x5a + { + size := m.MarginError.Size() + i -= size + if _, err := m.MarginError.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintParams(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x52 + { + size := m.RewardPercentage.Size() + i -= size + if _, err := m.RewardPercentage.MarshalTo(dAtA[i:]); err != nil { + return 0, err + } + i = encodeVarintParams(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4a + if m.LimitProcessOrder != 0 { + i = encodeVarintParams(dAtA, i, uint64(m.LimitProcessOrder)) + i-- + dAtA[i] = 0x40 + } + if m.LeverageEnabled { + i-- + if m.LeverageEnabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x38 + } + if m.RewardEnabled { + i-- + if m.RewardEnabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x30 + } + if m.PerpetualEnabled { + i-- + if m.PerpetualEnabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x28 + } + if m.SwapEnabled { + i-- + if m.SwapEnabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x20 + } + if m.ProcessOrdersEnabled { + i-- + if m.ProcessOrdersEnabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if m.StakeEnabled { + i-- + if m.StakeEnabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x10 + } + if m.MarketOrderEnabled { + i-- + if m.MarketOrderEnabled { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 + } return len(dAtA) - i, nil } @@ -119,6 +311,36 @@ func (m *Params) Size() (n int) { } var l int _ = l + if m.MarketOrderEnabled { + n += 2 + } + if m.StakeEnabled { + n += 2 + } + if m.ProcessOrdersEnabled { + n += 2 + } + if m.SwapEnabled { + n += 2 + } + if m.PerpetualEnabled { + n += 2 + } + if m.RewardEnabled { + n += 2 + } + if m.LeverageEnabled { + n += 2 + } + if m.LimitProcessOrder != 0 { + n += 1 + sovParams(uint64(m.LimitProcessOrder)) + } + l = m.RewardPercentage.Size() + n += 1 + l + sovParams(uint64(l)) + l = m.MarginError.Size() + n += 1 + l + sovParams(uint64(l)) + l = m.MinimumDeposit.Size() + n += 1 + l + sovParams(uint64(l)) return n } @@ -157,6 +379,267 @@ func (m *Params) Unmarshal(dAtA []byte) error { return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MarketOrderEnabled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.MarketOrderEnabled = bool(v != 0) + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field StakeEnabled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.StakeEnabled = bool(v != 0) + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProcessOrdersEnabled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.ProcessOrdersEnabled = bool(v != 0) + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SwapEnabled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.SwapEnabled = bool(v != 0) + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field PerpetualEnabled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.PerpetualEnabled = bool(v != 0) + case 6: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RewardEnabled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.RewardEnabled = bool(v != 0) + case 7: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LeverageEnabled", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.LeverageEnabled = bool(v != 0) + case 8: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LimitProcessOrder", wireType) + } + m.LimitProcessOrder = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.LimitProcessOrder |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RewardPercentage", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthParams + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthParams + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.RewardPercentage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MarginError", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthParams + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthParams + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.MarginError.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 11: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field MinimumDeposit", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowParams + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthParams + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthParams + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.MinimumDeposit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipParams(dAtA[iNdEx:]) diff --git a/x/tradeshield/types/tx.pb.go b/x/tradeshield/types/tx.pb.go index 89c2fa074..c198f9874 100644 --- a/x/tradeshield/types/tx.pb.go +++ b/x/tradeshield/types/tx.pb.go @@ -634,6 +634,96 @@ func (m *MsgDeletePendingPerpetualOrderResponse) XXX_DiscardUnknown() { var xxx_messageInfo_MsgDeletePendingPerpetualOrderResponse proto.InternalMessageInfo +type MsgUpdateParams struct { + // authority is the address that controls the module (defaults to x/gov unless overwritten). + Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"` + // NOTE: All parameters must be supplied. + Params *Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params,omitempty"` +} + +func (m *MsgUpdateParams) Reset() { *m = MsgUpdateParams{} } +func (m *MsgUpdateParams) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateParams) ProtoMessage() {} +func (*MsgUpdateParams) Descriptor() ([]byte, []int) { + return fileDescriptor_0534a5eaf85a8c0b, []int{12} +} +func (m *MsgUpdateParams) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateParams.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgUpdateParams) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateParams.Merge(m, src) +} +func (m *MsgUpdateParams) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateParams) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateParams.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateParams proto.InternalMessageInfo + +func (m *MsgUpdateParams) GetAuthority() string { + if m != nil { + return m.Authority + } + return "" +} + +func (m *MsgUpdateParams) GetParams() *Params { + if m != nil { + return m.Params + } + return nil +} + +type MsgUpdateParamsResponse struct { +} + +func (m *MsgUpdateParamsResponse) Reset() { *m = MsgUpdateParamsResponse{} } +func (m *MsgUpdateParamsResponse) String() string { return proto.CompactTextString(m) } +func (*MsgUpdateParamsResponse) ProtoMessage() {} +func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_0534a5eaf85a8c0b, []int{13} +} +func (m *MsgUpdateParamsResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgUpdateParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgUpdateParamsResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgUpdateParamsResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgUpdateParamsResponse.Merge(m, src) +} +func (m *MsgUpdateParamsResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgUpdateParamsResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgUpdateParamsResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgUpdateParamsResponse proto.InternalMessageInfo + func init() { proto.RegisterType((*MsgCreatePendingSpotOrder)(nil), "elys.tradeshield.MsgCreatePendingSpotOrder") proto.RegisterType((*MsgCreatePendingSpotOrderResponse)(nil), "elys.tradeshield.MsgCreatePendingSpotOrderResponse") @@ -647,52 +737,58 @@ func init() { proto.RegisterType((*MsgUpdatePendingPerpetualOrderResponse)(nil), "elys.tradeshield.MsgUpdatePendingPerpetualOrderResponse") proto.RegisterType((*MsgDeletePendingPerpetualOrder)(nil), "elys.tradeshield.MsgDeletePendingPerpetualOrder") proto.RegisterType((*MsgDeletePendingPerpetualOrderResponse)(nil), "elys.tradeshield.MsgDeletePendingPerpetualOrderResponse") + proto.RegisterType((*MsgUpdateParams)(nil), "elys.tradeshield.MsgUpdateParams") + proto.RegisterType((*MsgUpdateParamsResponse)(nil), "elys.tradeshield.MsgUpdateParamsResponse") } func init() { proto.RegisterFile("elys/tradeshield/tx.proto", fileDescriptor_0534a5eaf85a8c0b) } var fileDescriptor_0534a5eaf85a8c0b = []byte{ - // 626 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x55, 0xcd, 0x6e, 0xda, 0x4c, - 0x14, 0x8d, 0x09, 0x21, 0x1f, 0x93, 0x7c, 0x51, 0x34, 0xaa, 0x90, 0xa1, 0x91, 0x4b, 0x89, 0x54, - 0xa1, 0xfe, 0xd8, 0x04, 0x36, 0x59, 0xb4, 0x95, 0xd2, 0xd0, 0x4d, 0xa4, 0xa8, 0xc8, 0x6d, 0x37, - 0xed, 0x22, 0x35, 0xcc, 0x15, 0xb1, 0x0a, 0x1e, 0x6b, 0x66, 0x68, 0x42, 0xde, 0x20, 0xbb, 0xbe, - 0x40, 0xdf, 0xa7, 0xcb, 0x2c, 0xbb, 0xac, 0xe0, 0x45, 0x2a, 0x5f, 0x1b, 0x14, 0x82, 0x6d, 0x9c, - 0x76, 0x37, 0x3f, 0xe7, 0xde, 0x73, 0xee, 0xb9, 0x73, 0x6d, 0x52, 0x86, 0xc1, 0x58, 0x5a, 0x4a, - 0x38, 0x0c, 0xe4, 0xb9, 0x0b, 0x03, 0x66, 0xa9, 0x4b, 0xd3, 0x17, 0x5c, 0x71, 0xba, 0x1b, 0x5c, - 0x99, 0xb7, 0xae, 0x2a, 0x7b, 0xcb, 0xe0, 0xb1, 0x0f, 0x32, 0xc4, 0x57, 0x8c, 0x1e, 0x97, 0x43, - 0x2e, 0xad, 0xae, 0x23, 0xc1, 0xfa, 0x76, 0xd0, 0x05, 0xe5, 0x1c, 0x58, 0x3d, 0xee, 0x7a, 0xe1, - 0x7d, 0xed, 0x7a, 0x9d, 0x94, 0x4f, 0x65, 0xff, 0x58, 0x80, 0xa3, 0xa0, 0x03, 0x1e, 0x73, 0xbd, - 0xfe, 0x7b, 0x9f, 0xab, 0x77, 0x82, 0x81, 0xa0, 0xaf, 0x09, 0xe1, 0xc1, 0xe2, 0x2c, 0x48, 0xa9, - 0x6b, 0x55, 0xad, 0xbe, 0xd3, 0x7c, 0x64, 0xde, 0x95, 0x60, 0xce, 0x03, 0x3e, 0x8c, 0x7d, 0xb0, - 0x8b, 0x7c, 0xb6, 0xa4, 0xaf, 0xc8, 0x56, 0x18, 0xef, 0x0b, 0xb7, 0x07, 0xfa, 0x7a, 0x55, 0xab, - 0x6f, 0x35, 0xf7, 0x96, 0x13, 0x60, 0x70, 0x27, 0xc0, 0xd8, 0x21, 0x21, 0xae, 0xe9, 0x4b, 0xb2, - 0x1d, 0x86, 0x3b, 0x43, 0x3e, 0xf2, 0x94, 0x9e, 0xc7, 0xf8, 0xb2, 0x19, 0xd6, 0x64, 0x06, 0x35, - 0x99, 0x51, 0x4d, 0xe6, 0x31, 0x77, 0x3d, 0x3b, 0x64, 0x3b, 0x42, 0x34, 0xdd, 0x27, 0xff, 0xf3, - 0x0b, 0x2f, 0x88, 0x66, 0x4c, 0x80, 0x94, 0xfa, 0x46, 0x55, 0xab, 0x17, 0xed, 0x6d, 0x3c, 0x3c, - 0x0a, 0xcf, 0xe8, 0x73, 0x42, 0xa3, 0x0a, 0x1d, 0xd1, 0x07, 0x75, 0xc6, 0xc0, 0xe3, 0x43, 0xbd, - 0x80, 0xc8, 0xdd, 0xb0, 0x10, 0xbc, 0x68, 0x07, 0xe7, 0xb4, 0x41, 0x0a, 0x52, 0x39, 0x6a, 0x24, - 0xf5, 0x4d, 0xf4, 0x42, 0x8f, 0xf1, 0x02, 0xef, 0xed, 0x08, 0x47, 0x9f, 0x92, 0x3c, 0x73, 0x14, - 0xe8, 0xff, 0xa1, 0xf4, 0xd2, 0x32, 0xbe, 0xed, 0x28, 0xb0, 0x11, 0x53, 0x6b, 0x91, 0xc7, 0x89, - 0xad, 0xb0, 0x41, 0xfa, 0xdc, 0x93, 0x40, 0x77, 0x48, 0xce, 0x65, 0xd8, 0x8a, 0xbc, 0x9d, 0x73, - 0x59, 0xed, 0x33, 0xf6, 0xef, 0xa3, 0xcf, 0xe2, 0xfa, 0xa7, 0x93, 0xcd, 0x5e, 0x90, 0x8e, 0x0b, - 0x8c, 0x28, 0xda, 0xb3, 0x6d, 0x94, 0x26, 0x37, 0x4b, 0x43, 0x1f, 0x90, 0x0d, 0xac, 0x16, 0x7b, - 0x54, 0xb4, 0xc3, 0x4d, 0x6d, 0x1f, 0x15, 0xc5, 0x27, 0x9f, 0x29, 0xaa, 0xbd, 0x45, 0x05, 0x6d, - 0x18, 0xc0, 0xbf, 0x28, 0x88, 0xb8, 0xe2, 0xd3, 0xcc, 0xb9, 0x3a, 0xc4, 0xb8, 0x6b, 0x51, 0x07, - 0x84, 0x0f, 0x6a, 0xe4, 0x0c, 0x56, 0x11, 0xce, 0x4b, 0xcc, 0xdd, 0x2e, 0xf1, 0x90, 0x3c, 0x49, - 0xcf, 0x98, 0xe8, 0xfc, 0x17, 0xd4, 0xb2, 0x60, 0x4e, 0x66, 0x2d, 0xd9, 0xec, 0xaf, 0xa3, 0xb6, - 0x14, 0x86, 0xb9, 0x2f, 0x27, 0xa8, 0x65, 0xc1, 0xbc, 0xbf, 0xd5, 0x12, 0xb1, 0xa6, 0xe4, 0x9a, - 0xb1, 0x36, 0x7f, 0x14, 0xc8, 0xfa, 0xa9, 0xec, 0xd3, 0x2b, 0x52, 0x4a, 0xf8, 0x80, 0x3c, 0x5b, - 0x7e, 0xf0, 0x89, 0x4f, 0xbc, 0xd2, 0xba, 0x07, 0x78, 0xde, 0x95, 0x2b, 0x52, 0x4a, 0x78, 0xfc, - 0xf1, 0xdc, 0xf1, 0xe0, 0x04, 0xee, 0xf4, 0x97, 0x1f, 0x70, 0x27, 0x3c, 0xfb, 0x78, 0xee, 0x78, - 0x70, 0x02, 0x77, 0xfa, 0x24, 0xd0, 0x6b, 0x8d, 0x3c, 0x4c, 0x9b, 0x83, 0xc6, 0x6a, 0x33, 0x17, - 0x23, 0x2a, 0x87, 0xf7, 0x8d, 0x58, 0xd0, 0x92, 0x36, 0x07, 0x8d, 0xd5, 0xe6, 0x66, 0xd2, 0x92, - 0x61, 0x12, 0x50, 0x4b, 0xda, 0x1c, 0x34, 0x56, 0x9b, 0x9d, 0x49, 0x4b, 0x86, 0xf9, 0x78, 0x73, - 0xf2, 0x73, 0x62, 0x68, 0x37, 0x13, 0x43, 0xfb, 0x3d, 0x31, 0xb4, 0xef, 0x53, 0x63, 0xed, 0x66, - 0x6a, 0xac, 0xfd, 0x9a, 0x1a, 0x6b, 0x9f, 0x1a, 0x7d, 0x57, 0x9d, 0x8f, 0xba, 0x66, 0x8f, 0x0f, - 0xad, 0x20, 0xfb, 0x0b, 0x0f, 0xd4, 0x05, 0x17, 0x5f, 0x71, 0x63, 0x5d, 0x2e, 0xff, 0xce, 0xbb, - 0x05, 0xfc, 0x5f, 0xb7, 0xfe, 0x04, 0x00, 0x00, 0xff, 0xff, 0x9b, 0xda, 0x05, 0x62, 0x1c, 0x08, - 0x00, 0x00, + // 692 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0x4f, 0x4f, 0xdb, 0x4e, + 0x10, 0xc5, 0x01, 0xc2, 0x2f, 0x0b, 0x3f, 0x8a, 0x56, 0x15, 0x75, 0x52, 0xea, 0x42, 0x90, 0xaa, + 0xf4, 0x9f, 0x1d, 0xe0, 0xc2, 0xa1, 0xad, 0x44, 0xa1, 0x17, 0x24, 0xd4, 0xc8, 0x6d, 0x2f, 0x6d, + 0x25, 0xba, 0x89, 0x47, 0xc1, 0x6a, 0xe2, 0xb5, 0x76, 0x37, 0x85, 0xf0, 0x0d, 0xb8, 0xf5, 0x63, + 0xf5, 0xc8, 0xb1, 0xc7, 0x0a, 0x3e, 0x46, 0x2f, 0x95, 0x67, 0xed, 0x40, 0x88, 0xed, 0x84, 0xf6, + 0x66, 0xef, 0xbc, 0x79, 0xef, 0xcd, 0x6c, 0x9e, 0x15, 0x52, 0x86, 0x4e, 0x5f, 0x3a, 0x4a, 0x30, + 0x0f, 0xe4, 0x91, 0x0f, 0x1d, 0xcf, 0x51, 0x27, 0x76, 0x28, 0xb8, 0xe2, 0x74, 0x29, 0x2a, 0xd9, + 0xd7, 0x4a, 0x95, 0x95, 0x51, 0x70, 0x3f, 0x04, 0xa9, 0xf1, 0x95, 0x07, 0x23, 0xd5, 0x90, 0x09, + 0xd6, 0x4d, 0xca, 0x56, 0x8b, 0xcb, 0x2e, 0x97, 0x4e, 0x93, 0x49, 0x70, 0xbe, 0x6d, 0x34, 0x41, + 0xb1, 0x0d, 0xa7, 0xc5, 0xfd, 0x40, 0xd7, 0xab, 0x67, 0xd3, 0xa4, 0x7c, 0x20, 0xdb, 0xbb, 0x02, + 0x98, 0x82, 0x06, 0x04, 0x9e, 0x1f, 0xb4, 0xdf, 0x85, 0x5c, 0xbd, 0x15, 0x1e, 0x08, 0xfa, 0x8a, + 0x10, 0x1e, 0x3d, 0x1c, 0x46, 0x8a, 0xa6, 0xb1, 0x6a, 0xd4, 0x16, 0x37, 0x1f, 0xda, 0x37, 0x1d, + 0xda, 0x83, 0x86, 0xf7, 0xfd, 0x10, 0xdc, 0x12, 0x4f, 0x1e, 0xe9, 0x4b, 0x32, 0xaf, 0xfb, 0x43, + 0xe1, 0xb7, 0xc0, 0x9c, 0x5e, 0x35, 0x6a, 0xf3, 0x9b, 0x2b, 0xa3, 0x04, 0xd8, 0xdc, 0x88, 0x30, + 0xae, 0x16, 0xc4, 0x67, 0xfa, 0x82, 0x2c, 0xe8, 0x76, 0xd6, 0xe5, 0xbd, 0x40, 0x99, 0x33, 0xd8, + 0x5f, 0xb6, 0xf5, 0x4c, 0x76, 0x34, 0x93, 0x1d, 0xcf, 0x64, 0xef, 0x72, 0x3f, 0x70, 0xb5, 0xda, + 0x0e, 0xa2, 0xe9, 0x3a, 0xf9, 0x9f, 0x1f, 0x07, 0x51, 0xb7, 0xe7, 0x09, 0x90, 0xd2, 0x9c, 0x5d, + 0x35, 0x6a, 0x25, 0x77, 0x01, 0x0f, 0x77, 0xf4, 0x19, 0x7d, 0x46, 0x68, 0x3c, 0x21, 0x13, 0x6d, + 0x50, 0x87, 0x1e, 0x04, 0xbc, 0x6b, 0x16, 0x11, 0xb9, 0xa4, 0x07, 0xc1, 0xc2, 0x5e, 0x74, 0x4e, + 0xeb, 0xa4, 0x28, 0x15, 0x53, 0x3d, 0x69, 0xce, 0xe1, 0x2e, 0xcc, 0x94, 0x5d, 0x60, 0xdd, 0x8d, + 0x71, 0xf4, 0x09, 0x99, 0xf1, 0x98, 0x02, 0xf3, 0x3f, 0xb4, 0xbe, 0x3c, 0x8a, 0xdf, 0x63, 0x0a, + 0x5c, 0xc4, 0x54, 0xb7, 0xc8, 0x5a, 0xe6, 0x55, 0xb8, 0x20, 0x43, 0x1e, 0x48, 0xa0, 0x8b, 0xa4, + 0xe0, 0x7b, 0x78, 0x15, 0x33, 0x6e, 0xc1, 0xf7, 0xaa, 0x9f, 0xf0, 0xfe, 0x3e, 0x84, 0x5e, 0xda, + 0xfd, 0x99, 0x64, 0xae, 0x15, 0xd1, 0x71, 0x81, 0x1d, 0x25, 0x37, 0x79, 0x8d, 0x69, 0x0a, 0x09, + 0x0d, 0xbd, 0x4b, 0x66, 0x71, 0x5a, 0xbc, 0xa3, 0x92, 0xab, 0x5f, 0xaa, 0xeb, 0xe8, 0x28, 0x9d, + 0x3c, 0x71, 0x54, 0x7d, 0x83, 0x0e, 0xf6, 0xa0, 0x03, 0xff, 0xe2, 0x20, 0xd6, 0x4a, 0xa7, 0x19, + 0x68, 0x35, 0x88, 0x75, 0x73, 0x45, 0x0d, 0x10, 0x21, 0xa8, 0x1e, 0xeb, 0x8c, 0x13, 0x1c, 0x8c, + 0x58, 0xb8, 0x3e, 0xe2, 0x36, 0x79, 0x94, 0xcf, 0x98, 0xb9, 0xf9, 0x2f, 0xe8, 0x65, 0x68, 0x39, + 0x13, 0x7b, 0x99, 0x6c, 0xfd, 0x35, 0xf4, 0x96, 0xa3, 0x30, 0xd8, 0xcb, 0x3e, 0x7a, 0x19, 0x5a, + 0xde, 0xdf, 0x7a, 0x89, 0x55, 0x73, 0xb8, 0x06, 0xaa, 0x8c, 0xdc, 0xb9, 0xf2, 0x87, 0x5f, 0x1d, + 0xba, 0x42, 0x4a, 0xac, 0xa7, 0x8e, 0xb8, 0xf0, 0x55, 0x3f, 0x16, 0xba, 0x3a, 0x88, 0xf2, 0xa3, + 0xbf, 0x4e, 0x28, 0x37, 0x9f, 0x96, 0x1f, 0xcd, 0xe3, 0xc6, 0xb8, 0x6a, 0x99, 0xdc, 0xbb, 0x21, + 0x91, 0xa8, 0x6f, 0xfe, 0x2e, 0x92, 0xe9, 0x03, 0xd9, 0xa6, 0xa7, 0x64, 0x39, 0xe3, 0xf3, 0xf5, + 0x74, 0x94, 0x3e, 0x33, 0x60, 0x95, 0xad, 0x5b, 0x80, 0x07, 0xbf, 0x89, 0x53, 0xb2, 0x9c, 0x11, + 0xbd, 0x74, 0xed, 0x74, 0x70, 0x86, 0x76, 0x7e, 0xee, 0x22, 0xed, 0x8c, 0xd0, 0xa5, 0x6b, 0xa7, + 0x83, 0x33, 0xb4, 0xf3, 0x73, 0x48, 0xcf, 0x0c, 0x72, 0x3f, 0x2f, 0x85, 0xf5, 0xf1, 0xcb, 0x1c, + 0xee, 0xa8, 0x6c, 0xdf, 0xb6, 0x63, 0xc8, 0x4b, 0x5e, 0x0a, 0xeb, 0xe3, 0x97, 0x3b, 0x91, 0x97, + 0x09, 0x72, 0x88, 0x5e, 0xf2, 0x52, 0x58, 0x1f, 0xbf, 0xec, 0x89, 0xbc, 0x4c, 0x90, 0x4e, 0xfa, + 0x99, 0x2c, 0x0c, 0x45, 0x73, 0x2d, 0x6f, 0x2a, 0x84, 0x54, 0x1e, 0x8f, 0x85, 0x24, 0xec, 0xaf, + 0xf7, 0x7f, 0x5c, 0x58, 0xc6, 0xf9, 0x85, 0x65, 0xfc, 0xba, 0xb0, 0x8c, 0xef, 0x97, 0xd6, 0xd4, + 0xf9, 0xa5, 0x35, 0xf5, 0xf3, 0xd2, 0x9a, 0xfa, 0x58, 0x6f, 0xfb, 0xea, 0xa8, 0xd7, 0xb4, 0x5b, + 0xbc, 0xeb, 0x44, 0x74, 0xcf, 0x03, 0x50, 0xc7, 0x5c, 0x7c, 0xc5, 0x17, 0xe7, 0x64, 0xf4, 0x9f, + 0x4c, 0xb3, 0x88, 0xff, 0x45, 0xb6, 0xfe, 0x04, 0x00, 0x00, 0xff, 0xff, 0x05, 0xa5, 0xd1, 0x01, + 0x17, 0x09, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -713,6 +809,7 @@ type MsgClient interface { CreatePendingPerpetualOrder(ctx context.Context, in *MsgCreatePendingPerpetualOrder, opts ...grpc.CallOption) (*MsgCreatePendingPerpetualOrderResponse, error) UpdatePendingPerpetualOrder(ctx context.Context, in *MsgUpdatePendingPerpetualOrder, opts ...grpc.CallOption) (*MsgUpdatePendingPerpetualOrderResponse, error) DeletePendingPerpetualOrder(ctx context.Context, in *MsgDeletePendingPerpetualOrder, opts ...grpc.CallOption) (*MsgDeletePendingPerpetualOrderResponse, error) + UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) } type msgClient struct { @@ -777,6 +874,15 @@ func (c *msgClient) DeletePendingPerpetualOrder(ctx context.Context, in *MsgDele return out, nil } +func (c *msgClient) UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error) { + out := new(MsgUpdateParamsResponse) + err := c.cc.Invoke(ctx, "/elys.tradeshield.Msg/UpdateParams", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // MsgServer is the server API for Msg service. type MsgServer interface { CreatePendingSpotOrder(context.Context, *MsgCreatePendingSpotOrder) (*MsgCreatePendingSpotOrderResponse, error) @@ -785,6 +891,7 @@ type MsgServer interface { CreatePendingPerpetualOrder(context.Context, *MsgCreatePendingPerpetualOrder) (*MsgCreatePendingPerpetualOrderResponse, error) UpdatePendingPerpetualOrder(context.Context, *MsgUpdatePendingPerpetualOrder) (*MsgUpdatePendingPerpetualOrderResponse, error) DeletePendingPerpetualOrder(context.Context, *MsgDeletePendingPerpetualOrder) (*MsgDeletePendingPerpetualOrderResponse, error) + UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error) } // UnimplementedMsgServer can be embedded to have forward compatible implementations. @@ -809,6 +916,9 @@ func (*UnimplementedMsgServer) UpdatePendingPerpetualOrder(ctx context.Context, func (*UnimplementedMsgServer) DeletePendingPerpetualOrder(ctx context.Context, req *MsgDeletePendingPerpetualOrder) (*MsgDeletePendingPerpetualOrderResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method DeletePendingPerpetualOrder not implemented") } +func (*UnimplementedMsgServer) UpdateParams(ctx context.Context, req *MsgUpdateParams) (*MsgUpdateParamsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method UpdateParams not implemented") +} func RegisterMsgServer(s grpc1.Server, srv MsgServer) { s.RegisterService(&_Msg_serviceDesc, srv) @@ -922,6 +1032,24 @@ func _Msg_DeletePendingPerpetualOrder_Handler(srv interface{}, ctx context.Conte return interceptor(ctx, in, info, handler) } +func _Msg_UpdateParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgUpdateParams) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).UpdateParams(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/elys.tradeshield.Msg/UpdateParams", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).UpdateParams(ctx, req.(*MsgUpdateParams)) + } + return interceptor(ctx, in, info, handler) +} + var _Msg_serviceDesc = grpc.ServiceDesc{ ServiceName: "elys.tradeshield.Msg", HandlerType: (*MsgServer)(nil), @@ -950,6 +1078,10 @@ var _Msg_serviceDesc = grpc.ServiceDesc{ MethodName: "DeletePendingPerpetualOrder", Handler: _Msg_DeletePendingPerpetualOrder_Handler, }, + { + MethodName: "UpdateParams", + Handler: _Msg_UpdateParams_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "elys/tradeshield/tx.proto", @@ -1377,6 +1509,71 @@ func (m *MsgDeletePendingPerpetualOrderResponse) MarshalToSizedBuffer(dAtA []byt return len(dAtA) - i, nil } +func (m *MsgUpdateParams) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgUpdateParams) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Params != nil { + { + size, err := m.Params.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.Authority) > 0 { + i -= len(m.Authority) + copy(dAtA[i:], m.Authority) + i = encodeVarintTx(dAtA, i, uint64(len(m.Authority))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgUpdateParamsResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgUpdateParamsResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgUpdateParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + func encodeVarintTx(dAtA []byte, offset int, v uint64) int { offset -= sovTx(v) base := offset @@ -1572,6 +1769,32 @@ func (m *MsgDeletePendingPerpetualOrderResponse) Size() (n int) { return n } +func (m *MsgUpdateParams) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Authority) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if m.Params != nil { + l = m.Params.Size() + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgUpdateParamsResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + func sovTx(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -2758,6 +2981,174 @@ func (m *MsgDeletePendingPerpetualOrderResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *MsgUpdateParams) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateParams: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateParams: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Authority = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Params == nil { + m.Params = &Params{} + } + if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgUpdateParamsResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgUpdateParamsResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgUpdateParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipTx(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0