From 19c17cbf15785e0d96b8fe10e1e236065f27df41 Mon Sep 17 00:00:00 2001 From: pinosu <95283998+pinosu@users.noreply.github.com> Date: Wed, 19 Jul 2023 18:00:16 +0200 Subject: [PATCH] Add/Remove addresses for code upload params (#1493) * Start implementation * Add tests * Add fix * Fix comments * Minor chore (#1522) * Minor chore * Remove duplicate tests --------- Co-authored-by: Alexander Peters --- docs/proto/proto-docs.md | 62 ++ proto/cosmwasm/wasm/v1/tx.proto | 44 +- x/wasm/client/cli/gov_tx.go | 86 ++ x/wasm/keeper/msg_server.go | 75 ++ x/wasm/keeper/msg_server_integration_test.go | 192 ++++ x/wasm/types/codec.go | 4 + x/wasm/types/tx.go | 78 ++ x/wasm/types/tx.pb.go | 979 +++++++++++++++++-- x/wasm/types/tx_test.go | 174 +++- 9 files changed, 1561 insertions(+), 133 deletions(-) diff --git a/docs/proto/proto-docs.md b/docs/proto/proto-docs.md index 9c0cccb887..d460d66b6d 100644 --- a/docs/proto/proto-docs.md +++ b/docs/proto/proto-docs.md @@ -82,6 +82,8 @@ - [Query](#cosmwasm.wasm.v1.Query) - [cosmwasm/wasm/v1/tx.proto](#cosmwasm/wasm/v1/tx.proto) + - [MsgAddCodeUploadParamsAddresses](#cosmwasm.wasm.v1.MsgAddCodeUploadParamsAddresses) + - [MsgAddCodeUploadParamsAddressesResponse](#cosmwasm.wasm.v1.MsgAddCodeUploadParamsAddressesResponse) - [MsgClearAdmin](#cosmwasm.wasm.v1.MsgClearAdmin) - [MsgClearAdminResponse](#cosmwasm.wasm.v1.MsgClearAdminResponse) - [MsgExecuteContract](#cosmwasm.wasm.v1.MsgExecuteContract) @@ -94,6 +96,8 @@ - [MsgMigrateContractResponse](#cosmwasm.wasm.v1.MsgMigrateContractResponse) - [MsgPinCodes](#cosmwasm.wasm.v1.MsgPinCodes) - [MsgPinCodesResponse](#cosmwasm.wasm.v1.MsgPinCodesResponse) + - [MsgRemoveCodeUploadParamsAddresses](#cosmwasm.wasm.v1.MsgRemoveCodeUploadParamsAddresses) + - [MsgRemoveCodeUploadParamsAddressesResponse](#cosmwasm.wasm.v1.MsgRemoveCodeUploadParamsAddressesResponse) - [MsgStoreAndInstantiateContract](#cosmwasm.wasm.v1.MsgStoreAndInstantiateContract) - [MsgStoreAndInstantiateContractResponse](#cosmwasm.wasm.v1.MsgStoreAndInstantiateContractResponse) - [MsgStoreCode](#cosmwasm.wasm.v1.MsgStoreCode) @@ -1333,6 +1337,34 @@ Query provides defines the gRPC querier service + + +### MsgAddCodeUploadParamsAddresses +MsgAddCodeUploadParamsAddresses is the +MsgAddCodeUploadParamsAddresses request type. + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| `authority` | [string](#string) | | Authority is the address of the governance account. | +| `addresses` | [string](#string) | repeated | | + + + + + + + + +### MsgAddCodeUploadParamsAddressesResponse +MsgAddCodeUploadParamsAddressesResponse defines the response +structure for executing a MsgAddCodeUploadParamsAddresses message. + + + + + + ### MsgClearAdmin @@ -1532,6 +1564,34 @@ Since: 0.40 + + +### MsgRemoveCodeUploadParamsAddresses +MsgRemoveCodeUploadParamsAddresses is the +MsgRemoveCodeUploadParamsAddresses request type. + + +| Field | Type | Label | Description | +| ----- | ---- | ----- | ----------- | +| `authority` | [string](#string) | | Authority is the address of the governance account. | +| `addresses` | [string](#string) | repeated | | + + + + + + + + +### MsgRemoveCodeUploadParamsAddressesResponse +MsgRemoveCodeUploadParamsAddressesResponse defines the response +structure for executing a MsgRemoveCodeUploadParamsAddresses message. + + + + + + ### MsgStoreAndInstantiateContract @@ -1803,6 +1863,8 @@ Since: 0.40 | | | `StoreAndInstantiateContract` | [MsgStoreAndInstantiateContract](#cosmwasm.wasm.v1.MsgStoreAndInstantiateContract) | [MsgStoreAndInstantiateContractResponse](#cosmwasm.wasm.v1.MsgStoreAndInstantiateContractResponse) | StoreAndInstantiateContract defines a governance operation for storing and instantiating the contract. The authority is defined in the keeper. Since: 0.40 | | +| `RemoveCodeUploadParamsAddresses` | [MsgRemoveCodeUploadParamsAddresses](#cosmwasm.wasm.v1.MsgRemoveCodeUploadParamsAddresses) | [MsgRemoveCodeUploadParamsAddressesResponse](#cosmwasm.wasm.v1.MsgRemoveCodeUploadParamsAddressesResponse) | RemoveCodeUploadParamsAddresses defines a governance operation for removing addresses from code upload params. The authority is defined in the keeper. | | +| `AddCodeUploadParamsAddresses` | [MsgAddCodeUploadParamsAddresses](#cosmwasm.wasm.v1.MsgAddCodeUploadParamsAddresses) | [MsgAddCodeUploadParamsAddressesResponse](#cosmwasm.wasm.v1.MsgAddCodeUploadParamsAddressesResponse) | AddCodeUploadParamsAddresses defines a governance operation for adding addresses to code upload params. The authority is defined in the keeper. | | diff --git a/proto/cosmwasm/wasm/v1/tx.proto b/proto/cosmwasm/wasm/v1/tx.proto index 90905f5e7d..1ce7823c1b 100644 --- a/proto/cosmwasm/wasm/v1/tx.proto +++ b/proto/cosmwasm/wasm/v1/tx.proto @@ -60,6 +60,16 @@ service Msg { // Since: 0.40 rpc StoreAndInstantiateContract(MsgStoreAndInstantiateContract) returns (MsgStoreAndInstantiateContractResponse); + // RemoveCodeUploadParamsAddresses defines a governance operation for + // removing addresses from code upload params. + // The authority is defined in the keeper. + rpc RemoveCodeUploadParamsAddresses(MsgRemoveCodeUploadParamsAddresses) + returns (MsgRemoveCodeUploadParamsAddressesResponse); + // AddCodeUploadParamsAddresses defines a governance operation for + // adding addresses to code upload params. + // The authority is defined in the keeper. + rpc AddCodeUploadParamsAddresses(MsgAddCodeUploadParamsAddresses) + returns (MsgAddCodeUploadParamsAddressesResponse); } // MsgStoreCode submit Wasm code to the system @@ -388,4 +398,36 @@ message MsgStoreAndInstantiateContractResponse { string address = 1; // Data contains bytes to returned from the contract bytes data = 2; -} \ No newline at end of file +} + +// MsgAddCodeUploadParamsAddresses is the +// MsgAddCodeUploadParamsAddresses request type. +message MsgAddCodeUploadParamsAddresses { + option (amino.name) = "wasm/MsgAddCodeUploadParamsAddresses"; + option (cosmos.msg.v1.signer) = "authority"; + + // Authority is the address of the governance account. + string authority = 1 [ (cosmos_proto.scalar) = "cosmos.AddressString" ]; + + repeated string addresses = 2 [ (gogoproto.moretags) = "yaml:\"addresses\"" ]; +} + +// MsgAddCodeUploadParamsAddressesResponse defines the response +// structure for executing a MsgAddCodeUploadParamsAddresses message. +message MsgAddCodeUploadParamsAddressesResponse {} + +// MsgRemoveCodeUploadParamsAddresses is the +// MsgRemoveCodeUploadParamsAddresses request type. +message MsgRemoveCodeUploadParamsAddresses { + option (amino.name) = "wasm/MsgRemoveCodeUploadParamsAddresses"; + option (cosmos.msg.v1.signer) = "authority"; + + // Authority is the address of the governance account. + string authority = 1 [ (cosmos_proto.scalar) = "cosmos.AddressString" ]; + + repeated string addresses = 2 [ (gogoproto.moretags) = "yaml:\"addresses\"" ]; +} + +// MsgRemoveCodeUploadParamsAddressesResponse defines the response +// structure for executing a MsgRemoveCodeUploadParamsAddresses message. +message MsgRemoveCodeUploadParamsAddressesResponse {} \ No newline at end of file diff --git a/x/wasm/client/cli/gov_tx.go b/x/wasm/client/cli/gov_tx.go index 969cb263b3..0a46ac6ecf 100644 --- a/x/wasm/client/cli/gov_tx.go +++ b/x/wasm/client/cli/gov_tx.go @@ -48,6 +48,8 @@ func SubmitProposalCmd() *cobra.Command { ProposalPinCodesCmd(), ProposalUnpinCodesCmd(), ProposalUpdateInstantiateConfigCmd(), + ProposalAddCodeUploadParamsAddresses(), + ProposalRemoveCodeUploadParamsAddresses(), ) return cmd } @@ -805,6 +807,90 @@ $ %s tx gov submit-proposal update-instantiate-config 1:nobody 2:everybody 3:%s1 return cmd } +func ProposalAddCodeUploadParamsAddresses() *cobra.Command { + cmd := &cobra.Command{ + Use: "add-code-upload-params-addresses [addresses] --title [text] --summary [text] --authority [address]", + Short: "Submit an add code upload params addresses proposal to add addresses to code upload config params", + Args: cobra.MinimumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, proposalTitle, summary, deposit, err := getProposalInfo(cmd) + if err != nil { + return err + } + + authority, err := cmd.Flags().GetString(flagAuthority) + if err != nil { + return fmt.Errorf("authority: %s", err) + } + + if len(authority) == 0 { + return errors.New("authority address is required") + } + + msg := types.MsgAddCodeUploadParamsAddresses{ + Authority: authority, + Addresses: args, + } + + proposalMsg, err := v1.NewMsgSubmitProposal([]sdk.Msg{&msg}, deposit, clientCtx.GetFromAddress().String(), "", proposalTitle, summary) + if err != nil { + return err + } + if err = proposalMsg.ValidateBasic(); err != nil { + return err + } + + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), proposalMsg) + }, + SilenceUsage: true, + } + // proposal flags + addCommonProposalFlags(cmd) + return cmd +} + +func ProposalRemoveCodeUploadParamsAddresses() *cobra.Command { + cmd := &cobra.Command{ + Use: "remove-code-upload-params-addresses [addresses] --title [text] --summary [text] --authority [address]", + Short: "Submit a remove code upload params addresses proposal to remove addresses from code upload config params", + Args: cobra.MinimumNArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, proposalTitle, summary, deposit, err := getProposalInfo(cmd) + if err != nil { + return err + } + + authority, err := cmd.Flags().GetString(flagAuthority) + if err != nil { + return fmt.Errorf("authority: %s", err) + } + + if len(authority) == 0 { + return errors.New("authority address is required") + } + + msg := types.MsgRemoveCodeUploadParamsAddresses{ + Authority: authority, + Addresses: args, + } + + proposalMsg, err := v1.NewMsgSubmitProposal([]sdk.Msg{&msg}, deposit, clientCtx.GetFromAddress().String(), "", proposalTitle, summary) + if err != nil { + return err + } + if err = proposalMsg.ValidateBasic(); err != nil { + return err + } + + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), proposalMsg) + }, + SilenceUsage: true, + } + // proposal flags + addCommonProposalFlags(cmd) + return cmd +} + func addCommonProposalFlags(cmd *cobra.Command) { flags.AddTxFlagsToCmd(cmd) cmd.Flags().String(cli.FlagTitle, "", "Title of proposal") diff --git a/x/wasm/keeper/msg_server.go b/x/wasm/keeper/msg_server.go index 18bfc024cf..ace3059d66 100644 --- a/x/wasm/keeper/msg_server.go +++ b/x/wasm/keeper/msg_server.go @@ -357,6 +357,81 @@ func (m msgServer) StoreAndInstantiateContract(goCtx context.Context, req *types }, nil } +// AddCodeUploadParamsAddresses adds addresses to code upload params +func (m msgServer) AddCodeUploadParamsAddresses(goCtx context.Context, req *types.MsgAddCodeUploadParamsAddresses) (*types.MsgAddCodeUploadParamsAddressesResponse, error) { + if err := req.ValidateBasic(); err != nil { + return nil, err + } + authority := m.keeper.GetAuthority() + if authority != req.Authority { + return nil, errorsmod.Wrapf(types.ErrInvalid, "invalid authority; expected %s, got %s", authority, req.Authority) + } + + ctx := sdk.UnwrapSDKContext(goCtx) + + params := m.keeper.GetParams(ctx) + if params.CodeUploadAccess.Permission != types.AccessTypeAnyOfAddresses { + return nil, errorsmod.Wrap(types.ErrInvalid, "permission") + } + + addresses := params.CodeUploadAccess.Addresses + for _, newAddr := range req.Addresses { + if !contains(addresses, newAddr) { + addresses = append(addresses, newAddr) + } + } + + params.CodeUploadAccess.Addresses = addresses + if err := m.keeper.SetParams(ctx, params); err != nil { + return nil, err + } + + return &types.MsgAddCodeUploadParamsAddressesResponse{}, nil +} + +// RemoveCodeUploadParamsAddresses removes addresses to code upload params +func (m msgServer) RemoveCodeUploadParamsAddresses(goCtx context.Context, req *types.MsgRemoveCodeUploadParamsAddresses) (*types.MsgRemoveCodeUploadParamsAddressesResponse, error) { + if err := req.ValidateBasic(); err != nil { + return nil, err + } + authority := m.keeper.GetAuthority() + if authority != req.Authority { + return nil, errorsmod.Wrapf(types.ErrInvalid, "invalid authority; expected %s, got %s", authority, req.Authority) + } + + ctx := sdk.UnwrapSDKContext(goCtx) + + params := m.keeper.GetParams(ctx) + if params.CodeUploadAccess.Permission != types.AccessTypeAnyOfAddresses { + return nil, errorsmod.Wrap(types.ErrInvalid, "permission") + } + addresses := params.CodeUploadAccess.Addresses + newAddresses := make([]string, 0) + for _, addr := range addresses { + if contains(req.Addresses, addr) { + continue + } + newAddresses = append(newAddresses, addr) + } + + params.CodeUploadAccess.Addresses = newAddresses + + if err := m.keeper.SetParams(ctx, params); err != nil { + return nil, err + } + + return &types.MsgRemoveCodeUploadParamsAddressesResponse{}, nil +} + +func contains[T comparable](src []T, o T) bool { + for _, v := range src { + if v == o { + return true + } + } + return false +} + func (m msgServer) selectAuthorizationPolicy(ctx sdk.Context, actor string) types.AuthorizationPolicy { if actor == m.keeper.GetAuthority() { return newGovAuthorizationPolicy(m.keeper.propagateGovAuthorization) diff --git a/x/wasm/keeper/msg_server_integration_test.go b/x/wasm/keeper/msg_server_integration_test.go index 0ee2e21c22..e4b3ed6b45 100644 --- a/x/wasm/keeper/msg_server_integration_test.go +++ b/x/wasm/keeper/msg_server_integration_test.go @@ -145,6 +145,198 @@ func TestUpdateParams(t *testing.T) { } } +func TestAddCodeUploadParamsAddresses(t *testing.T) { + wasmApp := app.Setup(t) + ctx := wasmApp.BaseApp.NewContext(false, tmproto.Header{}) + + var ( + myAddress sdk.AccAddress = make([]byte, types.ContractAddrLen) + _, _, otherAddr = testdata.KeyTestPubAddr() + govAuthority = wasmApp.WasmKeeper.GetAuthority() + ) + + specs := map[string]struct { + src types.MsgAddCodeUploadParamsAddresses + uploadConfig types.AccessConfig + expUploadConfig types.AccessConfig + expErr bool + }{ + "authority can add addresses when permission is any of addresses": { + src: types.MsgAddCodeUploadParamsAddresses{ + Authority: govAuthority, + Addresses: []string{otherAddr.String()}, + }, + uploadConfig: types.AccessTypeAnyOfAddresses.With(myAddress), + expUploadConfig: types.AccessTypeAnyOfAddresses.With(myAddress, otherAddr), + }, + "add existing address": { + src: types.MsgAddCodeUploadParamsAddresses{ + Authority: govAuthority, + Addresses: []string{myAddress.String()}, + }, + uploadConfig: types.AccessTypeAnyOfAddresses.With(myAddress), + expUploadConfig: types.AccessTypeAnyOfAddresses.With(myAddress), + }, + "authority cannot add addresses when permission is allow everybody": { + src: types.MsgAddCodeUploadParamsAddresses{ + Authority: govAuthority, + Addresses: []string{otherAddr.String()}, + }, + uploadConfig: types.AllowEverybody, + expUploadConfig: types.AllowEverybody, + expErr: true, + }, + "authority cannot add addresses when permission is allow nobody": { + src: types.MsgAddCodeUploadParamsAddresses{ + Authority: govAuthority, + Addresses: []string{otherAddr.String()}, + }, + uploadConfig: types.AllowNobody, + expUploadConfig: types.AllowNobody, + expErr: true, + }, + "authority cannot add duplicate addresses when permission is any of addresses": { + src: types.MsgAddCodeUploadParamsAddresses{ + Authority: govAuthority, + Addresses: []string{otherAddr.String(), otherAddr.String()}, + }, + uploadConfig: types.AccessTypeAnyOfAddresses.With(myAddress), + expUploadConfig: types.AccessTypeAnyOfAddresses.With(myAddress), + expErr: true, + }, + "other address cannot add addresses when permission is any of addresses": { + src: types.MsgAddCodeUploadParamsAddresses{ + Authority: otherAddr.String(), + Addresses: []string{otherAddr.String()}, + }, + uploadConfig: types.AccessTypeAnyOfAddresses.With(myAddress), + expUploadConfig: types.AccessTypeAnyOfAddresses.With(myAddress, otherAddr), + expErr: true, + }, + } + for name, spec := range specs { + t.Run(name, func(t *testing.T) { + err := wasmApp.WasmKeeper.SetParams(ctx, types.Params{ + CodeUploadAccess: spec.uploadConfig, + InstantiateDefaultPermission: types.AccessTypeEverybody, + }) + require.NoError(t, err) + + // when + rsp, err := wasmApp.MsgServiceRouter().Handler(&spec.src)(ctx, &spec.src) + if spec.expErr { + require.Error(t, err) + require.Nil(t, rsp) + return + } + require.NoError(t, err) + require.Len(t, rsp.MsgResponses, 1) + assert.IsType(t, rsp.MsgResponses[0].GetCachedValue(), &types.MsgAddCodeUploadParamsAddressesResponse{}) + + // then + gotUploadConfig := wasmApp.WasmKeeper.GetParams(ctx).CodeUploadAccess + assert.True(t, spec.expUploadConfig.Equals(gotUploadConfig), + "got %#v not %#v", gotUploadConfig, spec.expUploadConfig) + }) + } +} + +func TestRemoveCodeUploadParamsAddresses(t *testing.T) { + wasmApp := app.Setup(t) + ctx := wasmApp.BaseApp.NewContext(false, tmproto.Header{}) + + var ( + myAddress sdk.AccAddress = make([]byte, types.ContractAddrLen) + _, _, otherAddr = testdata.KeyTestPubAddr() + govAuthority = wasmApp.WasmKeeper.GetAuthority() + ) + + specs := map[string]struct { + src types.MsgRemoveCodeUploadParamsAddresses + uploadConfig types.AccessConfig + expUploadConfig types.AccessConfig + expErr bool + }{ + "authority can remove addresses when permission is any of addresses": { + src: types.MsgRemoveCodeUploadParamsAddresses{ + Authority: govAuthority, + Addresses: []string{otherAddr.String()}, + }, + uploadConfig: types.AccessTypeAnyOfAddresses.With(myAddress, otherAddr), + expUploadConfig: types.AccessTypeAnyOfAddresses.With(myAddress), + }, + "authority cannot remove not existing addresses when permission is any of addresses": { + src: types.MsgRemoveCodeUploadParamsAddresses{ + Authority: govAuthority, + Addresses: []string{otherAddr.String()}, + }, + uploadConfig: types.AccessTypeAnyOfAddresses.With(myAddress), + expUploadConfig: types.AccessTypeAnyOfAddresses.With(myAddress), + }, + "authority cannot remove addresses when permission is allow everybody": { + src: types.MsgRemoveCodeUploadParamsAddresses{ + Authority: govAuthority, + Addresses: []string{otherAddr.String()}, + }, + uploadConfig: types.AllowEverybody, + expUploadConfig: types.AllowEverybody, + expErr: true, + }, + "authority cannot remove addresses when permission is allow nobody": { + src: types.MsgRemoveCodeUploadParamsAddresses{ + Authority: govAuthority, + Addresses: []string{otherAddr.String()}, + }, + uploadConfig: types.AllowNobody, + expUploadConfig: types.AllowNobody, + expErr: true, + }, + "authority cannot remove duplicate addresses when permission is any of addresses": { + src: types.MsgRemoveCodeUploadParamsAddresses{ + Authority: govAuthority, + Addresses: []string{otherAddr.String(), otherAddr.String()}, + }, + uploadConfig: types.AccessTypeAnyOfAddresses.With(myAddress, otherAddr), + expUploadConfig: types.AccessTypeAnyOfAddresses.With(myAddress, otherAddr), + expErr: true, + }, + "other address cannot remove addresses when permission is any of addresses": { + src: types.MsgRemoveCodeUploadParamsAddresses{ + Authority: otherAddr.String(), + Addresses: []string{otherAddr.String()}, + }, + uploadConfig: types.AccessTypeAnyOfAddresses.With(myAddress, otherAddr), + expUploadConfig: types.AccessTypeAnyOfAddresses.With(myAddress, otherAddr), + expErr: true, + }, + } + for name, spec := range specs { + t.Run(name, func(t *testing.T) { + err := wasmApp.WasmKeeper.SetParams(ctx, types.Params{ + CodeUploadAccess: spec.uploadConfig, + InstantiateDefaultPermission: types.AccessTypeEverybody, + }) + require.NoError(t, err) + + // when + rsp, err := wasmApp.MsgServiceRouter().Handler(&spec.src)(ctx, &spec.src) + if spec.expErr { + require.Error(t, err) + require.Nil(t, rsp) + return + } + require.NoError(t, err) + require.Len(t, rsp.MsgResponses, 1) + assert.IsType(t, rsp.MsgResponses[0].GetCachedValue(), &types.MsgRemoveCodeUploadParamsAddressesResponse{}) + + // then + gotUploadConfig := wasmApp.WasmKeeper.GetParams(ctx).CodeUploadAccess + assert.True(t, spec.expUploadConfig.Equals(gotUploadConfig), + "got %#v not %#v", gotUploadConfig, spec.expUploadConfig) + }) + } +} + func TestPinCodes(t *testing.T) { wasmApp := app.Setup(t) ctx := wasmApp.BaseApp.NewContext(false, tmproto.Header{}) diff --git a/x/wasm/types/codec.go b/x/wasm/types/codec.go index 10ff3af67d..aafa435fb9 100644 --- a/x/wasm/types/codec.go +++ b/x/wasm/types/codec.go @@ -28,6 +28,8 @@ func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) { cdc.RegisterConcrete(&MsgPinCodes{}, "wasm/MsgPinCodes", nil) cdc.RegisterConcrete(&MsgUnpinCodes{}, "wasm/MsgUnpinCodes", nil) cdc.RegisterConcrete(&MsgStoreAndInstantiateContract{}, "wasm/MsgStoreAndInstantiateContract", nil) + cdc.RegisterConcrete(&MsgAddCodeUploadParamsAddresses{}, "wasm/MsgAddCodeUploadParamsAddresses", nil) + cdc.RegisterConcrete(&MsgRemoveCodeUploadParamsAddresses{}, "wasm/MsgRemoveCodeUploadParamsAddresses", nil) cdc.RegisterConcrete(&PinCodesProposal{}, "wasm/PinCodesProposal", nil) cdc.RegisterConcrete(&UnpinCodesProposal{}, "wasm/UnpinCodesProposal", nil) @@ -76,6 +78,8 @@ func RegisterInterfaces(registry types.InterfaceRegistry) { &MsgPinCodes{}, &MsgUnpinCodes{}, &MsgStoreAndInstantiateContract{}, + &MsgAddCodeUploadParamsAddresses{}, + &MsgRemoveCodeUploadParamsAddresses{}, ) registry.RegisterImplementations( (*v1beta1.Content)(nil), diff --git a/x/wasm/types/tx.go b/x/wasm/types/tx.go index d75993b7f6..ba8acce15d 100644 --- a/x/wasm/types/tx.go +++ b/x/wasm/types/tx.go @@ -615,3 +615,81 @@ func (msg MsgStoreAndInstantiateContract) ValidateBasic() error { } return nil } + +func (msg MsgAddCodeUploadParamsAddresses) Route() string { + return RouterKey +} + +func (msg MsgAddCodeUploadParamsAddresses) Type() string { + return "add-code-upload-params-addresses" +} + +func (msg MsgAddCodeUploadParamsAddresses) GetSigners() []sdk.AccAddress { + authority, err := sdk.AccAddressFromBech32(msg.Authority) + if err != nil { // should never happen as valid basic rejects invalid addresses + panic(err.Error()) + } + return []sdk.AccAddress{authority} +} + +func (msg MsgAddCodeUploadParamsAddresses) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&msg)) +} + +func (msg MsgAddCodeUploadParamsAddresses) ValidateBasic() error { + if _, err := sdk.AccAddressFromBech32(msg.Authority); err != nil { + return errorsmod.Wrap(err, "authority") + } + + if len(msg.Addresses) == 0 { + return errorsmod.Wrap(ErrEmpty, "addresses") + } + + return checkDuplicatedAddresses(msg.Addresses) +} + +func (msg MsgRemoveCodeUploadParamsAddresses) Route() string { + return RouterKey +} + +func (msg MsgRemoveCodeUploadParamsAddresses) Type() string { + return "remove-code-upload-params-addresses" +} + +func (msg MsgRemoveCodeUploadParamsAddresses) GetSigners() []sdk.AccAddress { + authority, err := sdk.AccAddressFromBech32(msg.Authority) + if err != nil { // should never happen as valid basic rejects invalid addresses + panic(err.Error()) + } + return []sdk.AccAddress{authority} +} + +func (msg MsgRemoveCodeUploadParamsAddresses) GetSignBytes() []byte { + return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&msg)) +} + +func (msg MsgRemoveCodeUploadParamsAddresses) ValidateBasic() error { + if _, err := sdk.AccAddressFromBech32(msg.Authority); err != nil { + return errorsmod.Wrap(err, "authority") + } + + if len(msg.Addresses) == 0 { + return errorsmod.Wrap(ErrEmpty, "addresses") + } + + return checkDuplicatedAddresses(msg.Addresses) +} + +func checkDuplicatedAddresses(addresses []string) error { + index := map[string]struct{}{} + for _, addr := range addresses { + if _, err := sdk.AccAddressFromBech32(addr); err != nil { + return errorsmod.Wrap(err, "addresses") + } + if _, found := index[addr]; found { + return errorsmod.Wrap(ErrInvalid, "duplicate addresses") + } + index[addr] = struct{}{} + } + return nil +} diff --git a/x/wasm/types/tx.pb.go b/x/wasm/types/tx.pb.go index 4d4ad490e2..ba3dcc60f3 100644 --- a/x/wasm/types/tx.pb.go +++ b/x/wasm/types/tx.pb.go @@ -1289,6 +1289,189 @@ func (m *MsgStoreAndInstantiateContractResponse) XXX_DiscardUnknown() { var xxx_messageInfo_MsgStoreAndInstantiateContractResponse proto.InternalMessageInfo +// MsgAddCodeUploadParamsAddresses is the +// MsgAddCodeUploadParamsAddresses request type. +type MsgAddCodeUploadParamsAddresses struct { + // Authority is the address of the governance account. + Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"` + Addresses []string `protobuf:"bytes,2,rep,name=addresses,proto3" json:"addresses,omitempty" yaml:"addresses"` +} + +func (m *MsgAddCodeUploadParamsAddresses) Reset() { *m = MsgAddCodeUploadParamsAddresses{} } +func (m *MsgAddCodeUploadParamsAddresses) String() string { return proto.CompactTextString(m) } +func (*MsgAddCodeUploadParamsAddresses) ProtoMessage() {} +func (*MsgAddCodeUploadParamsAddresses) Descriptor() ([]byte, []int) { + return fileDescriptor_4f74d82755520264, []int{26} +} + +func (m *MsgAddCodeUploadParamsAddresses) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgAddCodeUploadParamsAddresses) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgAddCodeUploadParamsAddresses.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *MsgAddCodeUploadParamsAddresses) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgAddCodeUploadParamsAddresses.Merge(m, src) +} + +func (m *MsgAddCodeUploadParamsAddresses) XXX_Size() int { + return m.Size() +} + +func (m *MsgAddCodeUploadParamsAddresses) XXX_DiscardUnknown() { + xxx_messageInfo_MsgAddCodeUploadParamsAddresses.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgAddCodeUploadParamsAddresses proto.InternalMessageInfo + +// MsgAddCodeUploadParamsAddressesResponse defines the response +// structure for executing a MsgAddCodeUploadParamsAddresses message. +type MsgAddCodeUploadParamsAddressesResponse struct{} + +func (m *MsgAddCodeUploadParamsAddressesResponse) Reset() { + *m = MsgAddCodeUploadParamsAddressesResponse{} +} +func (m *MsgAddCodeUploadParamsAddressesResponse) String() string { return proto.CompactTextString(m) } +func (*MsgAddCodeUploadParamsAddressesResponse) ProtoMessage() {} +func (*MsgAddCodeUploadParamsAddressesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_4f74d82755520264, []int{27} +} + +func (m *MsgAddCodeUploadParamsAddressesResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgAddCodeUploadParamsAddressesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgAddCodeUploadParamsAddressesResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *MsgAddCodeUploadParamsAddressesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgAddCodeUploadParamsAddressesResponse.Merge(m, src) +} + +func (m *MsgAddCodeUploadParamsAddressesResponse) XXX_Size() int { + return m.Size() +} + +func (m *MsgAddCodeUploadParamsAddressesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgAddCodeUploadParamsAddressesResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgAddCodeUploadParamsAddressesResponse proto.InternalMessageInfo + +// MsgRemoveCodeUploadParamsAddresses is the +// MsgRemoveCodeUploadParamsAddresses request type. +type MsgRemoveCodeUploadParamsAddresses struct { + // Authority is the address of the governance account. + Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"` + Addresses []string `protobuf:"bytes,2,rep,name=addresses,proto3" json:"addresses,omitempty" yaml:"addresses"` +} + +func (m *MsgRemoveCodeUploadParamsAddresses) Reset() { *m = MsgRemoveCodeUploadParamsAddresses{} } +func (m *MsgRemoveCodeUploadParamsAddresses) String() string { return proto.CompactTextString(m) } +func (*MsgRemoveCodeUploadParamsAddresses) ProtoMessage() {} +func (*MsgRemoveCodeUploadParamsAddresses) Descriptor() ([]byte, []int) { + return fileDescriptor_4f74d82755520264, []int{28} +} + +func (m *MsgRemoveCodeUploadParamsAddresses) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgRemoveCodeUploadParamsAddresses) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgRemoveCodeUploadParamsAddresses.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *MsgRemoveCodeUploadParamsAddresses) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgRemoveCodeUploadParamsAddresses.Merge(m, src) +} + +func (m *MsgRemoveCodeUploadParamsAddresses) XXX_Size() int { + return m.Size() +} + +func (m *MsgRemoveCodeUploadParamsAddresses) XXX_DiscardUnknown() { + xxx_messageInfo_MsgRemoveCodeUploadParamsAddresses.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgRemoveCodeUploadParamsAddresses proto.InternalMessageInfo + +// MsgRemoveCodeUploadParamsAddressesResponse defines the response +// structure for executing a MsgRemoveCodeUploadParamsAddresses message. +type MsgRemoveCodeUploadParamsAddressesResponse struct{} + +func (m *MsgRemoveCodeUploadParamsAddressesResponse) Reset() { + *m = MsgRemoveCodeUploadParamsAddressesResponse{} +} + +func (m *MsgRemoveCodeUploadParamsAddressesResponse) String() string { + return proto.CompactTextString(m) +} +func (*MsgRemoveCodeUploadParamsAddressesResponse) ProtoMessage() {} +func (*MsgRemoveCodeUploadParamsAddressesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_4f74d82755520264, []int{29} +} + +func (m *MsgRemoveCodeUploadParamsAddressesResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} + +func (m *MsgRemoveCodeUploadParamsAddressesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgRemoveCodeUploadParamsAddressesResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} + +func (m *MsgRemoveCodeUploadParamsAddressesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgRemoveCodeUploadParamsAddressesResponse.Merge(m, src) +} + +func (m *MsgRemoveCodeUploadParamsAddressesResponse) XXX_Size() int { + return m.Size() +} + +func (m *MsgRemoveCodeUploadParamsAddressesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgRemoveCodeUploadParamsAddressesResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgRemoveCodeUploadParamsAddressesResponse proto.InternalMessageInfo + func init() { proto.RegisterType((*MsgStoreCode)(nil), "cosmwasm.wasm.v1.MsgStoreCode") proto.RegisterType((*MsgStoreCodeResponse)(nil), "cosmwasm.wasm.v1.MsgStoreCodeResponse") @@ -1316,103 +1499,115 @@ func init() { proto.RegisterType((*MsgUnpinCodesResponse)(nil), "cosmwasm.wasm.v1.MsgUnpinCodesResponse") proto.RegisterType((*MsgStoreAndInstantiateContract)(nil), "cosmwasm.wasm.v1.MsgStoreAndInstantiateContract") proto.RegisterType((*MsgStoreAndInstantiateContractResponse)(nil), "cosmwasm.wasm.v1.MsgStoreAndInstantiateContractResponse") + proto.RegisterType((*MsgAddCodeUploadParamsAddresses)(nil), "cosmwasm.wasm.v1.MsgAddCodeUploadParamsAddresses") + proto.RegisterType((*MsgAddCodeUploadParamsAddressesResponse)(nil), "cosmwasm.wasm.v1.MsgAddCodeUploadParamsAddressesResponse") + proto.RegisterType((*MsgRemoveCodeUploadParamsAddresses)(nil), "cosmwasm.wasm.v1.MsgRemoveCodeUploadParamsAddresses") + proto.RegisterType((*MsgRemoveCodeUploadParamsAddressesResponse)(nil), "cosmwasm.wasm.v1.MsgRemoveCodeUploadParamsAddressesResponse") } func init() { proto.RegisterFile("cosmwasm/wasm/v1/tx.proto", fileDescriptor_4f74d82755520264) } var fileDescriptor_4f74d82755520264 = []byte{ - // 1441 bytes of a gzipped FileDescriptorProto + // 1574 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x58, 0xcf, 0x6f, 0x1b, 0xc5, - 0x17, 0xcf, 0xc6, 0xbf, 0x5f, 0xfc, 0x6d, 0xd3, 0xad, 0x9b, 0x6c, 0xb6, 0xad, 0x9d, 0x6e, 0x7f, - 0xb9, 0xfd, 0xb6, 0x76, 0x63, 0xa0, 0x82, 0x70, 0x8a, 0x53, 0x24, 0x52, 0xc9, 0x10, 0x6d, 0xd4, - 0x56, 0xa0, 0x4a, 0xd6, 0xda, 0x3b, 0xd9, 0xac, 0x9a, 0xdd, 0x35, 0x9e, 0x75, 0x93, 0x1c, 0xb8, - 0x80, 0x84, 0x04, 0x27, 0xfe, 0x09, 0x24, 0xe0, 0x42, 0x0f, 0x20, 0x71, 0xec, 0xb1, 0x12, 0x97, - 0x8a, 0x13, 0xa7, 0x00, 0x2e, 0x52, 0xb9, 0x21, 0x71, 0xe4, 0x84, 0x66, 0x66, 0x77, 0x3d, 0x5e, - 0xef, 0x3a, 0x4e, 0x4a, 0xc5, 0x81, 0x4b, 0xb2, 0x33, 0xef, 0xc7, 0xbc, 0xcf, 0xe7, 0xbd, 0x99, - 0x79, 0x63, 0x58, 0x68, 0x3b, 0xd8, 0xda, 0xd1, 0xb0, 0x55, 0xa5, 0x7f, 0x1e, 0x2e, 0x55, 0xdd, - 0xdd, 0x4a, 0xa7, 0xeb, 0xb8, 0x8e, 0x38, 0xeb, 0x8b, 0x2a, 0xf4, 0xcf, 0xc3, 0x25, 0xb9, 0x48, - 0x66, 0x1c, 0x5c, 0x6d, 0x69, 0x18, 0x55, 0x1f, 0x2e, 0xb5, 0x90, 0xab, 0x2d, 0x55, 0xdb, 0x8e, - 0x69, 0x33, 0x0b, 0x79, 0xde, 0x93, 0x5b, 0xd8, 0x20, 0x9e, 0x2c, 0x6c, 0x78, 0x82, 0x82, 0xe1, - 0x18, 0x0e, 0xfd, 0xac, 0x92, 0x2f, 0x6f, 0xf6, 0xcc, 0xe8, 0xda, 0x7b, 0x1d, 0x84, 0x3d, 0xe9, - 0x02, 0x73, 0xd6, 0x64, 0x66, 0x6c, 0xe0, 0x89, 0x4e, 0x68, 0x96, 0x69, 0x3b, 0x55, 0xfa, 0x97, - 0x4d, 0x29, 0xbf, 0x09, 0x90, 0x6f, 0x60, 0x63, 0xc3, 0x75, 0xba, 0x68, 0xd5, 0xd1, 0x91, 0x38, - 0x07, 0x69, 0x8c, 0x6c, 0x1d, 0x75, 0x25, 0x61, 0x51, 0x28, 0xe7, 0x54, 0x6f, 0x24, 0xde, 0x84, - 0x63, 0x64, 0xb5, 0x66, 0x6b, 0xcf, 0x45, 0xcd, 0xb6, 0xa3, 0x23, 0x69, 0x7a, 0x51, 0x28, 0xe7, - 0xeb, 0xb3, 0xfd, 0xfd, 0x52, 0xfe, 0xde, 0xca, 0x46, 0xa3, 0xbe, 0xe7, 0x52, 0x0f, 0x6a, 0x9e, - 0xe8, 0xf9, 0x23, 0xf1, 0x0e, 0xcc, 0x99, 0x36, 0x76, 0x35, 0xdb, 0x35, 0x35, 0x17, 0x35, 0x3b, - 0xa8, 0x6b, 0x99, 0x18, 0x9b, 0x8e, 0x2d, 0xa5, 0x16, 0x85, 0xf2, 0x4c, 0xad, 0x58, 0x09, 0xd3, - 0x55, 0x59, 0x69, 0xb7, 0x11, 0xc6, 0xab, 0x8e, 0xbd, 0x69, 0x1a, 0xea, 0x29, 0xce, 0x7a, 0x3d, - 0x30, 0x5e, 0x3e, 0xf7, 0xd1, 0xf3, 0x47, 0x57, 0xbd, 0xd8, 0x3e, 0x7b, 0xfe, 0xe8, 0xea, 0x09, - 0x4a, 0x05, 0x8f, 0xe4, 0x76, 0x32, 0x9b, 0x98, 0x4d, 0xde, 0x4e, 0x66, 0x93, 0xb3, 0x29, 0xe5, - 0x1e, 0x14, 0x78, 0x99, 0x8a, 0x70, 0xc7, 0xb1, 0x31, 0x12, 0xcf, 0x43, 0x86, 0x60, 0x69, 0x9a, - 0x3a, 0x85, 0x9b, 0xac, 0x43, 0x7f, 0xbf, 0x94, 0x26, 0x2a, 0x6b, 0xb7, 0xd4, 0x34, 0x11, 0xad, - 0xe9, 0xa2, 0x0c, 0xd9, 0xf6, 0x16, 0x6a, 0x3f, 0xc0, 0x3d, 0x8b, 0x81, 0x56, 0x83, 0xb1, 0xf2, - 0x78, 0x1a, 0xe6, 0x1a, 0xd8, 0x58, 0x1b, 0x04, 0xb9, 0xea, 0xd8, 0x6e, 0x57, 0x6b, 0xbb, 0xb1, - 0x4c, 0x16, 0x20, 0xa5, 0xe9, 0x96, 0x69, 0x53, 0x5f, 0x39, 0x95, 0x0d, 0xf8, 0x48, 0x12, 0xb1, - 0x91, 0x14, 0x20, 0xb5, 0xad, 0xb5, 0xd0, 0xb6, 0x94, 0x64, 0xa6, 0x74, 0x20, 0x96, 0x21, 0x61, - 0x61, 0x83, 0xf2, 0x99, 0xaf, 0xcf, 0xfd, 0xb5, 0x5f, 0x12, 0x55, 0x6d, 0xc7, 0x0f, 0xa3, 0x81, - 0x30, 0xd6, 0x0c, 0xa4, 0x12, 0x15, 0x71, 0x13, 0x52, 0x9b, 0x3d, 0x5b, 0xc7, 0x52, 0x7a, 0x31, - 0x51, 0x9e, 0xa9, 0x2d, 0x54, 0xbc, 0xf2, 0x20, 0x85, 0x59, 0xf1, 0x0a, 0xb3, 0xb2, 0xea, 0x98, - 0x76, 0xfd, 0xb5, 0x27, 0xfb, 0xa5, 0xa9, 0xaf, 0x7f, 0x2e, 0x95, 0x0d, 0xd3, 0xdd, 0xea, 0xb5, - 0x2a, 0x6d, 0xc7, 0xf2, 0x6a, 0xc9, 0xfb, 0x77, 0x1d, 0xeb, 0x0f, 0xbc, 0xba, 0x23, 0x06, 0xf8, - 0xcb, 0xe7, 0x8f, 0xae, 0x0a, 0x2a, 0x73, 0xbf, 0xfc, 0xff, 0x50, 0x76, 0x4e, 0xfb, 0xd9, 0x89, - 0xe0, 0x49, 0x79, 0x07, 0x8a, 0xd1, 0x92, 0x20, 0x4b, 0x12, 0x64, 0x34, 0x5d, 0xef, 0x22, 0x8c, - 0x3d, 0x2a, 0xfd, 0xa1, 0x28, 0x42, 0x52, 0xd7, 0x5c, 0xcd, 0x4b, 0x0b, 0xfd, 0x56, 0xfe, 0x98, - 0x86, 0xf9, 0x68, 0x87, 0xb5, 0xff, 0x70, 0x4e, 0x08, 0x55, 0x58, 0xdb, 0x76, 0xa5, 0x0c, 0xa3, - 0x8a, 0x7c, 0x8b, 0xf3, 0x90, 0xd9, 0x34, 0x77, 0x9b, 0x24, 0xd2, 0xec, 0xa2, 0x50, 0xce, 0xaa, - 0xe9, 0x4d, 0x73, 0xb7, 0x81, 0x8d, 0xe5, 0x6b, 0xa1, 0x04, 0x9e, 0x19, 0x93, 0xc0, 0x9a, 0xf2, - 0x2e, 0x94, 0x62, 0x44, 0x47, 0x4c, 0xe1, 0xc7, 0xd3, 0x20, 0x36, 0xb0, 0xf1, 0xd6, 0x2e, 0x6a, - 0xf7, 0x26, 0xd8, 0x51, 0x64, 0x83, 0x7a, 0x3a, 0x5e, 0x02, 0x83, 0xb1, 0x9f, 0x88, 0xc4, 0x21, - 0x12, 0x91, 0x7a, 0xb9, 0x9b, 0xe3, 0x72, 0x88, 0xdb, 0x79, 0x9f, 0xdb, 0x10, 0x5c, 0xe5, 0x06, - 0xc8, 0xa3, 0xb3, 0x01, 0xa3, 0x3e, 0x6f, 0x02, 0xc7, 0xdb, 0x63, 0x81, 0xf2, 0xd6, 0x30, 0x8d, - 0xae, 0xf6, 0x82, 0xbc, 0x4d, 0x54, 0xfb, 0x1e, 0xb9, 0xc9, 0x03, 0xc9, 0x8d, 0x07, 0x1d, 0x8a, - 0xd5, 0x03, 0x1d, 0x9a, 0x1d, 0x0b, 0xfa, 0x13, 0x01, 0x8e, 0x35, 0xb0, 0x71, 0xa7, 0xa3, 0x6b, - 0x2e, 0x5a, 0xa1, 0x1b, 0x37, 0x0e, 0xf0, 0x69, 0xc8, 0xd9, 0x68, 0xa7, 0xc9, 0x6f, 0xf5, 0xac, - 0x8d, 0x76, 0x98, 0x11, 0xcf, 0x46, 0x62, 0x98, 0x8d, 0xe5, 0xf3, 0xa1, 0xf0, 0x4f, 0xfa, 0xe1, - 0x73, 0xab, 0x2a, 0x12, 0xbd, 0x0a, 0xb8, 0x19, 0x3f, 0x6c, 0xc5, 0x80, 0xff, 0x35, 0xb0, 0xb1, - 0xba, 0x8d, 0xb4, 0xee, 0xf8, 0x00, 0xc7, 0xc5, 0xa0, 0x84, 0x62, 0x10, 0xfd, 0x18, 0x06, 0x7e, - 0x95, 0x79, 0x38, 0x35, 0x34, 0x11, 0x44, 0xf0, 0xbb, 0x40, 0x79, 0x65, 0xc1, 0x0d, 0xef, 0xd4, - 0x4d, 0xd3, 0x88, 0x8d, 0x87, 0xab, 0x82, 0xe9, 0xd8, 0x2a, 0xb8, 0x0f, 0x32, 0x61, 0x35, 0xe6, - 0x9a, 0x4f, 0x4c, 0x74, 0xcd, 0x4b, 0x36, 0xda, 0x59, 0x8b, 0xbc, 0xe9, 0xab, 0x21, 0xd8, 0xa5, - 0x61, 0xea, 0x47, 0xb0, 0x28, 0x17, 0x40, 0x89, 0x97, 0x06, 0x84, 0x7c, 0x23, 0xc0, 0xf1, 0x40, - 0x6d, 0x5d, 0xeb, 0x6a, 0x16, 0x16, 0x6f, 0x42, 0x4e, 0xeb, 0xb9, 0x5b, 0x4e, 0xd7, 0x74, 0xf7, - 0x18, 0x11, 0x75, 0xe9, 0xc7, 0x6f, 0xaf, 0x17, 0xbc, 0x83, 0x60, 0x85, 0x9d, 0x58, 0x1b, 0x6e, - 0xd7, 0xb4, 0x0d, 0x75, 0xa0, 0x2a, 0xbe, 0x09, 0xe9, 0x0e, 0xf5, 0x40, 0x49, 0x9a, 0xa9, 0x49, - 0xa3, 0x60, 0xd9, 0x0a, 0xf5, 0x1c, 0x39, 0x39, 0xd8, 0x69, 0xe0, 0x99, 0xb0, 0x9d, 0x31, 0x70, - 0x46, 0x20, 0x16, 0x86, 0x21, 0x32, 0x5b, 0x65, 0x81, 0x5e, 0x6b, 0xfc, 0x54, 0x00, 0xe6, 0x7b, - 0x06, 0x66, 0xa3, 0xa7, 0x3b, 0xc1, 0xa6, 0x3f, 0x2a, 0x98, 0x7f, 0xe4, 0x30, 0x1d, 0x8b, 0x8a, - 0x0f, 0x53, 0xb9, 0x4e, 0x51, 0xf1, 0x53, 0x63, 0x37, 0xfb, 0x17, 0x02, 0xcc, 0x34, 0xb0, 0xb1, - 0x6e, 0xda, 0xa4, 0x08, 0x8f, 0x9e, 0xb2, 0x37, 0x08, 0x4a, 0x5a, 0xd8, 0x24, 0x69, 0x89, 0x72, - 0xb2, 0x5e, 0xec, 0xef, 0x97, 0x32, 0xac, 0xb2, 0xf1, 0x9f, 0xfb, 0xa5, 0xe3, 0x7b, 0x9a, 0xb5, - 0xbd, 0xac, 0xf8, 0x4a, 0x8a, 0x9a, 0x61, 0xd5, 0x8e, 0xd9, 0x59, 0x30, 0x0c, 0x6d, 0xd6, 0x87, - 0xe6, 0xc7, 0xa5, 0x9c, 0x82, 0x93, 0xdc, 0x30, 0x48, 0xd4, 0x57, 0x02, 0x3d, 0x09, 0xee, 0xd8, - 0x9d, 0x7f, 0x11, 0xc0, 0xc5, 0x51, 0x00, 0xc1, 0x59, 0x32, 0x88, 0xcc, 0x3b, 0x4b, 0x06, 0x13, - 0x01, 0x88, 0x1f, 0x92, 0xb4, 0x63, 0xa3, 0xdd, 0xf4, 0x8a, 0xad, 0x47, 0xf5, 0xbe, 0x47, 0x45, - 0x35, 0xfa, 0xca, 0x48, 0xbc, 0xe0, 0x2b, 0x23, 0xf9, 0x02, 0xaf, 0x0c, 0xf1, 0x2c, 0x40, 0x8f, - 0xe0, 0x67, 0xa1, 0xa4, 0x68, 0x8b, 0x94, 0xeb, 0xf9, 0x8c, 0x0c, 0xba, 0xc6, 0x34, 0xdf, 0x35, - 0x06, 0x0d, 0x61, 0x26, 0xa2, 0x21, 0xcc, 0x1e, 0xa2, 0x0f, 0xc9, 0xbd, 0xdc, 0x86, 0x90, 0x9c, - 0xf9, 0x4e, 0xaf, 0xdb, 0x46, 0x12, 0x78, 0x67, 0x3e, 0x1d, 0x91, 0x56, 0xad, 0xd5, 0x33, 0xb7, - 0xc9, 0x65, 0x30, 0xc3, 0x5a, 0x35, 0x6f, 0x48, 0xae, 0x4f, 0x5a, 0x4e, 0x5b, 0x1a, 0xde, 0x92, - 0xf2, 0xde, 0x4b, 0xc8, 0xd1, 0xd1, 0xdb, 0x1a, 0xde, 0x5a, 0xbe, 0x39, 0x5a, 0x55, 0xe7, 0x87, - 0x1e, 0x65, 0xd1, 0xa5, 0xa2, 0xdc, 0x85, 0x4b, 0xe3, 0x35, 0x8e, 0xd6, 0x43, 0xd6, 0xbe, 0x03, - 0x48, 0x34, 0xb0, 0x21, 0x6e, 0x40, 0x6e, 0xf0, 0xba, 0x8d, 0xa8, 0x03, 0xfe, 0x5d, 0x28, 0x5f, - 0x1a, 0x2f, 0x0f, 0x42, 0xf9, 0x00, 0x4e, 0x46, 0x95, 0x7d, 0x39, 0xd2, 0x3c, 0x42, 0x53, 0xbe, - 0x31, 0xa9, 0x66, 0xb0, 0xa4, 0x0b, 0x85, 0xc8, 0x27, 0xcd, 0x95, 0x49, 0x3d, 0xd5, 0xe4, 0xa5, - 0x89, 0x55, 0x83, 0x55, 0x11, 0x1c, 0x0f, 0x77, 0xe1, 0x17, 0x22, 0xbd, 0x84, 0xb4, 0xe4, 0x6b, - 0x93, 0x68, 0xf1, 0xcb, 0x84, 0x9b, 0xd6, 0xe8, 0x65, 0x42, 0x5a, 0x31, 0xcb, 0xc4, 0xb5, 0x8f, - 0xef, 0xc1, 0x0c, 0xdf, 0x26, 0x2e, 0x46, 0x1a, 0x73, 0x1a, 0x72, 0xf9, 0x20, 0x8d, 0xc0, 0xf5, - 0x5d, 0x00, 0xae, 0xbf, 0x2b, 0x45, 0xda, 0x0d, 0x14, 0xe4, 0xcb, 0x07, 0x28, 0x04, 0x7e, 0x3f, - 0x84, 0xf9, 0xb8, 0xa6, 0xed, 0xda, 0x98, 0xe0, 0x46, 0xb4, 0xe5, 0x57, 0x0f, 0xa3, 0x1d, 0x2c, - 0x7f, 0x1f, 0xf2, 0x43, 0x2d, 0xd2, 0xb9, 0x31, 0x5e, 0x98, 0x8a, 0x7c, 0xe5, 0x40, 0x15, 0xde, - 0xfb, 0x50, 0xcf, 0x12, 0xed, 0x9d, 0x57, 0x89, 0xf1, 0x1e, 0xd9, 0x3f, 0xac, 0x43, 0x36, 0xe8, - 0x13, 0xce, 0x46, 0x9a, 0xf9, 0x62, 0xf9, 0xe2, 0x58, 0x31, 0x9f, 0x64, 0xee, 0xea, 0x8e, 0x4e, - 0xf2, 0x40, 0x21, 0x26, 0xc9, 0xa3, 0x37, 0xaa, 0xf8, 0xa9, 0x00, 0xa7, 0xc7, 0x5d, 0xa7, 0x37, - 0xe2, 0x8f, 0xa5, 0x68, 0x0b, 0xf9, 0xf5, 0xc3, 0x5a, 0xf8, 0xb1, 0xd4, 0x6f, 0x3d, 0xf9, 0xb5, - 0x38, 0xf5, 0xa4, 0x5f, 0x14, 0x9e, 0xf6, 0x8b, 0xc2, 0x2f, 0xfd, 0xa2, 0xf0, 0xf9, 0xb3, 0xe2, - 0xd4, 0xd3, 0x67, 0xc5, 0xa9, 0x9f, 0x9e, 0x15, 0xa7, 0xde, 0xbf, 0xc4, 0x5d, 0x35, 0xab, 0x0e, - 0xb6, 0xee, 0xf9, 0x3f, 0x43, 0xea, 0xd5, 0x5d, 0xf6, 0x73, 0x24, 0xbd, 0x6e, 0x5a, 0x69, 0xfa, - 0xf3, 0xe2, 0x2b, 0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0xe9, 0x52, 0x18, 0xa3, 0x28, 0x15, 0x00, - 0x00, + 0x17, 0xcf, 0xc6, 0xbf, 0x5f, 0xfc, 0x6d, 0xd3, 0xad, 0x9b, 0x38, 0xdb, 0xd6, 0x4e, 0xb7, 0x3f, + 0xe2, 0xe6, 0x9b, 0xda, 0x8d, 0xbf, 0x5f, 0x0a, 0x35, 0x5c, 0xe2, 0x14, 0x89, 0x54, 0x32, 0x44, + 0x1b, 0xa5, 0x15, 0xa8, 0x92, 0xb5, 0xf6, 0x4e, 0x36, 0xab, 0x7a, 0x77, 0x8d, 0x67, 0x9d, 0x1f, + 0x07, 0x2e, 0x20, 0x21, 0x81, 0x38, 0x70, 0xe1, 0x4f, 0x40, 0x02, 0x2e, 0xf4, 0xc0, 0x81, 0x63, + 0x4f, 0xa8, 0x12, 0x1c, 0x2a, 0x4e, 0x1c, 0x90, 0x81, 0x14, 0xa9, 0xdc, 0x90, 0x7a, 0xe4, 0x84, + 0x76, 0x66, 0x77, 0xbd, 0x5e, 0xef, 0xae, 0x9d, 0x84, 0x0a, 0x24, 0x2e, 0x89, 0x67, 0xe6, 0xbd, + 0x37, 0xef, 0xf3, 0x79, 0x6f, 0xde, 0xbc, 0x59, 0x98, 0x6b, 0xea, 0x58, 0xdd, 0x15, 0xb1, 0x5a, + 0x22, 0x7f, 0x76, 0x96, 0x4b, 0xc6, 0x5e, 0xb1, 0xdd, 0xd1, 0x0d, 0x9d, 0x9d, 0xb6, 0x97, 0x8a, + 0xe4, 0xcf, 0xce, 0x32, 0x97, 0x33, 0x67, 0x74, 0x5c, 0x6a, 0x88, 0x18, 0x95, 0x76, 0x96, 0x1b, + 0xc8, 0x10, 0x97, 0x4b, 0x4d, 0x5d, 0xd1, 0xa8, 0x06, 0x37, 0x6b, 0xad, 0xab, 0x58, 0x36, 0x2d, + 0xa9, 0x58, 0xb6, 0x16, 0x32, 0xb2, 0x2e, 0xeb, 0xe4, 0x67, 0xc9, 0xfc, 0x65, 0xcd, 0x9e, 0x1b, + 0xde, 0x7b, 0xbf, 0x8d, 0xb0, 0xb5, 0x3a, 0x47, 0x8d, 0xd5, 0xa9, 0x1a, 0x1d, 0x58, 0x4b, 0xa7, + 0x44, 0x55, 0xd1, 0xf4, 0x12, 0xf9, 0x4b, 0xa7, 0xf8, 0x5f, 0x19, 0x48, 0xd7, 0xb0, 0xbc, 0x61, + 0xe8, 0x1d, 0xb4, 0xaa, 0x4b, 0x88, 0x9d, 0x81, 0x38, 0x46, 0x9a, 0x84, 0x3a, 0x59, 0x66, 0x9e, + 0x29, 0xa4, 0x04, 0x6b, 0xc4, 0xde, 0x80, 0x13, 0xe6, 0x6e, 0xf5, 0xc6, 0xbe, 0x81, 0xea, 0x4d, + 0x5d, 0x42, 0xd9, 0xc9, 0x79, 0xa6, 0x90, 0xae, 0x4e, 0x1f, 0xf4, 0xf2, 0xe9, 0xbb, 0x2b, 0x1b, + 0xb5, 0xea, 0xbe, 0x41, 0x2c, 0x08, 0x69, 0x53, 0xce, 0x1e, 0xb1, 0x9b, 0x30, 0xa3, 0x68, 0xd8, + 0x10, 0x35, 0x43, 0x11, 0x0d, 0x54, 0x6f, 0xa3, 0x8e, 0xaa, 0x60, 0xac, 0xe8, 0x5a, 0x36, 0x36, + 0xcf, 0x14, 0xa6, 0xca, 0xb9, 0xa2, 0x97, 0xae, 0xe2, 0x4a, 0xb3, 0x89, 0x30, 0x5e, 0xd5, 0xb5, + 0x2d, 0x45, 0x16, 0xce, 0xb8, 0xb4, 0xd7, 0x1d, 0xe5, 0xca, 0x85, 0x77, 0x9f, 0x3e, 0x58, 0xb4, + 0x7c, 0xfb, 0xf0, 0xe9, 0x83, 0xc5, 0x53, 0x84, 0x0a, 0x37, 0x92, 0xdb, 0xd1, 0x64, 0x64, 0x3a, + 0x7a, 0x3b, 0x9a, 0x8c, 0x4e, 0xc7, 0xf8, 0xbb, 0x90, 0x71, 0xaf, 0x09, 0x08, 0xb7, 0x75, 0x0d, + 0x23, 0xf6, 0x22, 0x24, 0x4c, 0x2c, 0x75, 0x45, 0x22, 0x70, 0xa3, 0x55, 0x38, 0xe8, 0xe5, 0xe3, + 0xa6, 0xc8, 0xda, 0x2d, 0x21, 0x6e, 0x2e, 0xad, 0x49, 0x2c, 0x07, 0xc9, 0xe6, 0x36, 0x6a, 0xde, + 0xc7, 0x5d, 0x95, 0x82, 0x16, 0x9c, 0x31, 0xff, 0x70, 0x12, 0x66, 0x6a, 0x58, 0x5e, 0xeb, 0x3b, + 0xb9, 0xaa, 0x6b, 0x46, 0x47, 0x6c, 0x1a, 0x81, 0x4c, 0x66, 0x20, 0x26, 0x4a, 0xaa, 0xa2, 0x11, + 0x5b, 0x29, 0x81, 0x0e, 0xdc, 0x9e, 0x44, 0x02, 0x3d, 0xc9, 0x40, 0xac, 0x25, 0x36, 0x50, 0x2b, + 0x1b, 0xa5, 0xaa, 0x64, 0xc0, 0x16, 0x20, 0xa2, 0x62, 0x99, 0xf0, 0x99, 0xae, 0xce, 0xfc, 0xd1, + 0xcb, 0xb3, 0x82, 0xb8, 0x6b, 0xbb, 0x51, 0x43, 0x18, 0x8b, 0x32, 0x12, 0x4c, 0x11, 0x76, 0x0b, + 0x62, 0x5b, 0x5d, 0x4d, 0xc2, 0xd9, 0xf8, 0x7c, 0xa4, 0x30, 0x55, 0x9e, 0x2b, 0x5a, 0xe9, 0x61, + 0x26, 0x66, 0xd1, 0x4a, 0xcc, 0xe2, 0xaa, 0xae, 0x68, 0xd5, 0x17, 0x1e, 0xf5, 0xf2, 0x13, 0x5f, + 0xfc, 0x94, 0x2f, 0xc8, 0x8a, 0xb1, 0xdd, 0x6d, 0x14, 0x9b, 0xba, 0x6a, 0xe5, 0x92, 0xf5, 0xef, + 0x1a, 0x96, 0xee, 0x5b, 0x79, 0x67, 0x2a, 0xe0, 0xcf, 0x9e, 0x3e, 0x58, 0x64, 0x04, 0x6a, 0xbe, + 0xf2, 0x5f, 0x4f, 0x74, 0xce, 0xda, 0xd1, 0xf1, 0xe1, 0x89, 0x7f, 0x1d, 0x72, 0xfe, 0x2b, 0x4e, + 0x94, 0xb2, 0x90, 0x10, 0x25, 0xa9, 0x83, 0x30, 0xb6, 0xa8, 0xb4, 0x87, 0x2c, 0x0b, 0x51, 0x49, + 0x34, 0x44, 0x2b, 0x2c, 0xe4, 0x37, 0xff, 0xfb, 0x24, 0xcc, 0xfa, 0x1b, 0x2c, 0xff, 0x8b, 0x63, + 0x62, 0x52, 0x85, 0xc5, 0x96, 0x91, 0x4d, 0x50, 0xaa, 0xcc, 0xdf, 0xec, 0x2c, 0x24, 0xb6, 0x94, + 0xbd, 0xba, 0xe9, 0x69, 0x72, 0x9e, 0x29, 0x24, 0x85, 0xf8, 0x96, 0xb2, 0x57, 0xc3, 0x72, 0x65, + 0xc9, 0x13, 0xc0, 0x73, 0x21, 0x01, 0x2c, 0xf3, 0x6f, 0x40, 0x3e, 0x60, 0xe9, 0x88, 0x21, 0x7c, + 0x6f, 0x12, 0xd8, 0x1a, 0x96, 0x5f, 0xdd, 0x43, 0xcd, 0xee, 0x18, 0x27, 0xca, 0x3c, 0xa0, 0x96, + 0x8c, 0x15, 0x40, 0x67, 0x6c, 0x07, 0x22, 0x72, 0x88, 0x40, 0xc4, 0x9e, 0xef, 0xe1, 0x58, 0xf0, + 0x70, 0x3b, 0x6b, 0x73, 0xeb, 0x81, 0xcb, 0x5f, 0x07, 0x6e, 0x78, 0xd6, 0x61, 0xd4, 0xe6, 0x8d, + 0x71, 0xf1, 0xf6, 0x90, 0x21, 0xbc, 0xd5, 0x14, 0xb9, 0x23, 0x1e, 0x93, 0xb7, 0xb1, 0x72, 0xdf, + 0x22, 0x37, 0x3a, 0x92, 0xdc, 0x60, 0xd0, 0x1e, 0x5f, 0x2d, 0xd0, 0x9e, 0xd9, 0x50, 0xd0, 0xef, + 0x33, 0x70, 0xa2, 0x86, 0xe5, 0xcd, 0xb6, 0x24, 0x1a, 0x68, 0x85, 0x1c, 0xdc, 0x20, 0xc0, 0x67, + 0x21, 0xa5, 0xa1, 0xdd, 0xba, 0xfb, 0xa8, 0x27, 0x35, 0xb4, 0x4b, 0x95, 0xdc, 0x6c, 0x44, 0x06, + 0xd9, 0xa8, 0x5c, 0xf4, 0xb8, 0x7f, 0xda, 0x76, 0xdf, 0xb5, 0x2b, 0x9f, 0x25, 0x57, 0x81, 0x6b, + 0xc6, 0x76, 0x9b, 0x97, 0xe1, 0x3f, 0x35, 0x2c, 0xaf, 0xb6, 0x90, 0xd8, 0x09, 0x77, 0x30, 0xcc, + 0x07, 0xde, 0xe3, 0x03, 0x6b, 0xfb, 0xd0, 0xb7, 0xcb, 0xcf, 0xc2, 0x99, 0x81, 0x09, 0xc7, 0x83, + 0xdf, 0x18, 0xc2, 0x2b, 0x75, 0x6e, 0xf0, 0xa4, 0x6e, 0x29, 0x72, 0xa0, 0x3f, 0xae, 0x2c, 0x98, + 0x0c, 0xcc, 0x82, 0x7b, 0xc0, 0x99, 0xac, 0x06, 0x5c, 0xf3, 0x91, 0xb1, 0xae, 0xf9, 0xac, 0x86, + 0x76, 0xd7, 0x7c, 0x6f, 0xfa, 0x92, 0x07, 0x76, 0x7e, 0x90, 0xfa, 0x21, 0x2c, 0xfc, 0x25, 0xe0, + 0x83, 0x57, 0x1d, 0x42, 0xbe, 0x64, 0xe0, 0xa4, 0x23, 0xb6, 0x2e, 0x76, 0x44, 0x15, 0xb3, 0x37, + 0x20, 0x25, 0x76, 0x8d, 0x6d, 0xbd, 0xa3, 0x18, 0xfb, 0x94, 0x88, 0x6a, 0xf6, 0xfb, 0xaf, 0xae, + 0x65, 0xac, 0x42, 0xb0, 0x42, 0x2b, 0xd6, 0x86, 0xd1, 0x51, 0x34, 0x59, 0xe8, 0x8b, 0xb2, 0x2f, + 0x43, 0xbc, 0x4d, 0x2c, 0x10, 0x92, 0xa6, 0xca, 0xd9, 0x61, 0xb0, 0x74, 0x87, 0x6a, 0xca, 0xac, + 0x1c, 0xb4, 0x1a, 0x58, 0x2a, 0xf4, 0x64, 0xf4, 0x8d, 0x99, 0x10, 0x33, 0x83, 0x10, 0xa9, 0x2e, + 0x3f, 0x47, 0xae, 0x35, 0xf7, 0x94, 0x03, 0xe6, 0x6b, 0x0a, 0x66, 0xa3, 0x2b, 0xe9, 0xce, 0xa1, + 0x3f, 0x2a, 0x98, 0xbf, 0xa4, 0x98, 0x86, 0xa2, 0x72, 0xbb, 0xc9, 0x5f, 0x23, 0xa8, 0xdc, 0x53, + 0xa1, 0x87, 0xfd, 0x53, 0x06, 0xa6, 0x6a, 0x58, 0x5e, 0x57, 0x34, 0x33, 0x09, 0x8f, 0x1e, 0xb2, + 0x9b, 0x26, 0x4a, 0x92, 0xd8, 0x66, 0xd0, 0x22, 0x85, 0x68, 0x35, 0x77, 0xd0, 0xcb, 0x27, 0x68, + 0x66, 0xe3, 0x67, 0xbd, 0xfc, 0xc9, 0x7d, 0x51, 0x6d, 0x55, 0x78, 0x5b, 0x88, 0x17, 0x12, 0x34, + 0xdb, 0x31, 0xad, 0x05, 0x83, 0xd0, 0xa6, 0x6d, 0x68, 0xb6, 0x5f, 0xfc, 0x19, 0x38, 0xed, 0x1a, + 0x3a, 0x81, 0xfa, 0x9c, 0x21, 0x95, 0x60, 0x53, 0x6b, 0xff, 0x8d, 0x00, 0x2e, 0x0f, 0x03, 0x70, + 0x6a, 0x49, 0xdf, 0x33, 0xab, 0x96, 0xf4, 0x27, 0x1c, 0x10, 0xdf, 0x46, 0x49, 0xc7, 0x46, 0xba, + 0xe9, 0x15, 0x4d, 0xf2, 0xeb, 0x7d, 0x8f, 0x8a, 0x6a, 0xf8, 0x95, 0x11, 0x39, 0xe6, 0x2b, 0x23, + 0x7a, 0x8c, 0x57, 0x06, 0x7b, 0x1e, 0xa0, 0x6b, 0xe2, 0xa7, 0xae, 0xc4, 0x48, 0x8b, 0x94, 0xea, + 0xda, 0x8c, 0xf4, 0xbb, 0xc6, 0xb8, 0xbb, 0x6b, 0x74, 0x1a, 0xc2, 0x84, 0x4f, 0x43, 0x98, 0x3c, + 0x44, 0x1f, 0x92, 0x7a, 0xbe, 0x0d, 0xa1, 0x59, 0xf3, 0xf5, 0x6e, 0xa7, 0x89, 0xb2, 0x60, 0xd5, + 0x7c, 0x32, 0x32, 0x5b, 0xb5, 0x46, 0x57, 0x69, 0x99, 0x97, 0xc1, 0x14, 0x6d, 0xd5, 0xac, 0xa1, + 0x79, 0x7d, 0x92, 0x74, 0xda, 0x16, 0xf1, 0x76, 0x36, 0x6d, 0xbd, 0x84, 0x74, 0x09, 0xbd, 0x26, + 0xe2, 0xed, 0xca, 0x8d, 0xe1, 0xac, 0xba, 0x38, 0xf0, 0x28, 0xf3, 0x4f, 0x15, 0xfe, 0x0e, 0x5c, + 0x09, 0x97, 0x38, 0x62, 0x0f, 0xf9, 0x0d, 0x43, 0xba, 0xd2, 0x15, 0x49, 0x32, 0x63, 0xb5, 0xd9, + 0x6e, 0xe9, 0xa2, 0x44, 0xcb, 0xa6, 0x95, 0x7d, 0xc7, 0x38, 0x7c, 0x65, 0x48, 0x89, 0xb6, 0x11, + 0x72, 0xfa, 0x52, 0xd5, 0xcc, 0xb3, 0x5e, 0x7e, 0x9a, 0x1e, 0x39, 0x67, 0x89, 0x17, 0xfa, 0x62, + 0x95, 0x17, 0x87, 0xf9, 0xb9, 0x64, 0xf3, 0x13, 0xe6, 0x24, 0x7f, 0x15, 0x16, 0x46, 0x88, 0x38, + 0x27, 0xf3, 0x3b, 0x86, 0xdc, 0x7d, 0x02, 0x52, 0xf5, 0x1d, 0xf4, 0xcf, 0x80, 0x5d, 0x19, 0x86, + 0xbd, 0x60, 0xc3, 0x1e, 0xe1, 0x27, 0xbf, 0x04, 0x8b, 0xa3, 0xa5, 0x6c, 0xf0, 0xe5, 0x1f, 0xd3, + 0x10, 0xa9, 0x61, 0x99, 0xdd, 0x80, 0x54, 0xff, 0x73, 0x86, 0xcf, 0xc1, 0x77, 0x7f, 0x08, 0xe0, + 0xae, 0x84, 0xaf, 0x3b, 0xb9, 0xf7, 0x36, 0x9c, 0xf6, 0xab, 0x73, 0x05, 0x5f, 0x75, 0x1f, 0x49, + 0xee, 0xfa, 0xb8, 0x92, 0xce, 0x96, 0x06, 0x64, 0x7c, 0xdf, 0xb0, 0x57, 0xc7, 0xb5, 0x54, 0xe6, + 0x96, 0xc7, 0x16, 0x75, 0x76, 0x45, 0x70, 0xd2, 0xfb, 0xec, 0xba, 0xe4, 0x6b, 0xc5, 0x23, 0xc5, + 0x2d, 0x8d, 0x23, 0xe5, 0xde, 0xc6, 0xfb, 0x4a, 0xf1, 0xdf, 0xc6, 0x23, 0x15, 0xb0, 0x4d, 0xd0, + 0x7b, 0xe1, 0x4d, 0x98, 0x72, 0xbf, 0x0b, 0xe6, 0x7d, 0x95, 0x5d, 0x12, 0x5c, 0x61, 0x94, 0x84, + 0x63, 0xfa, 0x0e, 0x80, 0xab, 0xa1, 0xcf, 0xfb, 0xea, 0xf5, 0x05, 0xb8, 0x85, 0x11, 0x02, 0x8e, + 0xdd, 0x77, 0x60, 0x36, 0xa8, 0x4b, 0x5f, 0x0a, 0x71, 0x6e, 0x48, 0x9a, 0xfb, 0xff, 0x61, 0xa4, + 0x9d, 0xed, 0xef, 0x41, 0x7a, 0xa0, 0x27, 0xbe, 0x10, 0x62, 0x85, 0x8a, 0x70, 0x57, 0x47, 0x8a, + 0xb8, 0xad, 0x0f, 0x34, 0xa9, 0xfe, 0xd6, 0xdd, 0x22, 0x01, 0xd6, 0x7d, 0x1b, 0xc6, 0x75, 0x48, + 0x3a, 0x8d, 0xe1, 0x79, 0x5f, 0x35, 0x7b, 0x99, 0xbb, 0x1c, 0xba, 0xec, 0x0e, 0xb2, 0xab, 0x57, + 0xf3, 0x0f, 0x72, 0x5f, 0x20, 0x20, 0xc8, 0xc3, 0x2d, 0x14, 0xfb, 0x01, 0x03, 0x67, 0xc3, 0xfa, + 0xa7, 0xeb, 0xc1, 0x65, 0xc9, 0x5f, 0x83, 0x7b, 0xe9, 0xb0, 0x1a, 0x8e, 0x2f, 0x9f, 0x30, 0x90, + 0x1f, 0x75, 0x63, 0xf8, 0xe7, 0xd2, 0x08, 0x2d, 0xee, 0x95, 0xa3, 0x68, 0x39, 0x7e, 0x7d, 0xc4, + 0xc0, 0xb9, 0xd0, 0xdb, 0xdb, 0xbf, 0xba, 0x85, 0xa9, 0x70, 0x37, 0x0f, 0xad, 0x62, 0xbb, 0x53, + 0xbd, 0xf5, 0xe8, 0x97, 0xdc, 0xc4, 0xa3, 0x83, 0x1c, 0xf3, 0xf8, 0x20, 0xc7, 0xfc, 0x7c, 0x90, + 0x63, 0x3e, 0x7e, 0x92, 0x9b, 0x78, 0xfc, 0x24, 0x37, 0xf1, 0xc3, 0x93, 0xdc, 0xc4, 0x5b, 0x57, + 0x5c, 0x2d, 0xd8, 0xaa, 0x8e, 0xd5, 0xbb, 0xf6, 0xe7, 0x79, 0xa9, 0xb4, 0x47, 0x3f, 0xd3, 0x93, + 0x36, 0xac, 0x11, 0x27, 0x9f, 0xdd, 0xff, 0xf7, 0x67, 0x00, 0x00, 0x00, 0xff, 0xff, 0x9f, 0x81, + 0xf1, 0x23, 0x40, 0x18, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -1472,6 +1667,14 @@ type MsgClient interface { // // Since: 0.40 StoreAndInstantiateContract(ctx context.Context, in *MsgStoreAndInstantiateContract, opts ...grpc.CallOption) (*MsgStoreAndInstantiateContractResponse, error) + // RemoveCodeUploadParamsAddresses defines a governance operation for + // removing addresses from code upload params. + // The authority is defined in the keeper. + RemoveCodeUploadParamsAddresses(ctx context.Context, in *MsgRemoveCodeUploadParamsAddresses, opts ...grpc.CallOption) (*MsgRemoveCodeUploadParamsAddressesResponse, error) + // AddCodeUploadParamsAddresses defines a governance operation for + // adding addresses to code upload params. + // The authority is defined in the keeper. + AddCodeUploadParamsAddresses(ctx context.Context, in *MsgAddCodeUploadParamsAddresses, opts ...grpc.CallOption) (*MsgAddCodeUploadParamsAddressesResponse, error) } type msgClient struct { @@ -1599,6 +1802,24 @@ func (c *msgClient) StoreAndInstantiateContract(ctx context.Context, in *MsgStor return out, nil } +func (c *msgClient) RemoveCodeUploadParamsAddresses(ctx context.Context, in *MsgRemoveCodeUploadParamsAddresses, opts ...grpc.CallOption) (*MsgRemoveCodeUploadParamsAddressesResponse, error) { + out := new(MsgRemoveCodeUploadParamsAddressesResponse) + err := c.cc.Invoke(ctx, "/cosmwasm.wasm.v1.Msg/RemoveCodeUploadParamsAddresses", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) AddCodeUploadParamsAddresses(ctx context.Context, in *MsgAddCodeUploadParamsAddresses, opts ...grpc.CallOption) (*MsgAddCodeUploadParamsAddressesResponse, error) { + out := new(MsgAddCodeUploadParamsAddressesResponse) + err := c.cc.Invoke(ctx, "/cosmwasm.wasm.v1.Msg/AddCodeUploadParamsAddresses", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // MsgServer is the server API for Msg service. type MsgServer interface { // StoreCode to submit Wasm code to the system @@ -1644,6 +1865,14 @@ type MsgServer interface { // // Since: 0.40 StoreAndInstantiateContract(context.Context, *MsgStoreAndInstantiateContract) (*MsgStoreAndInstantiateContractResponse, error) + // RemoveCodeUploadParamsAddresses defines a governance operation for + // removing addresses from code upload params. + // The authority is defined in the keeper. + RemoveCodeUploadParamsAddresses(context.Context, *MsgRemoveCodeUploadParamsAddresses) (*MsgRemoveCodeUploadParamsAddressesResponse, error) + // AddCodeUploadParamsAddresses defines a governance operation for + // adding addresses to code upload params. + // The authority is defined in the keeper. + AddCodeUploadParamsAddresses(context.Context, *MsgAddCodeUploadParamsAddresses) (*MsgAddCodeUploadParamsAddressesResponse, error) } // UnimplementedMsgServer can be embedded to have forward compatible implementations. @@ -1701,6 +1930,14 @@ func (*UnimplementedMsgServer) StoreAndInstantiateContract(ctx context.Context, return nil, status.Errorf(codes.Unimplemented, "method StoreAndInstantiateContract not implemented") } +func (*UnimplementedMsgServer) RemoveCodeUploadParamsAddresses(ctx context.Context, req *MsgRemoveCodeUploadParamsAddresses) (*MsgRemoveCodeUploadParamsAddressesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RemoveCodeUploadParamsAddresses not implemented") +} + +func (*UnimplementedMsgServer) AddCodeUploadParamsAddresses(ctx context.Context, req *MsgAddCodeUploadParamsAddresses) (*MsgAddCodeUploadParamsAddressesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method AddCodeUploadParamsAddresses not implemented") +} + func RegisterMsgServer(s grpc1.Server, srv MsgServer) { s.RegisterService(&_Msg_serviceDesc, srv) } @@ -1939,6 +2176,42 @@ func _Msg_StoreAndInstantiateContract_Handler(srv interface{}, ctx context.Conte return interceptor(ctx, in, info, handler) } +func _Msg_RemoveCodeUploadParamsAddresses_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgRemoveCodeUploadParamsAddresses) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).RemoveCodeUploadParamsAddresses(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmwasm.wasm.v1.Msg/RemoveCodeUploadParamsAddresses", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).RemoveCodeUploadParamsAddresses(ctx, req.(*MsgRemoveCodeUploadParamsAddresses)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_AddCodeUploadParamsAddresses_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgAddCodeUploadParamsAddresses) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).AddCodeUploadParamsAddresses(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/cosmwasm.wasm.v1.Msg/AddCodeUploadParamsAddresses", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).AddCodeUploadParamsAddresses(ctx, req.(*MsgAddCodeUploadParamsAddresses)) + } + return interceptor(ctx, in, info, handler) +} + var _Msg_serviceDesc = grpc.ServiceDesc{ ServiceName: "cosmwasm.wasm.v1.Msg", HandlerType: (*MsgServer)(nil), @@ -1995,6 +2268,14 @@ var _Msg_serviceDesc = grpc.ServiceDesc{ MethodName: "StoreAndInstantiateContract", Handler: _Msg_StoreAndInstantiateContract_Handler, }, + { + MethodName: "RemoveCodeUploadParamsAddresses", + Handler: _Msg_RemoveCodeUploadParamsAddresses_Handler, + }, + { + MethodName: "AddCodeUploadParamsAddresses", + Handler: _Msg_AddCodeUploadParamsAddresses_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "cosmwasm/wasm/v1/tx.proto", @@ -3110,6 +3391,130 @@ func (m *MsgStoreAndInstantiateContractResponse) MarshalToSizedBuffer(dAtA []byt return len(dAtA) - i, nil } +func (m *MsgAddCodeUploadParamsAddresses) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgAddCodeUploadParamsAddresses) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgAddCodeUploadParamsAddresses) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Addresses) > 0 { + for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Addresses[iNdEx]) + copy(dAtA[i:], m.Addresses[iNdEx]) + i = encodeVarintTx(dAtA, i, uint64(len(m.Addresses[iNdEx]))) + i-- + dAtA[i] = 0x12 + } + } + if len(m.Authority) > 0 { + i -= len(m.Authority) + copy(dAtA[i:], m.Authority) + i = encodeVarintTx(dAtA, i, uint64(len(m.Authority))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgAddCodeUploadParamsAddressesResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgAddCodeUploadParamsAddressesResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgAddCodeUploadParamsAddressesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgRemoveCodeUploadParamsAddresses) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgRemoveCodeUploadParamsAddresses) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgRemoveCodeUploadParamsAddresses) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Addresses) > 0 { + for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- { + i -= len(m.Addresses[iNdEx]) + copy(dAtA[i:], m.Addresses[iNdEx]) + i = encodeVarintTx(dAtA, i, uint64(len(m.Addresses[iNdEx]))) + i-- + dAtA[i] = 0x12 + } + } + if len(m.Authority) > 0 { + i -= len(m.Authority) + copy(dAtA[i:], m.Authority) + i = encodeVarintTx(dAtA, i, uint64(len(m.Authority))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgRemoveCodeUploadParamsAddressesResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgRemoveCodeUploadParamsAddressesResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgRemoveCodeUploadParamsAddressesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + func encodeVarintTx(dAtA []byte, offset int, v uint64) int { offset -= sovTx(v) base := offset @@ -3617,8 +4022,64 @@ func (m *MsgStoreAndInstantiateContractResponse) Size() (n int) { return n } -func sovTx(x uint64) (n int) { - return (math_bits.Len64(x|1) + 6) / 7 +func (m *MsgAddCodeUploadParamsAddresses) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Authority) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if len(m.Addresses) > 0 { + for _, s := range m.Addresses { + l = len(s) + n += 1 + l + sovTx(uint64(l)) + } + } + return n +} + +func (m *MsgAddCodeUploadParamsAddressesResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgRemoveCodeUploadParamsAddresses) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Authority) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + if len(m.Addresses) > 0 { + for _, s := range m.Addresses { + l = len(s) + n += 1 + l + sovTx(uint64(l)) + } + } + return n +} + +func (m *MsgRemoveCodeUploadParamsAddressesResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func sovTx(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 } func sozTx(x uint64) (n int) { @@ -7053,6 +7514,338 @@ func (m *MsgStoreAndInstantiateContractResponse) Unmarshal(dAtA []byte) error { return nil } +func (m *MsgAddCodeUploadParamsAddresses) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgAddCodeUploadParamsAddresses: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgAddCodeUploadParamsAddresses: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Authority = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *MsgAddCodeUploadParamsAddressesResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgAddCodeUploadParamsAddressesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgAddCodeUploadParamsAddressesResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *MsgRemoveCodeUploadParamsAddresses) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgRemoveCodeUploadParamsAddresses: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgRemoveCodeUploadParamsAddresses: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Authority", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Authority = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex])) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + +func (m *MsgRemoveCodeUploadParamsAddressesResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgRemoveCodeUploadParamsAddressesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgRemoveCodeUploadParamsAddressesResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} + func skipTx(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/wasm/types/tx_test.go b/x/wasm/types/tx_test.go index fd5cf5ba11..95bd3542ec 100644 --- a/x/wasm/types/tx_test.go +++ b/x/wasm/types/tx_test.go @@ -14,9 +14,7 @@ import ( const firstCodeID = 1 func TestStoreCodeValidation(t *testing.T) { - bad, err := sdk.AccAddressFromHexUnsafe("012345") - require.NoError(t, err) - badAddress := bad.String() + badAddress := "abcd" // proper address size goodAddress := sdk.AccAddress(make([]byte, ContractAddrLen)).String() sdk.GetConfig().SetAddressVerifier(VerifyAddressLen()) @@ -78,9 +76,7 @@ func TestStoreCodeValidation(t *testing.T) { } func TestInstantiateContractValidation(t *testing.T) { - bad, err := sdk.AccAddressFromHexUnsafe("012345") - require.NoError(t, err) - badAddress := bad.String() + badAddress := "abcd" // proper address size goodAddress := sdk.AccAddress(make([]byte, 20)).String() sdk.GetConfig().SetAddressVerifier(VerifyAddressLen()) @@ -186,9 +182,7 @@ func TestInstantiateContractValidation(t *testing.T) { } func TestInstantiateContract2Validation(t *testing.T) { - bad, err := sdk.AccAddressFromHexUnsafe("012345") - require.NoError(t, err) - badAddress := bad.String() + badAddress := "abcd" // proper address size goodAddress := sdk.AccAddress(make([]byte, 20)).String() sdk.GetConfig().SetAddressVerifier(VerifyAddressLen()) @@ -322,9 +316,7 @@ func TestInstantiateContract2Validation(t *testing.T) { } func TestExecuteContractValidation(t *testing.T) { - bad, err := sdk.AccAddressFromHexUnsafe("012345") - require.NoError(t, err) - badAddress := bad.String() + badAddress := "abcd" // proper address size goodAddress := sdk.AccAddress(make([]byte, 20)).String() @@ -431,9 +423,7 @@ func TestExecuteContractValidation(t *testing.T) { } func TestMsgUpdateAdministrator(t *testing.T) { - bad, err := sdk.AccAddressFromHexUnsafe("012345") - require.NoError(t, err) - badAddress := bad.String() + badAddress := "abcd" // proper address size goodAddress := sdk.AccAddress(make([]byte, 20)).String() otherGoodAddress := sdk.AccAddress(bytes.Repeat([]byte{0x1}, 20)).String() @@ -503,9 +493,7 @@ func TestMsgUpdateAdministrator(t *testing.T) { } func TestMsgClearAdministrator(t *testing.T) { - bad, err := sdk.AccAddressFromHexUnsafe("012345") - require.NoError(t, err) - badAddress := bad.String() + badAddress := "abcd" // proper address size goodAddress := sdk.AccAddress(make([]byte, 20)).String() anotherGoodAddress := sdk.AccAddress(bytes.Repeat([]byte{0x2}, 20)).String() @@ -554,9 +542,7 @@ func TestMsgClearAdministrator(t *testing.T) { } func TestMsgMigrateContract(t *testing.T) { - bad, err := sdk.AccAddressFromHexUnsafe("012345") - require.NoError(t, err) - badAddress := bad.String() + badAddress := "abcd" // proper address size goodAddress := sdk.AccAddress(make([]byte, 20)).String() anotherGoodAddress := sdk.AccAddress(bytes.Repeat([]byte{0x2}, 20)).String() @@ -680,9 +666,7 @@ func TestMsgJsonSignBytes(t *testing.T) { } func TestMsgUpdateInstantiateConfig(t *testing.T) { - bad, err := sdk.AccAddressFromHexUnsafe("012345") - require.NoError(t, err) - badAddress := bad.String() + badAddress := "abcd" // proper address size goodAddress := sdk.AccAddress(make([]byte, 20)).String() anotherGoodAddress := sdk.AccAddress(bytes.Repeat([]byte{0x2}, 20)).String() @@ -742,9 +726,7 @@ func TestMsgUpdateInstantiateConfig(t *testing.T) { } func TestMsgUpdateParamsValidation(t *testing.T) { - bad, err := sdk.AccAddressFromHexUnsafe("012345") - require.NoError(t, err) - badAddress := bad.String() + badAddress := "abcd" // proper address size goodAddress := sdk.AccAddress(make([]byte, 20)).String() @@ -784,10 +766,130 @@ func TestMsgUpdateParamsValidation(t *testing.T) { } } +func TestMsgAddCodeUploadParamsAddressesValidation(t *testing.T) { + badAddress := "abcd" + // proper address size + goodAddress := sdk.AccAddress(make([]byte, 20)).String() + + specs := map[string]struct { + src MsgAddCodeUploadParamsAddresses + expErr bool + }{ + "all good": { + src: MsgAddCodeUploadParamsAddresses{ + Authority: goodAddress, + Addresses: []string{goodAddress}, + }, + }, + "bad authority": { + src: MsgAddCodeUploadParamsAddresses{ + Authority: badAddress, + Addresses: []string{goodAddress}, + }, + expErr: true, + }, + "empty authority": { + src: MsgAddCodeUploadParamsAddresses{ + Addresses: []string{goodAddress}, + }, + expErr: true, + }, + "empty addresses": { + src: MsgAddCodeUploadParamsAddresses{ + Authority: goodAddress, + }, + expErr: true, + }, + "invalid addresses": { + src: MsgAddCodeUploadParamsAddresses{ + Authority: goodAddress, + Addresses: []string{badAddress}, + }, + expErr: true, + }, + "duplicate addresses": { + src: MsgAddCodeUploadParamsAddresses{ + Authority: goodAddress, + Addresses: []string{goodAddress, goodAddress}, + }, + expErr: true, + }, + } + for msg, spec := range specs { + t.Run(msg, func(t *testing.T) { + err := spec.src.ValidateBasic() + if spec.expErr { + require.Error(t, err) + return + } + require.NoError(t, err) + }) + } +} + +func TestMsgRemoveCodeUploadParamsAddressesValidation(t *testing.T) { + badAddress := "abcd" + // proper address size + goodAddress := sdk.AccAddress(make([]byte, 20)).String() + + specs := map[string]struct { + src MsgRemoveCodeUploadParamsAddresses + expErr bool + }{ + "all good": { + src: MsgRemoveCodeUploadParamsAddresses{ + Authority: goodAddress, + Addresses: []string{goodAddress}, + }, + }, + "bad authority": { + src: MsgRemoveCodeUploadParamsAddresses{ + Authority: badAddress, + Addresses: []string{goodAddress}, + }, + expErr: true, + }, + "empty authority": { + src: MsgRemoveCodeUploadParamsAddresses{ + Addresses: []string{goodAddress}, + }, + expErr: true, + }, + "empty addresses": { + src: MsgRemoveCodeUploadParamsAddresses{ + Authority: goodAddress, + }, + expErr: true, + }, + "invalid addresses": { + src: MsgRemoveCodeUploadParamsAddresses{ + Authority: goodAddress, + Addresses: []string{badAddress}, + }, + expErr: true, + }, + "duplicate addresses": { + src: MsgRemoveCodeUploadParamsAddresses{ + Authority: goodAddress, + Addresses: []string{goodAddress, goodAddress}, + }, + expErr: true, + }, + } + for msg, spec := range specs { + t.Run(msg, func(t *testing.T) { + err := spec.src.ValidateBasic() + if spec.expErr { + require.Error(t, err) + return + } + require.NoError(t, err) + }) + } +} + func TestMsgPinCodesValidation(t *testing.T) { - bad, err := sdk.AccAddressFromHexUnsafe("012345") - require.NoError(t, err) - badAddress := bad.String() + badAddress := "abcd" // proper address size goodAddress := sdk.AccAddress(make([]byte, 20)).String() @@ -834,9 +936,7 @@ func TestMsgPinCodesValidation(t *testing.T) { } func TestMsgUnpinCodesValidation(t *testing.T) { - bad, err := sdk.AccAddressFromHexUnsafe("012345") - require.NoError(t, err) - badAddress := bad.String() + badAddress := "abcd" // proper address size goodAddress := sdk.AccAddress(make([]byte, 20)).String() @@ -883,9 +983,7 @@ func TestMsgUnpinCodesValidation(t *testing.T) { } func TestMsgSudoContractValidation(t *testing.T) { - bad, err := sdk.AccAddressFromHexUnsafe("012345") - require.NoError(t, err) - badAddress := bad.String() + badAddress := "abcd" // proper address size goodAddress := sdk.AccAddress(make([]byte, 20)).String() anotherGoodAddress := sdk.AccAddress(bytes.Repeat([]byte{0x2}, 20)).String() @@ -960,9 +1058,7 @@ func TestMsgSudoContractValidation(t *testing.T) { } func TestMsgStoreAndInstantiateContractValidation(t *testing.T) { - bad, err := sdk.AccAddressFromHexUnsafe("012345") - require.NoError(t, err) - badAddress := bad.String() + badAddress := "abcd" // proper address size goodAddress := sdk.AccAddress(make([]byte, 20)).String() sdk.GetConfig().SetAddressVerifier(VerifyAddressLen())