From 7a1067697f077bd873e99c8bd05d0a36cee78cc9 Mon Sep 17 00:00:00 2001 From: Alex Peters Date: Thu, 9 Jul 2020 15:10:48 +0200 Subject: [PATCH 1/7] Add wasm gov proposals to cli --- app/app.go | 6 +- cmd/wasmcli/main.go | 9 +- x/wasm/client/cli/gov_tx.go | 295 ++++++++++++++++++ x/wasm/client/cli/new_tx.go | 79 +++-- x/wasm/client/cli/tx.go | 170 ++++++---- x/wasm/client/proposal_handler.go | 16 + x/wasm/client/rest/gov.go | 112 +++++++ x/wasm/internal/keeper/keeper.go | 2 +- x/wasm/internal/keeper/proposal_handler.go | 4 +- .../keeper/proposal_integration_test.go | 5 - x/wasm/internal/types/codec.go | 10 +- x/wasm/internal/types/proposal.go | 29 +- x/wasm/internal/types/proposal_test.go | 26 -- x/wasm/internal/types/test_fixtures.go | 4 - 14 files changed, 609 insertions(+), 158 deletions(-) create mode 100644 x/wasm/client/cli/gov_tx.go create mode 100644 x/wasm/client/proposal_handler.go create mode 100644 x/wasm/client/rest/gov.go diff --git a/app/app.go b/app/app.go index 92d6f40eb0..de42a70067 100644 --- a/app/app.go +++ b/app/app.go @@ -5,9 +5,8 @@ import ( "os" "path/filepath" - "github.com/spf13/viper" - "github.com/CosmWasm/wasmd/x/wasm" + wasmclient "github.com/CosmWasm/wasmd/x/wasm/client" bam "github.com/cosmos/cosmos-sdk/baseapp" "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/simapp" @@ -30,6 +29,7 @@ import ( "github.com/cosmos/cosmos-sdk/x/supply" "github.com/cosmos/cosmos-sdk/x/upgrade" upgradeclient "github.com/cosmos/cosmos-sdk/x/upgrade/client" + "github.com/spf13/viper" abci "github.com/tendermint/tendermint/abci/types" "github.com/tendermint/tendermint/libs/cli" "github.com/tendermint/tendermint/libs/log" @@ -56,7 +56,7 @@ var ( staking.AppModuleBasic{}, mint.AppModuleBasic{}, distr.AppModuleBasic{}, - gov.NewAppModuleBasic(paramsclient.ProposalHandler, distr.ProposalHandler, upgradeclient.ProposalHandler), + gov.NewAppModuleBasic(append(wasmclient.ProposalHandlers, paramsclient.ProposalHandler, distr.ProposalHandler, upgradeclient.ProposalHandler)...), params.AppModuleBasic{}, wasm.AppModuleBasic{}, crisis.AppModuleBasic{}, diff --git a/cmd/wasmcli/main.go b/cmd/wasmcli/main.go index 7c590ab87c..d7986b761e 100644 --- a/cmd/wasmcli/main.go +++ b/cmd/wasmcli/main.go @@ -17,7 +17,7 @@ import ( authrest "github.com/cosmos/cosmos-sdk/x/auth/client/rest" "github.com/cosmos/cosmos-sdk/x/bank" bankcmd "github.com/cosmos/cosmos-sdk/x/bank/client/cli" - + "github.com/cosmos/cosmos-sdk/x/gov" "github.com/spf13/cobra" "github.com/spf13/viper" @@ -127,12 +127,17 @@ func txCmd(cdc *amino.Codec) *cobra.Command { // add modules' tx commands app.ModuleBasics.AddTxCommands(txCmd, cdc) + //wasmGovCmds := []*cobra.Command{} + // remove auth and bank commands as they're mounted under the root tx command var cmdsToRemove []*cobra.Command - for _, cmd := range txCmd.Commands() { if cmd.Use == auth.ModuleName || cmd.Use == bank.ModuleName { cmdsToRemove = append(cmdsToRemove, cmd) + continue + } + if cmd.Use == gov.ModuleName { + //cmd.AddCommand(wasmGovCmds...) } } diff --git a/x/wasm/client/cli/gov_tx.go b/x/wasm/client/cli/gov_tx.go new file mode 100644 index 0000000000..8a947190be --- /dev/null +++ b/x/wasm/client/cli/gov_tx.go @@ -0,0 +1,295 @@ +package cli + +import ( + "bufio" + + "github.com/CosmWasm/wasmd/x/wasm/internal/types" + "github.com/cosmos/cosmos-sdk/client/context" + "github.com/cosmos/cosmos-sdk/codec" + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/cosmos/cosmos-sdk/x/auth" + "github.com/cosmos/cosmos-sdk/x/auth/client/utils" + "github.com/cosmos/cosmos-sdk/x/gov/client/cli" + govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" + "github.com/pkg/errors" + "github.com/spf13/cobra" + "github.com/spf13/viper" +) + +func ProposalStoreCodeCmd(cdc *codec.Codec) *cobra.Command { + cmd := &cobra.Command{ + Use: "wasm-store [wasm file] --source [source] --builder [builder] --title [text] --description [text] --creator [address]", + Short: "Submit a wasm binary proposal", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + inBuf := bufio.NewReader(cmd.InOrStdin()) + txBldr := auth.NewTxBuilderFromCLI(inBuf).WithTxEncoder(utils.GetTxEncoder(cdc)) + cliCtx := context.NewCLIContextWithInput(inBuf).WithCodec(cdc) + + src, err := parseStoreCodeArgs(args, cliCtx) + if err != nil { + return err + } + if len(viper.GetString(flagCreator)) == 0 { + return errors.New("creator address is required") + } + creator, err := sdk.AccAddressFromBech32(viper.GetString(flagCreator)) + if err != nil { + return errors.Wrap(err, "creator") + } + content := types.StoreCodeProposal{ + WasmProposal: types.WasmProposal{ + Title: viper.GetString(cli.FlagTitle), + Description: viper.GetString(cli.FlagDescription), + }, + Creator: creator, + WASMByteCode: src.WASMByteCode, + Source: src.Source, + Builder: src.Builder, + InstantiatePermission: src.InstantiatePermission, + } + + deposit, err := sdk.ParseCoins(viper.GetString(cli.FlagDeposit)) + if err != nil { + return err + } + + msg := govtypes.NewMsgSubmitProposal(content, deposit, cliCtx.GetFromAddress()) + if err = msg.ValidateBasic(); err != nil { + return err + } + + return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg}) + }, + } + + cmd.Flags().String(flagSource, "", "A valid URI reference to the contract's source code, optional") + cmd.Flags().String(flagBuilder, "", "A valid docker tag for the build system, optional") + cmd.Flags().String(flagCreator, "", "The address that is stored as code creator") + cmd.Flags().String(flagInstantiateByEverybody, "", "Everybody can instantiate a contract from the code, optional") + cmd.Flags().String(flagInstantiateByAddress, "", "Only this address can instantiate a contract instance from the code, optional") + + // proposal flags + cmd.Flags().String(cli.FlagTitle, "", "Title of proposal") + cmd.Flags().String(cli.FlagDescription, "", "Description of proposal") + cmd.Flags().String(cli.FlagDeposit, "", "Deposit of proposal") + cmd.Flags().String(cli.FlagProposal, "", "Proposal file path (if this path is given, other proposal flags are ignored)") + // type values must match the "ProposalHandler" "routes" in cli + cmd.Flags().String(flagProposalType, "", "Type of proposal, types: store-code/instantiate/migrate/update-admin/clear-admin/text/parameter_change/software_upgrade") + return cmd +} + +func ProposalInstantiateContractCmd(cdc *codec.Codec) *cobra.Command { + cmd := &cobra.Command{ + Use: "instantiate-contract [code_id_int64] [json_encoded_init_args] --label [text] --admin [address] --title [text] --description [text] --creator [address]", + Short: "Submit an instantiate wasm contract proposal", + Args: cobra.ExactArgs(2), + RunE: func(cmd *cobra.Command, args []string) error { + inBuf := bufio.NewReader(cmd.InOrStdin()) + txBldr := auth.NewTxBuilderFromCLI(inBuf).WithTxEncoder(utils.GetTxEncoder(cdc)) + cliCtx := context.NewCLIContextWithInput(inBuf).WithCodec(cdc) + + src, err := parseInstantiateArgs(args, cliCtx) + if err != nil { + return err + } + if len(viper.GetString(flagCreator)) == 0 { + return errors.New("creator address is required") + } + creator, err := sdk.AccAddressFromBech32(viper.GetString(flagCreator)) + if err != nil { + return errors.Wrap(err, "creator") + } + content := types.InstantiateContractProposal{ + WasmProposal: types.WasmProposal{ + Title: viper.GetString(cli.FlagTitle), + Description: viper.GetString(cli.FlagDescription), + }, + Creator: creator, + Admin: src.Admin, + Code: src.Code, + Label: src.Label, + InitMsg: src.InitMsg, + InitFunds: src.InitFunds, + } + + deposit, err := sdk.ParseCoins(viper.GetString(cli.FlagDeposit)) + if err != nil { + return err + } + + msg := govtypes.NewMsgSubmitProposal(content, deposit, cliCtx.GetFromAddress()) + if err = msg.ValidateBasic(); err != nil { + return err + } + + return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg}) + }, + } + cmd.Flags().String(flagAmount, "", "Coins to send to the contract during instantiation") + cmd.Flags().String(flagLabel, "", "A human-readable name for this contract in lists") + cmd.Flags().String(flagAdmin, "", "Address of an admin") + cmd.Flags().String(flagCreator, "", "The address that is stored as code creator") + + // proposal flags + cmd.Flags().String(cli.FlagTitle, "", "Title of proposal") + cmd.Flags().String(cli.FlagDescription, "", "Description of proposal") + cmd.Flags().String(cli.FlagDeposit, "", "Deposit of proposal") + cmd.Flags().String(cli.FlagProposal, "", "Proposal file path (if this path is given, other proposal flags are ignored)") + // type values must match the "ProposalHandler" "routes" in cli + cmd.Flags().String(flagProposalType, "", "Type of proposal, types: store-code/instantiate/migrate/update-admin/clear-admin/text/parameter_change/software_upgrade") + return cmd +} + +func ProposalMigrateContractCmd(cdc *codec.Codec) *cobra.Command { + cmd := &cobra.Command{ + Use: "migrate-contract [contract_addr_bech32] [new_code_id_int64] [json_encoded_migration_args]", + Short: "Submit a migrate wasm contract to a new code version proposal", + Args: cobra.ExactArgs(3), + RunE: func(cmd *cobra.Command, args []string) error { + inBuf := bufio.NewReader(cmd.InOrStdin()) + txBldr := auth.NewTxBuilderFromCLI(inBuf).WithTxEncoder(utils.GetTxEncoder(cdc)) + cliCtx := context.NewCLIContextWithInput(inBuf).WithCodec(cdc) + + src, err := parseMigrateContractArgs(args, cliCtx) + if err != nil { + return err + } + + if len(viper.GetString(flagSender)) == 0 { + return errors.New("sender address is required") + } + sender, err := sdk.AccAddressFromBech32(viper.GetString(flagSender)) + if err != nil { + return errors.Wrap(err, "sender") + } + + content := types.MigrateContractProposal{ + WasmProposal: types.WasmProposal{ + Title: viper.GetString(cli.FlagTitle), + Description: viper.GetString(cli.FlagDescription), + }, + Contract: src.Contract, + Code: src.Code, + MigrateMsg: src.MigrateMsg, + Sender: sender, + } + + deposit, err := sdk.ParseCoins(viper.GetString(cli.FlagDeposit)) + if err != nil { + return err + } + + msg := govtypes.NewMsgSubmitProposal(content, deposit, cliCtx.GetFromAddress()) + if err = msg.ValidateBasic(); err != nil { + return err + } + + return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg}) + }, + } + cmd.Flags().String(flagSender, "", "The address that is passed as sender to the contract") + + // proposal flags + cmd.Flags().String(cli.FlagTitle, "", "Title of proposal") + cmd.Flags().String(cli.FlagDescription, "", "Description of proposal") + cmd.Flags().String(cli.FlagDeposit, "", "Deposit of proposal") + cmd.Flags().String(cli.FlagProposal, "", "Proposal file path (if this path is given, other proposal flags are ignored)") + // type values must match the "ProposalHandler" "routes" in cli + cmd.Flags().String(flagProposalType, "", "Type of proposal, types: store-code/instantiate/migrate/update-admin/clear-admin/text/parameter_change/software_upgrade") + return cmd +} + +func ProposalUpdateContractAdminCmd(cdc *codec.Codec) *cobra.Command { + cmd := &cobra.Command{ + Use: "set-contract-admin [contract_addr_bech32] [new_admin_addr_bech32]", + Short: "Submit a new admin for a contract proposal", + Args: cobra.ExactArgs(2), + RunE: func(cmd *cobra.Command, args []string) error { + inBuf := bufio.NewReader(cmd.InOrStdin()) + txBldr := auth.NewTxBuilderFromCLI(inBuf).WithTxEncoder(utils.GetTxEncoder(cdc)) + cliCtx := context.NewCLIContextWithInput(inBuf).WithCodec(cdc) + + src, err := parseUpdateContractAdminArgs(args, cliCtx) + if err != nil { + return err + } + + content := types.UpdateAdminProposal{ + WasmProposal: types.WasmProposal{ + Title: viper.GetString(cli.FlagTitle), + Description: viper.GetString(cli.FlagDescription), + }, + Contract: src.Contract, + NewAdmin: src.NewAdmin, + } + + deposit, err := sdk.ParseCoins(viper.GetString(cli.FlagDeposit)) + if err != nil { + return err + } + + msg := govtypes.NewMsgSubmitProposal(content, deposit, cliCtx.GetFromAddress()) + if err = msg.ValidateBasic(); err != nil { + return err + } + + return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg}) + }, + } + // proposal flags + cmd.Flags().String(cli.FlagTitle, "", "Title of proposal") + cmd.Flags().String(cli.FlagDescription, "", "Description of proposal") + cmd.Flags().String(cli.FlagDeposit, "", "Deposit of proposal") + cmd.Flags().String(cli.FlagProposal, "", "Proposal file path (if this path is given, other proposal flags are ignored)") + // type values must match the "ProposalHandler" "routes" in cli + cmd.Flags().String(flagProposalType, "", "Type of proposal, types: store-code/instantiate/migrate/update-admin/clear-admin/text/parameter_change/software_upgrade") + return cmd +} + +func ProposalClearContractAdminCmd(cdc *codec.Codec) *cobra.Command { + cmd := &cobra.Command{ + Use: "clear-contract-admin [contract_addr_bech32]", + Short: "Submit a clear admin for a contract to prevent further migrations proposal", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + inBuf := bufio.NewReader(cmd.InOrStdin()) + txBldr := auth.NewTxBuilderFromCLI(inBuf).WithTxEncoder(utils.GetTxEncoder(cdc)) + cliCtx := context.NewCLIContextWithInput(inBuf).WithCodec(cdc) + + contractAddr, err := sdk.AccAddressFromBech32(args[0]) + if err != nil { + return sdkerrors.Wrap(err, "contract") + } + + content := types.ClearAdminProposal{ + WasmProposal: types.WasmProposal{ + Title: viper.GetString(cli.FlagTitle), + Description: viper.GetString(cli.FlagDescription), + }, + Contract: contractAddr, + } + + deposit, err := sdk.ParseCoins(viper.GetString(cli.FlagDeposit)) + if err != nil { + return err + } + + msg := govtypes.NewMsgSubmitProposal(content, deposit, cliCtx.GetFromAddress()) + if err = msg.ValidateBasic(); err != nil { + return err + } + + return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg}) + }, + } + // proposal flags + cmd.Flags().String(cli.FlagTitle, "", "Title of proposal") + cmd.Flags().String(cli.FlagDescription, "", "Description of proposal") + cmd.Flags().String(cli.FlagDeposit, "", "Deposit of proposal") + cmd.Flags().String(cli.FlagProposal, "", "Proposal file path (if this path is given, other proposal flags are ignored)") + // type values must match the "ProposalHandler" "routes" in cli + cmd.Flags().String(flagProposalType, "", "Type of proposal, types: store-code/instantiate/migrate/update-admin/clear-admin/text/parameter_change/software_upgrade") + return cmd +} diff --git a/x/wasm/client/cli/new_tx.go b/x/wasm/client/cli/new_tx.go index d69ed6b3fa..756562f2da 100644 --- a/x/wasm/client/cli/new_tx.go +++ b/x/wasm/client/cli/new_tx.go @@ -25,24 +25,12 @@ func MigrateContractCmd(cdc *codec.Codec) *cobra.Command { txBldr := auth.NewTxBuilderFromCLI(inBuf).WithTxEncoder(utils.GetTxEncoder(cdc)) cliCtx := context.NewCLIContextWithInput(inBuf).WithCodec(cdc) - contractAddr, err := sdk.AccAddressFromBech32(args[0]) - if err != nil { - return sdkerrors.Wrap(err, "contract") - } - - // get the id of the code to instantiate - codeID, err := strconv.ParseUint(args[1], 10, 64) + msg, err := parseMigrateContractArgs(args, cliCtx) if err != nil { - return sdkerrors.Wrap(err, "code id") + return err } - - migrateMsg := args[2] - - msg := types.MsgMigrateContract{ - Sender: cliCtx.GetFromAddress(), - Contract: contractAddr, - Code: codeID, - MigrateMsg: []byte(migrateMsg), + if err := msg.ValidateBasic(); err != nil { + return nil } return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg}) }, @@ -50,6 +38,29 @@ func MigrateContractCmd(cdc *codec.Codec) *cobra.Command { return cmd } +func parseMigrateContractArgs(args []string, cliCtx context.CLIContext) (types.MsgMigrateContract, error) { + contractAddr, err := sdk.AccAddressFromBech32(args[0]) + if err != nil { + return types.MsgMigrateContract{}, sdkerrors.Wrap(err, "contract") + } + + // get the id of the code to instantiate + codeID, err := strconv.ParseUint(args[1], 10, 64) + if err != nil { + return types.MsgMigrateContract{}, sdkerrors.Wrap(err, "code id") + } + + migrateMsg := args[2] + + msg := types.MsgMigrateContract{ + Sender: cliCtx.GetFromAddress(), + Contract: contractAddr, + Code: codeID, + MigrateMsg: []byte(migrateMsg), + } + return msg, nil +} + // UpdateContractAdminCmd sets an new admin for a contract func UpdateContractAdminCmd(cdc *codec.Codec) *cobra.Command { cmd := &cobra.Command{ @@ -61,19 +72,12 @@ func UpdateContractAdminCmd(cdc *codec.Codec) *cobra.Command { txBldr := auth.NewTxBuilderFromCLI(inBuf).WithTxEncoder(utils.GetTxEncoder(cdc)) cliCtx := context.NewCLIContextWithInput(inBuf).WithCodec(cdc) - contractAddr, err := sdk.AccAddressFromBech32(args[0]) - if err != nil { - return sdkerrors.Wrap(err, "contract") - } - newAdmin, err := sdk.AccAddressFromBech32(args[1]) + msg, err := parseUpdateContractAdminArgs(args, cliCtx) if err != nil { - return sdkerrors.Wrap(err, "new admin") + return err } - - msg := types.MsgUpdateAdmin{ - Sender: cliCtx.GetFromAddress(), - Contract: contractAddr, - NewAdmin: newAdmin, + if err := msg.ValidateBasic(); err != nil { + return err } return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg}) }, @@ -81,6 +85,24 @@ func UpdateContractAdminCmd(cdc *codec.Codec) *cobra.Command { return cmd } +func parseUpdateContractAdminArgs(args []string, cliCtx context.CLIContext) (types.MsgUpdateAdmin, error) { + contractAddr, err := sdk.AccAddressFromBech32(args[0]) + if err != nil { + return types.MsgUpdateAdmin{}, sdkerrors.Wrap(err, "contract") + } + newAdmin, err := sdk.AccAddressFromBech32(args[1]) + if err != nil { + return types.MsgUpdateAdmin{}, sdkerrors.Wrap(err, "new admin") + } + + msg := types.MsgUpdateAdmin{ + Sender: cliCtx.GetFromAddress(), + Contract: contractAddr, + NewAdmin: newAdmin, + } + return msg, nil +} + // ClearContractAdminCmd clears an admin for a contract func ClearContractAdminCmd(cdc *codec.Codec) *cobra.Command { cmd := &cobra.Command{ @@ -101,6 +123,9 @@ func ClearContractAdminCmd(cdc *codec.Codec) *cobra.Command { Sender: cliCtx.GetFromAddress(), Contract: contractAddr, } + if err := msg.ValidateBasic(); err != nil { + return err + } return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg}) }, } diff --git a/x/wasm/client/cli/tx.go b/x/wasm/client/cli/tx.go index 8d2d5ff5f3..b1aa00ba4a 100644 --- a/x/wasm/client/cli/tx.go +++ b/x/wasm/client/cli/tx.go @@ -23,13 +23,18 @@ import ( ) const ( - flagTo = "to" - flagAmount = "amount" - flagSource = "source" - flagBuilder = "builder" - flagLabel = "label" - flagAdmin = "admin" - flagNoAdmin = "no-admin" + flagTo = "to" + flagAmount = "amount" + flagSource = "source" + flagBuilder = "builder" + flagLabel = "label" + flagAdmin = "admin" + flagNoAdmin = "no-admin" + flagCreator = "creator" + flagSender = "sender" + flagInstantiateByEverybody = "instantiate-everybody" + flagInstantiateByAddress = "instantiate-only-address" + flagProposalType = "type" ) // GetTxCmd returns the transaction commands for this module @@ -63,37 +68,11 @@ func StoreCodeCmd(cdc *codec.Codec) *cobra.Command { txBldr := auth.NewTxBuilderFromCLI(inBuf).WithTxEncoder(utils.GetTxEncoder(cdc)) cliCtx := context.NewCLIContextWithInput(inBuf).WithCodec(cdc) - // parse coins trying to be sent - wasm, err := ioutil.ReadFile(args[0]) + msg, err := parseStoreCodeArgs(args, cliCtx) if err != nil { return err } - - source := viper.GetString(flagSource) - - builder := viper.GetString(flagBuilder) - - // gzip the wasm file - if wasmUtils.IsWasm(wasm) { - wasm, err = wasmUtils.GzipIt(wasm) - - if err != nil { - return err - } - } else if !wasmUtils.IsGzip(wasm) { - return fmt.Errorf("invalid input file. Use wasm binary or gzip") - } - - // build and sign the transaction, then broadcast to Tendermint - msg := types.MsgStoreCode{ - Sender: cliCtx.GetFromAddress(), - WASMByteCode: wasm, - Source: source, - Builder: builder, - } - err = msg.ValidateBasic() - - if err != nil { + if err = msg.ValidateBasic(); err != nil { return err } @@ -103,58 +82,70 @@ func StoreCodeCmd(cdc *codec.Codec) *cobra.Command { cmd.Flags().String(flagSource, "", "A valid URI reference to the contract's source code, optional") cmd.Flags().String(flagBuilder, "", "A valid docker tag for the build system, optional") + cmd.Flags().String(flagInstantiateByEverybody, "", "Everybody can instantiate a contract from the code, optional") + cmd.Flags().String(flagInstantiateByAddress, "", "Only this address can instantiate a contract instance from the code, optional") return cmd } +func parseStoreCodeArgs(args []string, cliCtx context.CLIContext) (types.MsgStoreCode, error) { + wasm, err := ioutil.ReadFile(args[0]) + if err != nil { + return types.MsgStoreCode{}, err + } + + // gzip the wasm file + if wasmUtils.IsWasm(wasm) { + wasm, err = wasmUtils.GzipIt(wasm) + + if err != nil { + return types.MsgStoreCode{}, err + } + } else if !wasmUtils.IsGzip(wasm) { + return types.MsgStoreCode{}, fmt.Errorf("invalid input file. Use wasm binary or gzip") + } + + var perm *types.AccessConfig + if onlyAddrStr := viper.GetString(flagInstantiateByAddress); onlyAddrStr != "" { + allowedAddr, err := sdk.AccAddressFromBech32(onlyAddrStr) + if err != nil { + return types.MsgStoreCode{}, sdkerrors.Wrap(err, flagInstantiateByAddress) + } + x := types.OnlyAddress.With(allowedAddr) + perm = &x + } else if everybody := viper.GetBool(flagInstantiateByEverybody); everybody { + perm = &types.AllowEverybody + } + + // build and sign the transaction, then broadcast to Tendermint + msg := types.MsgStoreCode{ + Sender: cliCtx.GetFromAddress(), + WASMByteCode: wasm, + Source: viper.GetString(flagSource), + Builder: viper.GetString(flagBuilder), + InstantiatePermission: perm, + } + return msg, nil +} + // InstantiateContractCmd will instantiate a contract from previously uploaded code. func InstantiateContractCmd(cdc *codec.Codec) *cobra.Command { cmd := &cobra.Command{ - Use: "instantiate [code_id_int64] [json_encoded_init_args]", + Use: "instantiate [code_id_int64] [json_encoded_init_args] --label [text] --admin [address]", Short: "Instantiate a wasm contract", - Args: cobra.RangeArgs(2, 3), + Args: cobra.ExactArgs(2), RunE: func(cmd *cobra.Command, args []string) error { inBuf := bufio.NewReader(cmd.InOrStdin()) txBldr := auth.NewTxBuilderFromCLI(inBuf).WithTxEncoder(utils.GetTxEncoder(cdc)) cliCtx := context.NewCLIContextWithInput(inBuf).WithCodec(cdc) - // get the id of the code to instantiate - codeID, err := strconv.ParseUint(args[0], 10, 64) + msg, err := parseInstantiateArgs(args, cliCtx) if err != nil { return err } - - amounstStr := viper.GetString(flagAmount) - amount, err := sdk.ParseCoins(amounstStr) - if err != nil { + if err := msg.ValidateBasic(); err != nil { return err } - - label := viper.GetString(flagLabel) - if label == "" { - return fmt.Errorf("Label is required on all contracts") - } - - initMsg := args[1] - - adminStr := viper.GetString(flagAdmin) - var adminAddr sdk.AccAddress - if len(adminStr) != 0 { - adminAddr, err = sdk.AccAddressFromBech32(adminStr) - if err != nil { - return sdkerrors.Wrap(err, "admin") - } - } - - // build and sign the transaction, then broadcast to Tendermint - msg := types.MsgInstantiateContract{ - Sender: cliCtx.GetFromAddress(), - Code: codeID, - Label: label, - InitFunds: amount, - InitMsg: []byte(initMsg), - Admin: adminAddr, - } return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg}) }, } @@ -165,6 +156,47 @@ func InstantiateContractCmd(cdc *codec.Codec) *cobra.Command { return cmd } +func parseInstantiateArgs(args []string, cliCtx context.CLIContext) (types.MsgInstantiateContract, error) { + // get the id of the code to instantiate + codeID, err := strconv.ParseUint(args[0], 10, 64) + if err != nil { + return types.MsgInstantiateContract{}, err + } + + amounstStr := viper.GetString(flagAmount) + amount, err := sdk.ParseCoins(amounstStr) + if err != nil { + return types.MsgInstantiateContract{}, err + } + + label := viper.GetString(flagLabel) + if label == "" { + return types.MsgInstantiateContract{}, fmt.Errorf("Label is required on all contracts") + } + + initMsg := args[1] + + adminStr := viper.GetString(flagAdmin) + var adminAddr sdk.AccAddress + if len(adminStr) != 0 { + adminAddr, err = sdk.AccAddressFromBech32(adminStr) + if err != nil { + return types.MsgInstantiateContract{}, sdkerrors.Wrap(err, "admin") + } + } + + // build and sign the transaction, then broadcast to Tendermint + msg := types.MsgInstantiateContract{ + Sender: cliCtx.GetFromAddress(), + Code: codeID, + Label: label, + InitFunds: amount, + InitMsg: []byte(initMsg), + Admin: adminAddr, + } + return msg, nil +} + // ExecuteContractCmd will instantiate a contract from previously uploaded code. func ExecuteContractCmd(cdc *codec.Codec) *cobra.Command { cmd := &cobra.Command{ diff --git a/x/wasm/client/proposal_handler.go b/x/wasm/client/proposal_handler.go new file mode 100644 index 0000000000..1f68a8684d --- /dev/null +++ b/x/wasm/client/proposal_handler.go @@ -0,0 +1,16 @@ +package client + +import ( + "github.com/CosmWasm/wasmd/x/wasm/client/cli" + "github.com/CosmWasm/wasmd/x/wasm/client/rest" + govclient "github.com/cosmos/cosmos-sdk/x/gov/client" +) + +// ProposalHandlers define the wasm cli proposal types and cli json parser. Not REST routes. +var ProposalHandlers = []govclient.ProposalHandler{ + govclient.NewProposalHandler(cli.ProposalStoreCodeCmd, rest.ProposalJsonHandler("store-code", rest.StoreCodeProposalJsonReq{})), + govclient.NewProposalHandler(cli.ProposalInstantiateContractCmd, rest.ProposalJsonHandler("instantiate", rest.InstantiateProposalJsonReq{})), + govclient.NewProposalHandler(cli.ProposalMigrateContractCmd, rest.ProposalJsonHandler("migrate", rest.MigrateProposalJsonReq{})), + govclient.NewProposalHandler(cli.ProposalUpdateContractAdminCmd, rest.ProposalJsonHandler("update-admin", rest.UpdateAdminJsonReq{})), + govclient.NewProposalHandler(cli.ProposalClearContractAdminCmd, rest.ProposalJsonHandler("clear-admin", rest.ClearAdminJsonReq{})), +} diff --git a/x/wasm/client/rest/gov.go b/x/wasm/client/rest/gov.go new file mode 100644 index 0000000000..a07220643c --- /dev/null +++ b/x/wasm/client/rest/gov.go @@ -0,0 +1,112 @@ +package rest + +import ( + "net/http" + "reflect" + + "github.com/CosmWasm/wasmd/x/wasm/internal/types" + "github.com/cosmos/cosmos-sdk/client/context" + sdk "github.com/cosmos/cosmos-sdk/types" + "github.com/cosmos/cosmos-sdk/types/rest" + "github.com/cosmos/cosmos-sdk/x/auth/client/utils" + "github.com/cosmos/cosmos-sdk/x/gov" + govrest "github.com/cosmos/cosmos-sdk/x/gov/client/rest" + govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" +) + +type WasmProposalJson struct { + BaseReq rest.BaseReq `json:"base_req" yaml:"base_req"` + + Proposer sdk.AccAddress `json:"proposer" yaml:"proposer"` + Deposit sdk.Coins `json:"deposit" yaml:"deposit"` +} + +func (p WasmProposalJson) GetProposer() sdk.AccAddress { + return p.Proposer +} + +func (p WasmProposalJson) GetDeposit() sdk.Coins { + return p.Deposit +} + +func (p WasmProposalJson) GetBaseReq() rest.BaseReq { + return p.BaseReq +} + +func (p *WasmProposalJson) validate(w http.ResponseWriter) { + p.BaseReq = p.BaseReq.Sanitize() + if p.BaseReq.ValidateBasic(w) { + return + } +} + +type ( + StoreCodeProposalJsonReq struct { + WasmProposalJson + types.StoreCodeProposal + } + + InstantiateProposalJsonReq struct { + WasmProposalJson + types.InstantiateContractProposal + } + MigrateProposalJsonReq struct { + WasmProposalJson + types.MigrateContractProposal + } + UpdateAdminJsonReq struct { + WasmProposalJson + types.UpdateAdminProposal + } + ClearAdminJsonReq struct { + WasmProposalJson + types.ClearAdminProposal + } +) + +func (s StoreCodeProposalJsonReq) Content() gov.Content { + return s.StoreCodeProposal +} +func (s InstantiateProposalJsonReq) Content() gov.Content { + return s.InstantiateContractProposal +} +func (s MigrateProposalJsonReq) Content() gov.Content { + return s.MigrateContractProposal +} +func (s UpdateAdminJsonReq) Content() gov.Content { + return s.UpdateAdminProposal +} +func (s ClearAdminJsonReq) Content() gov.Content { + return s.ClearAdminProposal +} + +type wasmProposalContent interface { + Content() gov.Content + GetProposer() sdk.AccAddress + GetDeposit() sdk.Coins + GetBaseReq() rest.BaseReq +} + +func ProposalJsonHandler(route string, p wasmProposalContent) func(cliCtx context.CLIContext) govrest.ProposalRESTHandler { + t := reflect.TypeOf(p) + return func(cliCtx context.CLIContext) govrest.ProposalRESTHandler { + return govrest.ProposalRESTHandler{ + SubRoute: route, + Handler: func(w http.ResponseWriter, r *http.Request) { + + var req = reflect.New(t).Interface().(wasmProposalContent) + if !rest.ReadRESTReq(w, r, cliCtx.Codec, &req) { + return + } + + msg := govtypes.NewMsgSubmitProposal(req.Content(), req.GetDeposit(), req.GetProposer()) + if err := msg.ValidateBasic(); err != nil { + rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error()) + return + } + + utils.WriteGenerateStdTxResponse(w, cliCtx, req.GetBaseReq(), []sdk.Msg{msg}) + }, + } + } +} diff --git a/x/wasm/internal/keeper/keeper.go b/x/wasm/internal/keeper/keeper.go index a6916bf239..d851da50d5 100644 --- a/x/wasm/internal/keeper/keeper.go +++ b/x/wasm/internal/keeper/keeper.go @@ -194,7 +194,7 @@ func (k Keeper) instantiate(ctx sdk.Context, codeID uint64, creator, admin sdk.A store := ctx.KVStore(k.storeKey) bz := store.Get(types.GetCodeKey(codeID)) if bz == nil { - return nil, sdkerrors.Wrap(types.ErrNotFound, "contract") + return nil, sdkerrors.Wrap(types.ErrNotFound, "code") } var codeInfo types.CodeInfo k.cdc.MustUnmarshalBinaryBare(bz, &codeInfo) diff --git a/x/wasm/internal/keeper/proposal_handler.go b/x/wasm/internal/keeper/proposal_handler.go index 862c13c7a4..78b463553c 100644 --- a/x/wasm/internal/keeper/proposal_handler.go +++ b/x/wasm/internal/keeper/proposal_handler.go @@ -108,7 +108,7 @@ func handleUpdateAdminProposal(ctx sdk.Context, k Keeper, p types.UpdateAdminPro return err } - if err := k.setContractAdmin(ctx, p.Contract, p.Sender, p.NewAdmin, GovAuthorizationPolicy{}); err != nil { + if err := k.setContractAdmin(ctx, p.Contract, nil, p.NewAdmin, GovAuthorizationPolicy{}); err != nil { return err } @@ -127,7 +127,7 @@ func handleClearAdminProposal(ctx sdk.Context, k Keeper, p types.ClearAdminPropo return err } - if err := k.setContractAdmin(ctx, p.Contract, p.Sender, nil, GovAuthorizationPolicy{}); err != nil { + if err := k.setContractAdmin(ctx, p.Contract, nil, nil, GovAuthorizationPolicy{}); err != nil { return err } ourEvent := sdk.NewEvent( diff --git a/x/wasm/internal/keeper/proposal_integration_test.go b/x/wasm/internal/keeper/proposal_integration_test.go index fe36d6e928..41d795de9a 100644 --- a/x/wasm/internal/keeper/proposal_integration_test.go +++ b/x/wasm/internal/keeper/proposal_integration_test.go @@ -176,7 +176,6 @@ func TestMigrateProposal(t *testing.T) { func TestAdminProposals(t *testing.T) { var ( - anyAddress sdk.AccAddress = bytes.Repeat([]byte{0x1}, sdk.AddrLen) otherAddress sdk.AccAddress = bytes.Repeat([]byte{0x2}, sdk.AddrLen) contractAddr = contractAddress(1, 1) ) @@ -196,7 +195,6 @@ func TestAdminProposals(t *testing.T) { Description: "Bar", }, Contract: contractAddr, - Sender: anyAddress, NewAdmin: otherAddress, }, expAdmin: otherAddress, @@ -211,7 +209,6 @@ func TestAdminProposals(t *testing.T) { Description: "Bar", }, Contract: contractAddr, - Sender: anyAddress, NewAdmin: otherAddress, }, expAdmin: otherAddress, @@ -224,7 +221,6 @@ func TestAdminProposals(t *testing.T) { Description: "Bar", }, Contract: contractAddr, - Sender: anyAddress, }, expAdmin: nil, }, @@ -238,7 +234,6 @@ func TestAdminProposals(t *testing.T) { Description: "Bar", }, Contract: contractAddr, - Sender: anyAddress, }, expAdmin: nil, }, diff --git a/x/wasm/internal/types/codec.go b/x/wasm/internal/types/codec.go index 92dcf7b0b5..33e90a2af5 100644 --- a/x/wasm/internal/types/codec.go +++ b/x/wasm/internal/types/codec.go @@ -13,11 +13,11 @@ func RegisterCodec(cdc *codec.Codec) { cdc.RegisterConcrete(&MsgUpdateAdmin{}, "wasm/update-contract-admin", nil) cdc.RegisterConcrete(&MsgClearAdmin{}, "wasm/clear-contract-admin", nil) - cdc.RegisterConcrete(&StoreCodeProposal{}, "wasm/store-proposal", nil) - cdc.RegisterConcrete(&InstantiateContractProposal{}, "wasm/instantiate-proposal", nil) - cdc.RegisterConcrete(&MigrateContractProposal{}, "wasm/migrate-proposal", nil) - cdc.RegisterConcrete(&UpdateAdminProposal{}, "wasm/update-admin-proposal", nil) - cdc.RegisterConcrete(&ClearAdminProposal{}, "wasm/clear-admin-proposal", nil) + cdc.RegisterConcrete(StoreCodeProposal{}, "wasm/store-proposal", nil) + cdc.RegisterConcrete(InstantiateContractProposal{}, "wasm/instantiate-proposal", nil) + cdc.RegisterConcrete(MigrateContractProposal{}, "wasm/migrate-proposal", nil) + cdc.RegisterConcrete(UpdateAdminProposal{}, "wasm/update-admin-proposal", nil) + cdc.RegisterConcrete(ClearAdminProposal{}, "wasm/clear-admin-proposal", nil) } // ModuleCdc generic sealed codec to be used throughout module diff --git a/x/wasm/internal/types/proposal.go b/x/wasm/internal/types/proposal.go index 49675e832f..1b662a7a88 100644 --- a/x/wasm/internal/types/proposal.go +++ b/x/wasm/internal/types/proposal.go @@ -26,6 +26,19 @@ var DefaultEnabledProposals = map[string]struct{}{ ProposalTypeClearAdmin: {}, } +func init() { // register new content types with the sdk + govtypes.RegisterProposalType(ProposalTypeStoreCode) + govtypes.RegisterProposalType(ProposalTypeStoreInstantiateContract) + govtypes.RegisterProposalType(ProposalTypeMigrateContract) + govtypes.RegisterProposalType(ProposalTypeUpdateAdmin) + govtypes.RegisterProposalType(ProposalTypeClearAdmin) + govtypes.RegisterProposalTypeCodec(StoreCodeProposal{}, "wasm/store-proposal") + govtypes.RegisterProposalTypeCodec(InstantiateContractProposal{}, "wasm/instantiate-proposal") + govtypes.RegisterProposalTypeCodec(MigrateContractProposal{}, "wasm/migrate-proposal") + govtypes.RegisterProposalTypeCodec(UpdateAdminProposal{}, "wasm/update-admin-proposal") + govtypes.RegisterProposalTypeCodec(ClearAdminProposal{}, "wasm/clear-admin-proposal") +} + type WasmProposal struct { Title string `json:"title" yaml:"title"` Description string `json:"description" yaml:"description"` @@ -227,8 +240,6 @@ type UpdateAdminProposal struct { WasmProposal NewAdmin sdk.AccAddress `json:"new_admin" yaml:"new_admin"` Contract sdk.AccAddress `json:"contract" yaml:"contract"` - // Sender is the role that is passed to the contract's environment - Sender sdk.AccAddress `json:"sender" yaml:"sender"` } // ProposalType returns the type @@ -245,9 +256,6 @@ func (p UpdateAdminProposal) ValidateBasic() error { if err := sdk.VerifyAddressFormat(p.NewAdmin); err != nil { return sdkerrors.Wrap(err, "new admin") } - if err := sdk.VerifyAddressFormat(p.Sender); err != nil { - return sdkerrors.Wrap(err, "sender") - } return nil } @@ -257,17 +265,14 @@ func (p UpdateAdminProposal) String() string { Title: %s Description: %s Contract: %s - Sender: %s New Admin: %s -`, p.Title, p.Description, p.Contract, p.Sender, p.NewAdmin) +`, p.Title, p.Description, p.Contract, p.NewAdmin) } type ClearAdminProposal struct { WasmProposal Contract sdk.AccAddress `json:"contract" yaml:"contract"` - // Sender is the role that is passed to the contract's environment - Sender sdk.AccAddress `json:"sender" yaml:"sender"` } // ProposalType returns the type @@ -281,9 +286,6 @@ func (p ClearAdminProposal) ValidateBasic() error { if err := sdk.VerifyAddressFormat(p.Contract); err != nil { return sdkerrors.Wrap(err, "contract") } - if err := sdk.VerifyAddressFormat(p.Sender); err != nil { - return sdkerrors.Wrap(err, "sender") - } return nil } @@ -293,6 +295,5 @@ func (p ClearAdminProposal) String() string { Title: %s Description: %s Contract: %s - Sender: %s -`, p.Title, p.Description, p.Contract, p.Sender) +`, p.Title, p.Description, p.Contract) } diff --git a/x/wasm/internal/types/proposal_test.go b/x/wasm/internal/types/proposal_test.go index 25cc950047..f4d844bc9e 100644 --- a/x/wasm/internal/types/proposal_test.go +++ b/x/wasm/internal/types/proposal_test.go @@ -370,18 +370,6 @@ func TestValidateUpdateAdminProposal(t *testing.T) { }), expErr: true, }, - "sender missing": { - src: UpdateAdminProposalFixture(func(p *UpdateAdminProposal) { - p.Sender = nil - }), - expErr: true, - }, - "sender invalid": { - src: UpdateAdminProposalFixture(func(p *UpdateAdminProposal) { - p.Sender = invalidAddress - }), - expErr: true, - }, } for msg, spec := range specs { t.Run(msg, func(t *testing.T) { @@ -425,18 +413,6 @@ func TestValidateClearAdminProposal(t *testing.T) { }), expErr: true, }, - "sender missing": { - src: ClearAdminProposalFixture(func(p *ClearAdminProposal) { - p.Sender = nil - }), - expErr: true, - }, - "sender invalid": { - src: ClearAdminProposalFixture(func(p *ClearAdminProposal) { - p.Sender = invalidAddress - }), - expErr: true, - }, } for msg, spec := range specs { t.Run(msg, func(t *testing.T) { @@ -526,7 +502,6 @@ func TestProposalStrings(t *testing.T) { Title: Foo Description: Bar Contract: cosmos18vd8fpwxzck93qlwghaj6arh4p7c5n89uzcee5 - Sender: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du New Admin: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du `, }, @@ -536,7 +511,6 @@ func TestProposalStrings(t *testing.T) { Title: Foo Description: Bar Contract: cosmos18vd8fpwxzck93qlwghaj6arh4p7c5n89uzcee5 - Sender: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du `, }, } diff --git a/x/wasm/internal/types/test_fixtures.go b/x/wasm/internal/types/test_fixtures.go index 6ef2018fbe..40651e1e36 100644 --- a/x/wasm/internal/types/test_fixtures.go +++ b/x/wasm/internal/types/test_fixtures.go @@ -216,7 +216,6 @@ func UpdateAdminProposalFixture(mutators ...func(p *UpdateAdminProposal)) Update }, NewAdmin: anyValidAddress, Contract: contractAddr, - Sender: anyValidAddress, } for _, m := range mutators { m(&p) @@ -225,8 +224,6 @@ func UpdateAdminProposalFixture(mutators ...func(p *UpdateAdminProposal)) Update } func ClearAdminProposalFixture(mutators ...func(p *ClearAdminProposal)) ClearAdminProposal { - var anyValidAddress sdk.AccAddress = bytes.Repeat([]byte{0x1}, sdk.AddrLen) - contractAddr, err := sdk.AccAddressFromBech32("cosmos18vd8fpwxzck93qlwghaj6arh4p7c5n89uzcee5") if err != nil { panic(err) @@ -238,7 +235,6 @@ func ClearAdminProposalFixture(mutators ...func(p *ClearAdminProposal)) ClearAdm Description: "Bar", }, Contract: contractAddr, - Sender: anyValidAddress, } for _, m := range mutators { m(&p) From 5fa8b1368e5603f2ff5a47f22e1f9a6349882ed8 Mon Sep 17 00:00:00 2001 From: Alex Peters Date: Fri, 10 Jul 2020 16:51:00 +0200 Subject: [PATCH 2/7] Update changelog --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6e731f0849..0d75980125 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -37,6 +37,7 @@ Ref: https://keepachangelog.com/en/1.0.0/ ## [Unreleased] ### Features +* (wasmd) [\#178](https://github.com/CosmWasm/wasmd/issues/178) Add cli support for wasm gov proposals * (wasmd) [\#163](https://github.com/CosmWasm/wasmd/issues/163) Control who can instantiate code * (wasmd) [\#164](https://github.com/CosmWasm/wasmd/issues/164) Control who can upload code * (wasmd) [\#173](https://github.com/CosmWasm/wasmd/issues/173) Gov proposal types and handler From 6c38d8ca6037f621ad3b63c3e2fb66264f407cae Mon Sep 17 00:00:00 2001 From: Alex Peters Date: Mon, 13 Jul 2020 14:58:51 +0200 Subject: [PATCH 3/7] Rework gov proposal rest handlers --- cmd/wasmcli/main.go | 8 +- x/wasm/client/proposal_handler.go | 12 +- x/wasm/client/proposal_handler_test.go | 198 +++++++++++++ x/wasm/client/rest/gov.go | 282 +++++++++++++++---- x/wasm/internal/keeper/testdata/genesis.json | 219 ++++++++++++++ x/wasm/internal/types/proposal.go | 2 +- 6 files changed, 645 insertions(+), 76 deletions(-) create mode 100644 x/wasm/client/proposal_handler_test.go create mode 100644 x/wasm/internal/keeper/testdata/genesis.json diff --git a/cmd/wasmcli/main.go b/cmd/wasmcli/main.go index d7986b761e..d7e6f42ecc 100644 --- a/cmd/wasmcli/main.go +++ b/cmd/wasmcli/main.go @@ -17,7 +17,6 @@ import ( authrest "github.com/cosmos/cosmos-sdk/x/auth/client/rest" "github.com/cosmos/cosmos-sdk/x/bank" bankcmd "github.com/cosmos/cosmos-sdk/x/bank/client/cli" - "github.com/cosmos/cosmos-sdk/x/gov" "github.com/spf13/cobra" "github.com/spf13/viper" @@ -127,17 +126,12 @@ func txCmd(cdc *amino.Codec) *cobra.Command { // add modules' tx commands app.ModuleBasics.AddTxCommands(txCmd, cdc) - //wasmGovCmds := []*cobra.Command{} - // remove auth and bank commands as they're mounted under the root tx command var cmdsToRemove []*cobra.Command + for _, cmd := range txCmd.Commands() { if cmd.Use == auth.ModuleName || cmd.Use == bank.ModuleName { cmdsToRemove = append(cmdsToRemove, cmd) - continue - } - if cmd.Use == gov.ModuleName { - //cmd.AddCommand(wasmGovCmds...) } } diff --git a/x/wasm/client/proposal_handler.go b/x/wasm/client/proposal_handler.go index 1f68a8684d..f6925d9084 100644 --- a/x/wasm/client/proposal_handler.go +++ b/x/wasm/client/proposal_handler.go @@ -6,11 +6,11 @@ import ( govclient "github.com/cosmos/cosmos-sdk/x/gov/client" ) -// ProposalHandlers define the wasm cli proposal types and cli json parser. Not REST routes. +// ProposalHandlers define the wasm cli proposal types and rest handler. var ProposalHandlers = []govclient.ProposalHandler{ - govclient.NewProposalHandler(cli.ProposalStoreCodeCmd, rest.ProposalJsonHandler("store-code", rest.StoreCodeProposalJsonReq{})), - govclient.NewProposalHandler(cli.ProposalInstantiateContractCmd, rest.ProposalJsonHandler("instantiate", rest.InstantiateProposalJsonReq{})), - govclient.NewProposalHandler(cli.ProposalMigrateContractCmd, rest.ProposalJsonHandler("migrate", rest.MigrateProposalJsonReq{})), - govclient.NewProposalHandler(cli.ProposalUpdateContractAdminCmd, rest.ProposalJsonHandler("update-admin", rest.UpdateAdminJsonReq{})), - govclient.NewProposalHandler(cli.ProposalClearContractAdminCmd, rest.ProposalJsonHandler("clear-admin", rest.ClearAdminJsonReq{})), + govclient.NewProposalHandler(cli.ProposalStoreCodeCmd, rest.StoreCodeProposalHandler), + govclient.NewProposalHandler(cli.ProposalInstantiateContractCmd, rest.InstantiateProposalHandler), + govclient.NewProposalHandler(cli.ProposalMigrateContractCmd, rest.MigrateProposalHandler), + govclient.NewProposalHandler(cli.ProposalUpdateContractAdminCmd, rest.UpdateContractAdminProposalHandler), + govclient.NewProposalHandler(cli.ProposalClearContractAdminCmd, rest.ClearContractAdminProposalHandler), } diff --git a/x/wasm/client/proposal_handler_test.go b/x/wasm/client/proposal_handler_test.go new file mode 100644 index 0000000000..0c7f42d79b --- /dev/null +++ b/x/wasm/client/proposal_handler_test.go @@ -0,0 +1,198 @@ +package client + +import ( + "bytes" + "encoding/json" + "fmt" + "net/http" + "net/http/httptest" + "testing" + + wasmtypes "github.com/CosmWasm/wasmd/x/wasm/internal/types" + "github.com/cosmos/cosmos-sdk/client/context" + "github.com/cosmos/cosmos-sdk/codec" + sdk "github.com/cosmos/cosmos-sdk/types" + authvesting "github.com/cosmos/cosmos-sdk/x/auth/vesting" + "github.com/cosmos/cosmos-sdk/x/gov" + "github.com/gorilla/mux" + "github.com/stretchr/testify/require" +) + +func TestGovRestHandlers(t *testing.T) { + type dict map[string]interface{} + var ( + anyAddress = "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz" + aBaseReq = dict{ + "from": anyAddress, + "memo": "rest test", + "chain_id": "testing", + "account_number": "1", + "sequence": "1", + "fees": []dict{{"denom": "ustake", "amount": "1000000"}}, + } + ) + cdc := MakeCodec() + clientCtx := context.CLIContext{}.WithChainID("testing").WithCodec(cdc) + + // router setup as in gov/client/rest/tx.go + propSubRtr := mux.NewRouter().PathPrefix("/gov/proposals").Subrouter() + for _, ph := range ProposalHandlers { + r := ph.RESTHandler(clientCtx) + propSubRtr.HandleFunc(fmt.Sprintf("/%s", r.SubRoute), r.Handler).Methods("POST") + } + + specs := map[string]struct { + srcBody dict + srcPath string + expCode int + }{ + "store-code": { + srcPath: "/gov/proposals/store-code", + srcBody: dict{ + "title": "Test Proposal", + "description": "My proposal", + "type": "store-code", + "creator": "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz", + "wasm_byte_code": "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", + "source": "https://example.com/", + "builder": "my/builder:tag", + "instantiate_permission": dict{ + "type": 2, + "address": "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np", + }, + "deposit": []dict{{"denom": "ustake", "amount": "10"}}, + "proposer": "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np", + "base_req": aBaseReq, + }, + expCode: http.StatusOK, + }, + "store-code with incomplete proposal data: blank title": { + srcPath: "/gov/proposals/store-code", + srcBody: dict{ + "title": "", + "description": "My proposal", + "type": "store-code", + "creator": "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz", + "wasm_byte_code": "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", + "source": "https://example.com/", + "builder": "my/builder:tag", + "instantiate_permission": dict{ + "type": 2, + "address": "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np", + }, + "deposit": []dict{{"denom": "ustake", "amount": "10"}}, + "proposer": "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np", + "base_req": aBaseReq, + }, + expCode: http.StatusBadRequest, + }, + "store-code with incomplete content data: no wasm_byte_code": { + srcPath: "/gov/proposals/store-code", + srcBody: dict{ + "title": "Test Proposal", + "description": "My proposal", + "type": "store-code", + "creator": "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz", + "wasm_byte_code": "", + "source": "https://example.com/", + "builder": "my/builder:tag", + "instantiate_permission": dict{ + "type": 2, + "address": "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np", + }, + "deposit": []dict{{"denom": "ustake", "amount": "10"}}, + "proposer": "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np", + "base_req": aBaseReq, + }, + expCode: http.StatusBadRequest, + }, + "instantiate contract": { + srcPath: "/gov/proposals/instantiate", + srcBody: dict{ + "title": "Test Proposal", + "description": "My proposal", + "type": "instantiate", + "sender": "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz", + "admin": "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz", + "code_id": "1", + "label": "https://example.com/", + "init_msg": "my/builder:tag", + "init_funds": []dict{{"denom": "ustake", "amount": "100"}}, + "deposit": []dict{{"denom": "ustake", "amount": "10"}}, + "proposer": "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np", + "base_req": aBaseReq, + }, + expCode: http.StatusOK, + }, + "migrate contract": { + srcPath: "/gov/proposals/migrate", + srcBody: dict{ + "title": "Test Proposal", + "description": "My proposal", + "type": "migrate", + "contract": "cosmos18vd8fpwxzck93qlwghaj6arh4p7c5n89uzcee5", + "code_id": "1", + "msg": dict{"foo": "bar"}, + "sender": "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz", + "deposit": []dict{{"denom": "ustake", "amount": "10"}}, + "proposer": "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np", + "base_req": aBaseReq, + }, + expCode: http.StatusOK, + }, + "update contract admin": { + srcPath: "/gov/proposals/update-admin", + srcBody: dict{ + "title": "Test Proposal", + "description": "My proposal", + "type": "migrate", + "contract": "cosmos18vd8fpwxzck93qlwghaj6arh4p7c5n89uzcee5", + "new_admin": "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz", + "deposit": []dict{{"denom": "ustake", "amount": "10"}}, + "proposer": "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np", + "base_req": aBaseReq, + }, + expCode: http.StatusOK, + }, + "clear contract admin": { + srcPath: "/gov/proposals/clear-admin", + srcBody: dict{ + "title": "Test Proposal", + "description": "My proposal", + "type": "migrate", + "contract": "cosmos18vd8fpwxzck93qlwghaj6arh4p7c5n89uzcee5", + "deposit": []dict{{"denom": "ustake", "amount": "10"}}, + "proposer": "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np", + "base_req": aBaseReq, + }, + expCode: http.StatusOK, + }, + } + for msg, spec := range specs { + t.Run(msg, func(t *testing.T) { + src, err := json.Marshal(spec.srcBody) + require.NoError(t, err) + + // when + r := httptest.NewRequest("POST", spec.srcPath, bytes.NewReader(src)) + w := httptest.NewRecorder() + propSubRtr.ServeHTTP(w, r) + + // then + require.Equal(t, spec.expCode, w.Code, w.Body.String()) + }) + } +} + +func MakeCodec() *codec.Codec { + var cdc = codec.New() + wasmtypes.RegisterCodec(cdc) + gov.RegisterCodec(cdc) + sdk.RegisterCodec(cdc) + codec.RegisterCrypto(cdc) + codec.RegisterEvidences(cdc) + authvesting.RegisterCodec(cdc) + + return cdc.Seal() + +} diff --git a/x/wasm/client/rest/gov.go b/x/wasm/client/rest/gov.go index a07220643c..cfb1749651 100644 --- a/x/wasm/client/rest/gov.go +++ b/x/wasm/client/rest/gov.go @@ -1,8 +1,8 @@ package rest import ( + "encoding/json" "net/http" - "reflect" "github.com/CosmWasm/wasmd/x/wasm/internal/types" "github.com/cosmos/cosmos-sdk/client/context" @@ -11,102 +11,260 @@ import ( "github.com/cosmos/cosmos-sdk/x/auth/client/utils" "github.com/cosmos/cosmos-sdk/x/gov" govrest "github.com/cosmos/cosmos-sdk/x/gov/client/rest" - govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" ) -type WasmProposalJson struct { +type StoreCodeProposalJsonReq struct { BaseReq rest.BaseReq `json:"base_req" yaml:"base_req"` + Title string `json:"title" yaml:"title"` + Description string `json:"description" yaml:"description"` Proposer sdk.AccAddress `json:"proposer" yaml:"proposer"` Deposit sdk.Coins `json:"deposit" yaml:"deposit"` + + Creator sdk.AccAddress `json:"creator" yaml:"creator"` + // WASMByteCode can be raw or gzip compressed + WASMByteCode []byte `json:"wasm_byte_code" yaml:"wasm_byte_code"` + // Source is a valid absolute HTTPS URI to the contract's source code, optional + Source string `json:"source" yaml:"source"` + // Builder is a valid docker image name with tag, optional + Builder string `json:"builder" yaml:"builder"` + // InstantiatePermission to apply on contract creation, optional + InstantiatePermission *types.AccessConfig `json:"instantiate_permission" yaml:"instantiate_permission"` } -func (p WasmProposalJson) GetProposer() sdk.AccAddress { - return p.Proposer +func (s StoreCodeProposalJsonReq) Content() gov.Content { + return types.StoreCodeProposal{ + WasmProposal: types.WasmProposal{ + Title: s.Title, + Description: s.Description, + }, + Creator: s.Creator, + WASMByteCode: s.WASMByteCode, + Source: s.Source, + Builder: s.Builder, + InstantiatePermission: s.InstantiatePermission, + } +} +func (s StoreCodeProposalJsonReq) GetProposer() sdk.AccAddress { + return s.Proposer +} +func (s StoreCodeProposalJsonReq) GetDeposit() sdk.Coins { + return s.Deposit +} +func (s StoreCodeProposalJsonReq) GetBaseReq() rest.BaseReq { + return s.BaseReq } -func (p WasmProposalJson) GetDeposit() sdk.Coins { - return p.Deposit +func StoreCodeProposalHandler(cliCtx context.CLIContext) govrest.ProposalRESTHandler { + return govrest.ProposalRESTHandler{ + SubRoute: "store-code", + Handler: func(w http.ResponseWriter, r *http.Request) { + var req StoreCodeProposalJsonReq + if !rest.ReadRESTReq(w, r, cliCtx.Codec, &req) { + return + } + toStdTxResponse(cliCtx, w, req) + }, + } } -func (p WasmProposalJson) GetBaseReq() rest.BaseReq { - return p.BaseReq +type InstantiateProposalJsonReq struct { + BaseReq rest.BaseReq `json:"base_req" yaml:"base_req"` + + Title string `json:"title" yaml:"title"` + Description string `json:"description" yaml:"description"` + + Proposer sdk.AccAddress `json:"proposer" yaml:"proposer"` + Deposit sdk.Coins `json:"deposit" yaml:"deposit"` + + Creator sdk.AccAddress `json:"sender" yaml:"sender"` + // Admin is an optional address that can execute migrations + Admin sdk.AccAddress `json:"admin,omitempty" yaml:"admin"` + Code uint64 `json:"code_id" yaml:"code_id"` + Label string `json:"label" yaml:"label"` + InitMsg json.RawMessage `json:"init_msg" yaml:"init_msg"` + InitFunds sdk.Coins `json:"init_funds" yaml:"init_funds"` } -func (p *WasmProposalJson) validate(w http.ResponseWriter) { - p.BaseReq = p.BaseReq.Sanitize() - if p.BaseReq.ValidateBasic(w) { - return +func (s InstantiateProposalJsonReq) Content() gov.Content { + return types.InstantiateContractProposal{ + WasmProposal: types.WasmProposal{Title: s.Title, Description: s.Description}, + Creator: s.Creator, + Admin: s.Admin, + Code: s.Code, + Label: s.Label, + InitMsg: s.InitMsg, + InitFunds: s.InitFunds, } } +func (s InstantiateProposalJsonReq) GetProposer() sdk.AccAddress { + return s.Proposer +} +func (s InstantiateProposalJsonReq) GetDeposit() sdk.Coins { + return s.Deposit +} +func (s InstantiateProposalJsonReq) GetBaseReq() rest.BaseReq { + return s.BaseReq +} -type ( - StoreCodeProposalJsonReq struct { - WasmProposalJson - types.StoreCodeProposal +func InstantiateProposalHandler(cliCtx context.CLIContext) govrest.ProposalRESTHandler { + return govrest.ProposalRESTHandler{ + SubRoute: "instantiate", + Handler: func(w http.ResponseWriter, r *http.Request) { + var req InstantiateProposalJsonReq + if !rest.ReadRESTReq(w, r, cliCtx.Codec, &req) { + return + } + toStdTxResponse(cliCtx, w, req) + }, } +} + +type MigrateProposalJsonReq struct { + BaseReq rest.BaseReq `json:"base_req" yaml:"base_req"` + + Title string `json:"title" yaml:"title"` + Description string `json:"description" yaml:"description"` + + Proposer sdk.AccAddress `json:"proposer" yaml:"proposer"` + Deposit sdk.Coins `json:"deposit" yaml:"deposit"` + + Contract sdk.AccAddress `json:"contract" yaml:"contract"` + Code uint64 `json:"code_id" yaml:"code_id"` + MigrateMsg json.RawMessage `json:"msg" yaml:"msg"` + // Sender is the role that is passed to the contract's environment + Sender sdk.AccAddress `json:"sender" yaml:"sender"` +} - InstantiateProposalJsonReq struct { - WasmProposalJson - types.InstantiateContractProposal +func (s MigrateProposalJsonReq) Content() gov.Content { + return types.MigrateContractProposal{ + WasmProposal: types.WasmProposal{Title: s.Title, Description: s.Description}, + Contract: s.Contract, + Code: s.Code, + MigrateMsg: s.MigrateMsg, + Sender: s.Sender, } - MigrateProposalJsonReq struct { - WasmProposalJson - types.MigrateContractProposal +} +func (s MigrateProposalJsonReq) GetProposer() sdk.AccAddress { + return s.Proposer +} +func (s MigrateProposalJsonReq) GetDeposit() sdk.Coins { + return s.Deposit +} +func (s MigrateProposalJsonReq) GetBaseReq() rest.BaseReq { + return s.BaseReq +} +func MigrateProposalHandler(cliCtx context.CLIContext) govrest.ProposalRESTHandler { + return govrest.ProposalRESTHandler{ + SubRoute: "migrate", + Handler: func(w http.ResponseWriter, r *http.Request) { + var req MigrateProposalJsonReq + if !rest.ReadRESTReq(w, r, cliCtx.Codec, &req) { + return + } + toStdTxResponse(cliCtx, w, req) + }, } - UpdateAdminJsonReq struct { - WasmProposalJson - types.UpdateAdminProposal +} + +type UpdateAdminJsonReq struct { + BaseReq rest.BaseReq `json:"base_req" yaml:"base_req"` + + Title string `json:"title" yaml:"title"` + Description string `json:"description" yaml:"description"` + + Proposer sdk.AccAddress `json:"proposer" yaml:"proposer"` + Deposit sdk.Coins `json:"deposit" yaml:"deposit"` + + NewAdmin sdk.AccAddress `json:"new_admin" yaml:"new_admin"` + Contract sdk.AccAddress `json:"contract" yaml:"contract"` +} + +func (s UpdateAdminJsonReq) Content() gov.Content { + return types.UpdateAdminProposal{ + WasmProposal: types.WasmProposal{Title: s.Title, Description: s.Description}, + Contract: s.Contract, + NewAdmin: s.NewAdmin, } - ClearAdminJsonReq struct { - WasmProposalJson - types.ClearAdminProposal +} +func (s UpdateAdminJsonReq) GetProposer() sdk.AccAddress { + return s.Proposer +} +func (s UpdateAdminJsonReq) GetDeposit() sdk.Coins { + return s.Deposit +} +func (s UpdateAdminJsonReq) GetBaseReq() rest.BaseReq { + return s.BaseReq +} +func UpdateContractAdminProposalHandler(cliCtx context.CLIContext) govrest.ProposalRESTHandler { + return govrest.ProposalRESTHandler{ + SubRoute: "update-admin", + Handler: func(w http.ResponseWriter, r *http.Request) { + var req UpdateAdminJsonReq + if !rest.ReadRESTReq(w, r, cliCtx.Codec, &req) { + return + } + toStdTxResponse(cliCtx, w, req) + }, } -) +} -func (s StoreCodeProposalJsonReq) Content() gov.Content { - return s.StoreCodeProposal +type ClearAdminJsonReq struct { + BaseReq rest.BaseReq `json:"base_req" yaml:"base_req"` + + Title string `json:"title" yaml:"title"` + Description string `json:"description" yaml:"description"` + + Proposer sdk.AccAddress `json:"proposer" yaml:"proposer"` + Deposit sdk.Coins `json:"deposit" yaml:"deposit"` + + Contract sdk.AccAddress `json:"contract" yaml:"contract"` } -func (s InstantiateProposalJsonReq) Content() gov.Content { - return s.InstantiateContractProposal + +func (s ClearAdminJsonReq) Content() gov.Content { + return types.ClearAdminProposal{ + WasmProposal: types.WasmProposal{Title: s.Title, Description: s.Description}, + Contract: s.Contract, + } } -func (s MigrateProposalJsonReq) Content() gov.Content { - return s.MigrateContractProposal +func (s ClearAdminJsonReq) GetProposer() sdk.AccAddress { + return s.Proposer } -func (s UpdateAdminJsonReq) Content() gov.Content { - return s.UpdateAdminProposal +func (s ClearAdminJsonReq) GetDeposit() sdk.Coins { + return s.Deposit } -func (s ClearAdminJsonReq) Content() gov.Content { - return s.ClearAdminProposal +func (s ClearAdminJsonReq) GetBaseReq() rest.BaseReq { + return s.BaseReq +} +func ClearContractAdminProposalHandler(cliCtx context.CLIContext) govrest.ProposalRESTHandler { + return govrest.ProposalRESTHandler{ + SubRoute: "clear-admin", + Handler: func(w http.ResponseWriter, r *http.Request) { + var req ClearAdminJsonReq + if !rest.ReadRESTReq(w, r, cliCtx.Codec, &req) { + return + } + toStdTxResponse(cliCtx, w, req) + }, + } } -type wasmProposalContent interface { +type wasmProposalData interface { Content() gov.Content GetProposer() sdk.AccAddress GetDeposit() sdk.Coins GetBaseReq() rest.BaseReq } -func ProposalJsonHandler(route string, p wasmProposalContent) func(cliCtx context.CLIContext) govrest.ProposalRESTHandler { - t := reflect.TypeOf(p) - return func(cliCtx context.CLIContext) govrest.ProposalRESTHandler { - return govrest.ProposalRESTHandler{ - SubRoute: route, - Handler: func(w http.ResponseWriter, r *http.Request) { - - var req = reflect.New(t).Interface().(wasmProposalContent) - if !rest.ReadRESTReq(w, r, cliCtx.Codec, &req) { - return - } - - msg := govtypes.NewMsgSubmitProposal(req.Content(), req.GetDeposit(), req.GetProposer()) - if err := msg.ValidateBasic(); err != nil { - rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error()) - return - } - - utils.WriteGenerateStdTxResponse(w, cliCtx, req.GetBaseReq(), []sdk.Msg{msg}) - }, - } +func toStdTxResponse(cliCtx context.CLIContext, w http.ResponseWriter, data wasmProposalData) { + msg := gov.NewMsgSubmitProposal(data.Content(), data.GetDeposit(), data.GetProposer()) + if err := msg.ValidateBasic(); err != nil { + rest.WriteErrorResponse(w, http.StatusBadRequest, err.Error()) + return + } + baseReq := data.GetBaseReq().Sanitize() + if !baseReq.ValidateBasic(w) { + return } + utils.WriteGenerateStdTxResponse(w, cliCtx, baseReq, []sdk.Msg{msg}) } diff --git a/x/wasm/internal/keeper/testdata/genesis.json b/x/wasm/internal/keeper/testdata/genesis.json new file mode 100644 index 0000000000..08969c7dd2 --- /dev/null +++ b/x/wasm/internal/keeper/testdata/genesis.json @@ -0,0 +1,219 @@ +{ + "genesis_time": "2020-07-13T07:49:08.2945876Z", + "chain_id": "testing", + "consensus_params": { + "block": { + "max_bytes": "22020096", + "max_gas": "-1", + "time_iota_ms": "1000" + }, + "evidence": { + "max_age_num_blocks": "100000", + "max_age_duration": "172800000000000" + }, + "validator": { + "pub_key_types": [ + "ed25519" + ] + } + }, + "app_hash": "", + "app_state": { + "upgrade": {}, + "evidence": { + "params": { + "max_evidence_age": "120000000000" + }, + "evidence": [] + }, + "supply": { + "supply": [] + }, + "mint": { + "minter": { + "inflation": "0.130000000000000000", + "annual_provisions": "0.000000000000000000" + }, + "params": { + "mint_denom": "ustake", + "inflation_rate_change": "0.130000000000000000", + "inflation_max": "0.200000000000000000", + "inflation_min": "0.070000000000000000", + "goal_bonded": "0.670000000000000000", + "blocks_per_year": "6311520" + } + }, + "gov": { + "starting_proposal_id": "1", + "deposits": null, + "votes": null, + "proposals": null, + "deposit_params": { + "min_deposit": [ + { + "denom": "ustake", + "amount": "1" + } + ], + "max_deposit_period": "172800000000000" + }, + "voting_params": { + "voting_period": "60000000000", + "voting_period_desc": "1minute" + }, + "tally_params": { + "quorum": "0.000000000000000001", + "threshold": "0.000000000000000001", + "veto": "0.334000000000000000" + } + }, + "slashing": { + "params": { + "signed_blocks_window": "100", + "min_signed_per_window": "0.500000000000000000", + "downtime_jail_duration": "600000000000", + "slash_fraction_double_sign": "0.050000000000000000", + "slash_fraction_downtime": "0.010000000000000000" + }, + "signing_infos": {}, + "missed_blocks": {} + }, + "wasm": { + "params": { + "upload_access": { + "type": 3, + "address": "" + }, + "instantiate_default_permission": 3 + }, + "codes": null, + "contracts": null, + "sequences": null + }, + "bank": { + "send_enabled": true + }, + "distribution": { + "params": { + "community_tax": "0.020000000000000000", + "base_proposer_reward": "0.010000000000000000", + "bonus_proposer_reward": "0.040000000000000000", + "withdraw_addr_enabled": true + }, + "fee_pool": { + "community_pool": [] + }, + "delegator_withdraw_infos": [], + "previous_proposer": "", + "outstanding_rewards": [], + "validator_accumulated_commissions": [], + "validator_historical_rewards": [], + "validator_current_rewards": [], + "delegator_starting_infos": [], + "validator_slash_events": [] + }, + "crisis": { + "constant_fee": { + "denom": "ustake", + "amount": "1000" + } + }, + "genutil": { + "gentxs": [ + { + "type": "cosmos-sdk/StdTx", + "value": { + "msg": [ + { + "type": "cosmos-sdk/MsgCreateValidator", + "value": { + "description": { + "moniker": "testing", + "identity": "", + "website": "", + "security_contact": "", + "details": "" + }, + "commission": { + "rate": "0.100000000000000000", + "max_rate": "0.200000000000000000", + "max_change_rate": "0.010000000000000000" + }, + "min_self_delegation": "1", + "delegator_address": "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np", + "validator_address": "cosmosvaloper1ve557a5g9yw2g2z57js3pdmcvd5my6g88d76lj", + "pubkey": "cosmosvalconspub1zcjduepqddfln4tujr2p8actpgqz4h2xnls9y7tu9c9tu5lqkdglmdjalzuqah4neg", + "value": { + "denom": "ustake", + "amount": "250000000" + } + } + } + ], + "fee": { + "amount": [], + "gas": "200000" + }, + "signatures": [ + { + "pub_key": { + "type": "tendermint/PubKeySecp256k1", + "value": "A//cqZxkpH1re0VrHBtH308nb5t8K+Y/hF0GeRdRBmaJ" + }, + "signature": "5QEEIuUVQTEBMuAtOOHnnKo6rPsIbmfzUxUqRnDFERVqwVr1Kg+ex4f/UGIK0yrOAvOG8zDADwFP4yF8lw+o5g==" + } + ], + "memo": "836fc54e9cad58f4ed6420223ec6290f75342afa@172.17.0.2:26656" + } + } + ] + }, + "auth": { + "params": { + "max_memo_characters": "256", + "tx_sig_limit": "7", + "tx_size_cost_per_byte": "10", + "sig_verify_cost_ed25519": "590", + "sig_verify_cost_secp256k1": "1000" + }, + "accounts": [ + { + "type": "cosmos-sdk/Account", + "value": { + "address": "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np", + "coins": [ + { + "denom": "ucosm", + "amount": "1000000000" + }, + { + "denom": "ustake", + "amount": "1000000000" + } + ], + "public_key": "", + "account_number": 0, + "sequence": 0 + } + } + ] + }, + "params": null, + "staking": { + "params": { + "unbonding_time": "1814400000000000", + "max_validators": 100, + "max_entries": 7, + "historical_entries": 0, + "bond_denom": "ustake" + }, + "last_total_power": "0", + "last_validator_powers": null, + "validators": null, + "delegations": null, + "unbonding_delegations": null, + "redelegations": null, + "exported": false + } + } +} \ No newline at end of file diff --git a/x/wasm/internal/types/proposal.go b/x/wasm/internal/types/proposal.go index 1b662a7a88..773272d461 100644 --- a/x/wasm/internal/types/proposal.go +++ b/x/wasm/internal/types/proposal.go @@ -99,7 +99,7 @@ func (p StoreCodeProposal) ValidateBasic() error { return err } if err := sdk.VerifyAddressFormat(p.Creator); err != nil { - return err + return sdkerrors.Wrap(err, "creator") } if err := validateWasmCode(p.WASMByteCode); err != nil { From c8359eab2423299308bfb6e4758deb51500f070a Mon Sep 17 00:00:00 2001 From: Alex Peters Date: Mon, 13 Jul 2020 15:13:57 +0200 Subject: [PATCH 4/7] Fix json naming --- x/wasm/client/proposal_handler_test.go | 2 +- x/wasm/client/rest/gov.go | 10 +++++----- x/wasm/internal/types/proposal.go | 2 +- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/x/wasm/client/proposal_handler_test.go b/x/wasm/client/proposal_handler_test.go index 0c7f42d79b..40fca83f06 100644 --- a/x/wasm/client/proposal_handler_test.go +++ b/x/wasm/client/proposal_handler_test.go @@ -112,7 +112,7 @@ func TestGovRestHandlers(t *testing.T) { "title": "Test Proposal", "description": "My proposal", "type": "instantiate", - "sender": "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz", + "creator": "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz", "admin": "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz", "code_id": "1", "label": "https://example.com/", diff --git a/x/wasm/client/rest/gov.go b/x/wasm/client/rest/gov.go index cfb1749651..7f55e1a37e 100644 --- a/x/wasm/client/rest/gov.go +++ b/x/wasm/client/rest/gov.go @@ -16,10 +16,10 @@ import ( type StoreCodeProposalJsonReq struct { BaseReq rest.BaseReq `json:"base_req" yaml:"base_req"` - Title string `json:"title" yaml:"title"` - Description string `json:"description" yaml:"description"` - Proposer sdk.AccAddress `json:"proposer" yaml:"proposer"` - Deposit sdk.Coins `json:"deposit" yaml:"deposit"` + Title string `json:"title" yaml:"title"` + Description string `json:"description" yaml:"description"` + Proposer sdk.AccAddress `json:"proposer" yaml:"proposer"` + Deposit sdk.Coins `json:"deposit" yaml:"deposit"` Creator sdk.AccAddress `json:"creator" yaml:"creator"` // WASMByteCode can be raw or gzip compressed @@ -77,7 +77,7 @@ type InstantiateProposalJsonReq struct { Proposer sdk.AccAddress `json:"proposer" yaml:"proposer"` Deposit sdk.Coins `json:"deposit" yaml:"deposit"` - Creator sdk.AccAddress `json:"sender" yaml:"sender"` + Creator sdk.AccAddress `json:"creator" yaml:"creator"` // Admin is an optional address that can execute migrations Admin sdk.AccAddress `json:"admin,omitempty" yaml:"admin"` Code uint64 `json:"code_id" yaml:"code_id"` diff --git a/x/wasm/internal/types/proposal.go b/x/wasm/internal/types/proposal.go index 773272d461..4ef2fec67b 100644 --- a/x/wasm/internal/types/proposal.go +++ b/x/wasm/internal/types/proposal.go @@ -136,7 +136,7 @@ func (p StoreCodeProposal) String() string { type InstantiateContractProposal struct { WasmProposal // Creator is the address that pays the init funds - Creator sdk.AccAddress `json:"sender" yaml:"sender"` + Creator sdk.AccAddress `json:"creator" yaml:"creator"` // Admin is an optional address that can execute migrations Admin sdk.AccAddress `json:"admin,omitempty" yaml:"admin"` Code uint64 `json:"code_id" yaml:"code_id"` From 4b5ad8cbe90e3f6974636cb96824f9b86d48ed43 Mon Sep 17 00:00:00 2001 From: Alex Peters Date: Mon, 13 Jul 2020 16:27:21 +0200 Subject: [PATCH 5/7] Pretty print byte arrays in CLI --- x/wasm/internal/types/proposal.go | 94 +++++++++++++++++++------ x/wasm/internal/types/proposal_test.go | 95 ++++++++++++++++++++++++++ 2 files changed, 169 insertions(+), 20 deletions(-) diff --git a/x/wasm/internal/types/proposal.go b/x/wasm/internal/types/proposal.go index 4ef2fec67b..875fefb905 100644 --- a/x/wasm/internal/types/proposal.go +++ b/x/wasm/internal/types/proposal.go @@ -1,6 +1,7 @@ package types import ( + "encoding/base64" "encoding/json" "fmt" "strings" @@ -79,15 +80,15 @@ func (p WasmProposal) ValidateBasic() error { type StoreCodeProposal struct { WasmProposal // Creator is the address that "owns" the code object - Creator sdk.AccAddress `json:"creator" yaml:"creator"` + Creator sdk.AccAddress `json:"creator"` // WASMByteCode can be raw or gzip compressed - WASMByteCode []byte `json:"wasm_byte_code" yaml:"wasm_byte_code"` + WASMByteCode []byte `json:"wasm_byte_code"` // Source is a valid absolute HTTPS URI to the contract's source code, optional - Source string `json:"source" yaml:"source"` + Source string `json:"source"` // Builder is a valid docker image name with tag, optional - Builder string `json:"builder" yaml:"builder"` + Builder string `json:"builder"` // InstantiatePermission to apply on contract creation, optional - InstantiatePermission *AccessConfig `json:"instantiate_permission" yaml:"instantiate_permission"` + InstantiatePermission *AccessConfig `json:"instantiate_permission"` } // ProposalType returns the type @@ -133,16 +134,34 @@ func (p StoreCodeProposal) String() string { `, p.Title, p.Description, p.Creator, p.WASMByteCode, p.Source, p.Builder) } +func (p StoreCodeProposal) MarshalYAML() (interface{}, error) { + return struct { + WasmProposal `yaml:",inline"` + Creator sdk.AccAddress `yaml:"creator"` + WASMByteCode string `yaml:"wasm_byte_code"` + Source string `yaml:"source"` + Builder string `yaml:"builder"` + InstantiatePermission *AccessConfig `yaml:"instantiate_permission"` + }{ + WasmProposal: p.WasmProposal, + Creator: p.Creator, + WASMByteCode: base64.StdEncoding.EncodeToString(p.WASMByteCode), + Source: p.Source, + Builder: p.Builder, + InstantiatePermission: p.InstantiatePermission, + }, nil +} + type InstantiateContractProposal struct { WasmProposal // Creator is the address that pays the init funds - Creator sdk.AccAddress `json:"creator" yaml:"creator"` + Creator sdk.AccAddress `json:"creator"` // Admin is an optional address that can execute migrations - Admin sdk.AccAddress `json:"admin,omitempty" yaml:"admin"` - Code uint64 `json:"code_id" yaml:"code_id"` - Label string `json:"label" yaml:"label"` - InitMsg json.RawMessage `json:"init_msg" yaml:"init_msg"` - InitFunds sdk.Coins `json:"init_funds" yaml:"init_funds"` + Admin sdk.AccAddress `json:"admin,omitempty"` + Code uint64 `json:"code_id"` + Label string `json:"label"` + InitMsg json.RawMessage `json:"init_msg"` + InitFunds sdk.Coins `json:"init_funds"` } // ProposalType returns the type @@ -192,16 +211,35 @@ func (p InstantiateContractProposal) String() string { InitMsg: %q InitFunds: %s `, p.Title, p.Description, p.Creator, p.Admin, p.Code, p.Label, p.InitMsg, p.InitFunds) +} +func (p InstantiateContractProposal) MarshalYAML() (interface{}, error) { + return struct { + WasmProposal `yaml:",inline"` + Creator sdk.AccAddress `yaml:"creator"` + Admin sdk.AccAddress `yaml:"admin"` + Code uint64 `yaml:"code_id"` + Label string `yaml:"label"` + InitMsg string `yaml:"init_msg"` + InitFunds sdk.Coins `yaml:"init_funds"` + }{ + WasmProposal: p.WasmProposal, + Creator: p.Creator, + Admin: p.Admin, + Code: p.Code, + Label: p.Label, + InitMsg: string(p.InitMsg), + InitFunds: p.InitFunds, + }, nil } type MigrateContractProposal struct { - WasmProposal - Contract sdk.AccAddress `json:"contract" yaml:"contract"` - Code uint64 `json:"code_id" yaml:"code_id"` - MigrateMsg json.RawMessage `json:"msg" yaml:"msg"` + WasmProposal `yaml:",inline"` + Contract sdk.AccAddress `json:"contract"` + Code uint64 `json:"code_id"` + MigrateMsg json.RawMessage `json:"msg"` // Sender is the role that is passed to the contract's environment - Sender sdk.AccAddress `json:"sender" yaml:"sender"` + Sender sdk.AccAddress `json:"sender"` } // ProposalType returns the type @@ -236,10 +274,26 @@ func (p MigrateContractProposal) String() string { `, p.Title, p.Description, p.Contract, p.Code, p.Sender, p.MigrateMsg) } +func (p MigrateContractProposal) MarshalYAML() (interface{}, error) { + return struct { + WasmProposal `yaml:",inline"` + Contract sdk.AccAddress `yaml:"contract"` + Code uint64 `yaml:"code_id"` + MigrateMsg string `yaml:"msg"` + Sender sdk.AccAddress `yaml:"sender"` + }{ + WasmProposal: p.WasmProposal, + Contract: p.Contract, + Code: p.Code, + MigrateMsg: string(p.MigrateMsg), + Sender: p.Sender, + }, nil +} + type UpdateAdminProposal struct { - WasmProposal - NewAdmin sdk.AccAddress `json:"new_admin" yaml:"new_admin"` - Contract sdk.AccAddress `json:"contract" yaml:"contract"` + WasmProposal `yaml:",inline"` + NewAdmin sdk.AccAddress `json:"new_admin" yaml:"new_admin"` + Contract sdk.AccAddress `json:"contract" yaml:"contract"` } // ProposalType returns the type @@ -270,7 +324,7 @@ func (p UpdateAdminProposal) String() string { } type ClearAdminProposal struct { - WasmProposal + WasmProposal `yaml:",inline"` Contract sdk.AccAddress `json:"contract" yaml:"contract"` } diff --git a/x/wasm/internal/types/proposal_test.go b/x/wasm/internal/types/proposal_test.go index f4d844bc9e..df6713f3ff 100644 --- a/x/wasm/internal/types/proposal_test.go +++ b/x/wasm/internal/types/proposal_test.go @@ -10,6 +10,7 @@ import ( govtypes "github.com/cosmos/cosmos-sdk/x/gov/types" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + "gopkg.in/yaml.v2" ) func TestValidateWasmProposal(t *testing.T) { @@ -519,5 +520,99 @@ func TestProposalStrings(t *testing.T) { assert.Equal(t, spec.exp, spec.src.String()) }) } +} +func TestProposalYaml(t *testing.T) { + specs := map[string]struct { + src gov.Content + exp string + }{ + "store code": { + src: StoreCodeProposalFixture(func(p *StoreCodeProposal) { + p.WASMByteCode = []byte{01, 02, 03, 04, 05, 06, 07, 0x08, 0x09, 0x0a} + }), + exp: `title: Foo +description: Bar +creator: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du +wasm_byte_code: AQIDBAUGBwgJCg== +source: https://example.com/code +builder: foo/bar:latest +instantiate_permission: null +`, + }, + "instantiate contract": { + src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) { + p.InitFunds = sdk.Coins{{Denom: "foo", Amount: sdk.NewInt(1)}, {Denom: "bar", Amount: sdk.NewInt(2)}} + }), + exp: `title: Foo +description: Bar +creator: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du +admin: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du +code_id: 1 +label: testing +init_msg: '{"verifier":"cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du","beneficiary":"cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du"}' +init_funds: +- denom: foo + amount: "1" +- denom: bar + amount: "2" +`, + }, + "instantiate contract without funds": { + src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) { p.InitFunds = nil }), + exp: `title: Foo +description: Bar +creator: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du +admin: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du +code_id: 1 +label: testing +init_msg: '{"verifier":"cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du","beneficiary":"cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du"}' +init_funds: [] +`, + }, + "instantiate contract without admin": { + src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) { p.Admin = nil }), + exp: `title: Foo +description: Bar +creator: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du +admin: "" +code_id: 1 +label: testing +init_msg: '{"verifier":"cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du","beneficiary":"cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du"}' +init_funds: [] +`, + }, + "migrate contract": { + src: MigrateContractProposalFixture(), + exp: `title: Foo +description: Bar +contract: cosmos18vd8fpwxzck93qlwghaj6arh4p7c5n89uzcee5 +code_id: 1 +msg: '{"verifier":"cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du"}' +sender: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du +`, + }, + "update admin": { + src: UpdateAdminProposalFixture(), + exp: `title: Foo +description: Bar +new_admin: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du +contract: cosmos18vd8fpwxzck93qlwghaj6arh4p7c5n89uzcee5 +`, + }, + "clear admin": { + src: ClearAdminProposalFixture(), + exp: `title: Foo +description: Bar +contract: cosmos18vd8fpwxzck93qlwghaj6arh4p7c5n89uzcee5 +`, + }, + } + for msg, spec := range specs { + t.Run(msg, func(t *testing.T) { + v, err := yaml.Marshal(&spec.src) + require.NoError(t, err) + assert.Equal(t, spec.exp, string(v)) + }) + } } From 37b4e9bbc8d453d9f76cb303852fce507bbfb892 Mon Sep 17 00:00:00 2001 From: Alex Peters Date: Tue, 14 Jul 2020 10:18:09 +0200 Subject: [PATCH 6/7] Replace ambiguous cli flag and rest routes --- x/wasm/client/cli/gov_tx.go | 36 ++++++------- x/wasm/client/cli/tx.go | 5 +- x/wasm/client/proposal_handler_test.go | 24 ++++----- x/wasm/client/rest/gov.go | 24 ++++----- x/wasm/internal/keeper/proposal_handler.go | 16 +++--- .../keeper/proposal_integration_test.go | 6 +-- x/wasm/internal/types/proposal.go | 50 +++++++++---------- x/wasm/internal/types/proposal_test.go | 44 ++++++++-------- x/wasm/internal/types/test_fixtures.go | 6 +-- 9 files changed, 104 insertions(+), 107 deletions(-) diff --git a/x/wasm/client/cli/gov_tx.go b/x/wasm/client/cli/gov_tx.go index 8a947190be..3bc39174f1 100644 --- a/x/wasm/client/cli/gov_tx.go +++ b/x/wasm/client/cli/gov_tx.go @@ -19,7 +19,7 @@ import ( func ProposalStoreCodeCmd(cdc *codec.Codec) *cobra.Command { cmd := &cobra.Command{ - Use: "wasm-store [wasm file] --source [source] --builder [builder] --title [text] --description [text] --creator [address]", + Use: "wasm-store [wasm file] --source [source] --builder [builder] --title [text] --description [text] --run-as [address]", Short: "Submit a wasm binary proposal", Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { @@ -31,19 +31,19 @@ func ProposalStoreCodeCmd(cdc *codec.Codec) *cobra.Command { if err != nil { return err } - if len(viper.GetString(flagCreator)) == 0 { - return errors.New("creator address is required") + if len(viper.GetString(flagRunAs)) == 0 { + return errors.New("run-as address is required") } - creator, err := sdk.AccAddressFromBech32(viper.GetString(flagCreator)) + runAsAddr, err := sdk.AccAddressFromBech32(viper.GetString(flagRunAs)) if err != nil { - return errors.Wrap(err, "creator") + return errors.Wrap(err, "run-as") } content := types.StoreCodeProposal{ WasmProposal: types.WasmProposal{ Title: viper.GetString(cli.FlagTitle), Description: viper.GetString(cli.FlagDescription), }, - Creator: creator, + RunAs: runAsAddr, WASMByteCode: src.WASMByteCode, Source: src.Source, Builder: src.Builder, @@ -66,7 +66,7 @@ func ProposalStoreCodeCmd(cdc *codec.Codec) *cobra.Command { cmd.Flags().String(flagSource, "", "A valid URI reference to the contract's source code, optional") cmd.Flags().String(flagBuilder, "", "A valid docker tag for the build system, optional") - cmd.Flags().String(flagCreator, "", "The address that is stored as code creator") + cmd.Flags().String(flagRunAs, "", "The address that is stored as code creator") cmd.Flags().String(flagInstantiateByEverybody, "", "Everybody can instantiate a contract from the code, optional") cmd.Flags().String(flagInstantiateByAddress, "", "Only this address can instantiate a contract instance from the code, optional") @@ -82,7 +82,7 @@ func ProposalStoreCodeCmd(cdc *codec.Codec) *cobra.Command { func ProposalInstantiateContractCmd(cdc *codec.Codec) *cobra.Command { cmd := &cobra.Command{ - Use: "instantiate-contract [code_id_int64] [json_encoded_init_args] --label [text] --admin [address] --title [text] --description [text] --creator [address]", + Use: "instantiate-contract [code_id_int64] [json_encoded_init_args] --label [text] --admin [address] --title [text] --description [text] --run-as [address]", Short: "Submit an instantiate wasm contract proposal", Args: cobra.ExactArgs(2), RunE: func(cmd *cobra.Command, args []string) error { @@ -94,10 +94,10 @@ func ProposalInstantiateContractCmd(cdc *codec.Codec) *cobra.Command { if err != nil { return err } - if len(viper.GetString(flagCreator)) == 0 { + if len(viper.GetString(flagRunAs)) == 0 { return errors.New("creator address is required") } - creator, err := sdk.AccAddressFromBech32(viper.GetString(flagCreator)) + creator, err := sdk.AccAddressFromBech32(viper.GetString(flagRunAs)) if err != nil { return errors.Wrap(err, "creator") } @@ -106,7 +106,7 @@ func ProposalInstantiateContractCmd(cdc *codec.Codec) *cobra.Command { Title: viper.GetString(cli.FlagTitle), Description: viper.GetString(cli.FlagDescription), }, - Creator: creator, + RunAs: creator, Admin: src.Admin, Code: src.Code, Label: src.Label, @@ -130,7 +130,7 @@ func ProposalInstantiateContractCmd(cdc *codec.Codec) *cobra.Command { cmd.Flags().String(flagAmount, "", "Coins to send to the contract during instantiation") cmd.Flags().String(flagLabel, "", "A human-readable name for this contract in lists") cmd.Flags().String(flagAdmin, "", "Address of an admin") - cmd.Flags().String(flagCreator, "", "The address that is stored as code creator") + cmd.Flags().String(flagRunAs, "", "The address that pays the init funds. It is the creator of the contract and passed to the contract as sender on proposal execution") // proposal flags cmd.Flags().String(cli.FlagTitle, "", "Title of proposal") @@ -157,12 +157,12 @@ func ProposalMigrateContractCmd(cdc *codec.Codec) *cobra.Command { return err } - if len(viper.GetString(flagSender)) == 0 { - return errors.New("sender address is required") + if len(viper.GetString(flagRunAs)) == 0 { + return errors.New("run-as address is required") } - sender, err := sdk.AccAddressFromBech32(viper.GetString(flagSender)) + runAs, err := sdk.AccAddressFromBech32(viper.GetString(flagRunAs)) if err != nil { - return errors.Wrap(err, "sender") + return errors.Wrap(err, "run-as") } content := types.MigrateContractProposal{ @@ -173,7 +173,7 @@ func ProposalMigrateContractCmd(cdc *codec.Codec) *cobra.Command { Contract: src.Contract, Code: src.Code, MigrateMsg: src.MigrateMsg, - Sender: sender, + RunAs: runAs, } deposit, err := sdk.ParseCoins(viper.GetString(cli.FlagDeposit)) @@ -189,7 +189,7 @@ func ProposalMigrateContractCmd(cdc *codec.Codec) *cobra.Command { return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg}) }, } - cmd.Flags().String(flagSender, "", "The address that is passed as sender to the contract") + cmd.Flags().String(flagRunAs, "", "The address that is passed as sender to the contract on proposal execution") // proposal flags cmd.Flags().String(cli.FlagTitle, "", "Title of proposal") diff --git a/x/wasm/client/cli/tx.go b/x/wasm/client/cli/tx.go index b1aa00ba4a..902814a6d3 100644 --- a/x/wasm/client/cli/tx.go +++ b/x/wasm/client/cli/tx.go @@ -23,15 +23,12 @@ import ( ) const ( - flagTo = "to" flagAmount = "amount" flagSource = "source" flagBuilder = "builder" flagLabel = "label" flagAdmin = "admin" - flagNoAdmin = "no-admin" - flagCreator = "creator" - flagSender = "sender" + flagRunAs = "run-as" flagInstantiateByEverybody = "instantiate-everybody" flagInstantiateByAddress = "instantiate-only-address" flagProposalType = "type" diff --git a/x/wasm/client/proposal_handler_test.go b/x/wasm/client/proposal_handler_test.go index 40fca83f06..c3222c072b 100644 --- a/x/wasm/client/proposal_handler_test.go +++ b/x/wasm/client/proposal_handler_test.go @@ -47,12 +47,12 @@ func TestGovRestHandlers(t *testing.T) { expCode int }{ "store-code": { - srcPath: "/gov/proposals/store-code", + srcPath: "/gov/proposals/wasm_store_code", srcBody: dict{ "title": "Test Proposal", "description": "My proposal", "type": "store-code", - "creator": "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz", + "run_as": "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz", "wasm_byte_code": "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", "source": "https://example.com/", "builder": "my/builder:tag", @@ -67,12 +67,12 @@ func TestGovRestHandlers(t *testing.T) { expCode: http.StatusOK, }, "store-code with incomplete proposal data: blank title": { - srcPath: "/gov/proposals/store-code", + srcPath: "/gov/proposals/wasm_store_code", srcBody: dict{ "title": "", "description": "My proposal", "type": "store-code", - "creator": "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz", + "run_as": "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz", "wasm_byte_code": "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", "source": "https://example.com/", "builder": "my/builder:tag", @@ -87,12 +87,12 @@ func TestGovRestHandlers(t *testing.T) { expCode: http.StatusBadRequest, }, "store-code with incomplete content data: no wasm_byte_code": { - srcPath: "/gov/proposals/store-code", + srcPath: "/gov/proposals/wasm_store_code", srcBody: dict{ "title": "Test Proposal", "description": "My proposal", "type": "store-code", - "creator": "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz", + "run_as": "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz", "wasm_byte_code": "", "source": "https://example.com/", "builder": "my/builder:tag", @@ -107,12 +107,12 @@ func TestGovRestHandlers(t *testing.T) { expCode: http.StatusBadRequest, }, "instantiate contract": { - srcPath: "/gov/proposals/instantiate", + srcPath: "/gov/proposals/wasm_instantiate", srcBody: dict{ "title": "Test Proposal", "description": "My proposal", "type": "instantiate", - "creator": "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz", + "run_as": "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz", "admin": "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz", "code_id": "1", "label": "https://example.com/", @@ -125,7 +125,7 @@ func TestGovRestHandlers(t *testing.T) { expCode: http.StatusOK, }, "migrate contract": { - srcPath: "/gov/proposals/migrate", + srcPath: "/gov/proposals/wasm_migrate", srcBody: dict{ "title": "Test Proposal", "description": "My proposal", @@ -133,7 +133,7 @@ func TestGovRestHandlers(t *testing.T) { "contract": "cosmos18vd8fpwxzck93qlwghaj6arh4p7c5n89uzcee5", "code_id": "1", "msg": dict{"foo": "bar"}, - "sender": "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz", + "run_as": "cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz", "deposit": []dict{{"denom": "ustake", "amount": "10"}}, "proposer": "cosmos1ve557a5g9yw2g2z57js3pdmcvd5my6g8ze20np", "base_req": aBaseReq, @@ -141,7 +141,7 @@ func TestGovRestHandlers(t *testing.T) { expCode: http.StatusOK, }, "update contract admin": { - srcPath: "/gov/proposals/update-admin", + srcPath: "/gov/proposals/wasm_update_admin", srcBody: dict{ "title": "Test Proposal", "description": "My proposal", @@ -155,7 +155,7 @@ func TestGovRestHandlers(t *testing.T) { expCode: http.StatusOK, }, "clear contract admin": { - srcPath: "/gov/proposals/clear-admin", + srcPath: "/gov/proposals/wasm_clear_admin", srcBody: dict{ "title": "Test Proposal", "description": "My proposal", diff --git a/x/wasm/client/rest/gov.go b/x/wasm/client/rest/gov.go index 7f55e1a37e..41e0037df7 100644 --- a/x/wasm/client/rest/gov.go +++ b/x/wasm/client/rest/gov.go @@ -21,7 +21,7 @@ type StoreCodeProposalJsonReq struct { Proposer sdk.AccAddress `json:"proposer" yaml:"proposer"` Deposit sdk.Coins `json:"deposit" yaml:"deposit"` - Creator sdk.AccAddress `json:"creator" yaml:"creator"` + RunAs sdk.AccAddress `json:"run_as" yaml:"run_as"` // WASMByteCode can be raw or gzip compressed WASMByteCode []byte `json:"wasm_byte_code" yaml:"wasm_byte_code"` // Source is a valid absolute HTTPS URI to the contract's source code, optional @@ -38,7 +38,7 @@ func (s StoreCodeProposalJsonReq) Content() gov.Content { Title: s.Title, Description: s.Description, }, - Creator: s.Creator, + RunAs: s.RunAs, WASMByteCode: s.WASMByteCode, Source: s.Source, Builder: s.Builder, @@ -57,7 +57,7 @@ func (s StoreCodeProposalJsonReq) GetBaseReq() rest.BaseReq { func StoreCodeProposalHandler(cliCtx context.CLIContext) govrest.ProposalRESTHandler { return govrest.ProposalRESTHandler{ - SubRoute: "store-code", + SubRoute: "wasm_store_code", Handler: func(w http.ResponseWriter, r *http.Request) { var req StoreCodeProposalJsonReq if !rest.ReadRESTReq(w, r, cliCtx.Codec, &req) { @@ -77,7 +77,7 @@ type InstantiateProposalJsonReq struct { Proposer sdk.AccAddress `json:"proposer" yaml:"proposer"` Deposit sdk.Coins `json:"deposit" yaml:"deposit"` - Creator sdk.AccAddress `json:"creator" yaml:"creator"` + RunAs sdk.AccAddress `json:"run_as" yaml:"run_as"` // Admin is an optional address that can execute migrations Admin sdk.AccAddress `json:"admin,omitempty" yaml:"admin"` Code uint64 `json:"code_id" yaml:"code_id"` @@ -89,7 +89,7 @@ type InstantiateProposalJsonReq struct { func (s InstantiateProposalJsonReq) Content() gov.Content { return types.InstantiateContractProposal{ WasmProposal: types.WasmProposal{Title: s.Title, Description: s.Description}, - Creator: s.Creator, + RunAs: s.RunAs, Admin: s.Admin, Code: s.Code, Label: s.Label, @@ -109,7 +109,7 @@ func (s InstantiateProposalJsonReq) GetBaseReq() rest.BaseReq { func InstantiateProposalHandler(cliCtx context.CLIContext) govrest.ProposalRESTHandler { return govrest.ProposalRESTHandler{ - SubRoute: "instantiate", + SubRoute: "wasm_instantiate", Handler: func(w http.ResponseWriter, r *http.Request) { var req InstantiateProposalJsonReq if !rest.ReadRESTReq(w, r, cliCtx.Codec, &req) { @@ -132,8 +132,8 @@ type MigrateProposalJsonReq struct { Contract sdk.AccAddress `json:"contract" yaml:"contract"` Code uint64 `json:"code_id" yaml:"code_id"` MigrateMsg json.RawMessage `json:"msg" yaml:"msg"` - // Sender is the role that is passed to the contract's environment - Sender sdk.AccAddress `json:"sender" yaml:"sender"` + // RunAs is the role that is passed to the contract's environment + RunAs sdk.AccAddress `json:"run_as" yaml:"run_as"` } func (s MigrateProposalJsonReq) Content() gov.Content { @@ -142,7 +142,7 @@ func (s MigrateProposalJsonReq) Content() gov.Content { Contract: s.Contract, Code: s.Code, MigrateMsg: s.MigrateMsg, - Sender: s.Sender, + RunAs: s.RunAs, } } func (s MigrateProposalJsonReq) GetProposer() sdk.AccAddress { @@ -156,7 +156,7 @@ func (s MigrateProposalJsonReq) GetBaseReq() rest.BaseReq { } func MigrateProposalHandler(cliCtx context.CLIContext) govrest.ProposalRESTHandler { return govrest.ProposalRESTHandler{ - SubRoute: "migrate", + SubRoute: "wasm_migrate", Handler: func(w http.ResponseWriter, r *http.Request) { var req MigrateProposalJsonReq if !rest.ReadRESTReq(w, r, cliCtx.Codec, &req) { @@ -198,7 +198,7 @@ func (s UpdateAdminJsonReq) GetBaseReq() rest.BaseReq { } func UpdateContractAdminProposalHandler(cliCtx context.CLIContext) govrest.ProposalRESTHandler { return govrest.ProposalRESTHandler{ - SubRoute: "update-admin", + SubRoute: "wasm_update_admin", Handler: func(w http.ResponseWriter, r *http.Request) { var req UpdateAdminJsonReq if !rest.ReadRESTReq(w, r, cliCtx.Codec, &req) { @@ -238,7 +238,7 @@ func (s ClearAdminJsonReq) GetBaseReq() rest.BaseReq { } func ClearContractAdminProposalHandler(cliCtx context.CLIContext) govrest.ProposalRESTHandler { return govrest.ProposalRESTHandler{ - SubRoute: "clear-admin", + SubRoute: "wasm_clear_admin", Handler: func(w http.ResponseWriter, r *http.Request) { var req ClearAdminJsonReq if !rest.ReadRESTReq(w, r, cliCtx.Codec, &req) { diff --git a/x/wasm/internal/keeper/proposal_handler.go b/x/wasm/internal/keeper/proposal_handler.go index 78b463553c..83991a2f01 100644 --- a/x/wasm/internal/keeper/proposal_handler.go +++ b/x/wasm/internal/keeper/proposal_handler.go @@ -47,7 +47,7 @@ func handleStoreCodeProposal(ctx sdk.Context, k Keeper, p types.StoreCodeProposa return err } - codeID, err := k.create(ctx, p.Creator, p.WASMByteCode, p.Source, p.Builder, p.InstantiatePermission, GovAuthorizationPolicy{}) + codeID, err := k.create(ctx, p.RunAs, p.WASMByteCode, p.Source, p.Builder, p.InstantiatePermission, GovAuthorizationPolicy{}) if err != nil { return err } @@ -55,7 +55,7 @@ func handleStoreCodeProposal(ctx sdk.Context, k Keeper, p types.StoreCodeProposa ourEvent := sdk.NewEvent( sdk.EventTypeMessage, sdk.NewAttribute(sdk.AttributeKeyModule, types.ModuleName), - //sdk.NewAttribute(AttributeSigner, p.Creator.String()), // todo: creator is not signer. rename attribute? + //sdk.NewAttribute(AttributeSigner, p.RunAs.String()), // todo: creator is not signer. rename attribute? sdk.NewAttribute(AttributeKeyCodeID, fmt.Sprintf("%d", codeID)), ) ctx.EventManager().EmitEvent(ourEvent) @@ -67,7 +67,7 @@ func handleInstantiateProposal(ctx sdk.Context, k Keeper, p types.InstantiateCon return err } - contractAddr, err := k.instantiate(ctx, p.Code, p.Creator, p.Admin, p.InitMsg, p.Label, p.InitFunds, GovAuthorizationPolicy{}) + contractAddr, err := k.instantiate(ctx, p.Code, p.RunAs, p.Admin, p.InitMsg, p.Label, p.InitFunds, GovAuthorizationPolicy{}) if err != nil { return err } @@ -75,7 +75,7 @@ func handleInstantiateProposal(ctx sdk.Context, k Keeper, p types.InstantiateCon ourEvent := sdk.NewEvent( sdk.EventTypeMessage, sdk.NewAttribute(sdk.AttributeKeyModule, types.ModuleName), - //sdk.NewAttribute(AttributeSigner, p.Creator.String()), + //sdk.NewAttribute(AttributeSigner, p.RunAs.String()), sdk.NewAttribute(AttributeKeyCodeID, fmt.Sprintf("%d", p.Code)), sdk.NewAttribute(AttributeKeyContract, contractAddr.String()), ) @@ -88,7 +88,7 @@ func handleMigrateProposal(ctx sdk.Context, k Keeper, p types.MigrateContractPro return err } - res, err := k.migrate(ctx, p.Contract, p.Sender, p.Code, p.MigrateMsg, GovAuthorizationPolicy{}) + res, err := k.migrate(ctx, p.Contract, p.RunAs, p.Code, p.MigrateMsg, GovAuthorizationPolicy{}) if err != nil { return err } @@ -96,7 +96,7 @@ func handleMigrateProposal(ctx sdk.Context, k Keeper, p types.MigrateContractPro ourEvent := sdk.NewEvent( sdk.EventTypeMessage, sdk.NewAttribute(sdk.AttributeKeyModule, types.ModuleName), - //sdk.NewAttribute(AttributeSigner, p.Creator.String()), + //sdk.NewAttribute(AttributeSigner, p.RunAs.String()), sdk.NewAttribute(AttributeKeyContract, p.Contract.String()), ) ctx.EventManager().EmitEvents(append(res.Events, ourEvent)) @@ -115,7 +115,7 @@ func handleUpdateAdminProposal(ctx sdk.Context, k Keeper, p types.UpdateAdminPro ourEvent := sdk.NewEvent( sdk.EventTypeMessage, sdk.NewAttribute(sdk.AttributeKeyModule, types.ModuleName), - //sdk.NewAttribute(AttributeSigner, p.Creator.String()), + //sdk.NewAttribute(AttributeSigner, p.RunAs.String()), sdk.NewAttribute(AttributeKeyContract, p.Contract.String()), ) ctx.EventManager().EmitEvent(ourEvent) @@ -133,7 +133,7 @@ func handleClearAdminProposal(ctx sdk.Context, k Keeper, p types.ClearAdminPropo ourEvent := sdk.NewEvent( sdk.EventTypeMessage, sdk.NewAttribute(sdk.AttributeKeyModule, types.ModuleName), - //sdk.NewAttribute(AttributeSigner, p.Creator.String()), + //sdk.NewAttribute(AttributeSigner, p.RunAs.String()), sdk.NewAttribute(AttributeKeyContract, p.Contract.String()), ) ctx.EventManager().EmitEvent(ourEvent) diff --git a/x/wasm/internal/keeper/proposal_integration_test.go b/x/wasm/internal/keeper/proposal_integration_test.go index 41d795de9a..9feee2dc73 100644 --- a/x/wasm/internal/keeper/proposal_integration_test.go +++ b/x/wasm/internal/keeper/proposal_integration_test.go @@ -30,7 +30,7 @@ func TestStoreCodeProposal(t *testing.T) { var anyAddress sdk.AccAddress = make([]byte, sdk.AddrLen) src := types.StoreCodeProposalFixture(func(p *types.StoreCodeProposal) { - p.Creator = anyAddress + p.RunAs = anyAddress p.WASMByteCode = wasmCode p.Source = "https://example.com/mysource" p.Builder = "foo/bar:v0.0.0" @@ -80,7 +80,7 @@ func TestInstantiateProposal(t *testing.T) { ) src := types.InstantiateContractProposalFixture(func(p *types.InstantiateContractProposal) { p.Code = 1 - p.Creator = oneAddress + p.RunAs = oneAddress p.Admin = otherAddress p.Label = "testing" }) @@ -152,7 +152,7 @@ func TestMigrateProposal(t *testing.T) { Code: 2, Contract: contractAddr, MigrateMsg: migMsgBz, - Sender: otherAddress, + RunAs: otherAddress, } // when stored diff --git a/x/wasm/internal/types/proposal.go b/x/wasm/internal/types/proposal.go index 875fefb905..090fc4fa3f 100644 --- a/x/wasm/internal/types/proposal.go +++ b/x/wasm/internal/types/proposal.go @@ -79,8 +79,8 @@ func (p WasmProposal) ValidateBasic() error { type StoreCodeProposal struct { WasmProposal - // Creator is the address that "owns" the code object - Creator sdk.AccAddress `json:"creator"` + // RunAs is the address that "owns" the code object + RunAs sdk.AccAddress `json:"run_as"` // WASMByteCode can be raw or gzip compressed WASMByteCode []byte `json:"wasm_byte_code"` // Source is a valid absolute HTTPS URI to the contract's source code, optional @@ -99,8 +99,8 @@ func (p StoreCodeProposal) ValidateBasic() error { if err := p.WasmProposal.ValidateBasic(); err != nil { return err } - if err := sdk.VerifyAddressFormat(p.Creator); err != nil { - return sdkerrors.Wrap(err, "creator") + if err := sdk.VerifyAddressFormat(p.RunAs); err != nil { + return sdkerrors.Wrap(err, "run as") } if err := validateWasmCode(p.WASMByteCode); err != nil { @@ -127,24 +127,24 @@ func (p StoreCodeProposal) String() string { return fmt.Sprintf(`Store Code Proposal: Title: %s Description: %s - Creator: %s + Run as: %s WasmCode: %X Source: %s Builder: %s -`, p.Title, p.Description, p.Creator, p.WASMByteCode, p.Source, p.Builder) +`, p.Title, p.Description, p.RunAs, p.WASMByteCode, p.Source, p.Builder) } func (p StoreCodeProposal) MarshalYAML() (interface{}, error) { return struct { WasmProposal `yaml:",inline"` - Creator sdk.AccAddress `yaml:"creator"` + RunAs sdk.AccAddress `yaml:"run_as"` WASMByteCode string `yaml:"wasm_byte_code"` Source string `yaml:"source"` Builder string `yaml:"builder"` InstantiatePermission *AccessConfig `yaml:"instantiate_permission"` }{ WasmProposal: p.WasmProposal, - Creator: p.Creator, + RunAs: p.RunAs, WASMByteCode: base64.StdEncoding.EncodeToString(p.WASMByteCode), Source: p.Source, Builder: p.Builder, @@ -154,8 +154,8 @@ func (p StoreCodeProposal) MarshalYAML() (interface{}, error) { type InstantiateContractProposal struct { WasmProposal - // Creator is the address that pays the init funds - Creator sdk.AccAddress `json:"creator"` + // RunAs is the address that pays the init funds + RunAs sdk.AccAddress `json:"run_as"` // Admin is an optional address that can execute migrations Admin sdk.AccAddress `json:"admin,omitempty"` Code uint64 `json:"code_id"` @@ -174,12 +174,12 @@ func (p InstantiateContractProposal) ValidateBasic() error { if err := p.WasmProposal.ValidateBasic(); err != nil { return err } - if err := sdk.VerifyAddressFormat(p.Creator); err != nil { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "creator is required") + if err := sdk.VerifyAddressFormat(p.RunAs); err != nil { + return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "run as") } if p.Code == 0 { - return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "code_id is required") + return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "code id is required") } if err := validateLabel(p.Label); err != nil { @@ -204,19 +204,19 @@ func (p InstantiateContractProposal) String() string { return fmt.Sprintf(`Instantiate Code Proposal: Title: %s Description: %s - Creator: %s + Run as: %s Admin: %s Code id: %d Label: %s InitMsg: %q InitFunds: %s -`, p.Title, p.Description, p.Creator, p.Admin, p.Code, p.Label, p.InitMsg, p.InitFunds) +`, p.Title, p.Description, p.RunAs, p.Admin, p.Code, p.Label, p.InitMsg, p.InitFunds) } func (p InstantiateContractProposal) MarshalYAML() (interface{}, error) { return struct { WasmProposal `yaml:",inline"` - Creator sdk.AccAddress `yaml:"creator"` + RunAs sdk.AccAddress `yaml:"run_as"` Admin sdk.AccAddress `yaml:"admin"` Code uint64 `yaml:"code_id"` Label string `yaml:"label"` @@ -224,7 +224,7 @@ func (p InstantiateContractProposal) MarshalYAML() (interface{}, error) { InitFunds sdk.Coins `yaml:"init_funds"` }{ WasmProposal: p.WasmProposal, - Creator: p.Creator, + RunAs: p.RunAs, Admin: p.Admin, Code: p.Code, Label: p.Label, @@ -238,8 +238,8 @@ type MigrateContractProposal struct { Contract sdk.AccAddress `json:"contract"` Code uint64 `json:"code_id"` MigrateMsg json.RawMessage `json:"msg"` - // Sender is the role that is passed to the contract's environment - Sender sdk.AccAddress `json:"sender"` + // RunAs is the address that is passed to the contract's environment as sender + RunAs sdk.AccAddress `json:"run_as"` } // ProposalType returns the type @@ -256,8 +256,8 @@ func (p MigrateContractProposal) ValidateBasic() error { if err := sdk.VerifyAddressFormat(p.Contract); err != nil { return sdkerrors.Wrap(err, "contract") } - if err := sdk.VerifyAddressFormat(p.Sender); err != nil { - return sdkerrors.Wrap(err, "sender") + if err := sdk.VerifyAddressFormat(p.RunAs); err != nil { + return sdkerrors.Wrap(err, "run as") } return nil } @@ -269,9 +269,9 @@ func (p MigrateContractProposal) String() string { Description: %s Contract: %s Code id: %d - Sender: %s + Run as: %s MigrateMsg %q -`, p.Title, p.Description, p.Contract, p.Code, p.Sender, p.MigrateMsg) +`, p.Title, p.Description, p.Contract, p.Code, p.RunAs, p.MigrateMsg) } func (p MigrateContractProposal) MarshalYAML() (interface{}, error) { @@ -280,13 +280,13 @@ func (p MigrateContractProposal) MarshalYAML() (interface{}, error) { Contract sdk.AccAddress `yaml:"contract"` Code uint64 `yaml:"code_id"` MigrateMsg string `yaml:"msg"` - Sender sdk.AccAddress `yaml:"sender"` + RunAs sdk.AccAddress `yaml:"run_as"` }{ WasmProposal: p.WasmProposal, Contract: p.Contract, Code: p.Code, MigrateMsg: string(p.MigrateMsg), - Sender: p.Sender, + RunAs: p.RunAs, }, nil } diff --git a/x/wasm/internal/types/proposal_test.go b/x/wasm/internal/types/proposal_test.go index df6713f3ff..151e4ac8d5 100644 --- a/x/wasm/internal/types/proposal_test.go +++ b/x/wasm/internal/types/proposal_test.go @@ -120,15 +120,15 @@ func TestValidateStoreCodeProposal(t *testing.T) { }), expErr: true, }, - "creator missing": { + "run_as missing": { src: StoreCodeProposalFixture(func(p *StoreCodeProposal) { - p.Creator = nil + p.RunAs = nil }), expErr: true, }, - "creator invalid": { + "run_as invalid": { src: StoreCodeProposalFixture(func(p *StoreCodeProposal) { - p.Creator = invalidAddress + p.RunAs = invalidAddress }), expErr: true, }, @@ -208,15 +208,15 @@ func TestValidateInstantiateContractProposal(t *testing.T) { }), expErr: true, }, - "creator missing": { + "run_as missing": { src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) { - p.Creator = nil + p.RunAs = nil }), expErr: true, }, - "creator invalid": { + "run_as invalid": { src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) { - p.Creator = invalidAddress + p.RunAs = invalidAddress }), expErr: true, }, @@ -304,15 +304,15 @@ func TestValidateMigrateContractProposal(t *testing.T) { }), expErr: true, }, - "sender missing": { + "run_as missing": { src: MigrateContractProposalFixture(func(p *MigrateContractProposal) { - p.Sender = nil + p.RunAs = nil }), expErr: true, }, - "sender invalid": { + "run_as invalid": { src: MigrateContractProposalFixture(func(p *MigrateContractProposal) { - p.Sender = invalidAddress + p.RunAs = invalidAddress }), expErr: true, }, @@ -439,7 +439,7 @@ func TestProposalStrings(t *testing.T) { exp: `Store Code Proposal: Title: Foo Description: Bar - Creator: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du + Run as: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du WasmCode: 0102030405060708090A Source: https://example.com/code Builder: foo/bar:latest @@ -452,7 +452,7 @@ func TestProposalStrings(t *testing.T) { exp: `Instantiate Code Proposal: Title: Foo Description: Bar - Creator: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du + Run as: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du Admin: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du Code id: 1 Label: testing @@ -465,7 +465,7 @@ func TestProposalStrings(t *testing.T) { exp: `Instantiate Code Proposal: Title: Foo Description: Bar - Creator: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du + Run as: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du Admin: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du Code id: 1 Label: testing @@ -478,7 +478,7 @@ func TestProposalStrings(t *testing.T) { exp: `Instantiate Code Proposal: Title: Foo Description: Bar - Creator: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du + Run as: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du Admin: Code id: 1 Label: testing @@ -493,7 +493,7 @@ func TestProposalStrings(t *testing.T) { Description: Bar Contract: cosmos18vd8fpwxzck93qlwghaj6arh4p7c5n89uzcee5 Code id: 1 - Sender: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du + Run as: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du MigrateMsg "{\"verifier\":\"cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du\"}" `, }, @@ -533,7 +533,7 @@ func TestProposalYaml(t *testing.T) { }), exp: `title: Foo description: Bar -creator: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du +run_as: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du wasm_byte_code: AQIDBAUGBwgJCg== source: https://example.com/code builder: foo/bar:latest @@ -546,7 +546,7 @@ instantiate_permission: null }), exp: `title: Foo description: Bar -creator: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du +run_as: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du admin: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du code_id: 1 label: testing @@ -562,7 +562,7 @@ init_funds: src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) { p.InitFunds = nil }), exp: `title: Foo description: Bar -creator: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du +run_as: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du admin: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du code_id: 1 label: testing @@ -574,7 +574,7 @@ init_funds: [] src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) { p.Admin = nil }), exp: `title: Foo description: Bar -creator: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du +run_as: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du admin: "" code_id: 1 label: testing @@ -589,7 +589,7 @@ description: Bar contract: cosmos18vd8fpwxzck93qlwghaj6arh4p7c5n89uzcee5 code_id: 1 msg: '{"verifier":"cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du"}' -sender: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du +run_as: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpjnp7du `, }, "update admin": { diff --git a/x/wasm/internal/types/test_fixtures.go b/x/wasm/internal/types/test_fixtures.go index 40651e1e36..555147377e 100644 --- a/x/wasm/internal/types/test_fixtures.go +++ b/x/wasm/internal/types/test_fixtures.go @@ -119,7 +119,7 @@ func StoreCodeProposalFixture(mutators ...func(*StoreCodeProposal)) StoreCodePro Title: "Foo", Description: "Bar", }, - Creator: anyValidAddress, + RunAs: anyValidAddress, WASMByteCode: []byte{0x0}, Source: "https://example.com/code", Builder: "foo/bar:latest", @@ -152,7 +152,7 @@ func InstantiateContractProposalFixture(mutators ...func(p *InstantiateContractP Title: "Foo", Description: "Bar", }, - Creator: anyValidAddress, + RunAs: anyValidAddress, Admin: anyValidAddress, Code: 1, Label: "testing", @@ -192,7 +192,7 @@ func MigrateContractProposalFixture(mutators ...func(p *MigrateContractProposal) Contract: contractAddr, Code: 1, MigrateMsg: migMsgBz, - Sender: anyValidAddress, + RunAs: anyValidAddress, } for _, m := range mutators { From 3bd01feec253e65201fa0946fb28e5244c8122c8 Mon Sep 17 00:00:00 2001 From: Alex Peters Date: Tue, 14 Jul 2020 11:33:05 +0200 Subject: [PATCH 7/7] Minor cli usage doc update --- x/wasm/client/cli/gov_tx.go | 2 +- x/wasm/client/cli/tx.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/x/wasm/client/cli/gov_tx.go b/x/wasm/client/cli/gov_tx.go index 3bc39174f1..cb315e4ce4 100644 --- a/x/wasm/client/cli/gov_tx.go +++ b/x/wasm/client/cli/gov_tx.go @@ -82,7 +82,7 @@ func ProposalStoreCodeCmd(cdc *codec.Codec) *cobra.Command { func ProposalInstantiateContractCmd(cdc *codec.Codec) *cobra.Command { cmd := &cobra.Command{ - Use: "instantiate-contract [code_id_int64] [json_encoded_init_args] --label [text] --admin [address] --title [text] --description [text] --run-as [address]", + Use: "instantiate-contract [code_id_int64] [json_encoded_init_args] --label [text] --title [text] --description [text] --run-as [address] --admin [address,optional] --amount [coins,optional]", Short: "Submit an instantiate wasm contract proposal", Args: cobra.ExactArgs(2), RunE: func(cmd *cobra.Command, args []string) error { diff --git a/x/wasm/client/cli/tx.go b/x/wasm/client/cli/tx.go index 902814a6d3..d6c93ed8dc 100644 --- a/x/wasm/client/cli/tx.go +++ b/x/wasm/client/cli/tx.go @@ -128,7 +128,7 @@ func parseStoreCodeArgs(args []string, cliCtx context.CLIContext) (types.MsgStor // InstantiateContractCmd will instantiate a contract from previously uploaded code. func InstantiateContractCmd(cdc *codec.Codec) *cobra.Command { cmd := &cobra.Command{ - Use: "instantiate [code_id_int64] [json_encoded_init_args] --label [text] --admin [address]", + Use: "instantiate [code_id_int64] [json_encoded_init_args] --label [text] --admin [address,optional] --amount [coins,optional]", Short: "Instantiate a wasm contract", Args: cobra.ExactArgs(2), RunE: func(cmd *cobra.Command, args []string) error {