From 21809bc112681a0044b360ee90368914bd6d28d1 Mon Sep 17 00:00:00 2001
From: pinosu <95283998+pinosu@users.noreply.github.com>
Date: Wed, 4 Oct 2023 09:32:25 +0200
Subject: [PATCH] Revert "Remove gov v1beta1 dependencies and deprecated
proposals (#1645)"
This reverts commit cb9f569b3aad3f1c68003210b695086957489941.
---
app/app.go | 7 +
docs/proto/proto-docs.md | 343 +-
proto/cosmwasm/wasm/v1/proposal.proto | 330 +
proto/cosmwasm/wasm/v1/tx.proto | 10 -
x/wasm/alias.go | 20 +
x/wasm/keeper/handler_plugin_encoders_test.go | 20 +-
x/wasm/keeper/proposal_handler.go | 342 +
x/wasm/keeper/proposal_integration_test.go | 940 +++
x/wasm/types/codec.go | 25 +
x/wasm/types/proposal.go | 987 +++
x/wasm/types/proposal.pb.go | 5855 +++++++++++++++++
x/wasm/types/proposal_test.go | 1130 ++++
x/wasm/types/test_fixtures.go | 250 +
x/wasm/types/tx.pb.go | 496 +-
14 files changed, 10367 insertions(+), 388 deletions(-)
create mode 100644 proto/cosmwasm/wasm/v1/proposal.proto
create mode 100644 x/wasm/keeper/proposal_handler.go
create mode 100644 x/wasm/keeper/proposal_integration_test.go
create mode 100644 x/wasm/types/proposal.go
create mode 100644 x/wasm/types/proposal.pb.go
create mode 100644 x/wasm/types/proposal_test.go
diff --git a/app/app.go b/app/app.go
index 409455e9dd..aa1e321f15 100644
--- a/app/app.go
+++ b/app/app.go
@@ -579,6 +579,13 @@ func NewWasmApp(
wasmOpts...,
)
+ // DEPRECATED: DO NOT USE
+ //
+ // The gov proposal types can be individually enabled
+ // if len(enabledProposals) != 0 {
+ // govRouter.AddRoute(wasmtypes.RouterKey, wasmkeeper.NewWasmProposalHandler(app.WasmKeeper, enabledProposals))
+ //}
+
// Set legacy router for backwards compatibility with gov v1beta1
app.GovKeeper.SetLegacyRouter(govRouter)
diff --git a/docs/proto/proto-docs.md b/docs/proto/proto-docs.md
index 2ea6190ed0..e7e57fa619 100644
--- a/docs/proto/proto-docs.md
+++ b/docs/proto/proto-docs.md
@@ -41,6 +41,21 @@
- [MsgIBCSend](#cosmwasm.wasm.v1.MsgIBCSend)
- [MsgIBCSendResponse](#cosmwasm.wasm.v1.MsgIBCSendResponse)
+- [cosmwasm/wasm/v1/proposal.proto](#cosmwasm/wasm/v1/proposal.proto)
+ - [AccessConfigUpdate](#cosmwasm.wasm.v1.AccessConfigUpdate)
+ - [ClearAdminProposal](#cosmwasm.wasm.v1.ClearAdminProposal)
+ - [ExecuteContractProposal](#cosmwasm.wasm.v1.ExecuteContractProposal)
+ - [InstantiateContract2Proposal](#cosmwasm.wasm.v1.InstantiateContract2Proposal)
+ - [InstantiateContractProposal](#cosmwasm.wasm.v1.InstantiateContractProposal)
+ - [MigrateContractProposal](#cosmwasm.wasm.v1.MigrateContractProposal)
+ - [PinCodesProposal](#cosmwasm.wasm.v1.PinCodesProposal)
+ - [StoreAndInstantiateContractProposal](#cosmwasm.wasm.v1.StoreAndInstantiateContractProposal)
+ - [StoreCodeProposal](#cosmwasm.wasm.v1.StoreCodeProposal)
+ - [SudoContractProposal](#cosmwasm.wasm.v1.SudoContractProposal)
+ - [UnpinCodesProposal](#cosmwasm.wasm.v1.UnpinCodesProposal)
+ - [UpdateAdminProposal](#cosmwasm.wasm.v1.UpdateAdminProposal)
+ - [UpdateInstantiateConfigProposal](#cosmwasm.wasm.v1.UpdateInstantiateConfigProposal)
+
- [cosmwasm/wasm/v1/query.proto](#cosmwasm/wasm/v1/query.proto)
- [CodeInfoResponse](#cosmwasm.wasm.v1.CodeInfoResponse)
- [QueryAllContractStateRequest](#cosmwasm.wasm.v1.QueryAllContractStateRequest)
@@ -69,7 +84,6 @@
- [Query](#cosmwasm.wasm.v1.Query)
- [cosmwasm/wasm/v1/tx.proto](#cosmwasm/wasm/v1/tx.proto)
- - [AccessConfigUpdate](#cosmwasm.wasm.v1.AccessConfigUpdate)
- [MsgAddCodeUploadParamsAddresses](#cosmwasm.wasm.v1.MsgAddCodeUploadParamsAddresses)
- [MsgAddCodeUploadParamsAddressesResponse](#cosmwasm.wasm.v1.MsgAddCodeUploadParamsAddressesResponse)
- [MsgClearAdmin](#cosmwasm.wasm.v1.MsgClearAdmin)
@@ -625,6 +639,316 @@ MsgIBCSendResponse
+
+
+
+
+
+
+
+
+
+
+
+Top
+
+## cosmwasm/wasm/v1/proposal.proto
+
+
+
+
+
+### AccessConfigUpdate
+AccessConfigUpdate contains the code id and the access config to be
+applied.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `code_id` | [uint64](#uint64) | | CodeID is the reference to the stored WASM code to be updated |
+| `instantiate_permission` | [AccessConfig](#cosmwasm.wasm.v1.AccessConfig) | | InstantiatePermission to apply to the set of code ids |
+
+
+
+
+
+
+
+
+### ClearAdminProposal
+Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+an explicit ClearAdminProposal. To clear the admin of a contract,
+a simple MsgClearAdmin can be invoked from the x/gov module via
+a v1 governance proposal.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `title` | [string](#string) | | Title is a short summary |
+| `description` | [string](#string) | | Description is a human readable text |
+| `contract` | [string](#string) | | Contract is the address of the smart contract |
+
+
+
+
+
+
+
+
+### ExecuteContractProposal
+Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+an explicit ExecuteContractProposal. To call execute on a contract,
+a simple MsgExecuteContract can be invoked from the x/gov module via
+a v1 governance proposal.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `title` | [string](#string) | | Title is a short summary |
+| `description` | [string](#string) | | Description is a human readable text |
+| `run_as` | [string](#string) | | RunAs is the address that is passed to the contract's environment as sender |
+| `contract` | [string](#string) | | Contract is the address of the smart contract |
+| `msg` | [bytes](#bytes) | | Msg json encoded message to be passed to the contract as execute |
+| `funds` | [cosmos.base.v1beta1.Coin](#cosmos.base.v1beta1.Coin) | repeated | Funds coins that are transferred to the contract on instantiation |
+
+
+
+
+
+
+
+
+### InstantiateContract2Proposal
+Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+an explicit InstantiateContract2Proposal. To instantiate contract 2,
+a simple MsgInstantiateContract2 can be invoked from the x/gov module via
+a v1 governance proposal.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `title` | [string](#string) | | Title is a short summary |
+| `description` | [string](#string) | | Description is a human readable text |
+| `run_as` | [string](#string) | | RunAs is the address that is passed to the contract's enviroment as sender |
+| `admin` | [string](#string) | | Admin is an optional address that can execute migrations |
+| `code_id` | [uint64](#uint64) | | CodeID is the reference to the stored WASM code |
+| `label` | [string](#string) | | Label is optional metadata to be stored with a constract instance. |
+| `msg` | [bytes](#bytes) | | Msg json encode message to be passed to the contract on instantiation |
+| `funds` | [cosmos.base.v1beta1.Coin](#cosmos.base.v1beta1.Coin) | repeated | Funds coins that are transferred to the contract on instantiation |
+| `salt` | [bytes](#bytes) | | Salt is an arbitrary value provided by the sender. Size can be 1 to 64. |
+| `fix_msg` | [bool](#bool) | | FixMsg include the msg value into the hash for the predictable address. Default is false |
+
+
+
+
+
+
+
+
+### InstantiateContractProposal
+Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+an explicit InstantiateContractProposal. To instantiate a contract,
+a simple MsgInstantiateContract can be invoked from the x/gov module via
+a v1 governance proposal.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `title` | [string](#string) | | Title is a short summary |
+| `description` | [string](#string) | | Description is a human readable text |
+| `run_as` | [string](#string) | | RunAs is the address that is passed to the contract's environment as sender |
+| `admin` | [string](#string) | | Admin is an optional address that can execute migrations |
+| `code_id` | [uint64](#uint64) | | CodeID is the reference to the stored WASM code |
+| `label` | [string](#string) | | Label is optional metadata to be stored with a constract instance. |
+| `msg` | [bytes](#bytes) | | Msg json encoded message to be passed to the contract on instantiation |
+| `funds` | [cosmos.base.v1beta1.Coin](#cosmos.base.v1beta1.Coin) | repeated | Funds coins that are transferred to the contract on instantiation |
+
+
+
+
+
+
+
+
+### MigrateContractProposal
+Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+an explicit MigrateContractProposal. To migrate a contract,
+a simple MsgMigrateContract can be invoked from the x/gov module via
+a v1 governance proposal.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `title` | [string](#string) | | Title is a short summary |
+| `description` | [string](#string) | | Description is a human readable text
+
+Note: skipping 3 as this was previously used for unneeded run_as |
+| `contract` | [string](#string) | | Contract is the address of the smart contract |
+| `code_id` | [uint64](#uint64) | | CodeID references the new WASM code |
+| `msg` | [bytes](#bytes) | | Msg json encoded message to be passed to the contract on migration |
+
+
+
+
+
+
+
+
+### PinCodesProposal
+Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+an explicit PinCodesProposal. To pin a set of code ids in the wasmvm
+cache, a simple MsgPinCodes can be invoked from the x/gov module via
+a v1 governance proposal.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `title` | [string](#string) | | Title is a short summary |
+| `description` | [string](#string) | | Description is a human readable text |
+| `code_ids` | [uint64](#uint64) | repeated | CodeIDs references the new WASM codes |
+
+
+
+
+
+
+
+
+### StoreAndInstantiateContractProposal
+Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+an explicit StoreAndInstantiateContractProposal. To store and instantiate
+the contract, a simple MsgStoreAndInstantiateContract can be invoked from
+the x/gov module via a v1 governance proposal.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `title` | [string](#string) | | Title is a short summary |
+| `description` | [string](#string) | | Description is a human readable text |
+| `run_as` | [string](#string) | | RunAs is the address that is passed to the contract's environment as sender |
+| `wasm_byte_code` | [bytes](#bytes) | | WASMByteCode can be raw or gzip compressed |
+| `instantiate_permission` | [AccessConfig](#cosmwasm.wasm.v1.AccessConfig) | | InstantiatePermission to apply on contract creation, optional |
+| `unpin_code` | [bool](#bool) | | UnpinCode code on upload, optional |
+| `admin` | [string](#string) | | Admin is an optional address that can execute migrations |
+| `label` | [string](#string) | | Label is optional metadata to be stored with a constract instance. |
+| `msg` | [bytes](#bytes) | | Msg json encoded message to be passed to the contract on instantiation |
+| `funds` | [cosmos.base.v1beta1.Coin](#cosmos.base.v1beta1.Coin) | repeated | Funds coins that are transferred to the contract on instantiation |
+| `source` | [string](#string) | | Source is the URL where the code is hosted |
+| `builder` | [string](#string) | | Builder is the docker image used to build the code deterministically, used for smart contract verification |
+| `code_hash` | [bytes](#bytes) | | CodeHash is the SHA256 sum of the code outputted by builder, used for smart contract verification |
+
+
+
+
+
+
+
+
+### StoreCodeProposal
+Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+an explicit StoreCodeProposal. To submit WASM code to the system,
+a simple MsgStoreCode can be invoked from the x/gov module via
+a v1 governance proposal.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `title` | [string](#string) | | Title is a short summary |
+| `description` | [string](#string) | | Description is a human readable text |
+| `run_as` | [string](#string) | | RunAs is the address that is passed to the contract's environment as sender |
+| `wasm_byte_code` | [bytes](#bytes) | | WASMByteCode can be raw or gzip compressed |
+| `instantiate_permission` | [AccessConfig](#cosmwasm.wasm.v1.AccessConfig) | | InstantiatePermission to apply on contract creation, optional |
+| `unpin_code` | [bool](#bool) | | UnpinCode code on upload, optional |
+| `source` | [string](#string) | | Source is the URL where the code is hosted |
+| `builder` | [string](#string) | | Builder is the docker image used to build the code deterministically, used for smart contract verification |
+| `code_hash` | [bytes](#bytes) | | CodeHash is the SHA256 sum of the code outputted by builder, used for smart contract verification |
+
+
+
+
+
+
+
+
+### SudoContractProposal
+Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+an explicit SudoContractProposal. To call sudo on a contract,
+a simple MsgSudoContract can be invoked from the x/gov module via
+a v1 governance proposal.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `title` | [string](#string) | | Title is a short summary |
+| `description` | [string](#string) | | Description is a human readable text |
+| `contract` | [string](#string) | | Contract is the address of the smart contract |
+| `msg` | [bytes](#bytes) | | Msg json encoded message to be passed to the contract as sudo |
+
+
+
+
+
+
+
+
+### UnpinCodesProposal
+Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+an explicit UnpinCodesProposal. To unpin a set of code ids in the wasmvm
+cache, a simple MsgUnpinCodes can be invoked from the x/gov module via
+a v1 governance proposal.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `title` | [string](#string) | | Title is a short summary |
+| `description` | [string](#string) | | Description is a human readable text |
+| `code_ids` | [uint64](#uint64) | repeated | CodeIDs references the WASM codes |
+
+
+
+
+
+
+
+
+### UpdateAdminProposal
+Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+an explicit UpdateAdminProposal. To set an admin for a contract,
+a simple MsgUpdateAdmin can be invoked from the x/gov module via
+a v1 governance proposal.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `title` | [string](#string) | | Title is a short summary |
+| `description` | [string](#string) | | Description is a human readable text |
+| `new_admin` | [string](#string) | | NewAdmin address to be set |
+| `contract` | [string](#string) | | Contract is the address of the smart contract |
+
+
+
+
+
+
+
+
+### UpdateInstantiateConfigProposal
+Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+an explicit UpdateInstantiateConfigProposal. To update instantiate config
+to a set of code ids, a simple MsgUpdateInstantiateConfig can be invoked from
+the x/gov module via a v1 governance proposal.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `title` | [string](#string) | | Title is a short summary |
+| `description` | [string](#string) | | Description is a human readable text |
+| `access_config_updates` | [AccessConfigUpdate](#cosmwasm.wasm.v1.AccessConfigUpdate) | repeated | AccessConfigUpdate contains the list of code ids and the access config to be applied. |
+
+
+
+
+
@@ -1051,23 +1375,6 @@ Query provides defines the gRPC querier service
-
-
-### AccessConfigUpdate
-AccessConfigUpdate contains the code id and the access config to be
-applied.
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| `code_id` | [uint64](#uint64) | | CodeID is the reference to the stored WASM code to be updated |
-| `instantiate_permission` | [AccessConfig](#cosmwasm.wasm.v1.AccessConfig) | | InstantiatePermission to apply to the set of code ids |
-
-
-
-
-
-
### MsgAddCodeUploadParamsAddresses
diff --git a/proto/cosmwasm/wasm/v1/proposal.proto b/proto/cosmwasm/wasm/v1/proposal.proto
new file mode 100644
index 0000000000..eedbb9b399
--- /dev/null
+++ b/proto/cosmwasm/wasm/v1/proposal.proto
@@ -0,0 +1,330 @@
+syntax = "proto3";
+package cosmwasm.wasm.v1;
+
+import "gogoproto/gogo.proto";
+import "cosmos_proto/cosmos.proto";
+import "cosmos/base/v1beta1/coin.proto";
+import "cosmwasm/wasm/v1/types.proto";
+import "amino/amino.proto";
+
+option go_package = "github.com/CosmWasm/wasmd/x/wasm/types";
+option (gogoproto.goproto_stringer_all) = false;
+option (gogoproto.goproto_getters_all) = false;
+option (gogoproto.equal_all) = true;
+
+// Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+// an explicit StoreCodeProposal. To submit WASM code to the system,
+// a simple MsgStoreCode can be invoked from the x/gov module via
+// a v1 governance proposal.
+message StoreCodeProposal {
+ option deprecated = true;
+ option (amino.name) = "wasm/StoreCodeProposal";
+ option (cosmos_proto.implements_interface) = "cosmos.gov.v1beta1.Content";
+
+ // Title is a short summary
+ string title = 1;
+ // Description is a human readable text
+ string description = 2;
+ // RunAs is the address that is passed to the contract's environment as sender
+ string run_as = 3;
+ // WASMByteCode can be raw or gzip compressed
+ bytes wasm_byte_code = 4 [ (gogoproto.customname) = "WASMByteCode" ];
+ // Used in v1beta1
+ reserved 5, 6;
+ // InstantiatePermission to apply on contract creation, optional
+ AccessConfig instantiate_permission = 7;
+ // UnpinCode code on upload, optional
+ bool unpin_code = 8;
+ // Source is the URL where the code is hosted
+ string source = 9;
+ // Builder is the docker image used to build the code deterministically, used
+ // for smart contract verification
+ string builder = 10;
+ // CodeHash is the SHA256 sum of the code outputted by builder, used for smart
+ // contract verification
+ bytes code_hash = 11;
+}
+
+// Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+// an explicit InstantiateContractProposal. To instantiate a contract,
+// a simple MsgInstantiateContract can be invoked from the x/gov module via
+// a v1 governance proposal.
+message InstantiateContractProposal {
+ option deprecated = true;
+ option (amino.name) = "wasm/InstantiateContractProposal";
+ option (cosmos_proto.implements_interface) = "cosmos.gov.v1beta1.Content";
+
+ // Title is a short summary
+ string title = 1;
+ // Description is a human readable text
+ string description = 2;
+ // RunAs is the address that is passed to the contract's environment as sender
+ string run_as = 3;
+ // Admin is an optional address that can execute migrations
+ string admin = 4;
+ // CodeID is the reference to the stored WASM code
+ uint64 code_id = 5 [ (gogoproto.customname) = "CodeID" ];
+ // Label is optional metadata to be stored with a constract instance.
+ string label = 6;
+ // Msg json encoded message to be passed to the contract on instantiation
+ bytes msg = 7 [ (gogoproto.casttype) = "RawContractMessage" ];
+ // Funds coins that are transferred to the contract on instantiation
+ repeated cosmos.base.v1beta1.Coin funds = 8 [
+ (gogoproto.nullable) = false,
+ (amino.dont_omitempty) = true,
+ (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"
+ ];
+}
+
+// Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+// an explicit InstantiateContract2Proposal. To instantiate contract 2,
+// a simple MsgInstantiateContract2 can be invoked from the x/gov module via
+// a v1 governance proposal.
+message InstantiateContract2Proposal {
+ option deprecated = true;
+ option (amino.name) = "wasm/InstantiateContract2Proposal";
+ option (cosmos_proto.implements_interface) = "cosmos.gov.v1beta1.Content";
+
+ // Title is a short summary
+ string title = 1;
+ // Description is a human readable text
+ string description = 2;
+ // RunAs is the address that is passed to the contract's enviroment as sender
+ string run_as = 3;
+ // Admin is an optional address that can execute migrations
+ string admin = 4;
+ // CodeID is the reference to the stored WASM code
+ uint64 code_id = 5 [ (gogoproto.customname) = "CodeID" ];
+ // Label is optional metadata to be stored with a constract instance.
+ string label = 6;
+ // Msg json encode message to be passed to the contract on instantiation
+ bytes msg = 7 [ (gogoproto.casttype) = "RawContractMessage" ];
+ // Funds coins that are transferred to the contract on instantiation
+ repeated cosmos.base.v1beta1.Coin funds = 8 [
+ (gogoproto.nullable) = false,
+ (amino.dont_omitempty) = true,
+ (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"
+ ];
+ // Salt is an arbitrary value provided by the sender. Size can be 1 to 64.
+ bytes salt = 9;
+ // FixMsg include the msg value into the hash for the predictable address.
+ // Default is false
+ bool fix_msg = 10;
+}
+
+// Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+// an explicit MigrateContractProposal. To migrate a contract,
+// a simple MsgMigrateContract can be invoked from the x/gov module via
+// a v1 governance proposal.
+message MigrateContractProposal {
+ option deprecated = true;
+ option (amino.name) = "wasm/MigrateContractProposal";
+ option (cosmos_proto.implements_interface) = "cosmos.gov.v1beta1.Content";
+
+ // Title is a short summary
+ string title = 1;
+ // Description is a human readable text
+ string description = 2;
+ // Note: skipping 3 as this was previously used for unneeded run_as
+
+ // Contract is the address of the smart contract
+ string contract = 4;
+ // CodeID references the new WASM code
+ uint64 code_id = 5 [ (gogoproto.customname) = "CodeID" ];
+ // Msg json encoded message to be passed to the contract on migration
+ bytes msg = 6 [ (gogoproto.casttype) = "RawContractMessage" ];
+}
+
+// Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+// an explicit SudoContractProposal. To call sudo on a contract,
+// a simple MsgSudoContract can be invoked from the x/gov module via
+// a v1 governance proposal.
+message SudoContractProposal {
+ option deprecated = true;
+ option (amino.name) = "wasm/SudoContractProposal";
+ option (cosmos_proto.implements_interface) = "cosmos.gov.v1beta1.Content";
+
+ // Title is a short summary
+ string title = 1;
+ // Description is a human readable text
+ string description = 2;
+ // Contract is the address of the smart contract
+ string contract = 3;
+ // Msg json encoded message to be passed to the contract as sudo
+ bytes msg = 4 [ (gogoproto.casttype) = "RawContractMessage" ];
+}
+
+// Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+// an explicit ExecuteContractProposal. To call execute on a contract,
+// a simple MsgExecuteContract can be invoked from the x/gov module via
+// a v1 governance proposal.
+message ExecuteContractProposal {
+ option deprecated = true;
+ option (amino.name) = "wasm/ExecuteContractProposal";
+ option (cosmos_proto.implements_interface) = "cosmos.gov.v1beta1.Content";
+
+ // Title is a short summary
+ string title = 1;
+ // Description is a human readable text
+ string description = 2;
+ // RunAs is the address that is passed to the contract's environment as sender
+ string run_as = 3;
+ // Contract is the address of the smart contract
+ string contract = 4;
+ // Msg json encoded message to be passed to the contract as execute
+ bytes msg = 5 [ (gogoproto.casttype) = "RawContractMessage" ];
+ // Funds coins that are transferred to the contract on instantiation
+ repeated cosmos.base.v1beta1.Coin funds = 6 [
+ (gogoproto.nullable) = false,
+ (amino.dont_omitempty) = true,
+ (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"
+ ];
+}
+
+// Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+// an explicit UpdateAdminProposal. To set an admin for a contract,
+// a simple MsgUpdateAdmin can be invoked from the x/gov module via
+// a v1 governance proposal.
+message UpdateAdminProposal {
+ option deprecated = true;
+ option (amino.name) = "wasm/UpdateAdminProposal";
+ option (cosmos_proto.implements_interface) = "cosmos.gov.v1beta1.Content";
+
+ // Title is a short summary
+ string title = 1;
+ // Description is a human readable text
+ string description = 2;
+ // NewAdmin address to be set
+ string new_admin = 3 [ (gogoproto.moretags) = "yaml:\"new_admin\"" ];
+ // Contract is the address of the smart contract
+ string contract = 4;
+}
+
+// Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+// an explicit ClearAdminProposal. To clear the admin of a contract,
+// a simple MsgClearAdmin can be invoked from the x/gov module via
+// a v1 governance proposal.
+message ClearAdminProposal {
+ option deprecated = true;
+ option (amino.name) = "wasm/ClearAdminProposal";
+ option (cosmos_proto.implements_interface) = "cosmos.gov.v1beta1.Content";
+
+ // Title is a short summary
+ string title = 1;
+ // Description is a human readable text
+ string description = 2;
+ // Contract is the address of the smart contract
+ string contract = 3;
+}
+
+// Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+// an explicit PinCodesProposal. To pin a set of code ids in the wasmvm
+// cache, a simple MsgPinCodes can be invoked from the x/gov module via
+// a v1 governance proposal.
+message PinCodesProposal {
+ option deprecated = true;
+ option (amino.name) = "wasm/PinCodesProposal";
+ option (cosmos_proto.implements_interface) = "cosmos.gov.v1beta1.Content";
+
+ // Title is a short summary
+ string title = 1 [ (gogoproto.moretags) = "yaml:\"title\"" ];
+ // Description is a human readable text
+ string description = 2 [ (gogoproto.moretags) = "yaml:\"description\"" ];
+ // CodeIDs references the new WASM codes
+ repeated uint64 code_ids = 3 [
+ (gogoproto.customname) = "CodeIDs",
+ (gogoproto.moretags) = "yaml:\"code_ids\""
+ ];
+}
+
+// Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+// an explicit UnpinCodesProposal. To unpin a set of code ids in the wasmvm
+// cache, a simple MsgUnpinCodes can be invoked from the x/gov module via
+// a v1 governance proposal.
+message UnpinCodesProposal {
+ option deprecated = true;
+ option (amino.name) = "wasm/UnpinCodesProposal";
+ option (cosmos_proto.implements_interface) = "cosmos.gov.v1beta1.Content";
+
+ // Title is a short summary
+ string title = 1 [ (gogoproto.moretags) = "yaml:\"title\"" ];
+ // Description is a human readable text
+ string description = 2 [ (gogoproto.moretags) = "yaml:\"description\"" ];
+ // CodeIDs references the WASM codes
+ repeated uint64 code_ids = 3 [
+ (gogoproto.customname) = "CodeIDs",
+ (gogoproto.moretags) = "yaml:\"code_ids\""
+ ];
+}
+
+// AccessConfigUpdate contains the code id and the access config to be
+// applied.
+message AccessConfigUpdate {
+ // CodeID is the reference to the stored WASM code to be updated
+ uint64 code_id = 1 [ (gogoproto.customname) = "CodeID" ];
+ // InstantiatePermission to apply to the set of code ids
+ AccessConfig instantiate_permission = 2
+ [ (gogoproto.nullable) = false, (amino.dont_omitempty) = true ];
+}
+
+// Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+// an explicit UpdateInstantiateConfigProposal. To update instantiate config
+// to a set of code ids, a simple MsgUpdateInstantiateConfig can be invoked from
+// the x/gov module via a v1 governance proposal.
+message UpdateInstantiateConfigProposal {
+ option deprecated = true;
+ option (amino.name) = "wasm/UpdateInstantiateConfigProposal";
+ option (cosmos_proto.implements_interface) = "cosmos.gov.v1beta1.Content";
+
+ // Title is a short summary
+ string title = 1 [ (gogoproto.moretags) = "yaml:\"title\"" ];
+ // Description is a human readable text
+ string description = 2 [ (gogoproto.moretags) = "yaml:\"description\"" ];
+ // AccessConfigUpdate contains the list of code ids and the access config
+ // to be applied.
+ repeated AccessConfigUpdate access_config_updates = 3
+ [ (gogoproto.nullable) = false, (amino.dont_omitempty) = true ];
+}
+
+// Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+// an explicit StoreAndInstantiateContractProposal. To store and instantiate
+// the contract, a simple MsgStoreAndInstantiateContract can be invoked from
+// the x/gov module via a v1 governance proposal.
+message StoreAndInstantiateContractProposal {
+ option deprecated = true;
+ option (amino.name) = "wasm/StoreAndInstantiateContractProposal";
+ option (cosmos_proto.implements_interface) = "cosmos.gov.v1beta1.Content";
+
+ // Title is a short summary
+ string title = 1;
+ // Description is a human readable text
+ string description = 2;
+ // RunAs is the address that is passed to the contract's environment as sender
+ string run_as = 3;
+ // WASMByteCode can be raw or gzip compressed
+ bytes wasm_byte_code = 4 [ (gogoproto.customname) = "WASMByteCode" ];
+ // InstantiatePermission to apply on contract creation, optional
+ AccessConfig instantiate_permission = 5;
+ // UnpinCode code on upload, optional
+ bool unpin_code = 6;
+ // Admin is an optional address that can execute migrations
+ string admin = 7;
+ // Label is optional metadata to be stored with a constract instance.
+ string label = 8;
+ // Msg json encoded message to be passed to the contract on instantiation
+ bytes msg = 9 [ (gogoproto.casttype) = "RawContractMessage" ];
+ // Funds coins that are transferred to the contract on instantiation
+ repeated cosmos.base.v1beta1.Coin funds = 10 [
+ (gogoproto.nullable) = false,
+ (amino.dont_omitempty) = true,
+ (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"
+ ];
+ // Source is the URL where the code is hosted
+ string source = 11;
+ // Builder is the docker image used to build the code deterministically, used
+ // for smart contract verification
+ string builder = 12;
+ // CodeHash is the SHA256 sum of the code outputted by builder, used for smart
+ // contract verification
+ bytes code_hash = 13;
+}
diff --git a/proto/cosmwasm/wasm/v1/tx.proto b/proto/cosmwasm/wasm/v1/tx.proto
index 3e0fadb58c..393c6a6822 100644
--- a/proto/cosmwasm/wasm/v1/tx.proto
+++ b/proto/cosmwasm/wasm/v1/tx.proto
@@ -252,16 +252,6 @@ message MsgClearAdmin {
// MsgClearAdminResponse returns empty data
message MsgClearAdminResponse {}
-// AccessConfigUpdate contains the code id and the access config to be
-// applied.
-message AccessConfigUpdate {
- // CodeID is the reference to the stored WASM code to be updated
- uint64 code_id = 1 [ (gogoproto.customname) = "CodeID" ];
- // InstantiatePermission to apply to the set of code ids
- AccessConfig instantiate_permission = 2
- [ (gogoproto.nullable) = false, (amino.dont_omitempty) = true ];
-}
-
// MsgUpdateInstantiateConfig updates instantiate config for a smart contract
message MsgUpdateInstantiateConfig {
option (amino.name) = "wasm/MsgUpdateInstantiateConfig";
diff --git a/x/wasm/alias.go b/x/wasm/alias.go
index fbe2656fa8..931cc837a6 100644
--- a/x/wasm/alias.go
+++ b/x/wasm/alias.go
@@ -24,6 +24,16 @@ const (
WasmModuleEventType = types.WasmModuleEventType
// Deprecated: Do not use.
AttributeKeyContractAddr = types.AttributeKeyContractAddr
+ // Deprecated: Do not use.
+ ProposalTypeStoreCode = types.ProposalTypeStoreCode
+ // Deprecated: Do not use.
+ ProposalTypeInstantiateContract = types.ProposalTypeInstantiateContract
+ // Deprecated: Do not use.
+ ProposalTypeMigrateContract = types.ProposalTypeMigrateContract
+ // Deprecated: Do not use.
+ ProposalTypeUpdateAdmin = types.ProposalTypeUpdateAdmin
+ // Deprecated: Do not use.
+ ProposalTypeClearAdmin = types.ProposalTypeClearAdmin
)
var (
@@ -35,6 +45,8 @@ var (
// Deprecated: Do not use.
ValidateGenesis = types.ValidateGenesis
// Deprecated: Do not use.
+ ConvertToProposals = types.ConvertToProposals
+ // Deprecated: Do not use.
GetCodeKey = types.GetCodeKey
// Deprecated: Do not use.
GetContractAddressKey = types.GetContractAddressKey
@@ -87,6 +99,8 @@ var (
// Deprecated: Do not use.
TestHandler = keeper.TestHandler
// Deprecated: Do not use.
+ NewWasmProposalHandler = keeper.NewWasmProposalHandler //nolint:staticcheck // we still require this alias despite the deprecation
+ // Deprecated: Do not use.
NewQuerier = keeper.Querier
// Deprecated: Do not use.
ContractFromPortID = keeper.ContractFromPortID
@@ -128,9 +142,15 @@ var (
ContractKeyPrefix = types.ContractKeyPrefix
// Deprecated: Do not use.
ContractStorePrefix = types.ContractStorePrefix
+ // Deprecated: Do not use.
+ EnableAllProposals = types.EnableAllProposals
+ // Deprecated: Do not use.
+ DisableAllProposals = types.DisableAllProposals
)
type (
+ // Deprecated: Do not use.
+ ProposalType = types.ProposalType
// Deprecated: Do not use.
GenesisState = types.GenesisState
// Deprecated: Do not use.
diff --git a/x/wasm/keeper/handler_plugin_encoders_test.go b/x/wasm/keeper/handler_plugin_encoders_test.go
index 6ef32a3d53..334f78526d 100644
--- a/x/wasm/keeper/handler_plugin_encoders_test.go
+++ b/x/wasm/keeper/handler_plugin_encoders_test.go
@@ -16,6 +16,7 @@ import (
banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
distributiontypes "github.com/cosmos/cosmos-sdk/x/distribution/types"
v1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1"
+ "github.com/cosmos/cosmos-sdk/x/gov/types/v1beta1"
stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
"github.com/CosmWasm/wasmd/x/wasm/keeper/wasmtesting"
@@ -47,14 +48,13 @@ func TestEncoding(t *testing.T) {
bankMsgBin, err := proto.Marshal(bankMsg)
require.NoError(t, err)
- msg, err := codectypes.NewAnyWithValue(types.MsgStoreCodeFixture())
+ content, err := codectypes.NewAnyWithValue(types.StoreCodeProposalFixture())
require.NoError(t, err)
- proposalMsg := &v1.MsgSubmitProposal{
+
+ proposalMsg := &v1beta1.MsgSubmitProposal{
Proposer: addr1.String(),
- Messages: []*codectypes.Any{msg},
InitialDeposit: sdk.NewCoins(sdk.NewInt64Coin("uatom", 12345)),
- Title: "proposal",
- Summary: "proposal summary",
+ Content: content,
}
proposalMsgBin, err := proto.Marshal(proposalMsg)
require.NoError(t, err)
@@ -294,7 +294,7 @@ func TestEncoding(t *testing.T) {
},
},
},
- "staking delegate to non-validator - invalid": {
+ "staking delegate to non-validator": {
sender: addr1,
srcMsg: wasmvmtypes.CosmosMsg{
Staking: &wasmvmtypes.StakingMsg{
@@ -420,7 +420,7 @@ func TestEncoding(t *testing.T) {
sender: addr2,
srcMsg: wasmvmtypes.CosmosMsg{
Stargate: &wasmvmtypes.StargateMsg{
- TypeURL: "/cosmos.gov.v1.MsgSubmitProposal",
+ TypeURL: "/cosmos.gov.v1beta1.MsgSubmitProposal",
Value: proposalMsgBin,
},
},
@@ -716,7 +716,7 @@ func TestEncodeGovMsg(t *testing.T) {
},
},
},
- "Gov weighted vote: duplicate option - invalid": {
+ "Gov weighted vote: duplicate option": {
sender: myAddr,
srcMsg: wasmvmtypes.CosmosMsg{
Gov: &wasmvmtypes.GovMsg{
@@ -741,7 +741,7 @@ func TestEncodeGovMsg(t *testing.T) {
},
expInvalid: true,
},
- "Gov weighted vote: weight sum exceeds 1- invalid": {
+ "Gov weighted vote: weight sum exceeds 1": {
sender: myAddr,
srcMsg: wasmvmtypes.CosmosMsg{
Gov: &wasmvmtypes.GovMsg{
@@ -766,7 +766,7 @@ func TestEncodeGovMsg(t *testing.T) {
},
expInvalid: true,
},
- "Gov weighted vote: weight sum less than 1 - invalid": {
+ "Gov weighted vote: weight sum less than 1": {
sender: myAddr,
srcMsg: wasmvmtypes.CosmosMsg{
Gov: &wasmvmtypes.GovMsg{
diff --git a/x/wasm/keeper/proposal_handler.go b/x/wasm/keeper/proposal_handler.go
new file mode 100644
index 0000000000..82048ca3e8
--- /dev/null
+++ b/x/wasm/keeper/proposal_handler.go
@@ -0,0 +1,342 @@
+package keeper
+
+import (
+ "bytes"
+ "encoding/hex"
+ "fmt"
+
+ errorsmod "cosmossdk.io/errors"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+ "github.com/cosmos/cosmos-sdk/x/gov/types/v1beta1"
+
+ "github.com/CosmWasm/wasmd/x/wasm/types"
+)
+
+// NewWasmProposalHandler creates a new governance Handler for wasm proposals
+//
+// Deprecated: Do not use.
+func NewWasmProposalHandler(k decoratedKeeper, enabledProposalTypes []types.ProposalType) v1beta1.Handler {
+ return NewWasmProposalHandlerX(NewGovPermissionKeeper(k), enabledProposalTypes)
+}
+
+// NewWasmProposalHandlerX creates a new governance Handler for wasm proposals
+//
+// Deprecated: Do not use.
+func NewWasmProposalHandlerX(k types.ContractOpsKeeper, enabledProposalTypes []types.ProposalType) v1beta1.Handler {
+ enabledTypes := make(map[string]struct{}, len(enabledProposalTypes))
+ for i := range enabledProposalTypes {
+ enabledTypes[string(enabledProposalTypes[i])] = struct{}{}
+ }
+ return func(ctx sdk.Context, content v1beta1.Content) error {
+ if content == nil {
+ return errorsmod.Wrap(sdkerrors.ErrUnknownRequest, "content must not be empty")
+ }
+ if _, ok := enabledTypes[content.ProposalType()]; !ok {
+ return errorsmod.Wrapf(sdkerrors.ErrUnknownRequest, "unsupported wasm proposal content type: %q", content.ProposalType())
+ }
+ switch c := content.(type) {
+ case *types.StoreCodeProposal:
+ return handleStoreCodeProposal(ctx, k, *c)
+ case *types.InstantiateContractProposal:
+ return handleInstantiateProposal(ctx, k, *c)
+ case *types.InstantiateContract2Proposal:
+ return handleInstantiate2Proposal(ctx, k, *c)
+ case *types.MigrateContractProposal:
+ return handleMigrateProposal(ctx, k, *c)
+ case *types.SudoContractProposal:
+ return handleSudoProposal(ctx, k, *c)
+ case *types.ExecuteContractProposal:
+ return handleExecuteProposal(ctx, k, *c)
+ case *types.UpdateAdminProposal:
+ return handleUpdateAdminProposal(ctx, k, *c)
+ case *types.ClearAdminProposal:
+ return handleClearAdminProposal(ctx, k, *c)
+ case *types.PinCodesProposal:
+ return handlePinCodesProposal(ctx, k, *c)
+ case *types.UnpinCodesProposal:
+ return handleUnpinCodesProposal(ctx, k, *c)
+ case *types.UpdateInstantiateConfigProposal:
+ return handleUpdateInstantiateConfigProposal(ctx, k, *c)
+ case *types.StoreAndInstantiateContractProposal:
+ return handleStoreAndInstantiateContractProposal(ctx, k, *c)
+ default:
+ return errorsmod.Wrapf(sdkerrors.ErrUnknownRequest, "unrecognized wasm proposal content type: %T", c)
+ }
+ }
+}
+
+//nolint:staticcheck
+func handleStoreCodeProposal(ctx sdk.Context, k types.ContractOpsKeeper, p types.StoreCodeProposal) error {
+ if err := p.ValidateBasic(); err != nil {
+ return err
+ }
+
+ runAsAddr, err := sdk.AccAddressFromBech32(p.RunAs)
+ if err != nil {
+ return errorsmod.Wrap(err, "run as address")
+ }
+ codeID, checksum, err := k.Create(ctx, runAsAddr, p.WASMByteCode, p.InstantiatePermission)
+ if err != nil {
+ return err
+ }
+
+ if len(p.CodeHash) != 0 && !bytes.Equal(checksum, p.CodeHash) {
+ return fmt.Errorf("code-hash mismatch: %X, checksum: %X", p.CodeHash, checksum)
+ }
+
+ // if code should not be pinned return earlier
+ if p.UnpinCode {
+ return nil
+ }
+ return k.PinCode(ctx, codeID)
+}
+
+//nolint:staticcheck
+func handleInstantiateProposal(ctx sdk.Context, k types.ContractOpsKeeper, p types.InstantiateContractProposal) error {
+ if err := p.ValidateBasic(); err != nil {
+ return err
+ }
+ runAsAddr, err := sdk.AccAddressFromBech32(p.RunAs)
+ if err != nil {
+ return errorsmod.Wrap(err, "run as address")
+ }
+ var adminAddr sdk.AccAddress
+ if p.Admin != "" {
+ if adminAddr, err = sdk.AccAddressFromBech32(p.Admin); err != nil {
+ return errorsmod.Wrap(err, "admin")
+ }
+ }
+
+ _, data, err := k.Instantiate(ctx, p.CodeID, runAsAddr, adminAddr, p.Msg, p.Label, p.Funds)
+ if err != nil {
+ return err
+ }
+
+ ctx.EventManager().EmitEvent(sdk.NewEvent(
+ types.EventTypeGovContractResult,
+ sdk.NewAttribute(types.AttributeKeyResultDataHex, hex.EncodeToString(data)),
+ ))
+ return nil
+}
+
+//nolint:staticcheck
+func handleInstantiate2Proposal(ctx sdk.Context, k types.ContractOpsKeeper, p types.InstantiateContract2Proposal) error {
+ // Validatebasic with proposal
+ if err := p.ValidateBasic(); err != nil {
+ return err
+ }
+
+ // Get runAsAddr as AccAddress
+ runAsAddr, err := sdk.AccAddressFromBech32(p.RunAs)
+ if err != nil {
+ return errorsmod.Wrap(err, "run as address")
+ }
+
+ // Get admin address
+ var adminAddr sdk.AccAddress
+ if p.Admin != "" {
+ if adminAddr, err = sdk.AccAddressFromBech32(p.Admin); err != nil {
+ return errorsmod.Wrap(err, "admin")
+ }
+ }
+
+ _, data, err := k.Instantiate2(ctx, p.CodeID, runAsAddr, adminAddr, p.Msg, p.Label, p.Funds, p.Salt, p.FixMsg)
+ if err != nil {
+ return err
+ }
+
+ ctx.EventManager().EmitEvent(sdk.NewEvent(
+ types.EventTypeGovContractResult,
+ sdk.NewAttribute(types.AttributeKeyResultDataHex, hex.EncodeToString(data)),
+ ))
+ return nil
+}
+
+//nolint:staticcheck
+func handleStoreAndInstantiateContractProposal(ctx sdk.Context, k types.ContractOpsKeeper, p types.StoreAndInstantiateContractProposal) error {
+ if err := p.ValidateBasic(); err != nil {
+ return err
+ }
+ runAsAddr, err := sdk.AccAddressFromBech32(p.RunAs)
+ if err != nil {
+ return errorsmod.Wrap(err, "run as address")
+ }
+ var adminAddr sdk.AccAddress
+ if p.Admin != "" {
+ if adminAddr, err = sdk.AccAddressFromBech32(p.Admin); err != nil {
+ return errorsmod.Wrap(err, "admin")
+ }
+ }
+
+ codeID, checksum, err := k.Create(ctx, runAsAddr, p.WASMByteCode, p.InstantiatePermission)
+ if err != nil {
+ return err
+ }
+
+ if p.CodeHash != nil && !bytes.Equal(checksum, p.CodeHash) {
+ return errorsmod.Wrap(fmt.Errorf("code-hash mismatch: %X, checksum: %X", p.CodeHash, checksum), "code-hash mismatch")
+ }
+
+ if !p.UnpinCode {
+ if err := k.PinCode(ctx, codeID); err != nil {
+ return err
+ }
+ }
+
+ _, data, err := k.Instantiate(ctx, codeID, runAsAddr, adminAddr, p.Msg, p.Label, p.Funds)
+ if err != nil {
+ return err
+ }
+
+ ctx.EventManager().EmitEvent(sdk.NewEvent(
+ types.EventTypeGovContractResult,
+ sdk.NewAttribute(types.AttributeKeyResultDataHex, hex.EncodeToString(data)),
+ ))
+ return nil
+}
+
+//nolint:staticcheck
+func handleMigrateProposal(ctx sdk.Context, k types.ContractOpsKeeper, p types.MigrateContractProposal) error {
+ if err := p.ValidateBasic(); err != nil {
+ return err
+ }
+
+ contractAddr, err := sdk.AccAddressFromBech32(p.Contract)
+ if err != nil {
+ return errorsmod.Wrap(err, "contract")
+ }
+
+ // runAs is not used if this is permissioned, so just put any valid address there (second contractAddr)
+ data, err := k.Migrate(ctx, contractAddr, contractAddr, p.CodeID, p.Msg)
+ if err != nil {
+ return err
+ }
+
+ ctx.EventManager().EmitEvent(sdk.NewEvent(
+ types.EventTypeGovContractResult,
+ sdk.NewAttribute(types.AttributeKeyResultDataHex, hex.EncodeToString(data)),
+ ))
+ return nil
+}
+
+//nolint:staticcheck
+func handleSudoProposal(ctx sdk.Context, k types.ContractOpsKeeper, p types.SudoContractProposal) error {
+ if err := p.ValidateBasic(); err != nil {
+ return err
+ }
+
+ contractAddr, err := sdk.AccAddressFromBech32(p.Contract)
+ if err != nil {
+ return errorsmod.Wrap(err, "contract")
+ }
+ data, err := k.Sudo(ctx, contractAddr, p.Msg)
+ if err != nil {
+ return err
+ }
+
+ ctx.EventManager().EmitEvent(sdk.NewEvent(
+ types.EventTypeGovContractResult,
+ sdk.NewAttribute(types.AttributeKeyResultDataHex, hex.EncodeToString(data)),
+ ))
+ return nil
+}
+
+//nolint:staticcheck
+func handleExecuteProposal(ctx sdk.Context, k types.ContractOpsKeeper, p types.ExecuteContractProposal) error {
+ if err := p.ValidateBasic(); err != nil {
+ return err
+ }
+
+ contractAddr, err := sdk.AccAddressFromBech32(p.Contract)
+ if err != nil {
+ return errorsmod.Wrap(err, "contract")
+ }
+ runAsAddr, err := sdk.AccAddressFromBech32(p.RunAs)
+ if err != nil {
+ return errorsmod.Wrap(err, "run as address")
+ }
+ data, err := k.Execute(ctx, contractAddr, runAsAddr, p.Msg, p.Funds)
+ if err != nil {
+ return err
+ }
+
+ ctx.EventManager().EmitEvent(sdk.NewEvent(
+ types.EventTypeGovContractResult,
+ sdk.NewAttribute(types.AttributeKeyResultDataHex, hex.EncodeToString(data)),
+ ))
+ return nil
+}
+
+//nolint:staticcheck
+func handleUpdateAdminProposal(ctx sdk.Context, k types.ContractOpsKeeper, p types.UpdateAdminProposal) error {
+ if err := p.ValidateBasic(); err != nil {
+ return err
+ }
+ contractAddr, err := sdk.AccAddressFromBech32(p.Contract)
+ if err != nil {
+ return errorsmod.Wrap(err, "contract")
+ }
+ newAdminAddr, err := sdk.AccAddressFromBech32(p.NewAdmin)
+ if err != nil {
+ return errorsmod.Wrap(err, "run as address")
+ }
+
+ return k.UpdateContractAdmin(ctx, contractAddr, nil, newAdminAddr)
+}
+
+//nolint:staticcheck
+func handleClearAdminProposal(ctx sdk.Context, k types.ContractOpsKeeper, p types.ClearAdminProposal) error {
+ if err := p.ValidateBasic(); err != nil {
+ return err
+ }
+
+ contractAddr, err := sdk.AccAddressFromBech32(p.Contract)
+ if err != nil {
+ return errorsmod.Wrap(err, "contract")
+ }
+ err = k.ClearContractAdmin(ctx, contractAddr, nil)
+ return err
+}
+
+//nolint:staticcheck
+func handlePinCodesProposal(ctx sdk.Context, k types.ContractOpsKeeper, p types.PinCodesProposal) error {
+ if err := p.ValidateBasic(); err != nil {
+ return err
+ }
+ for _, v := range p.CodeIDs {
+ if err := k.PinCode(ctx, v); err != nil {
+ return errorsmod.Wrapf(err, "code id: %d", v)
+ }
+ }
+ return nil
+}
+
+//nolint:staticcheck
+func handleUnpinCodesProposal(ctx sdk.Context, k types.ContractOpsKeeper, p types.UnpinCodesProposal) error {
+ if err := p.ValidateBasic(); err != nil {
+ return err
+ }
+ for _, v := range p.CodeIDs {
+ if err := k.UnpinCode(ctx, v); err != nil {
+ return errorsmod.Wrapf(err, "code id: %d", v)
+ }
+ }
+ return nil
+}
+
+//nolint:staticcheck
+func handleUpdateInstantiateConfigProposal(ctx sdk.Context, k types.ContractOpsKeeper, p types.UpdateInstantiateConfigProposal) error {
+ if err := p.ValidateBasic(); err != nil {
+ return err
+ }
+
+ var emptyCaller sdk.AccAddress
+ for _, accessConfigUpdate := range p.AccessConfigUpdates {
+ if err := k.SetAccessConfig(ctx, accessConfigUpdate.CodeID, emptyCaller, accessConfigUpdate.InstantiatePermission); err != nil {
+ return errorsmod.Wrapf(err, "code id: %d", accessConfigUpdate.CodeID)
+ }
+ }
+ return nil
+}
diff --git a/x/wasm/keeper/proposal_integration_test.go b/x/wasm/keeper/proposal_integration_test.go
new file mode 100644
index 0000000000..4ecee9c9a9
--- /dev/null
+++ b/x/wasm/keeper/proposal_integration_test.go
@@ -0,0 +1,940 @@
+package keeper
+
+import (
+ "bytes"
+ "encoding/hex"
+ "encoding/json"
+ "errors"
+ "os"
+ "testing"
+
+ wasmvm "github.com/CosmWasm/wasmvm"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ govkeeper "github.com/cosmos/cosmos-sdk/x/gov/keeper"
+ govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
+ v1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1"
+ "github.com/cosmos/cosmos-sdk/x/gov/types/v1beta1"
+
+ "github.com/CosmWasm/wasmd/x/wasm/keeper/testdata"
+ "github.com/CosmWasm/wasmd/x/wasm/keeper/wasmtesting"
+ "github.com/CosmWasm/wasmd/x/wasm/types"
+)
+
+const myTestLabel = "testing"
+
+func TestStoreCodeProposal(t *testing.T) {
+ t.Skip("DEPRECATED")
+ parentCtx, keepers := CreateTestInput(t, false, "staking")
+ wasmKeeper := keepers.WasmKeeper
+ err := wasmKeeper.SetParams(parentCtx, types.Params{
+ CodeUploadAccess: types.AllowNobody,
+ InstantiateDefaultPermission: types.AccessTypeNobody,
+ })
+ require.NoError(t, err)
+ rawWasmCode, err := os.ReadFile("./testdata/hackatom.wasm")
+ require.NoError(t, err)
+ gzippedWasmCode, err := os.ReadFile("./testdata/hackatom.wasm.gzip")
+ require.NoError(t, err)
+ checksum, err := hex.DecodeString(testdata.ChecksumHackatom)
+ require.NoError(t, err)
+
+ specs := map[string]struct {
+ codeID int64
+ code []byte
+ unpinCode bool
+ }{
+ "upload with pinning (default)": {
+ unpinCode: false,
+ code: rawWasmCode,
+ },
+ "upload with code unpin": {
+ unpinCode: true,
+ code: rawWasmCode,
+ },
+ "upload with raw wasm code": {
+ code: rawWasmCode,
+ },
+ "upload with zipped wasm code": {
+ code: gzippedWasmCode,
+ },
+ }
+
+ for msg, spec := range specs {
+ t.Run(msg, func(t *testing.T) {
+ ctx, _ := parentCtx.CacheContext()
+ myActorAddress := RandomBech32AccountAddress(t)
+
+ src := types.StoreCodeProposalFixture(func(p *types.StoreCodeProposal) { //nolint:staticcheck // testing deprecated function
+ p.RunAs = myActorAddress
+ p.WASMByteCode = spec.code
+ p.UnpinCode = spec.unpinCode
+ p.CodeHash = checksum
+ })
+
+ // when
+ mustSubmitAndExecuteLegacyProposal(t, ctx, src, myActorAddress, keepers)
+
+ // then
+ cInfo := wasmKeeper.GetCodeInfo(ctx, 1)
+ require.NotNil(t, cInfo)
+ assert.Equal(t, myActorAddress, cInfo.Creator)
+ assert.Equal(t, !spec.unpinCode, wasmKeeper.IsPinnedCode(ctx, 1))
+
+ storedCode, err := wasmKeeper.GetByteCode(ctx, 1)
+ require.NoError(t, err)
+ assert.Equal(t, rawWasmCode, storedCode)
+ })
+ }
+}
+
+func mustSubmitAndExecuteLegacyProposal(t *testing.T, ctx sdk.Context, content v1beta1.Content, myActorAddress string, keepers TestKeepers) {
+ t.Helper()
+ govAuthority := keepers.AccountKeeper.GetModuleAddress(govtypes.ModuleName).String()
+ msgServer := govkeeper.NewMsgServerImpl(keepers.GovKeeper)
+ // ignore all submit events
+ contentMsg, err := submitLegacyProposal(t, ctx.WithEventManager(sdk.NewEventManager()), content, myActorAddress, govAuthority, msgServer)
+ require.NoError(t, err)
+
+ _, err = msgServer.ExecLegacyContent(sdk.WrapSDKContext(ctx), v1.NewMsgExecLegacyContent(contentMsg.Content, govAuthority))
+ require.NoError(t, err)
+}
+
+// does not fail on submit proposal
+func submitLegacyProposal(t *testing.T, ctx sdk.Context, content v1beta1.Content, myActorAddress, govAuthority string, msgServer v1.MsgServer) (*v1.MsgExecLegacyContent, error) {
+ t.Helper()
+ contentMsg, err := v1.NewLegacyContent(content, govAuthority)
+ require.NoError(t, err)
+
+ proposal, err := v1.NewMsgSubmitProposal(
+ []sdk.Msg{contentMsg},
+ sdk.Coins{},
+ myActorAddress,
+ "",
+ "my title",
+ "my description",
+ )
+ require.NoError(t, err)
+
+ // when stored
+ _, err = msgServer.SubmitProposal(sdk.WrapSDKContext(ctx), proposal)
+ return contentMsg, err
+}
+
+func TestInstantiateProposal(t *testing.T) {
+ t.Skip("DEPRECATED")
+ ctx, keepers := CreateTestInput(t, false, "staking")
+ wasmKeeper := keepers.WasmKeeper
+ err := wasmKeeper.SetParams(ctx, types.Params{
+ CodeUploadAccess: types.AllowNobody,
+ InstantiateDefaultPermission: types.AccessTypeNobody,
+ })
+ require.NoError(t, err)
+
+ wasmCode, err := os.ReadFile("./testdata/hackatom.wasm")
+ require.NoError(t, err)
+
+ require.NoError(t, wasmKeeper.importCode(ctx, 1,
+ types.CodeInfoFixture(types.WithSHA256CodeHash(wasmCode)),
+ wasmCode),
+ )
+
+ var (
+ oneAddress sdk.AccAddress = bytes.Repeat([]byte{0x1}, types.ContractAddrLen)
+ otherAddress sdk.AccAddress = bytes.Repeat([]byte{0x2}, types.ContractAddrLen)
+ )
+ src := types.InstantiateContractProposalFixture(func(p *types.InstantiateContractProposal) { //nolint:staticcheck // testing deprecated function
+ p.CodeID = firstCodeID
+ p.RunAs = oneAddress.String()
+ p.Admin = otherAddress.String()
+ p.Label = myTestLabel
+ })
+ em := sdk.NewEventManager()
+
+ // when
+ mustSubmitAndExecuteLegacyProposal(t, ctx.WithEventManager(em), src, oneAddress.String(), keepers)
+
+ // then
+ contractAddr, err := sdk.AccAddressFromBech32("cosmos14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9s4hmalr")
+ require.NoError(t, err)
+
+ cInfo := wasmKeeper.GetContractInfo(ctx, contractAddr)
+ require.NotNil(t, cInfo)
+ assert.Equal(t, uint64(1), cInfo.CodeID)
+ assert.Equal(t, oneAddress.String(), cInfo.Creator)
+ assert.Equal(t, otherAddress.String(), cInfo.Admin)
+ assert.Equal(t, myTestLabel, cInfo.Label)
+ expHistory := []types.ContractCodeHistoryEntry{{
+ Operation: types.ContractCodeHistoryOperationTypeInit,
+ CodeID: src.CodeID,
+ Updated: types.NewAbsoluteTxPosition(ctx),
+ Msg: src.Msg,
+ }}
+ assert.Equal(t, expHistory, wasmKeeper.GetContractHistory(ctx, contractAddr))
+ // and event
+ require.Len(t, em.Events(), 3, "%#v", em.Events())
+ require.Equal(t, types.EventTypeInstantiate, em.Events()[0].Type)
+ require.Equal(t, types.WasmModuleEventType, em.Events()[1].Type)
+ require.Equal(t, types.EventTypeGovContractResult, em.Events()[2].Type)
+ require.Len(t, em.Events()[2].Attributes, 1)
+ require.NotEmpty(t, em.Events()[2].Attributes[0])
+}
+
+func TestInstantiate2Proposal(t *testing.T) {
+ t.Skip("DEPRECATED")
+ ctx, keepers := CreateTestInput(t, false, "staking")
+ wasmKeeper := keepers.WasmKeeper
+ err := wasmKeeper.SetParams(ctx, types.Params{
+ CodeUploadAccess: types.AllowNobody,
+ InstantiateDefaultPermission: types.AccessTypeNobody,
+ })
+ require.NoError(t, err)
+
+ wasmCode, err := os.ReadFile("./testdata/hackatom.wasm")
+ require.NoError(t, err)
+
+ codeInfo := types.CodeInfoFixture(types.WithSHA256CodeHash(wasmCode))
+ err = wasmKeeper.importCode(ctx, 1, codeInfo, wasmCode)
+ require.NoError(t, err)
+
+ var (
+ oneAddress sdk.AccAddress = bytes.Repeat([]byte{0x1}, types.ContractAddrLen)
+ otherAddress sdk.AccAddress = bytes.Repeat([]byte{0x2}, types.ContractAddrLen)
+ label = "label"
+ salt = []byte("mySalt")
+ )
+ src := types.InstantiateContract2ProposalFixture(func(p *types.InstantiateContract2Proposal) { //nolint:staticcheck // testing deprecated function
+ p.CodeID = firstCodeID
+ p.RunAs = oneAddress.String()
+ p.Admin = otherAddress.String()
+ p.Label = label
+ p.Salt = salt
+ })
+ contractAddress := BuildContractAddressPredictable(codeInfo.CodeHash, oneAddress, salt, []byte{})
+
+ em := sdk.NewEventManager()
+
+ // when
+ mustSubmitAndExecuteLegacyProposal(t, ctx.WithEventManager(em), src, oneAddress.String(), keepers)
+
+ cInfo := wasmKeeper.GetContractInfo(ctx, contractAddress)
+ require.NotNil(t, cInfo)
+
+ assert.Equal(t, uint64(1), cInfo.CodeID)
+ assert.Equal(t, oneAddress.String(), cInfo.Creator)
+ assert.Equal(t, otherAddress.String(), cInfo.Admin)
+ assert.Equal(t, "label", cInfo.Label)
+ expHistory := []types.ContractCodeHistoryEntry{{
+ Operation: types.ContractCodeHistoryOperationTypeInit,
+ CodeID: src.CodeID,
+ Updated: types.NewAbsoluteTxPosition(ctx),
+ Msg: src.Msg,
+ }}
+ assert.Equal(t, expHistory, wasmKeeper.GetContractHistory(ctx, contractAddress))
+ // and event
+ require.Len(t, em.Events(), 3, prettyEvents(t, em.Events()))
+ require.Equal(t, types.EventTypeInstantiate, em.Events()[0].Type)
+ require.Equal(t, types.WasmModuleEventType, em.Events()[1].Type)
+ require.Equal(t, types.EventTypeGovContractResult, em.Events()[2].Type)
+ require.Len(t, em.Events()[2].Attributes, 1)
+ require.NotEmpty(t, em.Events()[2].Attributes[0])
+}
+
+func TestInstantiateProposal_NoAdmin(t *testing.T) {
+ t.Skip("DEPRECATED")
+ ctx, keepers := CreateTestInput(t, false, "staking")
+ wasmKeeper := keepers.WasmKeeper
+ err := wasmKeeper.SetParams(ctx, types.Params{
+ CodeUploadAccess: types.AllowNobody,
+ InstantiateDefaultPermission: types.AccessTypeNobody,
+ })
+ require.NoError(t, err)
+
+ wasmCode, err := os.ReadFile("./testdata/hackatom.wasm")
+ require.NoError(t, err)
+
+ require.NoError(t, wasmKeeper.importCode(ctx, 1,
+ types.CodeInfoFixture(types.WithSHA256CodeHash(wasmCode)),
+ wasmCode),
+ )
+
+ var oneAddress sdk.AccAddress = bytes.Repeat([]byte{0x1}, types.ContractAddrLen)
+
+ specs := map[string]struct {
+ srcAdmin string
+ expErr bool
+ }{
+ "empty admin": {
+ srcAdmin: "",
+ },
+ "invalid admin": {
+ srcAdmin: "invalid",
+ expErr: true,
+ },
+ }
+ for name, spec := range specs {
+ t.Run(name, func(t *testing.T) {
+ src := types.InstantiateContractProposalFixture(func(p *types.InstantiateContractProposal) { //nolint:staticcheck // testing deprecated function
+ p.CodeID = firstCodeID
+ p.RunAs = oneAddress.String()
+ p.Admin = spec.srcAdmin
+ p.Label = myTestLabel
+ })
+ govAuthority := keepers.AccountKeeper.GetModuleAddress(govtypes.ModuleName).String()
+ msgServer := govkeeper.NewMsgServerImpl(keepers.GovKeeper)
+ // when
+ contentMsg, gotErr := submitLegacyProposal(t, ctx, src, oneAddress.String(), govAuthority, msgServer)
+ // then
+ if spec.expErr {
+ require.Error(t, gotErr)
+ return
+ }
+ require.NoError(t, gotErr)
+ // and when
+ em := sdk.NewEventManager()
+ _, err = msgServer.ExecLegacyContent(sdk.WrapSDKContext(ctx.WithEventManager(em)), v1.NewMsgExecLegacyContent(contentMsg.Content, govAuthority))
+ // then
+ require.NoError(t, err)
+ contractAddr, err := sdk.AccAddressFromBech32("cosmos14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9s4hmalr")
+ require.NoError(t, err)
+
+ cInfo := wasmKeeper.GetContractInfo(ctx, contractAddr)
+ require.NotNil(t, cInfo)
+ assert.Equal(t, uint64(1), cInfo.CodeID)
+ assert.Equal(t, oneAddress.String(), cInfo.Creator)
+ assert.Equal(t, "", cInfo.Admin)
+ assert.Equal(t, myTestLabel, cInfo.Label)
+ expHistory := []types.ContractCodeHistoryEntry{{
+ Operation: types.ContractCodeHistoryOperationTypeInit,
+ CodeID: src.CodeID,
+ Updated: types.NewAbsoluteTxPosition(ctx),
+ Msg: src.Msg,
+ }}
+ assert.Equal(t, expHistory, wasmKeeper.GetContractHistory(ctx, contractAddr))
+ // and event
+ require.Len(t, em.Events(), 3, "%#v", em.Events())
+ require.Equal(t, types.EventTypeInstantiate, em.Events()[0].Type)
+ require.Equal(t, types.WasmModuleEventType, em.Events()[1].Type)
+ require.Equal(t, types.EventTypeGovContractResult, em.Events()[2].Type)
+ require.Len(t, em.Events()[2].Attributes, 1)
+ require.NotEmpty(t, em.Events()[2].Attributes[0])
+ })
+ }
+}
+
+func TestStoreAndInstantiateContractProposal(t *testing.T) {
+ t.Skip("DEPRECATED")
+ ctx, keepers := CreateTestInput(t, false, "staking")
+ wasmKeeper := keepers.WasmKeeper
+ err := wasmKeeper.SetParams(ctx, types.Params{
+ CodeUploadAccess: types.AllowNobody,
+ InstantiateDefaultPermission: types.AccessTypeNobody,
+ })
+ require.NoError(t, err)
+
+ wasmCode, err := os.ReadFile("./testdata/hackatom.wasm")
+ require.NoError(t, err)
+
+ checksum, err := hex.DecodeString(testdata.ChecksumHackatom)
+ require.NoError(t, err)
+
+ var (
+ oneAddress sdk.AccAddress = bytes.Repeat([]byte{0x1}, types.ContractAddrLen)
+ otherAddress sdk.AccAddress = bytes.Repeat([]byte{0x2}, types.ContractAddrLen)
+ )
+
+ src := types.StoreAndInstantiateContractProposalFixture(func(p *types.StoreAndInstantiateContractProposal) { //nolint:staticcheck // testing deprecated function
+ p.WASMByteCode = wasmCode
+ p.RunAs = oneAddress.String()
+ p.Admin = otherAddress.String()
+ p.Label = myTestLabel
+ p.CodeHash = checksum
+ })
+ em := sdk.NewEventManager()
+
+ // when
+ mustSubmitAndExecuteLegacyProposal(t, ctx.WithEventManager(em), src, oneAddress.String(), keepers)
+
+ // then
+ contractAddr, err := sdk.AccAddressFromBech32("cosmos14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9s4hmalr")
+ require.NoError(t, err)
+
+ cInfo := wasmKeeper.GetContractInfo(ctx, contractAddr)
+ require.NotNil(t, cInfo)
+ assert.Equal(t, oneAddress.String(), cInfo.Creator)
+ assert.Equal(t, otherAddress.String(), cInfo.Admin)
+ assert.Equal(t, myTestLabel, cInfo.Label)
+ expHistory := []types.ContractCodeHistoryEntry{{
+ Operation: types.ContractCodeHistoryOperationTypeInit,
+ CodeID: cInfo.CodeID,
+ Updated: types.NewAbsoluteTxPosition(ctx),
+ Msg: src.Msg,
+ }}
+ assert.Equal(t, expHistory, wasmKeeper.GetContractHistory(ctx, contractAddr))
+ // and event
+ require.Len(t, em.Events(), 5, "%#v", em.Events())
+ require.Equal(t, types.EventTypeStoreCode, em.Events()[0].Type)
+ require.Equal(t, types.EventTypePinCode, em.Events()[1].Type)
+ require.Equal(t, types.EventTypeInstantiate, em.Events()[2].Type)
+ require.Equal(t, types.WasmModuleEventType, em.Events()[3].Type)
+ require.Equal(t, types.EventTypeGovContractResult, em.Events()[4].Type)
+ require.Len(t, em.Events()[4].Attributes, 1)
+ require.NotEmpty(t, em.Events()[4].Attributes[0])
+}
+
+func TestMigrateProposal(t *testing.T) {
+ t.Skip("DEPRECATED")
+ ctx, keepers := CreateTestInput(t, false, "staking")
+ wasmKeeper := keepers.WasmKeeper
+ err := wasmKeeper.SetParams(ctx, types.Params{
+ CodeUploadAccess: types.AllowNobody,
+ InstantiateDefaultPermission: types.AccessTypeNobody,
+ })
+ require.NoError(t, err)
+
+ wasmCode, err := os.ReadFile("./testdata/hackatom.wasm")
+ require.NoError(t, err)
+
+ codeInfoFixture := types.CodeInfoFixture(types.WithSHA256CodeHash(wasmCode))
+ require.NoError(t, wasmKeeper.importCode(ctx, 1, codeInfoFixture, wasmCode))
+ require.NoError(t, wasmKeeper.importCode(ctx, 2, codeInfoFixture, wasmCode))
+
+ var (
+ anyAddress = DeterministicAccountAddress(t, 1)
+ otherAddress = DeterministicAccountAddress(t, 2)
+ contractAddr = BuildContractAddressClassic(1, 1)
+ )
+
+ contractInfo := types.ContractInfoFixture(func(c *types.ContractInfo) {
+ c.Label = myTestLabel
+ c.Admin = anyAddress.String()
+ c.Created = types.NewAbsoluteTxPosition(ctx)
+ })
+ entries := []types.ContractCodeHistoryEntry{
+ {Operation: types.ContractCodeHistoryOperationTypeInit, CodeID: 1, Updated: contractInfo.Created},
+ }
+ key, err := hex.DecodeString("636F6E666967")
+ require.NoError(t, err)
+ m := types.Model{Key: key, Value: []byte(`{"verifier":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","beneficiary":"AAAAAAAAAAAAAAAAAAAAAAAAAAA=","funder":"AQEBAQEBAQEBAQEBAQEBAQEBAQE="}`)}
+ require.NoError(t, wasmKeeper.importContract(ctx, contractAddr, &contractInfo, []types.Model{m}, entries))
+
+ migMsg := struct {
+ Verifier sdk.AccAddress `json:"verifier"`
+ }{Verifier: otherAddress}
+ migMsgBz, err := json.Marshal(migMsg)
+ require.NoError(t, err)
+
+ src := &types.MigrateContractProposal{ //nolint:staticcheck // testing deprecated function
+ Title: "Foo",
+ Description: "Bar",
+ CodeID: 2,
+ Contract: contractAddr.String(),
+ Msg: migMsgBz,
+ }
+
+ em := sdk.NewEventManager()
+
+ // when
+ mustSubmitAndExecuteLegacyProposal(t, ctx.WithEventManager(em), src, anyAddress.String(), keepers)
+
+ // then
+ require.NoError(t, err)
+ cInfo := wasmKeeper.GetContractInfo(ctx, contractAddr)
+ require.NotNil(t, cInfo)
+ assert.Equal(t, uint64(2), cInfo.CodeID)
+ assert.Equal(t, anyAddress.String(), cInfo.Admin)
+ assert.Equal(t, myTestLabel, cInfo.Label)
+ expHistory := []types.ContractCodeHistoryEntry{{
+ Operation: types.ContractCodeHistoryOperationTypeInit,
+ CodeID: firstCodeID,
+ Updated: types.NewAbsoluteTxPosition(ctx),
+ }, {
+ Operation: types.ContractCodeHistoryOperationTypeMigrate,
+ CodeID: src.CodeID,
+ Updated: types.NewAbsoluteTxPosition(ctx),
+ Msg: src.Msg,
+ }}
+ assert.Equal(t, expHistory, wasmKeeper.GetContractHistory(ctx, contractAddr))
+ // and events emitted
+ require.Len(t, em.Events(), 2)
+ assert.Equal(t, types.EventTypeMigrate, em.Events()[0].Type)
+ require.Equal(t, types.EventTypeGovContractResult, em.Events()[1].Type)
+ require.Len(t, em.Events()[1].Attributes, 1)
+ assert.Equal(t, types.AttributeKeyResultDataHex, em.Events()[1].Attributes[0].Key)
+}
+
+func TestExecuteProposal(t *testing.T) {
+ t.Skip("DEPRECATED")
+ ctx, keepers := CreateTestInput(t, false, "staking")
+ bankKeeper := keepers.BankKeeper
+
+ exampleContract := InstantiateHackatomExampleContract(t, ctx, keepers)
+ contractAddr := exampleContract.Contract
+
+ // check balance
+ bal := bankKeeper.GetBalance(ctx, contractAddr, "denom")
+ require.Equal(t, bal.Amount, sdk.NewInt(100))
+
+ releaseMsg := struct {
+ Release struct{} `json:"release"`
+ }{}
+ releaseMsgBz, err := json.Marshal(releaseMsg)
+ require.NoError(t, err)
+
+ // try with runAs that doesn't have pemission
+ badSrc := &types.ExecuteContractProposal{ //nolint:staticcheck // testing deprecated function
+ Title: "First",
+ Description: "Beneficiary has no permission to run",
+ Contract: contractAddr.String(),
+ Msg: releaseMsgBz,
+ RunAs: exampleContract.BeneficiaryAddr.String(),
+ }
+
+ // fails on store - this doesn't have permission
+ govAuthority := keepers.AccountKeeper.GetModuleAddress(govtypes.ModuleName).String()
+ msgServer := govkeeper.NewMsgServerImpl(keepers.GovKeeper)
+ _, err = submitLegacyProposal(t, ctx, badSrc, exampleContract.BeneficiaryAddr.String(), govAuthority, msgServer)
+ require.Error(t, err)
+
+ // balance should not change
+ bal = bankKeeper.GetBalance(ctx, contractAddr, "denom")
+ require.Equal(t, bal.Amount, sdk.NewInt(100))
+
+ // try again with the proper run-as
+ src := &types.ExecuteContractProposal{ //nolint:staticcheck // testing deprecated function
+ Title: "Second",
+ Description: "Verifier can execute",
+ Contract: contractAddr.String(),
+ Msg: releaseMsgBz,
+ RunAs: exampleContract.VerifierAddr.String(),
+ }
+
+ em := sdk.NewEventManager()
+
+ // when
+ mustSubmitAndExecuteLegacyProposal(t, ctx.WithEventManager(em), src, exampleContract.BeneficiaryAddr.String(), keepers)
+
+ // balance should be empty (proper release)
+ bal = bankKeeper.GetBalance(ctx, contractAddr, "denom")
+ require.Equal(t, bal.Amount, sdk.NewInt(0))
+}
+
+func TestSudoProposal(t *testing.T) {
+ t.Skip("DEPRECATED")
+ ctx, keepers := CreateTestInput(t, false, "staking")
+ bankKeeper := keepers.BankKeeper
+
+ exampleContract := InstantiateHackatomExampleContract(t, ctx, keepers)
+ contractAddr := exampleContract.Contract
+ _, anyAddr := keyPubAddr()
+
+ // check balance
+ bal := bankKeeper.GetBalance(ctx, contractAddr, "denom")
+ require.Equal(t, bal.Amount, sdk.NewInt(100))
+ bal = bankKeeper.GetBalance(ctx, anyAddr, "denom")
+ require.Equal(t, bal.Amount, sdk.NewInt(0))
+
+ type StealMsg struct {
+ Recipient string `json:"recipient"`
+ Amount []sdk.Coin `json:"amount"`
+ }
+ stealMsg := struct {
+ Steal StealMsg `json:"steal_funds"`
+ }{Steal: StealMsg{
+ Recipient: anyAddr.String(),
+ Amount: []sdk.Coin{sdk.NewInt64Coin("denom", 75)},
+ }}
+ stealMsgBz, err := json.Marshal(stealMsg)
+ require.NoError(t, err)
+
+ // sudo can do anything
+ src := &types.SudoContractProposal{ //nolint:staticcheck // testing deprecated function
+ Title: "Sudo",
+ Description: "Steal funds for the verifier",
+ Contract: contractAddr.String(),
+ Msg: stealMsgBz,
+ }
+
+ em := sdk.NewEventManager()
+
+ // when
+ mustSubmitAndExecuteLegacyProposal(t, ctx.WithEventManager(em), src, exampleContract.BeneficiaryAddr.String(), keepers)
+
+ // balance should be empty (and verifier richer)
+ bal = bankKeeper.GetBalance(ctx, contractAddr, "denom")
+ require.Equal(t, bal.Amount, sdk.NewInt(25))
+ bal = bankKeeper.GetBalance(ctx, anyAddr, "denom")
+ require.Equal(t, bal.Amount, sdk.NewInt(75))
+}
+
+func TestAdminProposals(t *testing.T) {
+ t.Skip("DEPRECATED")
+ var (
+ otherAddress sdk.AccAddress = bytes.Repeat([]byte{0x2}, types.ContractAddrLen)
+ contractAddr = BuildContractAddressClassic(1, 1)
+ )
+ wasmCode, err := os.ReadFile("./testdata/hackatom.wasm")
+ require.NoError(t, err)
+
+ specs := map[string]struct {
+ state types.ContractInfo
+ srcProposal v1beta1.Content
+ expAdmin sdk.AccAddress
+ }{
+ "update with different admin": {
+ state: types.ContractInfoFixture(),
+ srcProposal: &types.UpdateAdminProposal{ //nolint:staticcheck // testing deprecated function
+ Title: "Foo",
+ Description: "Bar",
+ Contract: contractAddr.String(),
+ NewAdmin: otherAddress.String(),
+ },
+ expAdmin: otherAddress,
+ },
+ "update with old admin empty": {
+ state: types.ContractInfoFixture(func(info *types.ContractInfo) {
+ info.Admin = ""
+ }),
+ srcProposal: &types.UpdateAdminProposal{ //nolint:staticcheck // testing deprecated function
+ Title: "Foo",
+ Description: "Bar",
+ Contract: contractAddr.String(),
+ NewAdmin: otherAddress.String(),
+ },
+ expAdmin: otherAddress,
+ },
+ "clear admin": {
+ state: types.ContractInfoFixture(),
+ srcProposal: &types.ClearAdminProposal{ //nolint:staticcheck // testing deprecated function
+ Title: "Foo",
+ Description: "Bar",
+ Contract: contractAddr.String(),
+ },
+ expAdmin: nil,
+ },
+ "clear with old admin empty": {
+ state: types.ContractInfoFixture(func(info *types.ContractInfo) {
+ info.Admin = ""
+ }),
+ srcProposal: &types.ClearAdminProposal{ //nolint:staticcheck // testing deprecated function
+ Title: "Foo",
+ Description: "Bar",
+ Contract: contractAddr.String(),
+ },
+ expAdmin: nil,
+ },
+ }
+ for msg, spec := range specs {
+ t.Run(msg, func(t *testing.T) {
+ ctx, keepers := CreateTestInput(t, false, "staking")
+ wasmKeeper := keepers.WasmKeeper
+ err := wasmKeeper.SetParams(ctx, types.Params{
+ CodeUploadAccess: types.AllowNobody,
+ InstantiateDefaultPermission: types.AccessTypeNobody,
+ })
+ require.NoError(t, err)
+
+ codeInfo := types.CodeInfoFixture(types.WithSHA256CodeHash(wasmCode))
+ require.NoError(t, wasmKeeper.importCode(ctx, 1, codeInfo, wasmCode))
+
+ entries := []types.ContractCodeHistoryEntry{
+ {
+ Operation: types.ContractCodeHistoryOperationTypeInit,
+ CodeID: 1,
+ Updated: spec.state.Created,
+ },
+ }
+
+ require.NoError(t, wasmKeeper.importContract(ctx, contractAddr, &spec.state, []types.Model{}, entries)) //nolint:gosec
+
+ // when
+ mustSubmitAndExecuteLegacyProposal(t, ctx, spec.srcProposal, otherAddress.String(), keepers)
+
+ // then
+ cInfo := wasmKeeper.GetContractInfo(ctx, contractAddr)
+ require.NotNil(t, cInfo)
+ assert.Equal(t, spec.expAdmin.String(), cInfo.Admin)
+ })
+ }
+}
+
+func TestPinCodesProposal(t *testing.T) {
+ t.Skip("DEPRECATED")
+ ctx, keepers := CreateTestInput(t, false, "staking")
+ wasmKeeper := keepers.WasmKeeper
+
+ mock := wasmtesting.MockWasmEngine{
+ StoreCodeFn: wasmtesting.NoOpStoreCodeFn,
+ AnalyzeCodeFn: wasmtesting.WithoutIBCAnalyzeFn,
+ }
+ var (
+ hackatom = StoreHackatomExampleContract(t, ctx, keepers)
+ hackatomDuplicate = StoreHackatomExampleContract(t, ctx, keepers)
+ otherContract = StoreRandomContract(t, ctx, keepers, &mock)
+ gotPinnedChecksums []wasmvm.Checksum
+ )
+ checksumCollector := func(checksum wasmvm.Checksum) error {
+ gotPinnedChecksums = append(gotPinnedChecksums, checksum)
+ return nil
+ }
+ specs := map[string]struct {
+ srcCodeIDs []uint64
+ mockFn func(checksum wasmvm.Checksum) error
+ expPinned []wasmvm.Checksum
+ expErr bool
+ }{
+ "pin one": {
+ srcCodeIDs: []uint64{hackatom.CodeID},
+ mockFn: checksumCollector,
+ },
+ "pin multiple": {
+ srcCodeIDs: []uint64{hackatom.CodeID, otherContract.CodeID},
+ mockFn: checksumCollector,
+ },
+ "pin same code id": {
+ srcCodeIDs: []uint64{hackatom.CodeID, hackatomDuplicate.CodeID},
+ mockFn: checksumCollector,
+ },
+ "pin non existing code id": {
+ srcCodeIDs: []uint64{999},
+ mockFn: checksumCollector,
+ expErr: true,
+ },
+ "pin empty code id list": {
+ srcCodeIDs: []uint64{},
+ mockFn: checksumCollector,
+ expErr: true,
+ },
+ "wasmvm failed with error": {
+ srcCodeIDs: []uint64{hackatom.CodeID},
+ mockFn: func(_ wasmvm.Checksum) error {
+ return errors.New("test, ignore")
+ },
+ expErr: true,
+ },
+ }
+ parentCtx := ctx
+ for msg, spec := range specs {
+ t.Run(msg, func(t *testing.T) {
+ myActorAddress := RandomBech32AccountAddress(t)
+ gotPinnedChecksums = nil
+ ctx, _ := parentCtx.CacheContext()
+ mock.PinFn = spec.mockFn
+ proposal := &types.PinCodesProposal{ //nolint:staticcheck // testing deprecated function
+ Title: "Foo",
+ Description: "Bar",
+ CodeIDs: spec.srcCodeIDs,
+ }
+
+ govAuthority := keepers.AccountKeeper.GetModuleAddress(govtypes.ModuleName).String()
+ msgServer := govkeeper.NewMsgServerImpl(keepers.GovKeeper)
+
+ // when
+ contentMsg, gotErr := submitLegacyProposal(t, ctx, proposal, myActorAddress, govAuthority, msgServer)
+ if spec.expErr {
+ require.Error(t, gotErr)
+ return
+ }
+ require.NoError(t, gotErr)
+
+ // and proposal execute
+ _, err := msgServer.ExecLegacyContent(sdk.WrapSDKContext(ctx), v1.NewMsgExecLegacyContent(contentMsg.Content, govAuthority))
+ require.NoError(t, err)
+
+ // then
+ for i := range spec.srcCodeIDs {
+ c := wasmKeeper.GetCodeInfo(ctx, spec.srcCodeIDs[i])
+ require.Equal(t, wasmvm.Checksum(c.CodeHash), gotPinnedChecksums[i])
+ }
+ })
+ }
+}
+
+func TestUnpinCodesProposal(t *testing.T) {
+ t.Skip("DEPRECATED")
+ ctx, keepers := CreateTestInput(t, false, "staking")
+ wasmKeeper := keepers.WasmKeeper
+
+ mock := wasmtesting.MockWasmEngine{
+ StoreCodeFn: wasmtesting.NoOpStoreCodeFn,
+ AnalyzeCodeFn: wasmtesting.WithoutIBCAnalyzeFn,
+ }
+ var (
+ hackatom = StoreHackatomExampleContract(t, ctx, keepers)
+ hackatomDuplicate = StoreHackatomExampleContract(t, ctx, keepers)
+ otherContract = StoreRandomContract(t, ctx, keepers, &mock)
+ gotUnpinnedChecksums []wasmvm.Checksum
+ )
+ checksumCollector := func(checksum wasmvm.Checksum) error {
+ gotUnpinnedChecksums = append(gotUnpinnedChecksums, checksum)
+ return nil
+ }
+ specs := map[string]struct {
+ srcCodeIDs []uint64
+ mockFn func(checksum wasmvm.Checksum) error
+ expUnpinned []wasmvm.Checksum
+ expErr bool
+ }{
+ "unpin one": {
+ srcCodeIDs: []uint64{hackatom.CodeID},
+ mockFn: checksumCollector,
+ },
+ "unpin multiple": {
+ srcCodeIDs: []uint64{hackatom.CodeID, otherContract.CodeID},
+ mockFn: checksumCollector,
+ },
+ "unpin same code id": {
+ srcCodeIDs: []uint64{hackatom.CodeID, hackatomDuplicate.CodeID},
+ mockFn: checksumCollector,
+ },
+ "unpin non existing code id": {
+ srcCodeIDs: []uint64{999},
+ mockFn: checksumCollector,
+ expErr: true,
+ },
+ "unpin empty code id list": {
+ srcCodeIDs: []uint64{},
+ mockFn: checksumCollector,
+ expErr: true,
+ },
+ "wasmvm failed with error": {
+ srcCodeIDs: []uint64{hackatom.CodeID},
+ mockFn: func(_ wasmvm.Checksum) error {
+ return errors.New("test, ignore")
+ },
+ expErr: true,
+ },
+ }
+ parentCtx := ctx
+ for msg, spec := range specs {
+ t.Run(msg, func(t *testing.T) {
+ gotUnpinnedChecksums = nil
+ ctx, _ := parentCtx.CacheContext()
+ mock.UnpinFn = spec.mockFn
+ proposal := &types.UnpinCodesProposal{ //nolint:staticcheck // testing deprecated function
+ Title: "Foo",
+ Description: "Bar",
+ CodeIDs: spec.srcCodeIDs,
+ }
+
+ govAuthority := keepers.AccountKeeper.GetModuleAddress(govtypes.ModuleName).String()
+ msgServer := govkeeper.NewMsgServerImpl(keepers.GovKeeper)
+
+ // when
+ contentMsg, gotErr := submitLegacyProposal(t, ctx, proposal, RandomBech32AccountAddress(t), govAuthority, msgServer)
+ if spec.expErr {
+ require.Error(t, gotErr)
+ return
+ }
+ require.NoError(t, gotErr)
+
+ // and proposal execute
+ _, err := msgServer.ExecLegacyContent(sdk.WrapSDKContext(ctx), v1.NewMsgExecLegacyContent(contentMsg.Content, govAuthority))
+ require.NoError(t, err)
+
+ // then
+ for i := range spec.srcCodeIDs {
+ c := wasmKeeper.GetCodeInfo(ctx, spec.srcCodeIDs[i])
+ require.Equal(t, wasmvm.Checksum(c.CodeHash), gotUnpinnedChecksums[i])
+ }
+ })
+ }
+}
+
+func TestUpdateInstantiateConfigProposal(t *testing.T) {
+ t.Skip("DEPRECATED")
+ ctx, keepers := CreateTestInput(t, false, "staking")
+ wasmKeeper := keepers.WasmKeeper
+
+ mock := wasmtesting.MockWasmEngine{
+ StoreCodeFn: wasmtesting.NoOpStoreCodeFn,
+ AnalyzeCodeFn: wasmtesting.WithoutIBCAnalyzeFn,
+ }
+ anyAddress, err := sdk.AccAddressFromBech32("cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz")
+ require.NoError(t, err)
+
+ withAddressAccessConfig := types.AccessTypeAnyOfAddresses.With(anyAddress)
+ var (
+ nobody = StoreRandomContractWithAccessConfig(t, ctx, keepers, &mock, &types.AllowNobody)
+ everybody = StoreRandomContractWithAccessConfig(t, ctx, keepers, &mock, &types.AllowEverybody)
+ withAddress = StoreRandomContractWithAccessConfig(t, ctx, keepers, &mock, &withAddressAccessConfig)
+ )
+
+ specs := map[string]struct {
+ accessConfigUpdates []types.AccessConfigUpdate
+ expErr bool
+ }{
+ "update one": {
+ accessConfigUpdates: []types.AccessConfigUpdate{
+ {CodeID: nobody.CodeID, InstantiatePermission: types.AllowEverybody},
+ },
+ },
+ "update multiple": {
+ accessConfigUpdates: []types.AccessConfigUpdate{
+ {CodeID: everybody.CodeID, InstantiatePermission: types.AllowNobody},
+ {CodeID: nobody.CodeID, InstantiatePermission: withAddressAccessConfig},
+ {CodeID: withAddress.CodeID, InstantiatePermission: types.AllowEverybody},
+ },
+ },
+ "update same code id": {
+ accessConfigUpdates: []types.AccessConfigUpdate{
+ {CodeID: everybody.CodeID, InstantiatePermission: types.AllowNobody},
+ {CodeID: everybody.CodeID, InstantiatePermission: types.AllowEverybody},
+ },
+ expErr: true,
+ },
+ "update non existing code id": {
+ accessConfigUpdates: []types.AccessConfigUpdate{
+ {CodeID: 100, InstantiatePermission: types.AllowNobody},
+ {CodeID: everybody.CodeID, InstantiatePermission: types.AllowEverybody},
+ },
+ expErr: true,
+ },
+ "update empty list": {
+ accessConfigUpdates: make([]types.AccessConfigUpdate, 0),
+ expErr: true,
+ },
+ }
+ parentCtx := ctx
+ for msg, spec := range specs {
+ t.Run(msg, func(t *testing.T) {
+ ctx, _ := parentCtx.CacheContext()
+
+ updates := make([]types.AccessConfigUpdate, 0)
+ for _, cu := range spec.accessConfigUpdates {
+ updates = append(updates, types.AccessConfigUpdate{
+ CodeID: cu.CodeID,
+ InstantiatePermission: cu.InstantiatePermission,
+ })
+ }
+
+ govAuthority := keepers.AccountKeeper.GetModuleAddress(govtypes.ModuleName).String()
+ msgServer := govkeeper.NewMsgServerImpl(keepers.GovKeeper)
+ proposal := &types.UpdateInstantiateConfigProposal{ //nolint:staticcheck // testing deprecated function
+ Title: "Foo",
+ Description: "Bar",
+ AccessConfigUpdates: updates,
+ }
+
+ // when
+ contentMsg, gotErr := submitLegacyProposal(t, ctx, proposal, RandomBech32AccountAddress(t), govAuthority, msgServer)
+ if spec.expErr {
+ require.Error(t, gotErr)
+ return
+ }
+ require.NoError(t, gotErr)
+
+ // and proposal execute
+ _, err := msgServer.ExecLegacyContent(sdk.WrapSDKContext(ctx), v1.NewMsgExecLegacyContent(contentMsg.Content, govAuthority))
+ require.NoError(t, err)
+
+ // then
+ for i := range spec.accessConfigUpdates {
+ c := wasmKeeper.GetCodeInfo(ctx, spec.accessConfigUpdates[i].CodeID)
+ require.Equal(t, spec.accessConfigUpdates[i].InstantiatePermission, c.InstantiateConfig)
+ }
+ })
+ }
+}
diff --git a/x/wasm/types/codec.go b/x/wasm/types/codec.go
index c1fcfb9972..a23122052a 100644
--- a/x/wasm/types/codec.go
+++ b/x/wasm/types/codec.go
@@ -33,6 +33,19 @@ func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {
cdc.RegisterConcrete(&MsgStoreAndMigrateContract{}, "wasm/MsgStoreAndMigrateContract", nil)
cdc.RegisterConcrete(&MsgUpdateContractLabel{}, "wasm/MsgUpdateContractLabel", nil)
+ cdc.RegisterConcrete(&PinCodesProposal{}, "wasm/PinCodesProposal", nil)
+ cdc.RegisterConcrete(&UnpinCodesProposal{}, "wasm/UnpinCodesProposal", nil)
+ cdc.RegisterConcrete(&StoreCodeProposal{}, "wasm/StoreCodeProposal", nil)
+ cdc.RegisterConcrete(&InstantiateContractProposal{}, "wasm/InstantiateContractProposal", nil)
+ cdc.RegisterConcrete(&InstantiateContract2Proposal{}, "wasm/InstantiateContract2Proposal", nil)
+ cdc.RegisterConcrete(&MigrateContractProposal{}, "wasm/MigrateContractProposal", nil)
+ cdc.RegisterConcrete(&SudoContractProposal{}, "wasm/SudoContractProposal", nil)
+ cdc.RegisterConcrete(&ExecuteContractProposal{}, "wasm/ExecuteContractProposal", nil)
+ cdc.RegisterConcrete(&UpdateAdminProposal{}, "wasm/UpdateAdminProposal", nil)
+ cdc.RegisterConcrete(&ClearAdminProposal{}, "wasm/ClearAdminProposal", nil)
+ cdc.RegisterConcrete(&UpdateInstantiateConfigProposal{}, "wasm/UpdateInstantiateConfigProposal", nil)
+ cdc.RegisterConcrete(&StoreAndInstantiateContractProposal{}, "wasm/StoreAndInstantiateContractProposal", nil)
+
cdc.RegisterInterface((*ContractInfoExtension)(nil), nil)
cdc.RegisterInterface((*ContractAuthzFilterX)(nil), nil)
@@ -75,6 +88,18 @@ func RegisterInterfaces(registry types.InterfaceRegistry) {
)
registry.RegisterImplementations(
(*v1beta1.Content)(nil),
+ &StoreCodeProposal{},
+ &InstantiateContractProposal{},
+ &InstantiateContract2Proposal{},
+ &MigrateContractProposal{},
+ &SudoContractProposal{},
+ &ExecuteContractProposal{},
+ &UpdateAdminProposal{},
+ &ClearAdminProposal{},
+ &PinCodesProposal{},
+ &UnpinCodesProposal{},
+ &UpdateInstantiateConfigProposal{},
+ &StoreAndInstantiateContractProposal{},
)
registry.RegisterInterface("cosmwasm.wasm.v1.ContractInfoExtension", (*ContractInfoExtension)(nil))
diff --git a/x/wasm/types/proposal.go b/x/wasm/types/proposal.go
new file mode 100644
index 0000000000..9c85a08dff
--- /dev/null
+++ b/x/wasm/types/proposal.go
@@ -0,0 +1,987 @@
+package types
+
+import (
+ "encoding/base64"
+ "encoding/hex"
+ "fmt"
+ "strings"
+
+ errorsmod "cosmossdk.io/errors"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+ govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
+ "github.com/cosmos/cosmos-sdk/x/gov/types/v1beta1"
+)
+
+type ProposalType string
+
+const (
+ ProposalTypeStoreCode ProposalType = "StoreCode"
+ ProposalTypeInstantiateContract ProposalType = "InstantiateContract"
+ ProposalTypeInstantiateContract2 ProposalType = "InstantiateContract2"
+ ProposalTypeMigrateContract ProposalType = "MigrateContract"
+ ProposalTypeSudoContract ProposalType = "SudoContract"
+ ProposalTypeExecuteContract ProposalType = "ExecuteContract"
+ ProposalTypeUpdateAdmin ProposalType = "UpdateAdmin"
+ ProposalTypeClearAdmin ProposalType = "ClearAdmin"
+ ProposalTypePinCodes ProposalType = "PinCodes"
+ ProposalTypeUnpinCodes ProposalType = "UnpinCodes"
+ ProposalTypeUpdateInstantiateConfig ProposalType = "UpdateInstantiateConfig"
+ ProposalTypeStoreAndInstantiateContractProposal ProposalType = "StoreAndInstantiateContract"
+)
+
+// DisableAllProposals contains no wasm gov types.
+var DisableAllProposals []ProposalType
+
+// EnableAllProposals contains all wasm gov types as keys.
+var EnableAllProposals = []ProposalType{
+ ProposalTypeStoreCode,
+ ProposalTypeInstantiateContract,
+ ProposalTypeInstantiateContract2,
+ ProposalTypeMigrateContract,
+ ProposalTypeSudoContract,
+ ProposalTypeExecuteContract,
+ ProposalTypeUpdateAdmin,
+ ProposalTypeClearAdmin,
+ ProposalTypePinCodes,
+ ProposalTypeUnpinCodes,
+ ProposalTypeUpdateInstantiateConfig,
+ ProposalTypeStoreAndInstantiateContractProposal,
+}
+
+// ConvertToProposals maps each key to a ProposalType and returns a typed list.
+// If any string is not a valid type (in this file), then return an error
+func ConvertToProposals(keys []string) ([]ProposalType, error) {
+ valid := make(map[string]bool, len(EnableAllProposals))
+ for _, key := range EnableAllProposals {
+ valid[string(key)] = true
+ }
+
+ proposals := make([]ProposalType, len(keys))
+ for i, key := range keys {
+ if _, ok := valid[key]; !ok {
+ return nil, errorsmod.Wrapf(sdkerrors.ErrInvalidRequest, "'%s' is not a valid ProposalType", key)
+ }
+ proposals[i] = ProposalType(key)
+ }
+ return proposals, nil
+}
+
+func init() { // register new content types with the sdk
+ v1beta1.RegisterProposalType(string(ProposalTypeStoreCode))
+ v1beta1.RegisterProposalType(string(ProposalTypeInstantiateContract))
+ v1beta1.RegisterProposalType(string(ProposalTypeInstantiateContract2))
+ v1beta1.RegisterProposalType(string(ProposalTypeMigrateContract))
+ v1beta1.RegisterProposalType(string(ProposalTypeSudoContract))
+ v1beta1.RegisterProposalType(string(ProposalTypeExecuteContract))
+ v1beta1.RegisterProposalType(string(ProposalTypeUpdateAdmin))
+ v1beta1.RegisterProposalType(string(ProposalTypeClearAdmin))
+ v1beta1.RegisterProposalType(string(ProposalTypePinCodes))
+ v1beta1.RegisterProposalType(string(ProposalTypeUnpinCodes))
+ v1beta1.RegisterProposalType(string(ProposalTypeUpdateInstantiateConfig))
+ v1beta1.RegisterProposalType(string(ProposalTypeStoreAndInstantiateContractProposal))
+}
+
+func NewStoreCodeProposal(
+ title string,
+ description string,
+ runAs string,
+ wasmBz []byte,
+ permission *AccessConfig,
+ unpinCode bool,
+ source string,
+ builder string,
+ codeHash []byte,
+) *StoreCodeProposal {
+ return &StoreCodeProposal{title, description, runAs, wasmBz, permission, unpinCode, source, builder, codeHash}
+}
+
+// ProposalRoute returns the routing key of a parameter change proposal.
+func (p StoreCodeProposal) ProposalRoute() string { return RouterKey }
+
+// GetTitle returns the title of the proposal
+func (p *StoreCodeProposal) GetTitle() string { return p.Title }
+
+// GetDescription returns the human readable description of the proposal
+func (p StoreCodeProposal) GetDescription() string { return p.Description }
+
+// ProposalType returns the type
+func (p StoreCodeProposal) ProposalType() string { return string(ProposalTypeStoreCode) }
+
+// ValidateBasic validates the proposal
+func (p StoreCodeProposal) ValidateBasic() error {
+ if err := validateProposalCommons(p.Title, p.Description); err != nil {
+ return err
+ }
+ if _, err := sdk.AccAddressFromBech32(p.RunAs); err != nil {
+ return errorsmod.Wrap(err, "run as")
+ }
+
+ if err := validateWasmCode(p.WASMByteCode, MaxProposalWasmSize); err != nil {
+ return errorsmod.Wrapf(sdkerrors.ErrInvalidRequest, "code bytes %s", err.Error())
+ }
+
+ if p.InstantiatePermission != nil {
+ if err := p.InstantiatePermission.ValidateBasic(); err != nil {
+ return errorsmod.Wrap(err, "instantiate permission")
+ }
+ }
+
+ if err := ValidateVerificationInfo(p.Source, p.Builder, p.CodeHash); err != nil {
+ return errorsmod.Wrapf(err, "code verification info")
+ }
+ return nil
+}
+
+// String implements the Stringer interface.
+func (p StoreCodeProposal) String() string {
+ return fmt.Sprintf(`Store Code Proposal:
+ Title: %s
+ Description: %s
+ Run as: %s
+ WasmCode: %X
+ Source: %s
+ Builder: %s
+ Code Hash: %X
+`, p.Title, p.Description, p.RunAs, p.WASMByteCode, p.Source, p.Builder, p.CodeHash)
+}
+
+// MarshalYAML pretty prints the wasm byte code
+func (p StoreCodeProposal) MarshalYAML() (interface{}, error) {
+ return struct {
+ Title string `yaml:"title"`
+ Description string `yaml:"description"`
+ RunAs string `yaml:"run_as"`
+ WASMByteCode string `yaml:"wasm_byte_code"`
+ InstantiatePermission *AccessConfig `yaml:"instantiate_permission"`
+ Source string `yaml:"source"`
+ Builder string `yaml:"builder"`
+ CodeHash string `yaml:"code_hash"`
+ }{
+ Title: p.Title,
+ Description: p.Description,
+ RunAs: p.RunAs,
+ WASMByteCode: base64.StdEncoding.EncodeToString(p.WASMByteCode),
+ InstantiatePermission: p.InstantiatePermission,
+ Source: p.Source,
+ Builder: p.Builder,
+ CodeHash: hex.EncodeToString(p.CodeHash),
+ }, nil
+}
+
+func NewInstantiateContractProposal(
+ title string,
+ description string,
+ runAs string,
+ admin string,
+ codeID uint64,
+ label string,
+ msg RawContractMessage,
+ funds sdk.Coins,
+) *InstantiateContractProposal {
+ return &InstantiateContractProposal{title, description, runAs, admin, codeID, label, msg, funds}
+}
+
+// ProposalRoute returns the routing key of a parameter change proposal.
+func (p InstantiateContractProposal) ProposalRoute() string { return RouterKey }
+
+// GetTitle returns the title of the proposal
+func (p *InstantiateContractProposal) GetTitle() string { return p.Title }
+
+// GetDescription returns the human readable description of the proposal
+func (p InstantiateContractProposal) GetDescription() string { return p.Description }
+
+// ProposalType returns the type
+func (p InstantiateContractProposal) ProposalType() string {
+ return string(ProposalTypeInstantiateContract)
+}
+
+// ValidateBasic validates the proposal
+func (p InstantiateContractProposal) ValidateBasic() error {
+ if err := validateProposalCommons(p.Title, p.Description); err != nil {
+ return err
+ }
+ if _, err := sdk.AccAddressFromBech32(p.RunAs); err != nil {
+ return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "run as")
+ }
+
+ if p.CodeID == 0 {
+ return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "code id is required")
+ }
+
+ if err := ValidateLabel(p.Label); err != nil {
+ return err
+ }
+
+ if !p.Funds.IsValid() {
+ return sdkerrors.ErrInvalidCoins
+ }
+
+ if len(p.Admin) != 0 {
+ if _, err := sdk.AccAddressFromBech32(p.Admin); err != nil {
+ return err
+ }
+ }
+ if err := p.Msg.ValidateBasic(); err != nil {
+ return errorsmod.Wrap(err, "payload msg")
+ }
+ return nil
+}
+
+// String implements the Stringer interface.
+func (p InstantiateContractProposal) String() string {
+ return fmt.Sprintf(`Instantiate Code Proposal:
+ Title: %s
+ Description: %s
+ Run as: %s
+ Admin: %s
+ Code id: %d
+ Label: %s
+ Msg: %q
+ Funds: %s
+`, p.Title, p.Description, p.RunAs, p.Admin, p.CodeID, p.Label, p.Msg, p.Funds)
+}
+
+// MarshalYAML pretty prints the init message
+func (p InstantiateContractProposal) MarshalYAML() (interface{}, error) {
+ return struct {
+ Title string `yaml:"title"`
+ Description string `yaml:"description"`
+ RunAs string `yaml:"run_as"`
+ Admin string `yaml:"admin"`
+ CodeID uint64 `yaml:"code_id"`
+ Label string `yaml:"label"`
+ Msg string `yaml:"msg"`
+ Funds sdk.Coins `yaml:"funds"`
+ }{
+ Title: p.Title,
+ Description: p.Description,
+ RunAs: p.RunAs,
+ Admin: p.Admin,
+ CodeID: p.CodeID,
+ Label: p.Label,
+ Msg: string(p.Msg),
+ Funds: p.Funds,
+ }, nil
+}
+
+func NewInstantiateContract2Proposal(
+ title string,
+ description string,
+ runAs string,
+ admin string,
+ codeID uint64,
+ label string,
+ msg RawContractMessage,
+ funds sdk.Coins,
+ salt []byte,
+ fixMsg bool,
+) *InstantiateContract2Proposal {
+ return &InstantiateContract2Proposal{title, description, runAs, admin, codeID, label, msg, funds, salt, fixMsg}
+}
+
+// ProposalRoute returns the routing key of a parameter change proposal.
+func (p InstantiateContract2Proposal) ProposalRoute() string { return RouterKey }
+
+// GetTitle returns the title of the proposal
+func (p *InstantiateContract2Proposal) GetTitle() string { return p.Title }
+
+// GetDescription returns the human readable description of the proposal
+func (p InstantiateContract2Proposal) GetDescription() string { return p.Description }
+
+// ProposalType returns the type
+func (p InstantiateContract2Proposal) ProposalType() string {
+ return string(ProposalTypeInstantiateContract2)
+}
+
+// ValidateBasic validates the proposal
+func (p InstantiateContract2Proposal) ValidateBasic() error {
+ // Validate title and description
+ if err := validateProposalCommons(p.Title, p.Description); err != nil {
+ return err
+ }
+ // Validate run as
+ if _, err := sdk.AccAddressFromBech32(p.RunAs); err != nil {
+ return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "run as")
+ }
+ // Validate admin
+ if len(p.Admin) != 0 {
+ if _, err := sdk.AccAddressFromBech32(p.Admin); err != nil {
+ return err
+ }
+ }
+ // Validate codeid
+ if p.CodeID == 0 {
+ return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "code id is required")
+ }
+ // Validate label
+ if err := ValidateLabel(p.Label); err != nil {
+ return err
+ }
+ // Validate msg
+ if err := p.Msg.ValidateBasic(); err != nil {
+ return errorsmod.Wrap(err, "payload msg")
+ }
+ // Validate funds
+ if !p.Funds.IsValid() {
+ return sdkerrors.ErrInvalidCoins
+ }
+ // Validate salt
+ if len(p.Salt) == 0 {
+ return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "salt is required")
+ }
+ return nil
+}
+
+// String implements the Stringer interface.
+func (p InstantiateContract2Proposal) String() string {
+ return fmt.Sprintf(`Instantiate Code Proposal:
+ Title: %s
+ Description: %s
+ Run as: %s
+ Admin: %s
+ Code id: %d
+ Label: %s
+ Msg: %q
+ Funds: %s
+ Salt: %X
+`, p.Title, p.Description, p.RunAs, p.Admin, p.CodeID, p.Label, p.Msg, p.Funds, p.Salt)
+}
+
+// MarshalYAML pretty prints the init message
+func (p InstantiateContract2Proposal) MarshalYAML() (interface{}, error) {
+ return struct {
+ Title string `yaml:"title"`
+ Description string `yaml:"description"`
+ RunAs string `yaml:"run_as"`
+ Admin string `yaml:"admin"`
+ CodeID uint64 `yaml:"code_id"`
+ Label string `yaml:"label"`
+ Msg string `yaml:"msg"`
+ Funds sdk.Coins `yaml:"funds"`
+ Salt string `yaml:"salt"`
+ }{
+ Title: p.Title,
+ Description: p.Description,
+ RunAs: p.RunAs,
+ Admin: p.Admin,
+ CodeID: p.CodeID,
+ Label: p.Label,
+ Msg: string(p.Msg),
+ Funds: p.Funds,
+ Salt: base64.StdEncoding.EncodeToString(p.Salt),
+ }, nil
+}
+
+func NewStoreAndInstantiateContractProposal(
+ title string,
+ description string,
+ runAs string,
+ wasmBz []byte,
+ source string,
+ builder string,
+ codeHash []byte,
+ permission *AccessConfig,
+ unpinCode bool,
+ admin string,
+ label string,
+ msg RawContractMessage,
+ funds sdk.Coins,
+) *StoreAndInstantiateContractProposal {
+ return &StoreAndInstantiateContractProposal{
+ Title: title,
+ Description: description,
+ RunAs: runAs,
+ WASMByteCode: wasmBz,
+ Source: source,
+ Builder: builder,
+ CodeHash: codeHash,
+ InstantiatePermission: permission,
+ UnpinCode: unpinCode,
+ Admin: admin,
+ Label: label,
+ Msg: msg,
+ Funds: funds,
+ }
+}
+
+// ProposalRoute returns the routing key of a parameter change proposal.
+func (p StoreAndInstantiateContractProposal) ProposalRoute() string { return RouterKey }
+
+// GetTitle returns the title of the proposal
+func (p *StoreAndInstantiateContractProposal) GetTitle() string { return p.Title }
+
+// GetDescription returns the human readable description of the proposal
+func (p StoreAndInstantiateContractProposal) GetDescription() string { return p.Description }
+
+// ProposalType returns the type
+func (p StoreAndInstantiateContractProposal) ProposalType() string {
+ return string(ProposalTypeStoreAndInstantiateContractProposal)
+}
+
+// ValidateBasic validates the proposal
+func (p StoreAndInstantiateContractProposal) ValidateBasic() error {
+ if err := validateProposalCommons(p.Title, p.Description); err != nil {
+ return err
+ }
+ if _, err := sdk.AccAddressFromBech32(p.RunAs); err != nil {
+ return errorsmod.Wrap(err, "run as")
+ }
+
+ if err := validateWasmCode(p.WASMByteCode, MaxProposalWasmSize); err != nil {
+ return errorsmod.Wrapf(sdkerrors.ErrInvalidRequest, "code bytes %s", err.Error())
+ }
+
+ if err := ValidateVerificationInfo(p.Source, p.Builder, p.CodeHash); err != nil {
+ return errorsmod.Wrap(err, "code info")
+ }
+
+ if p.InstantiatePermission != nil {
+ if err := p.InstantiatePermission.ValidateBasic(); err != nil {
+ return errorsmod.Wrap(err, "instantiate permission")
+ }
+ }
+
+ if err := ValidateLabel(p.Label); err != nil {
+ return err
+ }
+
+ if !p.Funds.IsValid() {
+ return sdkerrors.ErrInvalidCoins
+ }
+
+ if len(p.Admin) != 0 {
+ if _, err := sdk.AccAddressFromBech32(p.Admin); err != nil {
+ return err
+ }
+ }
+ if err := p.Msg.ValidateBasic(); err != nil {
+ return errorsmod.Wrap(err, "payload msg")
+ }
+ return nil
+}
+
+// String implements the Stringer interface.
+func (p StoreAndInstantiateContractProposal) String() string {
+ return fmt.Sprintf(`Store And Instantiate Coontract Proposal:
+ Title: %s
+ Description: %s
+ Run as: %s
+ WasmCode: %X
+ Source: %s
+ Builder: %s
+ Code Hash: %X
+ Instantiate permission: %s
+ Unpin code: %t
+ Admin: %s
+ Label: %s
+ Msg: %q
+ Funds: %s
+`, p.Title, p.Description, p.RunAs, p.WASMByteCode, p.Source, p.Builder, p.CodeHash, p.InstantiatePermission, p.UnpinCode, p.Admin, p.Label, p.Msg, p.Funds)
+}
+
+// MarshalYAML pretty prints the wasm byte code and the init message
+func (p StoreAndInstantiateContractProposal) MarshalYAML() (interface{}, error) {
+ return struct {
+ Title string `yaml:"title"`
+ Description string `yaml:"description"`
+ RunAs string `yaml:"run_as"`
+ WASMByteCode string `yaml:"wasm_byte_code"`
+ Source string `yaml:"source"`
+ Builder string `yaml:"builder"`
+ CodeHash string `yaml:"code_hash"`
+ InstantiatePermission *AccessConfig `yaml:"instantiate_permission"`
+ UnpinCode bool `yaml:"unpin_code"`
+ Admin string `yaml:"admin"`
+ Label string `yaml:"label"`
+ Msg string `yaml:"msg"`
+ Funds sdk.Coins `yaml:"funds"`
+ }{
+ Title: p.Title,
+ Description: p.Description,
+ RunAs: p.RunAs,
+ WASMByteCode: base64.StdEncoding.EncodeToString(p.WASMByteCode),
+ InstantiatePermission: p.InstantiatePermission,
+ UnpinCode: p.UnpinCode,
+ Admin: p.Admin,
+ Label: p.Label,
+ Source: p.Source,
+ Builder: p.Builder,
+ CodeHash: hex.EncodeToString(p.CodeHash),
+ Msg: string(p.Msg),
+ Funds: p.Funds,
+ }, nil
+}
+
+func NewMigrateContractProposal(
+ title string,
+ description string,
+ contract string,
+ codeID uint64,
+ msg RawContractMessage,
+) *MigrateContractProposal {
+ return &MigrateContractProposal{
+ Title: title,
+ Description: description,
+ Contract: contract,
+ CodeID: codeID,
+ Msg: msg,
+ }
+}
+
+// ProposalRoute returns the routing key of a parameter change proposal.
+func (p MigrateContractProposal) ProposalRoute() string { return RouterKey }
+
+// GetTitle returns the title of the proposal
+func (p *MigrateContractProposal) GetTitle() string { return p.Title }
+
+// GetDescription returns the human readable description of the proposal
+func (p MigrateContractProposal) GetDescription() string { return p.Description }
+
+// ProposalType returns the type
+func (p MigrateContractProposal) ProposalType() string { return string(ProposalTypeMigrateContract) }
+
+// ValidateBasic validates the proposal
+func (p MigrateContractProposal) ValidateBasic() error {
+ if err := validateProposalCommons(p.Title, p.Description); err != nil {
+ return err
+ }
+ if p.CodeID == 0 {
+ return errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "code_id is required")
+ }
+ if _, err := sdk.AccAddressFromBech32(p.Contract); err != nil {
+ return errorsmod.Wrap(err, "contract")
+ }
+ if err := p.Msg.ValidateBasic(); err != nil {
+ return errorsmod.Wrap(err, "payload msg")
+ }
+ return nil
+}
+
+// String implements the Stringer interface.
+func (p MigrateContractProposal) String() string {
+ return fmt.Sprintf(`Migrate Contract Proposal:
+ Title: %s
+ Description: %s
+ Contract: %s
+ Code id: %d
+ Msg: %q
+`, p.Title, p.Description, p.Contract, p.CodeID, p.Msg)
+}
+
+// MarshalYAML pretty prints the migrate message
+func (p MigrateContractProposal) MarshalYAML() (interface{}, error) {
+ return struct {
+ Title string `yaml:"title"`
+ Description string `yaml:"description"`
+ Contract string `yaml:"contract"`
+ CodeID uint64 `yaml:"code_id"`
+ Msg string `yaml:"msg"`
+ }{
+ Title: p.Title,
+ Description: p.Description,
+ Contract: p.Contract,
+ CodeID: p.CodeID,
+ Msg: string(p.Msg),
+ }, nil
+}
+
+func NewSudoContractProposal(
+ title string,
+ description string,
+ contract string,
+ msg RawContractMessage,
+) *SudoContractProposal {
+ return &SudoContractProposal{
+ Title: title,
+ Description: description,
+ Contract: contract,
+ Msg: msg,
+ }
+}
+
+// ProposalRoute returns the routing key of a parameter change proposal.
+func (p SudoContractProposal) ProposalRoute() string { return RouterKey }
+
+// GetTitle returns the title of the proposal
+func (p *SudoContractProposal) GetTitle() string { return p.Title }
+
+// GetDescription returns the human readable description of the proposal
+func (p SudoContractProposal) GetDescription() string { return p.Description }
+
+// ProposalType returns the type
+func (p SudoContractProposal) ProposalType() string { return string(ProposalTypeSudoContract) }
+
+// ValidateBasic validates the proposal
+func (p SudoContractProposal) ValidateBasic() error {
+ if err := validateProposalCommons(p.Title, p.Description); err != nil {
+ return err
+ }
+ if _, err := sdk.AccAddressFromBech32(p.Contract); err != nil {
+ return errorsmod.Wrap(err, "contract")
+ }
+ if err := p.Msg.ValidateBasic(); err != nil {
+ return errorsmod.Wrap(err, "payload msg")
+ }
+ return nil
+}
+
+// String implements the Stringer interface.
+func (p SudoContractProposal) String() string {
+ return fmt.Sprintf(`Migrate Contract Proposal:
+ Title: %s
+ Description: %s
+ Contract: %s
+ Msg: %q
+`, p.Title, p.Description, p.Contract, p.Msg)
+}
+
+// MarshalYAML pretty prints the migrate message
+func (p SudoContractProposal) MarshalYAML() (interface{}, error) {
+ return struct {
+ Title string `yaml:"title"`
+ Description string `yaml:"description"`
+ Contract string `yaml:"contract"`
+ Msg string `yaml:"msg"`
+ }{
+ Title: p.Title,
+ Description: p.Description,
+ Contract: p.Contract,
+ Msg: string(p.Msg),
+ }, nil
+}
+
+func NewExecuteContractProposal(
+ title string,
+ description string,
+ runAs string,
+ contract string,
+ msg RawContractMessage,
+ funds sdk.Coins,
+) *ExecuteContractProposal {
+ return &ExecuteContractProposal{title, description, runAs, contract, msg, funds}
+}
+
+// ProposalRoute returns the routing key of a parameter change proposal.
+func (p ExecuteContractProposal) ProposalRoute() string { return RouterKey }
+
+// GetTitle returns the title of the proposal
+func (p *ExecuteContractProposal) GetTitle() string { return p.Title }
+
+// GetDescription returns the human readable description of the proposal
+func (p ExecuteContractProposal) GetDescription() string { return p.Description }
+
+// ProposalType returns the type
+func (p ExecuteContractProposal) ProposalType() string { return string(ProposalTypeExecuteContract) }
+
+// ValidateBasic validates the proposal
+func (p ExecuteContractProposal) ValidateBasic() error {
+ if err := validateProposalCommons(p.Title, p.Description); err != nil {
+ return err
+ }
+ if _, err := sdk.AccAddressFromBech32(p.Contract); err != nil {
+ return errorsmod.Wrap(err, "contract")
+ }
+ if _, err := sdk.AccAddressFromBech32(p.RunAs); err != nil {
+ return errorsmod.Wrap(err, "run as")
+ }
+ if !p.Funds.IsValid() {
+ return sdkerrors.ErrInvalidCoins
+ }
+ if err := p.Msg.ValidateBasic(); err != nil {
+ return errorsmod.Wrap(err, "payload msg")
+ }
+ return nil
+}
+
+// String implements the Stringer interface.
+func (p ExecuteContractProposal) String() string {
+ return fmt.Sprintf(`Migrate Contract Proposal:
+ Title: %s
+ Description: %s
+ Contract: %s
+ Run as: %s
+ Msg: %q
+ Funds: %s
+`, p.Title, p.Description, p.Contract, p.RunAs, p.Msg, p.Funds)
+}
+
+// MarshalYAML pretty prints the migrate message
+func (p ExecuteContractProposal) MarshalYAML() (interface{}, error) {
+ return struct {
+ Title string `yaml:"title"`
+ Description string `yaml:"description"`
+ Contract string `yaml:"contract"`
+ Msg string `yaml:"msg"`
+ RunAs string `yaml:"run_as"`
+ Funds sdk.Coins `yaml:"funds"`
+ }{
+ Title: p.Title,
+ Description: p.Description,
+ Contract: p.Contract,
+ Msg: string(p.Msg),
+ RunAs: p.RunAs,
+ Funds: p.Funds,
+ }, nil
+}
+
+func NewUpdateAdminProposal(
+ title string,
+ description string,
+ newAdmin string,
+ contract string,
+) *UpdateAdminProposal {
+ return &UpdateAdminProposal{title, description, newAdmin, contract}
+}
+
+// ProposalRoute returns the routing key of a parameter change proposal.
+func (p UpdateAdminProposal) ProposalRoute() string { return RouterKey }
+
+// GetTitle returns the title of the proposal
+func (p *UpdateAdminProposal) GetTitle() string { return p.Title }
+
+// GetDescription returns the human readable description of the proposal
+func (p UpdateAdminProposal) GetDescription() string { return p.Description }
+
+// ProposalType returns the type
+func (p UpdateAdminProposal) ProposalType() string { return string(ProposalTypeUpdateAdmin) }
+
+// ValidateBasic validates the proposal
+func (p UpdateAdminProposal) ValidateBasic() error {
+ if err := validateProposalCommons(p.Title, p.Description); err != nil {
+ return err
+ }
+ if _, err := sdk.AccAddressFromBech32(p.Contract); err != nil {
+ return errorsmod.Wrap(err, "contract")
+ }
+ if _, err := sdk.AccAddressFromBech32(p.NewAdmin); err != nil {
+ return errorsmod.Wrap(err, "new admin")
+ }
+ return nil
+}
+
+// String implements the Stringer interface.
+func (p UpdateAdminProposal) String() string {
+ return fmt.Sprintf(`Update Contract Admin Proposal:
+ Title: %s
+ Description: %s
+ Contract: %s
+ New Admin: %s
+`, p.Title, p.Description, p.Contract, p.NewAdmin)
+}
+
+func NewClearAdminProposal(
+ title string,
+ description string,
+ contract string,
+) *ClearAdminProposal {
+ return &ClearAdminProposal{title, description, contract}
+}
+
+// ProposalRoute returns the routing key of a parameter change proposal.
+func (p ClearAdminProposal) ProposalRoute() string { return RouterKey }
+
+// GetTitle returns the title of the proposal
+func (p *ClearAdminProposal) GetTitle() string { return p.Title }
+
+// GetDescription returns the human readable description of the proposal
+func (p ClearAdminProposal) GetDescription() string { return p.Description }
+
+// ProposalType returns the type
+func (p ClearAdminProposal) ProposalType() string { return string(ProposalTypeClearAdmin) }
+
+// ValidateBasic validates the proposal
+func (p ClearAdminProposal) ValidateBasic() error {
+ if err := validateProposalCommons(p.Title, p.Description); err != nil {
+ return err
+ }
+ if _, err := sdk.AccAddressFromBech32(p.Contract); err != nil {
+ return errorsmod.Wrap(err, "contract")
+ }
+ return nil
+}
+
+// String implements the Stringer interface.
+func (p ClearAdminProposal) String() string {
+ return fmt.Sprintf(`Clear Contract Admin Proposal:
+ Title: %s
+ Description: %s
+ Contract: %s
+`, p.Title, p.Description, p.Contract)
+}
+
+func NewPinCodesProposal(
+ title string,
+ description string,
+ codeIDs []uint64,
+) *PinCodesProposal {
+ return &PinCodesProposal{
+ Title: title,
+ Description: description,
+ CodeIDs: codeIDs,
+ }
+}
+
+// ProposalRoute returns the routing key of a parameter change proposal.
+func (p PinCodesProposal) ProposalRoute() string { return RouterKey }
+
+// GetTitle returns the title of the proposal
+func (p *PinCodesProposal) GetTitle() string { return p.Title }
+
+// GetDescription returns the human readable description of the proposal
+func (p PinCodesProposal) GetDescription() string { return p.Description }
+
+// ProposalType returns the type
+func (p PinCodesProposal) ProposalType() string { return string(ProposalTypePinCodes) }
+
+// ValidateBasic validates the proposal
+func (p PinCodesProposal) ValidateBasic() error {
+ if err := validateProposalCommons(p.Title, p.Description); err != nil {
+ return err
+ }
+ if len(p.CodeIDs) == 0 {
+ return errorsmod.Wrap(ErrEmpty, "code ids")
+ }
+ return nil
+}
+
+// String implements the Stringer interface.
+func (p PinCodesProposal) String() string {
+ return fmt.Sprintf(`Pin Wasm Codes Proposal:
+ Title: %s
+ Description: %s
+ Codes: %v
+`, p.Title, p.Description, p.CodeIDs)
+}
+
+func NewUnpinCodesProposal(
+ title string,
+ description string,
+ codeIDs []uint64,
+) *UnpinCodesProposal {
+ return &UnpinCodesProposal{
+ Title: title,
+ Description: description,
+ CodeIDs: codeIDs,
+ }
+}
+
+// ProposalRoute returns the routing key of a parameter change proposal.
+func (p UnpinCodesProposal) ProposalRoute() string { return RouterKey }
+
+// GetTitle returns the title of the proposal
+func (p *UnpinCodesProposal) GetTitle() string { return p.Title }
+
+// GetDescription returns the human readable description of the proposal
+func (p UnpinCodesProposal) GetDescription() string { return p.Description }
+
+// ProposalType returns the type
+func (p UnpinCodesProposal) ProposalType() string { return string(ProposalTypeUnpinCodes) }
+
+// ValidateBasic validates the proposal
+func (p UnpinCodesProposal) ValidateBasic() error {
+ if err := validateProposalCommons(p.Title, p.Description); err != nil {
+ return err
+ }
+ if len(p.CodeIDs) == 0 {
+ return errorsmod.Wrap(ErrEmpty, "code ids")
+ }
+ return nil
+}
+
+// String implements the Stringer interface.
+func (p UnpinCodesProposal) String() string {
+ return fmt.Sprintf(`Unpin Wasm Codes Proposal:
+ Title: %s
+ Description: %s
+ Codes: %v
+`, p.Title, p.Description, p.CodeIDs)
+}
+
+func validateProposalCommons(title, description string) error {
+ if strings.TrimSpace(title) != title {
+ return errorsmod.Wrap(govtypes.ErrInvalidProposalContent, "proposal title must not start/end with white spaces")
+ }
+ if len(title) == 0 {
+ return errorsmod.Wrap(govtypes.ErrInvalidProposalContent, "proposal title cannot be blank")
+ }
+ if len(title) > v1beta1.MaxTitleLength {
+ return errorsmod.Wrapf(govtypes.ErrInvalidProposalContent, "proposal title is longer than max length of %d", v1beta1.MaxTitleLength)
+ }
+ if strings.TrimSpace(description) != description {
+ return errorsmod.Wrap(govtypes.ErrInvalidProposalContent, "proposal description must not start/end with white spaces")
+ }
+ if len(description) == 0 {
+ return errorsmod.Wrap(govtypes.ErrInvalidProposalContent, "proposal description cannot be blank")
+ }
+ if len(description) > v1beta1.MaxDescriptionLength {
+ return errorsmod.Wrapf(govtypes.ErrInvalidProposalContent, "proposal description is longer than max length of %d", v1beta1.MaxDescriptionLength)
+ }
+ return nil
+}
+
+func NewUpdateInstantiateConfigProposal(
+ title string,
+ description string,
+ accessConfigUpdates ...AccessConfigUpdate,
+) *UpdateInstantiateConfigProposal {
+ return &UpdateInstantiateConfigProposal{
+ Title: title,
+ Description: description,
+ AccessConfigUpdates: accessConfigUpdates,
+ }
+}
+
+// ProposalRoute returns the routing key of a parameter change proposal.
+func (p UpdateInstantiateConfigProposal) ProposalRoute() string { return RouterKey }
+
+// GetTitle returns the title of the proposal
+func (p *UpdateInstantiateConfigProposal) GetTitle() string { return p.Title }
+
+// GetDescription returns the human readable description of the proposal
+func (p UpdateInstantiateConfigProposal) GetDescription() string { return p.Description }
+
+// ProposalType returns the type
+func (p UpdateInstantiateConfigProposal) ProposalType() string {
+ return string(ProposalTypeUpdateInstantiateConfig)
+}
+
+// ValidateBasic validates the proposal
+func (p UpdateInstantiateConfigProposal) ValidateBasic() error {
+ if err := validateProposalCommons(p.Title, p.Description); err != nil {
+ return err
+ }
+ if len(p.AccessConfigUpdates) == 0 {
+ return errorsmod.Wrap(ErrEmpty, "code updates")
+ }
+ dedup := make(map[uint64]bool)
+ for _, codeUpdate := range p.AccessConfigUpdates {
+ _, found := dedup[codeUpdate.CodeID]
+ if found {
+ return errorsmod.Wrapf(ErrDuplicate, "duplicate code: %d", codeUpdate.CodeID)
+ }
+ if err := codeUpdate.InstantiatePermission.ValidateBasic(); err != nil {
+ return errorsmod.Wrap(err, "instantiate permission")
+ }
+ dedup[codeUpdate.CodeID] = true
+ }
+ return nil
+}
+
+// String implements the Stringer interface.
+func (p UpdateInstantiateConfigProposal) String() string {
+ return fmt.Sprintf(`Update Instantiate Config Proposal:
+ Title: %s
+ Description: %s
+ AccessConfigUpdates: %v
+`, p.Title, p.Description, p.AccessConfigUpdates)
+}
+
+// String implements the Stringer interface.
+func (c AccessConfigUpdate) String() string {
+ return fmt.Sprintf(`AccessConfigUpdate:
+ CodeID: %d
+ AccessConfig: %v
+`, c.CodeID, c.InstantiatePermission)
+}
diff --git a/x/wasm/types/proposal.pb.go b/x/wasm/types/proposal.pb.go
new file mode 100644
index 0000000000..8c69183055
--- /dev/null
+++ b/x/wasm/types/proposal.pb.go
@@ -0,0 +1,5855 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: cosmwasm/wasm/v1/proposal.proto
+
+package types
+
+import (
+ bytes "bytes"
+ fmt "fmt"
+ io "io"
+ math "math"
+ math_bits "math/bits"
+
+ _ "github.com/cosmos/cosmos-proto"
+ github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
+ types "github.com/cosmos/cosmos-sdk/types"
+ _ "github.com/cosmos/cosmos-sdk/types/tx/amino"
+ _ "github.com/cosmos/gogoproto/gogoproto"
+ proto "github.com/cosmos/gogoproto/proto"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var (
+ _ = proto.Marshal
+ _ = fmt.Errorf
+ _ = math.Inf
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+
+// Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+// an explicit StoreCodeProposal. To submit WASM code to the system,
+// a simple MsgStoreCode can be invoked from the x/gov module via
+// a v1 governance proposal.
+//
+// Deprecated: Do not use.
+type StoreCodeProposal struct {
+ // Title is a short summary
+ Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
+ // Description is a human readable text
+ Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
+ // RunAs is the address that is passed to the contract's environment as sender
+ RunAs string `protobuf:"bytes,3,opt,name=run_as,json=runAs,proto3" json:"run_as,omitempty"`
+ // WASMByteCode can be raw or gzip compressed
+ WASMByteCode []byte `protobuf:"bytes,4,opt,name=wasm_byte_code,json=wasmByteCode,proto3" json:"wasm_byte_code,omitempty"`
+ // InstantiatePermission to apply on contract creation, optional
+ InstantiatePermission *AccessConfig `protobuf:"bytes,7,opt,name=instantiate_permission,json=instantiatePermission,proto3" json:"instantiate_permission,omitempty"`
+ // UnpinCode code on upload, optional
+ UnpinCode bool `protobuf:"varint,8,opt,name=unpin_code,json=unpinCode,proto3" json:"unpin_code,omitempty"`
+ // Source is the URL where the code is hosted
+ Source string `protobuf:"bytes,9,opt,name=source,proto3" json:"source,omitempty"`
+ // Builder is the docker image used to build the code deterministically, used
+ // for smart contract verification
+ Builder string `protobuf:"bytes,10,opt,name=builder,proto3" json:"builder,omitempty"`
+ // CodeHash is the SHA256 sum of the code outputted by builder, used for smart
+ // contract verification
+ CodeHash []byte `protobuf:"bytes,11,opt,name=code_hash,json=codeHash,proto3" json:"code_hash,omitempty"`
+}
+
+func (m *StoreCodeProposal) Reset() { *m = StoreCodeProposal{} }
+func (*StoreCodeProposal) ProtoMessage() {}
+func (*StoreCodeProposal) Descriptor() ([]byte, []int) {
+ return fileDescriptor_be6422d717c730cb, []int{0}
+}
+
+func (m *StoreCodeProposal) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+
+func (m *StoreCodeProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_StoreCodeProposal.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 *StoreCodeProposal) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_StoreCodeProposal.Merge(m, src)
+}
+
+func (m *StoreCodeProposal) XXX_Size() int {
+ return m.Size()
+}
+
+func (m *StoreCodeProposal) XXX_DiscardUnknown() {
+ xxx_messageInfo_StoreCodeProposal.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StoreCodeProposal proto.InternalMessageInfo
+
+// Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+// an explicit InstantiateContractProposal. To instantiate a contract,
+// a simple MsgInstantiateContract can be invoked from the x/gov module via
+// a v1 governance proposal.
+//
+// Deprecated: Do not use.
+type InstantiateContractProposal struct {
+ // Title is a short summary
+ Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
+ // Description is a human readable text
+ Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
+ // RunAs is the address that is passed to the contract's environment as sender
+ RunAs string `protobuf:"bytes,3,opt,name=run_as,json=runAs,proto3" json:"run_as,omitempty"`
+ // Admin is an optional address that can execute migrations
+ Admin string `protobuf:"bytes,4,opt,name=admin,proto3" json:"admin,omitempty"`
+ // CodeID is the reference to the stored WASM code
+ CodeID uint64 `protobuf:"varint,5,opt,name=code_id,json=codeId,proto3" json:"code_id,omitempty"`
+ // Label is optional metadata to be stored with a constract instance.
+ Label string `protobuf:"bytes,6,opt,name=label,proto3" json:"label,omitempty"`
+ // Msg json encoded message to be passed to the contract on instantiation
+ Msg RawContractMessage `protobuf:"bytes,7,opt,name=msg,proto3,casttype=RawContractMessage" json:"msg,omitempty"`
+ // Funds coins that are transferred to the contract on instantiation
+ Funds github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,8,rep,name=funds,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"funds"`
+}
+
+func (m *InstantiateContractProposal) Reset() { *m = InstantiateContractProposal{} }
+func (*InstantiateContractProposal) ProtoMessage() {}
+func (*InstantiateContractProposal) Descriptor() ([]byte, []int) {
+ return fileDescriptor_be6422d717c730cb, []int{1}
+}
+
+func (m *InstantiateContractProposal) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+
+func (m *InstantiateContractProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_InstantiateContractProposal.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 *InstantiateContractProposal) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_InstantiateContractProposal.Merge(m, src)
+}
+
+func (m *InstantiateContractProposal) XXX_Size() int {
+ return m.Size()
+}
+
+func (m *InstantiateContractProposal) XXX_DiscardUnknown() {
+ xxx_messageInfo_InstantiateContractProposal.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_InstantiateContractProposal proto.InternalMessageInfo
+
+// Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+// an explicit InstantiateContract2Proposal. To instantiate contract 2,
+// a simple MsgInstantiateContract2 can be invoked from the x/gov module via
+// a v1 governance proposal.
+//
+// Deprecated: Do not use.
+type InstantiateContract2Proposal struct {
+ // Title is a short summary
+ Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
+ // Description is a human readable text
+ Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
+ // RunAs is the address that is passed to the contract's environment as sender
+ RunAs string `protobuf:"bytes,3,opt,name=run_as,json=runAs,proto3" json:"run_as,omitempty"`
+ // Admin is an optional address that can execute migrations
+ Admin string `protobuf:"bytes,4,opt,name=admin,proto3" json:"admin,omitempty"`
+ // CodeID is the reference to the stored WASM code
+ CodeID uint64 `protobuf:"varint,5,opt,name=code_id,json=codeId,proto3" json:"code_id,omitempty"`
+ // Label is optional metadata to be stored with a constract instance.
+ Label string `protobuf:"bytes,6,opt,name=label,proto3" json:"label,omitempty"`
+ // Msg json encode message to be passed to the contract on instantiation
+ Msg RawContractMessage `protobuf:"bytes,7,opt,name=msg,proto3,casttype=RawContractMessage" json:"msg,omitempty"`
+ // Funds coins that are transferred to the contract on instantiation
+ Funds github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,8,rep,name=funds,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"funds"`
+ // Salt is an arbitrary value provided by the sender. Size can be 1 to 64.
+ Salt []byte `protobuf:"bytes,9,opt,name=salt,proto3" json:"salt,omitempty"`
+ // FixMsg include the msg value into the hash for the predictable address.
+ // Default is false
+ FixMsg bool `protobuf:"varint,10,opt,name=fix_msg,json=fixMsg,proto3" json:"fix_msg,omitempty"`
+}
+
+func (m *InstantiateContract2Proposal) Reset() { *m = InstantiateContract2Proposal{} }
+func (*InstantiateContract2Proposal) ProtoMessage() {}
+func (*InstantiateContract2Proposal) Descriptor() ([]byte, []int) {
+ return fileDescriptor_be6422d717c730cb, []int{2}
+}
+
+func (m *InstantiateContract2Proposal) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+
+func (m *InstantiateContract2Proposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_InstantiateContract2Proposal.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 *InstantiateContract2Proposal) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_InstantiateContract2Proposal.Merge(m, src)
+}
+
+func (m *InstantiateContract2Proposal) XXX_Size() int {
+ return m.Size()
+}
+
+func (m *InstantiateContract2Proposal) XXX_DiscardUnknown() {
+ xxx_messageInfo_InstantiateContract2Proposal.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_InstantiateContract2Proposal proto.InternalMessageInfo
+
+// Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+// an explicit MigrateContractProposal. To migrate a contract,
+// a simple MsgMigrateContract can be invoked from the x/gov module via
+// a v1 governance proposal.
+//
+// Deprecated: Do not use.
+type MigrateContractProposal struct {
+ // Title is a short summary
+ Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
+ // Description is a human readable text
+ Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
+ // Contract is the address of the smart contract
+ Contract string `protobuf:"bytes,4,opt,name=contract,proto3" json:"contract,omitempty"`
+ // CodeID references the new WASM code
+ CodeID uint64 `protobuf:"varint,5,opt,name=code_id,json=codeId,proto3" json:"code_id,omitempty"`
+ // Msg json encoded message to be passed to the contract on migration
+ Msg RawContractMessage `protobuf:"bytes,6,opt,name=msg,proto3,casttype=RawContractMessage" json:"msg,omitempty"`
+}
+
+func (m *MigrateContractProposal) Reset() { *m = MigrateContractProposal{} }
+func (*MigrateContractProposal) ProtoMessage() {}
+func (*MigrateContractProposal) Descriptor() ([]byte, []int) {
+ return fileDescriptor_be6422d717c730cb, []int{3}
+}
+
+func (m *MigrateContractProposal) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+
+func (m *MigrateContractProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_MigrateContractProposal.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 *MigrateContractProposal) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MigrateContractProposal.Merge(m, src)
+}
+
+func (m *MigrateContractProposal) XXX_Size() int {
+ return m.Size()
+}
+
+func (m *MigrateContractProposal) XXX_DiscardUnknown() {
+ xxx_messageInfo_MigrateContractProposal.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MigrateContractProposal proto.InternalMessageInfo
+
+// Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+// an explicit SudoContractProposal. To call sudo on a contract,
+// a simple MsgSudoContract can be invoked from the x/gov module via
+// a v1 governance proposal.
+//
+// Deprecated: Do not use.
+type SudoContractProposal struct {
+ // Title is a short summary
+ Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
+ // Description is a human readable text
+ Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
+ // Contract is the address of the smart contract
+ Contract string `protobuf:"bytes,3,opt,name=contract,proto3" json:"contract,omitempty"`
+ // Msg json encoded message to be passed to the contract as sudo
+ Msg RawContractMessage `protobuf:"bytes,4,opt,name=msg,proto3,casttype=RawContractMessage" json:"msg,omitempty"`
+}
+
+func (m *SudoContractProposal) Reset() { *m = SudoContractProposal{} }
+func (*SudoContractProposal) ProtoMessage() {}
+func (*SudoContractProposal) Descriptor() ([]byte, []int) {
+ return fileDescriptor_be6422d717c730cb, []int{4}
+}
+
+func (m *SudoContractProposal) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+
+func (m *SudoContractProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_SudoContractProposal.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 *SudoContractProposal) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_SudoContractProposal.Merge(m, src)
+}
+
+func (m *SudoContractProposal) XXX_Size() int {
+ return m.Size()
+}
+
+func (m *SudoContractProposal) XXX_DiscardUnknown() {
+ xxx_messageInfo_SudoContractProposal.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SudoContractProposal proto.InternalMessageInfo
+
+// Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+// an explicit ExecuteContractProposal. To call execute on a contract,
+// a simple MsgExecuteContract can be invoked from the x/gov module via
+// a v1 governance proposal.
+//
+// Deprecated: Do not use.
+type ExecuteContractProposal struct {
+ // Title is a short summary
+ Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
+ // Description is a human readable text
+ Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
+ // RunAs is the address that is passed to the contract's environment as sender
+ RunAs string `protobuf:"bytes,3,opt,name=run_as,json=runAs,proto3" json:"run_as,omitempty"`
+ // Contract is the address of the smart contract
+ Contract string `protobuf:"bytes,4,opt,name=contract,proto3" json:"contract,omitempty"`
+ // Msg json encoded message to be passed to the contract as execute
+ Msg RawContractMessage `protobuf:"bytes,5,opt,name=msg,proto3,casttype=RawContractMessage" json:"msg,omitempty"`
+ // Funds coins that are transferred to the contract on instantiation
+ Funds github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,6,rep,name=funds,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"funds"`
+}
+
+func (m *ExecuteContractProposal) Reset() { *m = ExecuteContractProposal{} }
+func (*ExecuteContractProposal) ProtoMessage() {}
+func (*ExecuteContractProposal) Descriptor() ([]byte, []int) {
+ return fileDescriptor_be6422d717c730cb, []int{5}
+}
+
+func (m *ExecuteContractProposal) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+
+func (m *ExecuteContractProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_ExecuteContractProposal.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 *ExecuteContractProposal) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ExecuteContractProposal.Merge(m, src)
+}
+
+func (m *ExecuteContractProposal) XXX_Size() int {
+ return m.Size()
+}
+
+func (m *ExecuteContractProposal) XXX_DiscardUnknown() {
+ xxx_messageInfo_ExecuteContractProposal.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ExecuteContractProposal proto.InternalMessageInfo
+
+// Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+// an explicit UpdateAdminProposal. To set an admin for a contract,
+// a simple MsgUpdateAdmin can be invoked from the x/gov module via
+// a v1 governance proposal.
+//
+// Deprecated: Do not use.
+type UpdateAdminProposal struct {
+ // Title is a short summary
+ Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
+ // Description is a human readable text
+ Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
+ // NewAdmin address to be set
+ NewAdmin string `protobuf:"bytes,3,opt,name=new_admin,json=newAdmin,proto3" json:"new_admin,omitempty" yaml:"new_admin"`
+ // Contract is the address of the smart contract
+ Contract string `protobuf:"bytes,4,opt,name=contract,proto3" json:"contract,omitempty"`
+}
+
+func (m *UpdateAdminProposal) Reset() { *m = UpdateAdminProposal{} }
+func (*UpdateAdminProposal) ProtoMessage() {}
+func (*UpdateAdminProposal) Descriptor() ([]byte, []int) {
+ return fileDescriptor_be6422d717c730cb, []int{6}
+}
+
+func (m *UpdateAdminProposal) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+
+func (m *UpdateAdminProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_UpdateAdminProposal.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 *UpdateAdminProposal) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_UpdateAdminProposal.Merge(m, src)
+}
+
+func (m *UpdateAdminProposal) XXX_Size() int {
+ return m.Size()
+}
+
+func (m *UpdateAdminProposal) XXX_DiscardUnknown() {
+ xxx_messageInfo_UpdateAdminProposal.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UpdateAdminProposal proto.InternalMessageInfo
+
+// Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+// an explicit ClearAdminProposal. To clear the admin of a contract,
+// a simple MsgClearAdmin can be invoked from the x/gov module via
+// a v1 governance proposal.
+//
+// Deprecated: Do not use.
+type ClearAdminProposal struct {
+ // Title is a short summary
+ Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
+ // Description is a human readable text
+ Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
+ // Contract is the address of the smart contract
+ Contract string `protobuf:"bytes,3,opt,name=contract,proto3" json:"contract,omitempty"`
+}
+
+func (m *ClearAdminProposal) Reset() { *m = ClearAdminProposal{} }
+func (*ClearAdminProposal) ProtoMessage() {}
+func (*ClearAdminProposal) Descriptor() ([]byte, []int) {
+ return fileDescriptor_be6422d717c730cb, []int{7}
+}
+
+func (m *ClearAdminProposal) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+
+func (m *ClearAdminProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_ClearAdminProposal.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 *ClearAdminProposal) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ClearAdminProposal.Merge(m, src)
+}
+
+func (m *ClearAdminProposal) XXX_Size() int {
+ return m.Size()
+}
+
+func (m *ClearAdminProposal) XXX_DiscardUnknown() {
+ xxx_messageInfo_ClearAdminProposal.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ClearAdminProposal proto.InternalMessageInfo
+
+// Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+// an explicit PinCodesProposal. To pin a set of code ids in the wasmvm
+// cache, a simple MsgPinCodes can be invoked from the x/gov module via
+// a v1 governance proposal.
+//
+// Deprecated: Do not use.
+type PinCodesProposal struct {
+ // Title is a short summary
+ Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty" yaml:"title"`
+ // Description is a human readable text
+ Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty" yaml:"description"`
+ // CodeIDs references the new WASM codes
+ CodeIDs []uint64 `protobuf:"varint,3,rep,packed,name=code_ids,json=codeIds,proto3" json:"code_ids,omitempty" yaml:"code_ids"`
+}
+
+func (m *PinCodesProposal) Reset() { *m = PinCodesProposal{} }
+func (*PinCodesProposal) ProtoMessage() {}
+func (*PinCodesProposal) Descriptor() ([]byte, []int) {
+ return fileDescriptor_be6422d717c730cb, []int{8}
+}
+
+func (m *PinCodesProposal) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+
+func (m *PinCodesProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_PinCodesProposal.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 *PinCodesProposal) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_PinCodesProposal.Merge(m, src)
+}
+
+func (m *PinCodesProposal) XXX_Size() int {
+ return m.Size()
+}
+
+func (m *PinCodesProposal) XXX_DiscardUnknown() {
+ xxx_messageInfo_PinCodesProposal.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PinCodesProposal proto.InternalMessageInfo
+
+// Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+// an explicit UnpinCodesProposal. To unpin a set of code ids in the wasmvm
+// cache, a simple MsgUnpinCodes can be invoked from the x/gov module via
+// a v1 governance proposal.
+//
+// Deprecated: Do not use.
+type UnpinCodesProposal struct {
+ // Title is a short summary
+ Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty" yaml:"title"`
+ // Description is a human readable text
+ Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty" yaml:"description"`
+ // CodeIDs references the WASM codes
+ CodeIDs []uint64 `protobuf:"varint,3,rep,packed,name=code_ids,json=codeIds,proto3" json:"code_ids,omitempty" yaml:"code_ids"`
+}
+
+func (m *UnpinCodesProposal) Reset() { *m = UnpinCodesProposal{} }
+func (*UnpinCodesProposal) ProtoMessage() {}
+func (*UnpinCodesProposal) Descriptor() ([]byte, []int) {
+ return fileDescriptor_be6422d717c730cb, []int{9}
+}
+
+func (m *UnpinCodesProposal) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+
+func (m *UnpinCodesProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_UnpinCodesProposal.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 *UnpinCodesProposal) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_UnpinCodesProposal.Merge(m, src)
+}
+
+func (m *UnpinCodesProposal) XXX_Size() int {
+ return m.Size()
+}
+
+func (m *UnpinCodesProposal) XXX_DiscardUnknown() {
+ xxx_messageInfo_UnpinCodesProposal.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UnpinCodesProposal proto.InternalMessageInfo
+
+// AccessConfigUpdate contains the code id and the access config to be
+// applied.
+type AccessConfigUpdate struct {
+ // CodeID is the reference to the stored WASM code to be updated
+ CodeID uint64 `protobuf:"varint,1,opt,name=code_id,json=codeId,proto3" json:"code_id,omitempty"`
+ // InstantiatePermission to apply to the set of code ids
+ InstantiatePermission AccessConfig `protobuf:"bytes,2,opt,name=instantiate_permission,json=instantiatePermission,proto3" json:"instantiate_permission"`
+}
+
+func (m *AccessConfigUpdate) Reset() { *m = AccessConfigUpdate{} }
+func (*AccessConfigUpdate) ProtoMessage() {}
+func (*AccessConfigUpdate) Descriptor() ([]byte, []int) {
+ return fileDescriptor_be6422d717c730cb, []int{10}
+}
+
+func (m *AccessConfigUpdate) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+
+func (m *AccessConfigUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_AccessConfigUpdate.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 *AccessConfigUpdate) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_AccessConfigUpdate.Merge(m, src)
+}
+
+func (m *AccessConfigUpdate) XXX_Size() int {
+ return m.Size()
+}
+
+func (m *AccessConfigUpdate) XXX_DiscardUnknown() {
+ xxx_messageInfo_AccessConfigUpdate.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AccessConfigUpdate proto.InternalMessageInfo
+
+// Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+// an explicit UpdateInstantiateConfigProposal. To update instantiate config
+// to a set of code ids, a simple MsgUpdateInstantiateConfig can be invoked from
+// the x/gov module via a v1 governance proposal.
+//
+// Deprecated: Do not use.
+type UpdateInstantiateConfigProposal struct {
+ // Title is a short summary
+ Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty" yaml:"title"`
+ // Description is a human readable text
+ Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty" yaml:"description"`
+ // AccessConfigUpdate contains the list of code ids and the access config
+ // to be applied.
+ AccessConfigUpdates []AccessConfigUpdate `protobuf:"bytes,3,rep,name=access_config_updates,json=accessConfigUpdates,proto3" json:"access_config_updates"`
+}
+
+func (m *UpdateInstantiateConfigProposal) Reset() { *m = UpdateInstantiateConfigProposal{} }
+func (*UpdateInstantiateConfigProposal) ProtoMessage() {}
+func (*UpdateInstantiateConfigProposal) Descriptor() ([]byte, []int) {
+ return fileDescriptor_be6422d717c730cb, []int{11}
+}
+
+func (m *UpdateInstantiateConfigProposal) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+
+func (m *UpdateInstantiateConfigProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_UpdateInstantiateConfigProposal.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 *UpdateInstantiateConfigProposal) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_UpdateInstantiateConfigProposal.Merge(m, src)
+}
+
+func (m *UpdateInstantiateConfigProposal) XXX_Size() int {
+ return m.Size()
+}
+
+func (m *UpdateInstantiateConfigProposal) XXX_DiscardUnknown() {
+ xxx_messageInfo_UpdateInstantiateConfigProposal.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UpdateInstantiateConfigProposal proto.InternalMessageInfo
+
+// Deprecated: Do not use. Since wasmd v0.40, there is no longer a need for
+// an explicit StoreAndInstantiateContractProposal. To store and instantiate
+// the contract, a simple MsgStoreAndInstantiateContract can be invoked from
+// the x/gov module via a v1 governance proposal.
+//
+// Deprecated: Do not use.
+type StoreAndInstantiateContractProposal struct {
+ // Title is a short summary
+ Title string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
+ // Description is a human readable text
+ Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
+ // RunAs is the address that is passed to the contract's environment as sender
+ RunAs string `protobuf:"bytes,3,opt,name=run_as,json=runAs,proto3" json:"run_as,omitempty"`
+ // WASMByteCode can be raw or gzip compressed
+ WASMByteCode []byte `protobuf:"bytes,4,opt,name=wasm_byte_code,json=wasmByteCode,proto3" json:"wasm_byte_code,omitempty"`
+ // InstantiatePermission to apply on contract creation, optional
+ InstantiatePermission *AccessConfig `protobuf:"bytes,5,opt,name=instantiate_permission,json=instantiatePermission,proto3" json:"instantiate_permission,omitempty"`
+ // UnpinCode code on upload, optional
+ UnpinCode bool `protobuf:"varint,6,opt,name=unpin_code,json=unpinCode,proto3" json:"unpin_code,omitempty"`
+ // Admin is an optional address that can execute migrations
+ Admin string `protobuf:"bytes,7,opt,name=admin,proto3" json:"admin,omitempty"`
+ // Label is optional metadata to be stored with a constract instance.
+ Label string `protobuf:"bytes,8,opt,name=label,proto3" json:"label,omitempty"`
+ // Msg json encoded message to be passed to the contract on instantiation
+ Msg RawContractMessage `protobuf:"bytes,9,opt,name=msg,proto3,casttype=RawContractMessage" json:"msg,omitempty"`
+ // Funds coins that are transferred to the contract on instantiation
+ Funds github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,10,rep,name=funds,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"funds"`
+ // Source is the URL where the code is hosted
+ Source string `protobuf:"bytes,11,opt,name=source,proto3" json:"source,omitempty"`
+ // Builder is the docker image used to build the code deterministically, used
+ // for smart contract verification
+ Builder string `protobuf:"bytes,12,opt,name=builder,proto3" json:"builder,omitempty"`
+ // CodeHash is the SHA256 sum of the code outputted by builder, used for smart
+ // contract verification
+ CodeHash []byte `protobuf:"bytes,13,opt,name=code_hash,json=codeHash,proto3" json:"code_hash,omitempty"`
+}
+
+func (m *StoreAndInstantiateContractProposal) Reset() { *m = StoreAndInstantiateContractProposal{} }
+func (*StoreAndInstantiateContractProposal) ProtoMessage() {}
+func (*StoreAndInstantiateContractProposal) Descriptor() ([]byte, []int) {
+ return fileDescriptor_be6422d717c730cb, []int{12}
+}
+
+func (m *StoreAndInstantiateContractProposal) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+
+func (m *StoreAndInstantiateContractProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_StoreAndInstantiateContractProposal.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 *StoreAndInstantiateContractProposal) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_StoreAndInstantiateContractProposal.Merge(m, src)
+}
+
+func (m *StoreAndInstantiateContractProposal) XXX_Size() int {
+ return m.Size()
+}
+
+func (m *StoreAndInstantiateContractProposal) XXX_DiscardUnknown() {
+ xxx_messageInfo_StoreAndInstantiateContractProposal.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StoreAndInstantiateContractProposal proto.InternalMessageInfo
+
+func init() {
+ proto.RegisterType((*StoreCodeProposal)(nil), "cosmwasm.wasm.v1.StoreCodeProposal")
+ proto.RegisterType((*InstantiateContractProposal)(nil), "cosmwasm.wasm.v1.InstantiateContractProposal")
+ proto.RegisterType((*InstantiateContract2Proposal)(nil), "cosmwasm.wasm.v1.InstantiateContract2Proposal")
+ proto.RegisterType((*MigrateContractProposal)(nil), "cosmwasm.wasm.v1.MigrateContractProposal")
+ proto.RegisterType((*SudoContractProposal)(nil), "cosmwasm.wasm.v1.SudoContractProposal")
+ proto.RegisterType((*ExecuteContractProposal)(nil), "cosmwasm.wasm.v1.ExecuteContractProposal")
+ proto.RegisterType((*UpdateAdminProposal)(nil), "cosmwasm.wasm.v1.UpdateAdminProposal")
+ proto.RegisterType((*ClearAdminProposal)(nil), "cosmwasm.wasm.v1.ClearAdminProposal")
+ proto.RegisterType((*PinCodesProposal)(nil), "cosmwasm.wasm.v1.PinCodesProposal")
+ proto.RegisterType((*UnpinCodesProposal)(nil), "cosmwasm.wasm.v1.UnpinCodesProposal")
+ proto.RegisterType((*AccessConfigUpdate)(nil), "cosmwasm.wasm.v1.AccessConfigUpdate")
+ proto.RegisterType((*UpdateInstantiateConfigProposal)(nil), "cosmwasm.wasm.v1.UpdateInstantiateConfigProposal")
+ proto.RegisterType((*StoreAndInstantiateContractProposal)(nil), "cosmwasm.wasm.v1.StoreAndInstantiateContractProposal")
+}
+
+func init() { proto.RegisterFile("cosmwasm/wasm/v1/proposal.proto", fileDescriptor_be6422d717c730cb) }
+
+var fileDescriptor_be6422d717c730cb = []byte{
+ // 1163 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x58, 0xcd, 0x6f, 0xe3, 0x44,
+ 0x14, 0xcf, 0x34, 0x89, 0x93, 0x4c, 0x02, 0x64, 0xbd, 0xfd, 0x98, 0xed, 0x16, 0x3b, 0x78, 0x57,
+ 0xab, 0x68, 0xa5, 0x4d, 0xd4, 0x22, 0x10, 0x84, 0x0f, 0x29, 0x2e, 0x8b, 0xe8, 0x8a, 0x4a, 0x95,
+ 0xab, 0x6a, 0x25, 0x2e, 0x61, 0x62, 0x4f, 0x52, 0x8b, 0xc4, 0x13, 0x79, 0xec, 0x7e, 0xfc, 0x0b,
+ 0x9c, 0x38, 0x71, 0xe1, 0x8e, 0x2a, 0x4e, 0x2b, 0xc1, 0xbf, 0x80, 0x54, 0x71, 0xda, 0x03, 0x87,
+ 0x45, 0x48, 0x81, 0x4d, 0x0f, 0x7b, 0xe0, 0x80, 0xd4, 0x23, 0x07, 0x40, 0x9e, 0x71, 0x52, 0xb7,
+ 0x4d, 0xe2, 0x2e, 0xb4, 0x2b, 0x21, 0x71, 0x71, 0xf2, 0xe6, 0xcd, 0xd8, 0xbf, 0xdf, 0xfb, 0xcd,
+ 0x3c, 0xbf, 0x67, 0xa8, 0x9a, 0x94, 0x75, 0x77, 0x31, 0xeb, 0x56, 0xf9, 0x65, 0x67, 0xb9, 0xda,
+ 0x73, 0x69, 0x8f, 0x32, 0xdc, 0xa9, 0xf4, 0x5c, 0xea, 0x51, 0xb9, 0x38, 0x9c, 0x50, 0xe1, 0x97,
+ 0x9d, 0xe5, 0xc5, 0xd9, 0x36, 0x6d, 0x53, 0xee, 0xac, 0x06, 0xff, 0xc4, 0xbc, 0xc5, 0x1b, 0xc1,
+ 0x3c, 0xca, 0x1a, 0xc2, 0x21, 0x8c, 0xd0, 0xa5, 0x08, 0xab, 0xda, 0xc4, 0x8c, 0x54, 0x77, 0x96,
+ 0x9b, 0xc4, 0xc3, 0xcb, 0x55, 0x93, 0xda, 0x4e, 0xe8, 0x5f, 0x3a, 0x87, 0xc1, 0xdb, 0xef, 0x91,
+ 0xe1, 0xea, 0x6b, 0xb8, 0x6b, 0x3b, 0xb4, 0xca, 0xaf, 0x62, 0x48, 0x3b, 0x48, 0xc2, 0x6b, 0x9b,
+ 0x1e, 0x75, 0xc9, 0x2a, 0xb5, 0xc8, 0x46, 0x88, 0x57, 0x9e, 0x85, 0x69, 0xcf, 0xf6, 0x3a, 0x04,
+ 0x81, 0x12, 0x28, 0xe7, 0x0c, 0x61, 0xc8, 0x25, 0x98, 0xb7, 0x08, 0x33, 0x5d, 0xbb, 0xe7, 0xd9,
+ 0xd4, 0x41, 0x33, 0xdc, 0x17, 0x1d, 0x92, 0xe7, 0xa0, 0xe4, 0xfa, 0x4e, 0x03, 0x33, 0x94, 0x14,
+ 0x0b, 0x5d, 0xdf, 0xa9, 0x33, 0xf9, 0x4d, 0xf8, 0x72, 0x00, 0xa7, 0xd1, 0xdc, 0xf7, 0x48, 0xc3,
+ 0xa4, 0x16, 0x41, 0xa9, 0x12, 0x28, 0x17, 0xf4, 0xe2, 0xa0, 0xaf, 0x16, 0x1e, 0xd6, 0x37, 0xd7,
+ 0xf5, 0x7d, 0x8f, 0x03, 0x30, 0x0a, 0xc1, 0xbc, 0xa1, 0x25, 0x6f, 0xc1, 0x79, 0xdb, 0x61, 0x1e,
+ 0x76, 0x3c, 0x1b, 0x7b, 0xa4, 0xd1, 0x23, 0x6e, 0xd7, 0x66, 0x2c, 0x78, 0x76, 0xa6, 0x04, 0xca,
+ 0xf9, 0x15, 0xa5, 0x72, 0x36, 0xa2, 0x95, 0xba, 0x69, 0x12, 0xc6, 0x56, 0xa9, 0xd3, 0xb2, 0xdb,
+ 0xc6, 0x5c, 0x64, 0xf5, 0xc6, 0x68, 0xb1, 0xfc, 0x2a, 0x84, 0xbe, 0xd3, 0xb3, 0x1d, 0x01, 0x25,
+ 0x5b, 0x02, 0xe5, 0xac, 0x91, 0xe3, 0x23, 0xfc, 0xa9, 0xf3, 0x50, 0x62, 0xd4, 0x77, 0x4d, 0x82,
+ 0x72, 0x9c, 0x44, 0x68, 0xc9, 0x08, 0x66, 0x9a, 0xbe, 0xdd, 0xb1, 0x88, 0x8b, 0x20, 0x77, 0x0c,
+ 0x4d, 0xf9, 0x26, 0xcc, 0x05, 0xb7, 0x6a, 0x6c, 0x63, 0xb6, 0x8d, 0xf2, 0x01, 0x35, 0x23, 0x1b,
+ 0x0c, 0x7c, 0x84, 0xd9, 0x76, 0xed, 0x9d, 0x1f, 0xbe, 0xbb, 0xb7, 0x18, 0x8a, 0xd8, 0xa6, 0x3b,
+ 0x95, 0x50, 0xb5, 0xca, 0x2a, 0x75, 0x3c, 0xe2, 0x78, 0x9f, 0x3f, 0x7b, 0x74, 0x77, 0x9e, 0x8b,
+ 0x75, 0x4e, 0x06, 0x04, 0x1e, 0xa4, 0xb2, 0xe9, 0xa2, 0xf4, 0x20, 0x95, 0x95, 0x8a, 0x19, 0xed,
+ 0xcb, 0x24, 0xbc, 0xb9, 0x76, 0x42, 0x28, 0x58, 0xef, 0x62, 0xd3, 0xbb, 0x2a, 0xd1, 0x66, 0x61,
+ 0x1a, 0x5b, 0x5d, 0xdb, 0xe1, 0x5a, 0xe5, 0x0c, 0x61, 0xc8, 0xb7, 0x60, 0x86, 0x53, 0xb5, 0x2d,
+ 0x94, 0x2e, 0x81, 0x72, 0x4a, 0x87, 0x83, 0xbe, 0x2a, 0x05, 0xa8, 0xd7, 0x3e, 0x30, 0xa4, 0xc0,
+ 0xb5, 0x66, 0x05, 0x4b, 0x3b, 0xb8, 0x49, 0x3a, 0x48, 0x12, 0x4b, 0xb9, 0x21, 0x97, 0x61, 0xb2,
+ 0xcb, 0xda, 0x5c, 0xba, 0x82, 0x3e, 0xff, 0x47, 0x5f, 0x95, 0x0d, 0xbc, 0x3b, 0x64, 0xb1, 0x4e,
+ 0x18, 0xc3, 0x6d, 0x62, 0x04, 0x53, 0xe4, 0x16, 0x4c, 0xb7, 0x7c, 0xc7, 0x62, 0x28, 0x5b, 0x4a,
+ 0x96, 0xf3, 0x2b, 0x37, 0x2a, 0x61, 0xf8, 0x82, 0x5d, 0x1f, 0x89, 0x9f, 0xed, 0xe8, 0x6f, 0x1c,
+ 0xf6, 0xd5, 0xc4, 0x37, 0xbf, 0xa8, 0xe5, 0xb6, 0xed, 0x6d, 0xfb, 0xcd, 0x8a, 0x49, 0xbb, 0xe1,
+ 0x81, 0x09, 0x7f, 0xee, 0x31, 0xeb, 0xb3, 0xf0, 0x0c, 0x04, 0x0b, 0xd8, 0xc1, 0xb3, 0x47, 0x77,
+ 0x81, 0x21, 0x6e, 0x5f, 0xbb, 0x1f, 0x2f, 0x4d, 0x89, 0x4b, 0x33, 0x25, 0xec, 0x08, 0x68, 0xdf,
+ 0x27, 0xe1, 0xd2, 0x98, 0x19, 0x2b, 0xff, 0x2b, 0xf3, 0x4f, 0x95, 0x91, 0x65, 0x98, 0x62, 0xb8,
+ 0xe3, 0xf1, 0x13, 0x58, 0x30, 0xf8, 0x7f, 0x79, 0x01, 0x66, 0x5a, 0xf6, 0x5e, 0x23, 0x40, 0x0a,
+ 0xf9, 0x99, 0x95, 0x5a, 0xf6, 0xde, 0x3a, 0x6b, 0xd7, 0x3e, 0x8c, 0x97, 0xf1, 0xb5, 0x49, 0x32,
+ 0xae, 0x44, 0x74, 0xfc, 0x0b, 0xc0, 0x85, 0x75, 0xbb, 0xed, 0x5e, 0xe6, 0xe1, 0x5a, 0x84, 0x59,
+ 0x33, 0xbc, 0x57, 0x28, 0xd7, 0xc8, 0xbe, 0x98, 0x62, 0xa1, 0x36, 0x52, 0xac, 0x36, 0xb5, 0x7a,
+ 0x7c, 0x18, 0x96, 0x78, 0x18, 0x26, 0x70, 0x44, 0x40, 0xfb, 0x11, 0xc0, 0xd9, 0x4d, 0xdf, 0xa2,
+ 0x57, 0x42, 0x3f, 0x79, 0x86, 0x7e, 0xc8, 0x2c, 0x15, 0xcf, 0xec, 0xfd, 0x78, 0x66, 0x37, 0x44,
+ 0x0a, 0x1d, 0x83, 0x1d, 0x01, 0xed, 0xa7, 0x19, 0xb8, 0x70, 0x7f, 0x8f, 0x98, 0xfe, 0xd5, 0x67,
+ 0xcd, 0x69, 0x7a, 0x87, 0x84, 0xd3, 0xcf, 0x71, 0xcc, 0xa4, 0xab, 0x4d, 0x80, 0x17, 0xde, 0x32,
+ 0x13, 0xa2, 0x87, 0x80, 0xf6, 0x33, 0x80, 0xd7, 0xb7, 0x7a, 0x16, 0xf6, 0x48, 0x3d, 0x48, 0x43,
+ 0xff, 0x3a, 0xae, 0xcb, 0x30, 0xe7, 0x90, 0xdd, 0x86, 0x48, 0x70, 0x3c, 0xb4, 0xfa, 0xec, 0x71,
+ 0x5f, 0x2d, 0xee, 0xe3, 0x6e, 0xa7, 0xa6, 0x8d, 0x5c, 0x9a, 0x91, 0x75, 0xc8, 0x2e, 0x7f, 0xe4,
+ 0xb4, 0x98, 0xd7, 0xde, 0x8b, 0x67, 0x88, 0x38, 0xc3, 0x31, 0x1c, 0x10, 0xd0, 0xbe, 0x06, 0x50,
+ 0x5e, 0xed, 0x10, 0xec, 0x5e, 0x0e, 0xb9, 0x29, 0xc7, 0xa1, 0xf6, 0x6e, 0x3c, 0xd2, 0x05, 0x8e,
+ 0xf4, 0x3c, 0x1e, 0x04, 0xb4, 0xdf, 0x00, 0x2c, 0x6e, 0x88, 0x02, 0x86, 0x8d, 0x60, 0xde, 0x39,
+ 0x05, 0x53, 0x2f, 0x1e, 0xf7, 0xd5, 0x82, 0x88, 0x23, 0x1f, 0xd6, 0x86, 0xc0, 0xdf, 0x1a, 0x03,
+ 0x5c, 0x9f, 0x3f, 0xee, 0xab, 0xb2, 0x98, 0x1d, 0x71, 0x6a, 0xa7, 0x09, 0xbd, 0x0d, 0xb3, 0x61,
+ 0x0a, 0x0b, 0xce, 0x41, 0xb2, 0x9c, 0xd2, 0x95, 0x41, 0x5f, 0xcd, 0x88, 0x1c, 0xc6, 0x8e, 0xfb,
+ 0xea, 0x2b, 0xe2, 0x0e, 0xc3, 0x49, 0x9a, 0x91, 0x11, 0x79, 0x8d, 0xd5, 0x6a, 0xf1, 0x7c, 0xe7,
+ 0x38, 0xdf, 0xb3, 0xb4, 0x10, 0xd0, 0x7e, 0x07, 0x50, 0xde, 0x1a, 0x16, 0x6c, 0xff, 0x11, 0xbe,
+ 0x17, 0xd6, 0xf7, 0x3c, 0x31, 0x04, 0xb4, 0xaf, 0x00, 0x94, 0xa3, 0xb5, 0xad, 0xd8, 0xae, 0xd1,
+ 0x57, 0x08, 0x98, 0xf8, 0x0a, 0xf9, 0x74, 0x62, 0x19, 0x3d, 0x73, 0x91, 0x32, 0x5a, 0xcf, 0x05,
+ 0x39, 0x46, 0xe4, 0x8d, 0xf1, 0x15, 0xb5, 0xf6, 0xed, 0x0c, 0x54, 0x05, 0xa2, 0xd3, 0xaf, 0xd8,
+ 0x96, 0xdd, 0x7e, 0x81, 0xe2, 0x98, 0x70, 0x0e, 0x73, 0xdc, 0x0d, 0x93, 0x3f, 0xba, 0xe1, 0x73,
+ 0x48, 0x42, 0xa9, 0xfc, 0xca, 0xed, 0xe9, 0x34, 0x05, 0xfe, 0x28, 0xd9, 0xeb, 0xf8, 0x9c, 0x9b,
+ 0xd5, 0xd6, 0xe2, 0x65, 0xbc, 0x1d, 0x49, 0x28, 0x13, 0xe3, 0x81, 0x80, 0xf6, 0x67, 0x0a, 0xde,
+ 0xe2, 0x45, 0x7f, 0xdd, 0xb1, 0x5e, 0x60, 0x61, 0x7f, 0xf9, 0xdd, 0x58, 0xfa, 0xf2, 0xba, 0x31,
+ 0xe9, 0x6c, 0x37, 0x36, 0x2a, 0x76, 0x33, 0xd1, 0x62, 0x77, 0x54, 0xc7, 0x66, 0xc7, 0xd4, 0xb1,
+ 0xb9, 0xe7, 0x78, 0xc1, 0xc2, 0xab, 0xad, 0x63, 0x4f, 0x7a, 0xc9, 0xfc, 0xa4, 0x5e, 0xb2, 0x30,
+ 0xa5, 0x97, 0x7c, 0xe9, 0x4c, 0x2f, 0xb9, 0x1e, 0xbf, 0xf9, 0xca, 0x27, 0xbd, 0xe4, 0xf4, 0x6d,
+ 0x85, 0x80, 0xfe, 0xf1, 0xe1, 0x53, 0x25, 0xf1, 0xe4, 0xa9, 0x92, 0x38, 0x18, 0x28, 0xe0, 0x70,
+ 0xa0, 0x80, 0xc7, 0x03, 0x05, 0xfc, 0x3a, 0x50, 0xc0, 0x17, 0x47, 0x4a, 0xe2, 0xf1, 0x91, 0x92,
+ 0x78, 0x72, 0xa4, 0x24, 0x3e, 0xb9, 0x13, 0x61, 0xbe, 0x4a, 0x59, 0xf7, 0xe1, 0xf0, 0xf3, 0x82,
+ 0x55, 0xdd, 0x13, 0x9f, 0x19, 0x38, 0xfb, 0xa6, 0xc4, 0xbf, 0x28, 0xbc, 0xfe, 0x77, 0x00, 0x00,
+ 0x00, 0xff, 0xff, 0x0f, 0x40, 0x90, 0x22, 0x08, 0x11, 0x00, 0x00,
+}
+
+func (this *StoreCodeProposal) Equal(that interface{}) bool {
+ if that == nil {
+ return this == nil
+ }
+
+ that1, ok := that.(*StoreCodeProposal)
+ if !ok {
+ that2, ok := that.(StoreCodeProposal)
+ if ok {
+ that1 = &that2
+ } else {
+ return false
+ }
+ }
+ if that1 == nil {
+ return this == nil
+ } else if this == nil {
+ return false
+ }
+ if this.Title != that1.Title {
+ return false
+ }
+ if this.Description != that1.Description {
+ return false
+ }
+ if this.RunAs != that1.RunAs {
+ return false
+ }
+ if !bytes.Equal(this.WASMByteCode, that1.WASMByteCode) {
+ return false
+ }
+ if !this.InstantiatePermission.Equal(that1.InstantiatePermission) {
+ return false
+ }
+ if this.UnpinCode != that1.UnpinCode {
+ return false
+ }
+ if this.Source != that1.Source {
+ return false
+ }
+ if this.Builder != that1.Builder {
+ return false
+ }
+ if !bytes.Equal(this.CodeHash, that1.CodeHash) {
+ return false
+ }
+ return true
+}
+
+func (this *InstantiateContractProposal) Equal(that interface{}) bool {
+ if that == nil {
+ return this == nil
+ }
+
+ that1, ok := that.(*InstantiateContractProposal)
+ if !ok {
+ that2, ok := that.(InstantiateContractProposal)
+ if ok {
+ that1 = &that2
+ } else {
+ return false
+ }
+ }
+ if that1 == nil {
+ return this == nil
+ } else if this == nil {
+ return false
+ }
+ if this.Title != that1.Title {
+ return false
+ }
+ if this.Description != that1.Description {
+ return false
+ }
+ if this.RunAs != that1.RunAs {
+ return false
+ }
+ if this.Admin != that1.Admin {
+ return false
+ }
+ if this.CodeID != that1.CodeID {
+ return false
+ }
+ if this.Label != that1.Label {
+ return false
+ }
+ if !bytes.Equal(this.Msg, that1.Msg) {
+ return false
+ }
+ if len(this.Funds) != len(that1.Funds) {
+ return false
+ }
+ for i := range this.Funds {
+ if !this.Funds[i].Equal(&that1.Funds[i]) {
+ return false
+ }
+ }
+ return true
+}
+
+func (this *InstantiateContract2Proposal) Equal(that interface{}) bool {
+ if that == nil {
+ return this == nil
+ }
+
+ that1, ok := that.(*InstantiateContract2Proposal)
+ if !ok {
+ that2, ok := that.(InstantiateContract2Proposal)
+ if ok {
+ that1 = &that2
+ } else {
+ return false
+ }
+ }
+ if that1 == nil {
+ return this == nil
+ } else if this == nil {
+ return false
+ }
+ if this.Title != that1.Title {
+ return false
+ }
+ if this.Description != that1.Description {
+ return false
+ }
+ if this.RunAs != that1.RunAs {
+ return false
+ }
+ if this.Admin != that1.Admin {
+ return false
+ }
+ if this.CodeID != that1.CodeID {
+ return false
+ }
+ if this.Label != that1.Label {
+ return false
+ }
+ if !bytes.Equal(this.Msg, that1.Msg) {
+ return false
+ }
+ if len(this.Funds) != len(that1.Funds) {
+ return false
+ }
+ for i := range this.Funds {
+ if !this.Funds[i].Equal(&that1.Funds[i]) {
+ return false
+ }
+ }
+ if !bytes.Equal(this.Salt, that1.Salt) {
+ return false
+ }
+ if this.FixMsg != that1.FixMsg {
+ return false
+ }
+ return true
+}
+
+func (this *MigrateContractProposal) Equal(that interface{}) bool {
+ if that == nil {
+ return this == nil
+ }
+
+ that1, ok := that.(*MigrateContractProposal)
+ if !ok {
+ that2, ok := that.(MigrateContractProposal)
+ if ok {
+ that1 = &that2
+ } else {
+ return false
+ }
+ }
+ if that1 == nil {
+ return this == nil
+ } else if this == nil {
+ return false
+ }
+ if this.Title != that1.Title {
+ return false
+ }
+ if this.Description != that1.Description {
+ return false
+ }
+ if this.Contract != that1.Contract {
+ return false
+ }
+ if this.CodeID != that1.CodeID {
+ return false
+ }
+ if !bytes.Equal(this.Msg, that1.Msg) {
+ return false
+ }
+ return true
+}
+
+func (this *SudoContractProposal) Equal(that interface{}) bool {
+ if that == nil {
+ return this == nil
+ }
+
+ that1, ok := that.(*SudoContractProposal)
+ if !ok {
+ that2, ok := that.(SudoContractProposal)
+ if ok {
+ that1 = &that2
+ } else {
+ return false
+ }
+ }
+ if that1 == nil {
+ return this == nil
+ } else if this == nil {
+ return false
+ }
+ if this.Title != that1.Title {
+ return false
+ }
+ if this.Description != that1.Description {
+ return false
+ }
+ if this.Contract != that1.Contract {
+ return false
+ }
+ if !bytes.Equal(this.Msg, that1.Msg) {
+ return false
+ }
+ return true
+}
+
+func (this *ExecuteContractProposal) Equal(that interface{}) bool {
+ if that == nil {
+ return this == nil
+ }
+
+ that1, ok := that.(*ExecuteContractProposal)
+ if !ok {
+ that2, ok := that.(ExecuteContractProposal)
+ if ok {
+ that1 = &that2
+ } else {
+ return false
+ }
+ }
+ if that1 == nil {
+ return this == nil
+ } else if this == nil {
+ return false
+ }
+ if this.Title != that1.Title {
+ return false
+ }
+ if this.Description != that1.Description {
+ return false
+ }
+ if this.RunAs != that1.RunAs {
+ return false
+ }
+ if this.Contract != that1.Contract {
+ return false
+ }
+ if !bytes.Equal(this.Msg, that1.Msg) {
+ return false
+ }
+ if len(this.Funds) != len(that1.Funds) {
+ return false
+ }
+ for i := range this.Funds {
+ if !this.Funds[i].Equal(&that1.Funds[i]) {
+ return false
+ }
+ }
+ return true
+}
+
+func (this *UpdateAdminProposal) Equal(that interface{}) bool {
+ if that == nil {
+ return this == nil
+ }
+
+ that1, ok := that.(*UpdateAdminProposal)
+ if !ok {
+ that2, ok := that.(UpdateAdminProposal)
+ if ok {
+ that1 = &that2
+ } else {
+ return false
+ }
+ }
+ if that1 == nil {
+ return this == nil
+ } else if this == nil {
+ return false
+ }
+ if this.Title != that1.Title {
+ return false
+ }
+ if this.Description != that1.Description {
+ return false
+ }
+ if this.NewAdmin != that1.NewAdmin {
+ return false
+ }
+ if this.Contract != that1.Contract {
+ return false
+ }
+ return true
+}
+
+func (this *ClearAdminProposal) Equal(that interface{}) bool {
+ if that == nil {
+ return this == nil
+ }
+
+ that1, ok := that.(*ClearAdminProposal)
+ if !ok {
+ that2, ok := that.(ClearAdminProposal)
+ if ok {
+ that1 = &that2
+ } else {
+ return false
+ }
+ }
+ if that1 == nil {
+ return this == nil
+ } else if this == nil {
+ return false
+ }
+ if this.Title != that1.Title {
+ return false
+ }
+ if this.Description != that1.Description {
+ return false
+ }
+ if this.Contract != that1.Contract {
+ return false
+ }
+ return true
+}
+
+func (this *PinCodesProposal) Equal(that interface{}) bool {
+ if that == nil {
+ return this == nil
+ }
+
+ that1, ok := that.(*PinCodesProposal)
+ if !ok {
+ that2, ok := that.(PinCodesProposal)
+ if ok {
+ that1 = &that2
+ } else {
+ return false
+ }
+ }
+ if that1 == nil {
+ return this == nil
+ } else if this == nil {
+ return false
+ }
+ if this.Title != that1.Title {
+ return false
+ }
+ if this.Description != that1.Description {
+ return false
+ }
+ if len(this.CodeIDs) != len(that1.CodeIDs) {
+ return false
+ }
+ for i := range this.CodeIDs {
+ if this.CodeIDs[i] != that1.CodeIDs[i] {
+ return false
+ }
+ }
+ return true
+}
+
+func (this *UnpinCodesProposal) Equal(that interface{}) bool {
+ if that == nil {
+ return this == nil
+ }
+
+ that1, ok := that.(*UnpinCodesProposal)
+ if !ok {
+ that2, ok := that.(UnpinCodesProposal)
+ if ok {
+ that1 = &that2
+ } else {
+ return false
+ }
+ }
+ if that1 == nil {
+ return this == nil
+ } else if this == nil {
+ return false
+ }
+ if this.Title != that1.Title {
+ return false
+ }
+ if this.Description != that1.Description {
+ return false
+ }
+ if len(this.CodeIDs) != len(that1.CodeIDs) {
+ return false
+ }
+ for i := range this.CodeIDs {
+ if this.CodeIDs[i] != that1.CodeIDs[i] {
+ return false
+ }
+ }
+ return true
+}
+
+func (this *AccessConfigUpdate) Equal(that interface{}) bool {
+ if that == nil {
+ return this == nil
+ }
+
+ that1, ok := that.(*AccessConfigUpdate)
+ if !ok {
+ that2, ok := that.(AccessConfigUpdate)
+ if ok {
+ that1 = &that2
+ } else {
+ return false
+ }
+ }
+ if that1 == nil {
+ return this == nil
+ } else if this == nil {
+ return false
+ }
+ if this.CodeID != that1.CodeID {
+ return false
+ }
+ if !this.InstantiatePermission.Equal(&that1.InstantiatePermission) {
+ return false
+ }
+ return true
+}
+
+func (this *UpdateInstantiateConfigProposal) Equal(that interface{}) bool {
+ if that == nil {
+ return this == nil
+ }
+
+ that1, ok := that.(*UpdateInstantiateConfigProposal)
+ if !ok {
+ that2, ok := that.(UpdateInstantiateConfigProposal)
+ if ok {
+ that1 = &that2
+ } else {
+ return false
+ }
+ }
+ if that1 == nil {
+ return this == nil
+ } else if this == nil {
+ return false
+ }
+ if this.Title != that1.Title {
+ return false
+ }
+ if this.Description != that1.Description {
+ return false
+ }
+ if len(this.AccessConfigUpdates) != len(that1.AccessConfigUpdates) {
+ return false
+ }
+ for i := range this.AccessConfigUpdates {
+ if !this.AccessConfigUpdates[i].Equal(&that1.AccessConfigUpdates[i]) {
+ return false
+ }
+ }
+ return true
+}
+
+func (this *StoreAndInstantiateContractProposal) Equal(that interface{}) bool {
+ if that == nil {
+ return this == nil
+ }
+
+ that1, ok := that.(*StoreAndInstantiateContractProposal)
+ if !ok {
+ that2, ok := that.(StoreAndInstantiateContractProposal)
+ if ok {
+ that1 = &that2
+ } else {
+ return false
+ }
+ }
+ if that1 == nil {
+ return this == nil
+ } else if this == nil {
+ return false
+ }
+ if this.Title != that1.Title {
+ return false
+ }
+ if this.Description != that1.Description {
+ return false
+ }
+ if this.RunAs != that1.RunAs {
+ return false
+ }
+ if !bytes.Equal(this.WASMByteCode, that1.WASMByteCode) {
+ return false
+ }
+ if !this.InstantiatePermission.Equal(that1.InstantiatePermission) {
+ return false
+ }
+ if this.UnpinCode != that1.UnpinCode {
+ return false
+ }
+ if this.Admin != that1.Admin {
+ return false
+ }
+ if this.Label != that1.Label {
+ return false
+ }
+ if !bytes.Equal(this.Msg, that1.Msg) {
+ return false
+ }
+ if len(this.Funds) != len(that1.Funds) {
+ return false
+ }
+ for i := range this.Funds {
+ if !this.Funds[i].Equal(&that1.Funds[i]) {
+ return false
+ }
+ }
+ if this.Source != that1.Source {
+ return false
+ }
+ if this.Builder != that1.Builder {
+ return false
+ }
+ if !bytes.Equal(this.CodeHash, that1.CodeHash) {
+ return false
+ }
+ return true
+}
+
+func (m *StoreCodeProposal) 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 *StoreCodeProposal) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *StoreCodeProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.CodeHash) > 0 {
+ i -= len(m.CodeHash)
+ copy(dAtA[i:], m.CodeHash)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.CodeHash)))
+ i--
+ dAtA[i] = 0x5a
+ }
+ if len(m.Builder) > 0 {
+ i -= len(m.Builder)
+ copy(dAtA[i:], m.Builder)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Builder)))
+ i--
+ dAtA[i] = 0x52
+ }
+ if len(m.Source) > 0 {
+ i -= len(m.Source)
+ copy(dAtA[i:], m.Source)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Source)))
+ i--
+ dAtA[i] = 0x4a
+ }
+ if m.UnpinCode {
+ i--
+ if m.UnpinCode {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
+ }
+ i--
+ dAtA[i] = 0x40
+ }
+ if m.InstantiatePermission != nil {
+ {
+ size, err := m.InstantiatePermission.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintProposal(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x3a
+ }
+ if len(m.WASMByteCode) > 0 {
+ i -= len(m.WASMByteCode)
+ copy(dAtA[i:], m.WASMByteCode)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.WASMByteCode)))
+ i--
+ dAtA[i] = 0x22
+ }
+ if len(m.RunAs) > 0 {
+ i -= len(m.RunAs)
+ copy(dAtA[i:], m.RunAs)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.RunAs)))
+ i--
+ dAtA[i] = 0x1a
+ }
+ if len(m.Description) > 0 {
+ i -= len(m.Description)
+ copy(dAtA[i:], m.Description)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Description)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(m.Title) > 0 {
+ i -= len(m.Title)
+ copy(dAtA[i:], m.Title)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Title)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *InstantiateContractProposal) 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 *InstantiateContractProposal) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *InstantiateContractProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.Funds) > 0 {
+ for iNdEx := len(m.Funds) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Funds[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintProposal(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x42
+ }
+ }
+ if len(m.Msg) > 0 {
+ i -= len(m.Msg)
+ copy(dAtA[i:], m.Msg)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Msg)))
+ i--
+ dAtA[i] = 0x3a
+ }
+ if len(m.Label) > 0 {
+ i -= len(m.Label)
+ copy(dAtA[i:], m.Label)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Label)))
+ i--
+ dAtA[i] = 0x32
+ }
+ if m.CodeID != 0 {
+ i = encodeVarintProposal(dAtA, i, uint64(m.CodeID))
+ i--
+ dAtA[i] = 0x28
+ }
+ if len(m.Admin) > 0 {
+ i -= len(m.Admin)
+ copy(dAtA[i:], m.Admin)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Admin)))
+ i--
+ dAtA[i] = 0x22
+ }
+ if len(m.RunAs) > 0 {
+ i -= len(m.RunAs)
+ copy(dAtA[i:], m.RunAs)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.RunAs)))
+ i--
+ dAtA[i] = 0x1a
+ }
+ if len(m.Description) > 0 {
+ i -= len(m.Description)
+ copy(dAtA[i:], m.Description)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Description)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(m.Title) > 0 {
+ i -= len(m.Title)
+ copy(dAtA[i:], m.Title)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Title)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *InstantiateContract2Proposal) 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 *InstantiateContract2Proposal) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *InstantiateContract2Proposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.FixMsg {
+ i--
+ if m.FixMsg {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
+ }
+ i--
+ dAtA[i] = 0x50
+ }
+ if len(m.Salt) > 0 {
+ i -= len(m.Salt)
+ copy(dAtA[i:], m.Salt)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Salt)))
+ i--
+ dAtA[i] = 0x4a
+ }
+ if len(m.Funds) > 0 {
+ for iNdEx := len(m.Funds) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Funds[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintProposal(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x42
+ }
+ }
+ if len(m.Msg) > 0 {
+ i -= len(m.Msg)
+ copy(dAtA[i:], m.Msg)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Msg)))
+ i--
+ dAtA[i] = 0x3a
+ }
+ if len(m.Label) > 0 {
+ i -= len(m.Label)
+ copy(dAtA[i:], m.Label)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Label)))
+ i--
+ dAtA[i] = 0x32
+ }
+ if m.CodeID != 0 {
+ i = encodeVarintProposal(dAtA, i, uint64(m.CodeID))
+ i--
+ dAtA[i] = 0x28
+ }
+ if len(m.Admin) > 0 {
+ i -= len(m.Admin)
+ copy(dAtA[i:], m.Admin)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Admin)))
+ i--
+ dAtA[i] = 0x22
+ }
+ if len(m.RunAs) > 0 {
+ i -= len(m.RunAs)
+ copy(dAtA[i:], m.RunAs)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.RunAs)))
+ i--
+ dAtA[i] = 0x1a
+ }
+ if len(m.Description) > 0 {
+ i -= len(m.Description)
+ copy(dAtA[i:], m.Description)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Description)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(m.Title) > 0 {
+ i -= len(m.Title)
+ copy(dAtA[i:], m.Title)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Title)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *MigrateContractProposal) 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 *MigrateContractProposal) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MigrateContractProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.Msg) > 0 {
+ i -= len(m.Msg)
+ copy(dAtA[i:], m.Msg)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Msg)))
+ i--
+ dAtA[i] = 0x32
+ }
+ if m.CodeID != 0 {
+ i = encodeVarintProposal(dAtA, i, uint64(m.CodeID))
+ i--
+ dAtA[i] = 0x28
+ }
+ if len(m.Contract) > 0 {
+ i -= len(m.Contract)
+ copy(dAtA[i:], m.Contract)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Contract)))
+ i--
+ dAtA[i] = 0x22
+ }
+ if len(m.Description) > 0 {
+ i -= len(m.Description)
+ copy(dAtA[i:], m.Description)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Description)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(m.Title) > 0 {
+ i -= len(m.Title)
+ copy(dAtA[i:], m.Title)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Title)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *SudoContractProposal) 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 *SudoContractProposal) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *SudoContractProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.Msg) > 0 {
+ i -= len(m.Msg)
+ copy(dAtA[i:], m.Msg)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Msg)))
+ i--
+ dAtA[i] = 0x22
+ }
+ if len(m.Contract) > 0 {
+ i -= len(m.Contract)
+ copy(dAtA[i:], m.Contract)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Contract)))
+ i--
+ dAtA[i] = 0x1a
+ }
+ if len(m.Description) > 0 {
+ i -= len(m.Description)
+ copy(dAtA[i:], m.Description)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Description)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(m.Title) > 0 {
+ i -= len(m.Title)
+ copy(dAtA[i:], m.Title)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Title)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *ExecuteContractProposal) 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 *ExecuteContractProposal) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ExecuteContractProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.Funds) > 0 {
+ for iNdEx := len(m.Funds) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Funds[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintProposal(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x32
+ }
+ }
+ if len(m.Msg) > 0 {
+ i -= len(m.Msg)
+ copy(dAtA[i:], m.Msg)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Msg)))
+ i--
+ dAtA[i] = 0x2a
+ }
+ if len(m.Contract) > 0 {
+ i -= len(m.Contract)
+ copy(dAtA[i:], m.Contract)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Contract)))
+ i--
+ dAtA[i] = 0x22
+ }
+ if len(m.RunAs) > 0 {
+ i -= len(m.RunAs)
+ copy(dAtA[i:], m.RunAs)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.RunAs)))
+ i--
+ dAtA[i] = 0x1a
+ }
+ if len(m.Description) > 0 {
+ i -= len(m.Description)
+ copy(dAtA[i:], m.Description)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Description)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(m.Title) > 0 {
+ i -= len(m.Title)
+ copy(dAtA[i:], m.Title)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Title)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *UpdateAdminProposal) 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 *UpdateAdminProposal) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *UpdateAdminProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.Contract) > 0 {
+ i -= len(m.Contract)
+ copy(dAtA[i:], m.Contract)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Contract)))
+ i--
+ dAtA[i] = 0x22
+ }
+ if len(m.NewAdmin) > 0 {
+ i -= len(m.NewAdmin)
+ copy(dAtA[i:], m.NewAdmin)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.NewAdmin)))
+ i--
+ dAtA[i] = 0x1a
+ }
+ if len(m.Description) > 0 {
+ i -= len(m.Description)
+ copy(dAtA[i:], m.Description)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Description)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(m.Title) > 0 {
+ i -= len(m.Title)
+ copy(dAtA[i:], m.Title)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Title)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *ClearAdminProposal) 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 *ClearAdminProposal) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ClearAdminProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.Contract) > 0 {
+ i -= len(m.Contract)
+ copy(dAtA[i:], m.Contract)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Contract)))
+ i--
+ dAtA[i] = 0x1a
+ }
+ if len(m.Description) > 0 {
+ i -= len(m.Description)
+ copy(dAtA[i:], m.Description)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Description)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(m.Title) > 0 {
+ i -= len(m.Title)
+ copy(dAtA[i:], m.Title)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Title)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *PinCodesProposal) 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 *PinCodesProposal) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *PinCodesProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.CodeIDs) > 0 {
+ dAtA3 := make([]byte, len(m.CodeIDs)*10)
+ var j2 int
+ for _, num := range m.CodeIDs {
+ for num >= 1<<7 {
+ dAtA3[j2] = uint8(uint64(num)&0x7f | 0x80)
+ num >>= 7
+ j2++
+ }
+ dAtA3[j2] = uint8(num)
+ j2++
+ }
+ i -= j2
+ copy(dAtA[i:], dAtA3[:j2])
+ i = encodeVarintProposal(dAtA, i, uint64(j2))
+ i--
+ dAtA[i] = 0x1a
+ }
+ if len(m.Description) > 0 {
+ i -= len(m.Description)
+ copy(dAtA[i:], m.Description)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Description)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(m.Title) > 0 {
+ i -= len(m.Title)
+ copy(dAtA[i:], m.Title)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Title)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *UnpinCodesProposal) 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 *UnpinCodesProposal) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *UnpinCodesProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.CodeIDs) > 0 {
+ dAtA5 := make([]byte, len(m.CodeIDs)*10)
+ var j4 int
+ for _, num := range m.CodeIDs {
+ for num >= 1<<7 {
+ dAtA5[j4] = uint8(uint64(num)&0x7f | 0x80)
+ num >>= 7
+ j4++
+ }
+ dAtA5[j4] = uint8(num)
+ j4++
+ }
+ i -= j4
+ copy(dAtA[i:], dAtA5[:j4])
+ i = encodeVarintProposal(dAtA, i, uint64(j4))
+ i--
+ dAtA[i] = 0x1a
+ }
+ if len(m.Description) > 0 {
+ i -= len(m.Description)
+ copy(dAtA[i:], m.Description)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Description)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(m.Title) > 0 {
+ i -= len(m.Title)
+ copy(dAtA[i:], m.Title)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Title)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *AccessConfigUpdate) 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 *AccessConfigUpdate) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *AccessConfigUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ {
+ size, err := m.InstantiatePermission.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintProposal(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x12
+ if m.CodeID != 0 {
+ i = encodeVarintProposal(dAtA, i, uint64(m.CodeID))
+ i--
+ dAtA[i] = 0x8
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *UpdateInstantiateConfigProposal) 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 *UpdateInstantiateConfigProposal) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *UpdateInstantiateConfigProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.AccessConfigUpdates) > 0 {
+ for iNdEx := len(m.AccessConfigUpdates) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.AccessConfigUpdates[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintProposal(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x1a
+ }
+ }
+ if len(m.Description) > 0 {
+ i -= len(m.Description)
+ copy(dAtA[i:], m.Description)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Description)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(m.Title) > 0 {
+ i -= len(m.Title)
+ copy(dAtA[i:], m.Title)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Title)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *StoreAndInstantiateContractProposal) 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 *StoreAndInstantiateContractProposal) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *StoreAndInstantiateContractProposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.CodeHash) > 0 {
+ i -= len(m.CodeHash)
+ copy(dAtA[i:], m.CodeHash)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.CodeHash)))
+ i--
+ dAtA[i] = 0x6a
+ }
+ if len(m.Builder) > 0 {
+ i -= len(m.Builder)
+ copy(dAtA[i:], m.Builder)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Builder)))
+ i--
+ dAtA[i] = 0x62
+ }
+ if len(m.Source) > 0 {
+ i -= len(m.Source)
+ copy(dAtA[i:], m.Source)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Source)))
+ i--
+ dAtA[i] = 0x5a
+ }
+ if len(m.Funds) > 0 {
+ for iNdEx := len(m.Funds) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.Funds[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintProposal(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x52
+ }
+ }
+ if len(m.Msg) > 0 {
+ i -= len(m.Msg)
+ copy(dAtA[i:], m.Msg)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Msg)))
+ i--
+ dAtA[i] = 0x4a
+ }
+ if len(m.Label) > 0 {
+ i -= len(m.Label)
+ copy(dAtA[i:], m.Label)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Label)))
+ i--
+ dAtA[i] = 0x42
+ }
+ if len(m.Admin) > 0 {
+ i -= len(m.Admin)
+ copy(dAtA[i:], m.Admin)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Admin)))
+ i--
+ dAtA[i] = 0x3a
+ }
+ if m.UnpinCode {
+ i--
+ if m.UnpinCode {
+ dAtA[i] = 1
+ } else {
+ dAtA[i] = 0
+ }
+ i--
+ dAtA[i] = 0x30
+ }
+ if m.InstantiatePermission != nil {
+ {
+ size, err := m.InstantiatePermission.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintProposal(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x2a
+ }
+ if len(m.WASMByteCode) > 0 {
+ i -= len(m.WASMByteCode)
+ copy(dAtA[i:], m.WASMByteCode)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.WASMByteCode)))
+ i--
+ dAtA[i] = 0x22
+ }
+ if len(m.RunAs) > 0 {
+ i -= len(m.RunAs)
+ copy(dAtA[i:], m.RunAs)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.RunAs)))
+ i--
+ dAtA[i] = 0x1a
+ }
+ if len(m.Description) > 0 {
+ i -= len(m.Description)
+ copy(dAtA[i:], m.Description)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Description)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(m.Title) > 0 {
+ i -= len(m.Title)
+ copy(dAtA[i:], m.Title)
+ i = encodeVarintProposal(dAtA, i, uint64(len(m.Title)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func encodeVarintProposal(dAtA []byte, offset int, v uint64) int {
+ offset -= sovProposal(v)
+ base := offset
+ for v >= 1<<7 {
+ dAtA[offset] = uint8(v&0x7f | 0x80)
+ v >>= 7
+ offset++
+ }
+ dAtA[offset] = uint8(v)
+ return base
+}
+
+func (m *StoreCodeProposal) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.Title)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Description)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.RunAs)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.WASMByteCode)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ if m.InstantiatePermission != nil {
+ l = m.InstantiatePermission.Size()
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ if m.UnpinCode {
+ n += 2
+ }
+ l = len(m.Source)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Builder)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.CodeHash)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ return n
+}
+
+func (m *InstantiateContractProposal) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.Title)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Description)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.RunAs)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Admin)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ if m.CodeID != 0 {
+ n += 1 + sovProposal(uint64(m.CodeID))
+ }
+ l = len(m.Label)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Msg)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ if len(m.Funds) > 0 {
+ for _, e := range m.Funds {
+ l = e.Size()
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *InstantiateContract2Proposal) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.Title)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Description)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.RunAs)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Admin)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ if m.CodeID != 0 {
+ n += 1 + sovProposal(uint64(m.CodeID))
+ }
+ l = len(m.Label)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Msg)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ if len(m.Funds) > 0 {
+ for _, e := range m.Funds {
+ l = e.Size()
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ }
+ l = len(m.Salt)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ if m.FixMsg {
+ n += 2
+ }
+ return n
+}
+
+func (m *MigrateContractProposal) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.Title)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Description)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Contract)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ if m.CodeID != 0 {
+ n += 1 + sovProposal(uint64(m.CodeID))
+ }
+ l = len(m.Msg)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ return n
+}
+
+func (m *SudoContractProposal) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.Title)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Description)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Contract)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Msg)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ return n
+}
+
+func (m *ExecuteContractProposal) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.Title)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Description)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.RunAs)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Contract)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Msg)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ if len(m.Funds) > 0 {
+ for _, e := range m.Funds {
+ l = e.Size()
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *UpdateAdminProposal) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.Title)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Description)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.NewAdmin)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Contract)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ return n
+}
+
+func (m *ClearAdminProposal) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.Title)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Description)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Contract)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ return n
+}
+
+func (m *PinCodesProposal) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.Title)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Description)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ if len(m.CodeIDs) > 0 {
+ l = 0
+ for _, e := range m.CodeIDs {
+ l += sovProposal(uint64(e))
+ }
+ n += 1 + sovProposal(uint64(l)) + l
+ }
+ return n
+}
+
+func (m *UnpinCodesProposal) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.Title)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Description)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ if len(m.CodeIDs) > 0 {
+ l = 0
+ for _, e := range m.CodeIDs {
+ l += sovProposal(uint64(e))
+ }
+ n += 1 + sovProposal(uint64(l)) + l
+ }
+ return n
+}
+
+func (m *AccessConfigUpdate) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if m.CodeID != 0 {
+ n += 1 + sovProposal(uint64(m.CodeID))
+ }
+ l = m.InstantiatePermission.Size()
+ n += 1 + l + sovProposal(uint64(l))
+ return n
+}
+
+func (m *UpdateInstantiateConfigProposal) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.Title)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Description)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ if len(m.AccessConfigUpdates) > 0 {
+ for _, e := range m.AccessConfigUpdates {
+ l = e.Size()
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *StoreAndInstantiateContractProposal) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.Title)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Description)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.RunAs)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.WASMByteCode)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ if m.InstantiatePermission != nil {
+ l = m.InstantiatePermission.Size()
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ if m.UnpinCode {
+ n += 2
+ }
+ l = len(m.Admin)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Label)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Msg)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ if len(m.Funds) > 0 {
+ for _, e := range m.Funds {
+ l = e.Size()
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ }
+ l = len(m.Source)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.Builder)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ l = len(m.CodeHash)
+ if l > 0 {
+ n += 1 + l + sovProposal(uint64(l))
+ }
+ return n
+}
+
+func sovProposal(x uint64) (n int) {
+ return (math_bits.Len64(x|1) + 6) / 7
+}
+
+func sozProposal(x uint64) (n int) {
+ return sovProposal(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+
+func (m *StoreCodeProposal) 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 ErrIntOverflowProposal
+ }
+ 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: StoreCodeProposal: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: StoreCodeProposal: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Title = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Description = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RunAs", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.RunAs = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field WASMByteCode", wireType)
+ }
+ var byteLen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ byteLen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if byteLen < 0 {
+ return ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + byteLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.WASMByteCode = append(m.WASMByteCode[:0], dAtA[iNdEx:postIndex]...)
+ if m.WASMByteCode == nil {
+ m.WASMByteCode = []byte{}
+ }
+ iNdEx = postIndex
+ case 7:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field InstantiatePermission", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ msglen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.InstantiatePermission == nil {
+ m.InstantiatePermission = &AccessConfig{}
+ }
+ if err := m.InstantiatePermission.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 8:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field UnpinCode", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ v |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.UnpinCode = bool(v != 0)
+ case 9:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Source = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 10:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Builder", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Builder = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 11:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field CodeHash", wireType)
+ }
+ var byteLen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ byteLen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if byteLen < 0 {
+ return ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + byteLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.CodeHash = append(m.CodeHash[:0], dAtA[iNdEx:postIndex]...)
+ if m.CodeHash == nil {
+ m.CodeHash = []byte{}
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipProposal(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+
+func (m *InstantiateContractProposal) 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 ErrIntOverflowProposal
+ }
+ 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: InstantiateContractProposal: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: InstantiateContractProposal: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Title = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Description = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RunAs", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.RunAs = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Admin", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Admin = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field CodeID", wireType)
+ }
+ m.CodeID = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.CodeID |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Label", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Label = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 7:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
+ }
+ var byteLen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ byteLen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if byteLen < 0 {
+ return ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + byteLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Msg = append(m.Msg[:0], dAtA[iNdEx:postIndex]...)
+ if m.Msg == nil {
+ m.Msg = []byte{}
+ }
+ iNdEx = postIndex
+ case 8:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Funds", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ msglen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Funds = append(m.Funds, types.Coin{})
+ if err := m.Funds[len(m.Funds)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipProposal(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+
+func (m *InstantiateContract2Proposal) 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 ErrIntOverflowProposal
+ }
+ 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: InstantiateContract2Proposal: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: InstantiateContract2Proposal: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Title = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Description = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RunAs", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.RunAs = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Admin", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Admin = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field CodeID", wireType)
+ }
+ m.CodeID = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.CodeID |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Label", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Label = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 7:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
+ }
+ var byteLen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ byteLen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if byteLen < 0 {
+ return ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + byteLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Msg = append(m.Msg[:0], dAtA[iNdEx:postIndex]...)
+ if m.Msg == nil {
+ m.Msg = []byte{}
+ }
+ iNdEx = postIndex
+ case 8:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Funds", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ msglen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Funds = append(m.Funds, types.Coin{})
+ if err := m.Funds[len(m.Funds)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 9:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Salt", wireType)
+ }
+ var byteLen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ byteLen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if byteLen < 0 {
+ return ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + byteLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Salt = append(m.Salt[:0], dAtA[iNdEx:postIndex]...)
+ if m.Salt == nil {
+ m.Salt = []byte{}
+ }
+ iNdEx = postIndex
+ case 10:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FixMsg", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ v |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.FixMsg = bool(v != 0)
+ default:
+ iNdEx = preIndex
+ skippy, err := skipProposal(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+
+func (m *MigrateContractProposal) 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 ErrIntOverflowProposal
+ }
+ 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: MigrateContractProposal: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: MigrateContractProposal: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Title = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Description = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Contract = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 5:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field CodeID", wireType)
+ }
+ m.CodeID = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.CodeID |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
+ }
+ var byteLen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ byteLen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if byteLen < 0 {
+ return ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + byteLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Msg = append(m.Msg[:0], dAtA[iNdEx:postIndex]...)
+ if m.Msg == nil {
+ m.Msg = []byte{}
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipProposal(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+
+func (m *SudoContractProposal) 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 ErrIntOverflowProposal
+ }
+ 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: SudoContractProposal: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: SudoContractProposal: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Title = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Description = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Contract = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
+ }
+ var byteLen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ byteLen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if byteLen < 0 {
+ return ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + byteLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Msg = append(m.Msg[:0], dAtA[iNdEx:postIndex]...)
+ if m.Msg == nil {
+ m.Msg = []byte{}
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipProposal(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+
+func (m *ExecuteContractProposal) 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 ErrIntOverflowProposal
+ }
+ 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: ExecuteContractProposal: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ExecuteContractProposal: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Title = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Description = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RunAs", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.RunAs = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Contract = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
+ }
+ var byteLen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ byteLen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if byteLen < 0 {
+ return ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + byteLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Msg = append(m.Msg[:0], dAtA[iNdEx:postIndex]...)
+ if m.Msg == nil {
+ m.Msg = []byte{}
+ }
+ iNdEx = postIndex
+ case 6:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Funds", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ msglen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Funds = append(m.Funds, types.Coin{})
+ if err := m.Funds[len(m.Funds)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipProposal(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+
+func (m *UpdateAdminProposal) 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 ErrIntOverflowProposal
+ }
+ 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: UpdateAdminProposal: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: UpdateAdminProposal: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Title = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Description = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field NewAdmin", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.NewAdmin = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Contract = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipProposal(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+
+func (m *ClearAdminProposal) 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 ErrIntOverflowProposal
+ }
+ 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: ClearAdminProposal: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: ClearAdminProposal: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Title = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Description = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Contract = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipProposal(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+
+func (m *PinCodesProposal) 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 ErrIntOverflowProposal
+ }
+ 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: PinCodesProposal: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: PinCodesProposal: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Title = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Description = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType == 0 {
+ var v uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ v |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.CodeIDs = append(m.CodeIDs, v)
+ } else if wireType == 2 {
+ var packedLen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ packedLen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if packedLen < 0 {
+ return ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + packedLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var elementCount int
+ var count int
+ for _, integer := range dAtA[iNdEx:postIndex] {
+ if integer < 128 {
+ count++
+ }
+ }
+ elementCount = count
+ if elementCount != 0 && len(m.CodeIDs) == 0 {
+ m.CodeIDs = make([]uint64, 0, elementCount)
+ }
+ for iNdEx < postIndex {
+ var v uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ v |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.CodeIDs = append(m.CodeIDs, v)
+ }
+ } else {
+ return fmt.Errorf("proto: wrong wireType = %d for field CodeIDs", wireType)
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipProposal(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+
+func (m *UnpinCodesProposal) 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 ErrIntOverflowProposal
+ }
+ 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: UnpinCodesProposal: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: UnpinCodesProposal: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Title = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Description = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType == 0 {
+ var v uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ v |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.CodeIDs = append(m.CodeIDs, v)
+ } else if wireType == 2 {
+ var packedLen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ packedLen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if packedLen < 0 {
+ return ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + packedLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ var elementCount int
+ var count int
+ for _, integer := range dAtA[iNdEx:postIndex] {
+ if integer < 128 {
+ count++
+ }
+ }
+ elementCount = count
+ if elementCount != 0 && len(m.CodeIDs) == 0 {
+ m.CodeIDs = make([]uint64, 0, elementCount)
+ }
+ for iNdEx < postIndex {
+ var v uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ v |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.CodeIDs = append(m.CodeIDs, v)
+ }
+ } else {
+ return fmt.Errorf("proto: wrong wireType = %d for field CodeIDs", wireType)
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipProposal(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+
+func (m *AccessConfigUpdate) 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 ErrIntOverflowProposal
+ }
+ 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: AccessConfigUpdate: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: AccessConfigUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field CodeID", wireType)
+ }
+ m.CodeID = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.CodeID |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field InstantiatePermission", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ msglen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.InstantiatePermission.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipProposal(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+
+func (m *UpdateInstantiateConfigProposal) 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 ErrIntOverflowProposal
+ }
+ 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: UpdateInstantiateConfigProposal: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: UpdateInstantiateConfigProposal: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Title = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Description = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field AccessConfigUpdates", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ msglen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.AccessConfigUpdates = append(m.AccessConfigUpdates, AccessConfigUpdate{})
+ if err := m.AccessConfigUpdates[len(m.AccessConfigUpdates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipProposal(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+
+func (m *StoreAndInstantiateContractProposal) 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 ErrIntOverflowProposal
+ }
+ 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: StoreAndInstantiateContractProposal: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: StoreAndInstantiateContractProposal: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Title = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Description = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field RunAs", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.RunAs = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 4:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field WASMByteCode", wireType)
+ }
+ var byteLen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ byteLen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if byteLen < 0 {
+ return ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + byteLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.WASMByteCode = append(m.WASMByteCode[:0], dAtA[iNdEx:postIndex]...)
+ if m.WASMByteCode == nil {
+ m.WASMByteCode = []byte{}
+ }
+ iNdEx = postIndex
+ case 5:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field InstantiatePermission", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ msglen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if m.InstantiatePermission == nil {
+ m.InstantiatePermission = &AccessConfig{}
+ }
+ if err := m.InstantiatePermission.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 6:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field UnpinCode", wireType)
+ }
+ var v int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ v |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ m.UnpinCode = bool(v != 0)
+ case 7:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Admin", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Admin = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 8:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Label", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Label = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 9:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Msg", wireType)
+ }
+ var byteLen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ byteLen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if byteLen < 0 {
+ return ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + byteLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Msg = append(m.Msg[:0], dAtA[iNdEx:postIndex]...)
+ if m.Msg == nil {
+ m.Msg = []byte{}
+ }
+ iNdEx = postIndex
+ case 10:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Funds", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ msglen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Funds = append(m.Funds, types.Coin{})
+ if err := m.Funds[len(m.Funds)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 11:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Source = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 12:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Builder", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ 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 ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Builder = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 13:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field CodeHash", wireType)
+ }
+ var byteLen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ byteLen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if byteLen < 0 {
+ return ErrInvalidLengthProposal
+ }
+ postIndex := iNdEx + byteLen
+ if postIndex < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.CodeHash = append(m.CodeHash[:0], dAtA[iNdEx:postIndex]...)
+ if m.CodeHash == nil {
+ m.CodeHash = []byte{}
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipProposal(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthProposal
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+
+func skipProposal(dAtA []byte) (n int, err error) {
+ l := len(dAtA)
+ iNdEx := 0
+ depth := 0
+ for iNdEx < l {
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ wireType := int(wire & 0x7)
+ switch wireType {
+ case 0:
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ iNdEx++
+ if dAtA[iNdEx-1] < 0x80 {
+ break
+ }
+ }
+ case 1:
+ iNdEx += 8
+ case 2:
+ var length int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowProposal
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ length |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if length < 0 {
+ return 0, ErrInvalidLengthProposal
+ }
+ iNdEx += length
+ case 3:
+ depth++
+ case 4:
+ if depth == 0 {
+ return 0, ErrUnexpectedEndOfGroupProposal
+ }
+ depth--
+ case 5:
+ iNdEx += 4
+ default:
+ return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+ }
+ if iNdEx < 0 {
+ return 0, ErrInvalidLengthProposal
+ }
+ if depth == 0 {
+ return iNdEx, nil
+ }
+ }
+ return 0, io.ErrUnexpectedEOF
+}
+
+var (
+ ErrInvalidLengthProposal = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowProposal = fmt.Errorf("proto: integer overflow")
+ ErrUnexpectedEndOfGroupProposal = fmt.Errorf("proto: unexpected end of group")
+)
diff --git a/x/wasm/types/proposal_test.go b/x/wasm/types/proposal_test.go
new file mode 100644
index 0000000000..622485886f
--- /dev/null
+++ b/x/wasm/types/proposal_test.go
@@ -0,0 +1,1130 @@
+package types
+
+import (
+ "bytes"
+ "encoding/json"
+ "strings"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+ "gopkg.in/yaml.v2"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/cosmos/cosmos-sdk/x/gov/types/v1beta1"
+)
+
+func TestValidateProposalCommons(t *testing.T) {
+ type commonProposal struct {
+ Title, Description string
+ }
+
+ specs := map[string]struct {
+ src commonProposal
+ expErr bool
+ }{
+ "all good": {src: commonProposal{
+ Title: "Foo",
+ Description: "Bar",
+ }},
+ "prevent empty title": {
+ src: commonProposal{
+ Description: "Bar",
+ },
+ expErr: true,
+ },
+ "prevent white space only title": {
+ src: commonProposal{
+ Title: " ",
+ Description: "Bar",
+ },
+ expErr: true,
+ },
+ "prevent leading white spaces in title": {
+ src: commonProposal{
+ Title: " Foo",
+ Description: "Bar",
+ },
+ expErr: true,
+ },
+ "prevent title exceeds max length ": {
+ src: commonProposal{
+ Title: strings.Repeat("a", v1beta1.MaxTitleLength+1),
+ Description: "Bar",
+ },
+ expErr: true,
+ },
+ "prevent empty description": {
+ src: commonProposal{
+ Title: "Foo",
+ },
+ expErr: true,
+ },
+ "prevent leading white spaces in description": {
+ src: commonProposal{
+ Title: "Foo",
+ Description: " Bar",
+ },
+ expErr: true,
+ },
+ "prevent white space only description": {
+ src: commonProposal{
+ Title: "Foo",
+ Description: " ",
+ },
+ expErr: true,
+ },
+ "prevent descr exceeds max length ": {
+ src: commonProposal{
+ Title: "Foo",
+ Description: strings.Repeat("a", v1beta1.MaxDescriptionLength+1),
+ },
+ expErr: true,
+ },
+ }
+ for msg, spec := range specs {
+ t.Run(msg, func(t *testing.T) {
+ err := validateProposalCommons(spec.src.Title, spec.src.Description)
+ if spec.expErr {
+ require.Error(t, err)
+ } else {
+ require.NoError(t, err)
+ }
+ })
+ }
+}
+
+func TestValidateStoreCodeProposal(t *testing.T) {
+ var anyAddress sdk.AccAddress = bytes.Repeat([]byte{0x0}, ContractAddrLen)
+
+ specs := map[string]struct {
+ src *StoreCodeProposal
+ expErr bool
+ }{
+ "all good": {
+ src: StoreCodeProposalFixture(),
+ },
+ "all good no code verification info": {
+ src: StoreCodeProposalFixture(func(p *StoreCodeProposal) {
+ p.Source = ""
+ p.Builder = ""
+ p.CodeHash = nil
+ }),
+ },
+ "source missing": {
+ src: StoreCodeProposalFixture(func(p *StoreCodeProposal) {
+ p.Source = ""
+ }),
+ expErr: true,
+ },
+ "builder missing": {
+ src: StoreCodeProposalFixture(func(p *StoreCodeProposal) {
+ p.Builder = ""
+ }),
+ expErr: true,
+ },
+ "code hash missing": {
+ src: StoreCodeProposalFixture(func(p *StoreCodeProposal) {
+ p.CodeHash = nil
+ }),
+ expErr: true,
+ },
+ "with instantiate permission": {
+ src: StoreCodeProposalFixture(func(p *StoreCodeProposal) {
+ accessConfig := AccessTypeAnyOfAddresses.With(anyAddress)
+ p.InstantiatePermission = &accessConfig
+ }),
+ },
+ "base data missing": {
+ src: StoreCodeProposalFixture(func(p *StoreCodeProposal) {
+ p.Title = ""
+ }),
+ expErr: true,
+ },
+ "run_as missing": {
+ src: StoreCodeProposalFixture(func(p *StoreCodeProposal) {
+ p.RunAs = ""
+ }),
+ expErr: true,
+ },
+ "run_as invalid": {
+ src: StoreCodeProposalFixture(func(p *StoreCodeProposal) {
+ p.RunAs = invalidAddress
+ }),
+ expErr: true,
+ },
+ "wasm code missing": {
+ src: StoreCodeProposalFixture(func(p *StoreCodeProposal) {
+ p.WASMByteCode = nil
+ }),
+ expErr: true,
+ },
+ "wasm code invalid": {
+ src: StoreCodeProposalFixture(func(p *StoreCodeProposal) {
+ p.WASMByteCode = bytes.Repeat([]byte{0x0}, MaxProposalWasmSize+1)
+ }),
+ expErr: true,
+ },
+ "with invalid instantiate permission": {
+ src: StoreCodeProposalFixture(func(p *StoreCodeProposal) {
+ p.InstantiatePermission = &AccessConfig{}
+ }),
+ 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)
+ } else {
+ require.NoError(t, err)
+ }
+ })
+ }
+}
+
+func TestValidateInstantiateContractProposal(t *testing.T) {
+ specs := map[string]struct {
+ src *InstantiateContractProposal
+ expErr bool
+ }{
+ "all good": {
+ src: InstantiateContractProposalFixture(),
+ },
+ "without admin": {
+ src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) {
+ p.Admin = ""
+ }),
+ },
+ "without init msg": {
+ src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) {
+ p.Msg = nil
+ }),
+ expErr: true,
+ },
+ "with invalid init msg": {
+ src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) {
+ p.Msg = []byte("not a json string")
+ }),
+ expErr: true,
+ },
+ "without init funds": {
+ src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) {
+ p.Funds = nil
+ }),
+ },
+ "base data missing": {
+ src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) {
+ p.Title = ""
+ }),
+ expErr: true,
+ },
+ "run_as missing": {
+ src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) {
+ p.RunAs = ""
+ }),
+ expErr: true,
+ },
+ "run_as invalid": {
+ src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) {
+ p.RunAs = invalidAddress
+ }),
+ expErr: true,
+ },
+ "admin invalid": {
+ src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) {
+ p.Admin = invalidAddress
+ }),
+ expErr: true,
+ },
+ "code id empty": {
+ src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) {
+ p.CodeID = 0
+ }),
+ expErr: true,
+ },
+ "label empty": {
+ src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) {
+ p.Label = ""
+ }),
+ expErr: true,
+ },
+ "init funds negative": {
+ src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) {
+ p.Funds = sdk.Coins{{Denom: "foo", Amount: sdk.NewInt(-1)}}
+ }),
+ expErr: true,
+ },
+ "init funds with duplicates": {
+ src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) {
+ p.Funds = sdk.Coins{{Denom: "foo", Amount: sdk.NewInt(1)}, {Denom: "foo", Amount: sdk.NewInt(2)}}
+ }),
+ 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)
+ } else {
+ require.NoError(t, err)
+ }
+ })
+ }
+}
+
+func TestValidateInstantiateContract2Proposal(t *testing.T) {
+ specs := map[string]struct {
+ src *InstantiateContract2Proposal
+ expErr bool
+ }{
+ "all good": {
+ src: InstantiateContract2ProposalFixture(),
+ },
+ "without admin": {
+ src: InstantiateContract2ProposalFixture(func(p *InstantiateContract2Proposal) {
+ p.Admin = ""
+ }),
+ },
+ "without init msg": {
+ src: InstantiateContract2ProposalFixture(func(p *InstantiateContract2Proposal) {
+ p.Msg = nil
+ }),
+ expErr: true,
+ },
+ "with invalid init msg": {
+ src: InstantiateContract2ProposalFixture(func(p *InstantiateContract2Proposal) {
+ p.Msg = []byte("not a json string")
+ }),
+ expErr: true,
+ },
+ "without init funds": {
+ src: InstantiateContract2ProposalFixture(func(p *InstantiateContract2Proposal) {
+ p.Funds = nil
+ }),
+ },
+ "base data missing": {
+ src: InstantiateContract2ProposalFixture(func(p *InstantiateContract2Proposal) {
+ p.Title = ""
+ }),
+ expErr: true,
+ },
+ "run_as missing": {
+ src: InstantiateContract2ProposalFixture(func(p *InstantiateContract2Proposal) {
+ p.RunAs = ""
+ }),
+ expErr: true,
+ },
+ "run_as invalid": {
+ src: InstantiateContract2ProposalFixture(func(p *InstantiateContract2Proposal) {
+ p.RunAs = invalidAddress
+ }),
+ expErr: true,
+ },
+ "admin invalid": {
+ src: InstantiateContract2ProposalFixture(func(p *InstantiateContract2Proposal) {
+ p.Admin = invalidAddress
+ }),
+ expErr: true,
+ },
+ "code id empty": {
+ src: InstantiateContract2ProposalFixture(func(p *InstantiateContract2Proposal) {
+ p.CodeID = 0
+ }),
+ expErr: true,
+ },
+ "label empty": {
+ src: InstantiateContract2ProposalFixture(func(p *InstantiateContract2Proposal) {
+ p.Label = ""
+ }),
+ expErr: true,
+ },
+ "untrimmed label ": {
+ src: InstantiateContract2ProposalFixture(func(p *InstantiateContract2Proposal) {
+ p.Label = " label "
+ }),
+ expErr: true,
+ },
+ "init funds negative": {
+ src: InstantiateContract2ProposalFixture(func(p *InstantiateContract2Proposal) {
+ p.Funds = sdk.Coins{{Denom: "foo", Amount: sdk.NewInt(-1)}}
+ }),
+ expErr: true,
+ },
+ "init funds with duplicates": {
+ src: InstantiateContract2ProposalFixture(func(p *InstantiateContract2Proposal) {
+ p.Funds = sdk.Coins{{Denom: "foo", Amount: sdk.NewInt(1)}, {Denom: "foo", Amount: sdk.NewInt(2)}}
+ }),
+ expErr: true,
+ },
+ "init with empty salt": {
+ src: InstantiateContract2ProposalFixture(func(p *InstantiateContract2Proposal) {
+ p.Salt = nil
+ }),
+ 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)
+ } else {
+ require.NoError(t, err)
+ }
+ })
+ }
+}
+
+func TestValidateStoreAndInstantiateContractProposal(t *testing.T) {
+ var anyAddress sdk.AccAddress = bytes.Repeat([]byte{0x0}, ContractAddrLen)
+
+ specs := map[string]struct {
+ src *StoreAndInstantiateContractProposal
+ expErr bool
+ }{
+ "all good": {
+ src: StoreAndInstantiateContractProposalFixture(),
+ },
+ "all good no code verification info": {
+ src: StoreAndInstantiateContractProposalFixture(func(p *StoreAndInstantiateContractProposal) {
+ p.Source = ""
+ p.Builder = ""
+ p.CodeHash = nil
+ }),
+ },
+ "source missing": {
+ src: StoreAndInstantiateContractProposalFixture(func(p *StoreAndInstantiateContractProposal) {
+ p.Source = ""
+ }),
+ expErr: true,
+ },
+ "builder missing": {
+ src: StoreAndInstantiateContractProposalFixture(func(p *StoreAndInstantiateContractProposal) {
+ p.Builder = ""
+ }),
+ expErr: true,
+ },
+ "code hash missing": {
+ src: StoreAndInstantiateContractProposalFixture(func(p *StoreAndInstantiateContractProposal) {
+ p.CodeHash = nil
+ }),
+ expErr: true,
+ },
+ "with instantiate permission": {
+ src: StoreAndInstantiateContractProposalFixture(func(p *StoreAndInstantiateContractProposal) {
+ accessConfig := AccessTypeAnyOfAddresses.With(anyAddress)
+ p.InstantiatePermission = &accessConfig
+ }),
+ },
+ "base data missing": {
+ src: StoreAndInstantiateContractProposalFixture(func(p *StoreAndInstantiateContractProposal) {
+ p.Title = ""
+ }),
+ expErr: true,
+ },
+ "run_as missing": {
+ src: StoreAndInstantiateContractProposalFixture(func(p *StoreAndInstantiateContractProposal) {
+ p.RunAs = ""
+ }),
+ expErr: true,
+ },
+ "run_as invalid": {
+ src: StoreAndInstantiateContractProposalFixture(func(p *StoreAndInstantiateContractProposal) {
+ p.RunAs = invalidAddress
+ }),
+ expErr: true,
+ },
+ "wasm code missing": {
+ src: StoreAndInstantiateContractProposalFixture(func(p *StoreAndInstantiateContractProposal) {
+ p.WASMByteCode = nil
+ }),
+ expErr: true,
+ },
+ "wasm code invalid": {
+ src: StoreAndInstantiateContractProposalFixture(func(p *StoreAndInstantiateContractProposal) {
+ p.WASMByteCode = bytes.Repeat([]byte{0x0}, MaxProposalWasmSize+1)
+ }),
+ expErr: true,
+ },
+ "with invalid instantiate permission": {
+ src: StoreAndInstantiateContractProposalFixture(func(p *StoreAndInstantiateContractProposal) {
+ p.InstantiatePermission = &AccessConfig{}
+ }),
+ expErr: true,
+ },
+ "without admin": {
+ src: StoreAndInstantiateContractProposalFixture(func(p *StoreAndInstantiateContractProposal) {
+ p.Admin = ""
+ }),
+ },
+ "without init msg": {
+ src: StoreAndInstantiateContractProposalFixture(func(p *StoreAndInstantiateContractProposal) {
+ p.Msg = nil
+ }),
+ expErr: true,
+ },
+ "with invalid init msg": {
+ src: StoreAndInstantiateContractProposalFixture(func(p *StoreAndInstantiateContractProposal) {
+ p.Msg = []byte("not a json string")
+ }),
+ expErr: true,
+ },
+ "without init funds": {
+ src: StoreAndInstantiateContractProposalFixture(func(p *StoreAndInstantiateContractProposal) {
+ p.Funds = nil
+ }),
+ },
+ "admin invalid": {
+ src: StoreAndInstantiateContractProposalFixture(func(p *StoreAndInstantiateContractProposal) {
+ p.Admin = invalidAddress
+ }),
+ expErr: true,
+ },
+ "label empty": {
+ src: StoreAndInstantiateContractProposalFixture(func(p *StoreAndInstantiateContractProposal) {
+ p.Label = ""
+ }),
+ expErr: true,
+ },
+ "init funds negative": {
+ src: StoreAndInstantiateContractProposalFixture(func(p *StoreAndInstantiateContractProposal) {
+ p.Funds = sdk.Coins{{Denom: "foo", Amount: sdk.NewInt(-1)}}
+ }),
+ expErr: true,
+ },
+ "init funds with duplicates": {
+ src: StoreAndInstantiateContractProposalFixture(func(p *StoreAndInstantiateContractProposal) {
+ p.Funds = sdk.Coins{{Denom: "foo", Amount: sdk.NewInt(1)}, {Denom: "foo", Amount: sdk.NewInt(2)}}
+ }),
+ 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)
+ } else {
+ require.NoError(t, err)
+ }
+ })
+ }
+}
+
+func TestValidateMigrateContractProposal(t *testing.T) {
+ invalidAddress := "invalid address2"
+
+ specs := map[string]struct {
+ src *MigrateContractProposal
+ expErr bool
+ }{
+ "all good": {
+ src: MigrateContractProposalFixture(),
+ },
+ "without migrate msg": {
+ src: MigrateContractProposalFixture(func(p *MigrateContractProposal) {
+ p.Msg = nil
+ }),
+ expErr: true,
+ },
+ "migrate msg with invalid json": {
+ src: MigrateContractProposalFixture(func(p *MigrateContractProposal) {
+ p.Msg = []byte("not a json message")
+ }),
+ expErr: true,
+ },
+ "base data missing": {
+ src: MigrateContractProposalFixture(func(p *MigrateContractProposal) {
+ p.Title = ""
+ }),
+ expErr: true,
+ },
+ "contract missing": {
+ src: MigrateContractProposalFixture(func(p *MigrateContractProposal) {
+ p.Contract = ""
+ }),
+ expErr: true,
+ },
+ "contract invalid": {
+ src: MigrateContractProposalFixture(func(p *MigrateContractProposal) {
+ p.Contract = invalidAddress
+ }),
+ expErr: true,
+ },
+ "code id empty": {
+ src: MigrateContractProposalFixture(func(p *MigrateContractProposal) {
+ p.CodeID = 0
+ }),
+ 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)
+ } else {
+ require.NoError(t, err)
+ }
+ })
+ }
+}
+
+func TestValidateSudoContractProposal(t *testing.T) {
+ specs := map[string]struct {
+ src *SudoContractProposal
+ expErr bool
+ }{
+ "all good": {
+ src: SudoContractProposalFixture(),
+ },
+ "msg is nil": {
+ src: SudoContractProposalFixture(func(p *SudoContractProposal) {
+ p.Msg = nil
+ }),
+ expErr: true,
+ },
+ "msg with invalid json": {
+ src: SudoContractProposalFixture(func(p *SudoContractProposal) {
+ p.Msg = []byte("not a json message")
+ }),
+ expErr: true,
+ },
+ "base data missing": {
+ src: SudoContractProposalFixture(func(p *SudoContractProposal) {
+ p.Title = ""
+ }),
+ expErr: true,
+ },
+ "contract missing": {
+ src: SudoContractProposalFixture(func(p *SudoContractProposal) {
+ p.Contract = ""
+ }),
+ expErr: true,
+ },
+ "contract invalid": {
+ src: SudoContractProposalFixture(func(p *SudoContractProposal) {
+ p.Contract = invalidAddress
+ }),
+ 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)
+ } else {
+ require.NoError(t, err)
+ }
+ })
+ }
+}
+
+func TestValidateExecuteContractProposal(t *testing.T) {
+ specs := map[string]struct {
+ src *ExecuteContractProposal
+ expErr bool
+ }{
+ "all good": {
+ src: ExecuteContractProposalFixture(),
+ },
+ "msg is nil": {
+ src: ExecuteContractProposalFixture(func(p *ExecuteContractProposal) {
+ p.Msg = nil
+ }),
+ expErr: true,
+ },
+ "msg with invalid json": {
+ src: ExecuteContractProposalFixture(func(p *ExecuteContractProposal) {
+ p.Msg = []byte("not a valid json message")
+ }),
+ expErr: true,
+ },
+ "base data missing": {
+ src: ExecuteContractProposalFixture(func(p *ExecuteContractProposal) {
+ p.Title = ""
+ }),
+ expErr: true,
+ },
+ "contract missing": {
+ src: ExecuteContractProposalFixture(func(p *ExecuteContractProposal) {
+ p.Contract = ""
+ }),
+ expErr: true,
+ },
+ "contract invalid": {
+ src: ExecuteContractProposalFixture(func(p *ExecuteContractProposal) {
+ p.Contract = invalidAddress
+ }),
+ expErr: true,
+ },
+ "run as is invalid": {
+ src: ExecuteContractProposalFixture(func(p *ExecuteContractProposal) {
+ p.RunAs = invalidAddress
+ }),
+ 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)
+ } else {
+ require.NoError(t, err)
+ }
+ })
+ }
+}
+
+func TestValidateUpdateAdminProposal(t *testing.T) {
+ specs := map[string]struct {
+ src *UpdateAdminProposal
+ expErr bool
+ }{
+ "all good": {
+ src: UpdateAdminProposalFixture(),
+ },
+ "base data missing": {
+ src: UpdateAdminProposalFixture(func(p *UpdateAdminProposal) {
+ p.Title = ""
+ }),
+ expErr: true,
+ },
+ "contract missing": {
+ src: UpdateAdminProposalFixture(func(p *UpdateAdminProposal) {
+ p.Contract = ""
+ }),
+ expErr: true,
+ },
+ "contract invalid": {
+ src: UpdateAdminProposalFixture(func(p *UpdateAdminProposal) {
+ p.Contract = invalidAddress
+ }),
+ expErr: true,
+ },
+ "admin missing": {
+ src: UpdateAdminProposalFixture(func(p *UpdateAdminProposal) {
+ p.NewAdmin = ""
+ }),
+ expErr: true,
+ },
+ "admin invalid": {
+ src: UpdateAdminProposalFixture(func(p *UpdateAdminProposal) {
+ p.NewAdmin = invalidAddress
+ }),
+ 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)
+ } else {
+ require.NoError(t, err)
+ }
+ })
+ }
+}
+
+func TestValidateClearAdminProposal(t *testing.T) {
+ specs := map[string]struct {
+ src *ClearAdminProposal
+ expErr bool
+ }{
+ "all good": {
+ src: ClearAdminProposalFixture(),
+ },
+ "base data missing": {
+ src: ClearAdminProposalFixture(func(p *ClearAdminProposal) {
+ p.Title = ""
+ }),
+ expErr: true,
+ },
+ "contract missing": {
+ src: ClearAdminProposalFixture(func(p *ClearAdminProposal) {
+ p.Contract = ""
+ }),
+ expErr: true,
+ },
+ "contract invalid": {
+ src: ClearAdminProposalFixture(func(p *ClearAdminProposal) {
+ p.Contract = invalidAddress
+ }),
+ 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)
+ } else {
+ require.NoError(t, err)
+ }
+ })
+ }
+}
+
+func TestProposalStrings(t *testing.T) {
+ specs := map[string]struct {
+ src v1beta1.Content
+ exp string
+ }{
+ "store code": {
+ src: StoreCodeProposalFixture(func(p *StoreCodeProposal) {
+ p.WASMByteCode = []byte{0o1, 0o2, 0o3, 0o4, 0o5, 0o6, 0o7, 0x08, 0x09, 0x0a}
+ }),
+ exp: `Store Code Proposal:
+ Title: Foo
+ Description: Bar
+ Run as: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4
+ WasmCode: 0102030405060708090A
+ Source: https://example.com/
+ Builder: cosmwasm/workspace-optimizer:v0.12.8
+ Code Hash: 6E340B9CFFB37A989CA544E6BB780A2C78901D3FB33738768511A30617AFA01D
+`,
+ },
+ "instantiate contract": {
+ src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) {
+ p.Funds = sdk.Coins{{Denom: "foo", Amount: sdk.NewInt(1)}, {Denom: "bar", Amount: sdk.NewInt(2)}}
+ }),
+ exp: `Instantiate Code Proposal:
+ Title: Foo
+ Description: Bar
+ Run as: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4
+ Admin: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4
+ Code id: 1
+ Label: testing
+ Msg: "{\"verifier\":\"cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4\",\"beneficiary\":\"cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4\"}"
+ Funds: 1foo,2bar
+`,
+ },
+ "instantiate contract without funds": {
+ src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) { p.Funds = nil }),
+ exp: `Instantiate Code Proposal:
+ Title: Foo
+ Description: Bar
+ Run as: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4
+ Admin: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4
+ Code id: 1
+ Label: testing
+ Msg: "{\"verifier\":\"cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4\",\"beneficiary\":\"cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4\"}"
+ Funds:
+`,
+ },
+ "instantiate contract without admin": {
+ src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) { p.Admin = "" }),
+ exp: `Instantiate Code Proposal:
+ Title: Foo
+ Description: Bar
+ Run as: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4
+ Admin:
+ Code id: 1
+ Label: testing
+ Msg: "{\"verifier\":\"cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4\",\"beneficiary\":\"cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4\"}"
+ Funds:
+`,
+ },
+ "migrate contract": {
+ src: MigrateContractProposalFixture(),
+ exp: `Migrate Contract Proposal:
+ Title: Foo
+ Description: Bar
+ Contract: cosmos14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9s4hmalr
+ Code id: 1
+ Msg: "{\"verifier\":\"cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4\"}"
+`,
+ },
+ "update admin": {
+ src: UpdateAdminProposalFixture(),
+ exp: `Update Contract Admin Proposal:
+ Title: Foo
+ Description: Bar
+ Contract: cosmos14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9s4hmalr
+ New Admin: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4
+`,
+ },
+ "clear admin": {
+ src: ClearAdminProposalFixture(),
+ exp: `Clear Contract Admin Proposal:
+ Title: Foo
+ Description: Bar
+ Contract: cosmos14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9s4hmalr
+`,
+ },
+ "pin codes": {
+ src: &PinCodesProposal{
+ Title: "Foo",
+ Description: "Bar",
+ CodeIDs: []uint64{1, 2, 3},
+ },
+ exp: `Pin Wasm Codes Proposal:
+ Title: Foo
+ Description: Bar
+ Codes: [1 2 3]
+`,
+ },
+ "unpin codes": {
+ src: &UnpinCodesProposal{
+ Title: "Foo",
+ Description: "Bar",
+ CodeIDs: []uint64{3, 2, 1},
+ },
+ exp: `Unpin Wasm Codes Proposal:
+ Title: Foo
+ Description: Bar
+ Codes: [3 2 1]
+`,
+ },
+ }
+ for msg, spec := range specs {
+ t.Run(msg, func(t *testing.T) {
+ assert.Equal(t, spec.exp, spec.src.String())
+ })
+ }
+}
+
+func TestProposalYaml(t *testing.T) {
+ specs := map[string]struct {
+ src v1beta1.Content
+ exp string
+ }{
+ "store code": {
+ src: StoreCodeProposalFixture(func(p *StoreCodeProposal) {
+ p.WASMByteCode = []byte{0o1, 0o2, 0o3, 0o4, 0o5, 0o6, 0o7, 0x08, 0x09, 0x0a}
+ }),
+ exp: `title: Foo
+description: Bar
+run_as: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4
+wasm_byte_code: AQIDBAUGBwgJCg==
+instantiate_permission: null
+source: https://example.com/
+builder: cosmwasm/workspace-optimizer:v0.12.8
+code_hash: 6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d
+`,
+ },
+ "instantiate contract": {
+ src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) {
+ p.Funds = sdk.Coins{{Denom: "foo", Amount: sdk.NewInt(1)}, {Denom: "bar", Amount: sdk.NewInt(2)}}
+ }),
+ exp: `title: Foo
+description: Bar
+run_as: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4
+admin: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4
+code_id: 1
+label: testing
+msg: '{"verifier":"cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4","beneficiary":"cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4"}'
+funds:
+- denom: foo
+ amount: "1"
+- denom: bar
+ amount: "2"
+`,
+ },
+ "instantiate contract without funds": {
+ src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) { p.Funds = nil }),
+ exp: `title: Foo
+description: Bar
+run_as: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4
+admin: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4
+code_id: 1
+label: testing
+msg: '{"verifier":"cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4","beneficiary":"cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4"}'
+funds: []
+`,
+ },
+ "instantiate contract without admin": {
+ src: InstantiateContractProposalFixture(func(p *InstantiateContractProposal) { p.Admin = "" }),
+ exp: `title: Foo
+description: Bar
+run_as: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4
+admin: ""
+code_id: 1
+label: testing
+msg: '{"verifier":"cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4","beneficiary":"cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4"}'
+funds: []
+`,
+ },
+ "migrate contract": {
+ src: MigrateContractProposalFixture(),
+ exp: `title: Foo
+description: Bar
+contract: cosmos14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9s4hmalr
+code_id: 1
+msg: '{"verifier":"cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4"}'
+`,
+ },
+ "update admin": {
+ src: UpdateAdminProposalFixture(),
+ exp: `title: Foo
+description: Bar
+new_admin: cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4
+contract: cosmos14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9s4hmalr
+`,
+ },
+ "clear admin": {
+ src: ClearAdminProposalFixture(),
+ exp: `title: Foo
+description: Bar
+contract: cosmos14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9s4hmalr
+`,
+ },
+ "pin codes": {
+ src: &PinCodesProposal{
+ Title: "Foo",
+ Description: "Bar",
+ CodeIDs: []uint64{1, 2, 3},
+ },
+ exp: `title: Foo
+description: Bar
+code_ids:
+- 1
+- 2
+- 3
+`,
+ },
+ }
+ for msg, spec := range specs {
+ t.Run(msg, func(t *testing.T) {
+ v, err := yaml.Marshal(&spec.src) //nolint:gosec
+ require.NoError(t, err)
+ assert.Equal(t, spec.exp, string(v))
+ })
+ }
+}
+
+func TestConvertToProposals(t *testing.T) {
+ cases := map[string]struct {
+ input string
+ isError bool
+ proposals []ProposalType
+ }{
+ "one proper item": {
+ input: "UpdateAdmin",
+ proposals: []ProposalType{ProposalTypeUpdateAdmin},
+ },
+ "multiple proper items": {
+ input: "StoreCode,InstantiateContract,MigrateContract",
+ proposals: []ProposalType{ProposalTypeStoreCode, ProposalTypeInstantiateContract, ProposalTypeMigrateContract},
+ },
+ "empty trailing item": {
+ input: "StoreCode,",
+ isError: true,
+ },
+ "invalid item": {
+ input: "StoreCode,InvalidProposalType",
+ isError: true,
+ },
+ }
+
+ for name, tc := range cases {
+ t.Run(name, func(t *testing.T) {
+ chunks := strings.Split(tc.input, ",")
+ proposals, err := ConvertToProposals(chunks)
+ if tc.isError {
+ require.Error(t, err)
+ } else {
+ require.NoError(t, err)
+ require.Equal(t, proposals, tc.proposals)
+ }
+ })
+ }
+}
+
+func TestUnmarshalContentFromJson(t *testing.T) {
+ specs := map[string]struct {
+ src string
+ got v1beta1.Content
+ exp v1beta1.Content
+ }{
+ "instantiate ": {
+ src: `
+{
+ "title": "foo",
+ "description": "bar",
+ "admin": "myAdminAddress",
+ "code_id": 1,
+ "funds": [{"denom": "ALX", "amount": "2"},{"denom": "BLX","amount": "3"}],
+ "msg": {},
+ "label": "testing",
+ "run_as": "myRunAsAddress"
+}`,
+ got: &InstantiateContractProposal{},
+ exp: &InstantiateContractProposal{
+ Title: "foo",
+ Description: "bar",
+ RunAs: "myRunAsAddress",
+ Admin: "myAdminAddress",
+ CodeID: 1,
+ Label: "testing",
+ Msg: []byte("{}"),
+ Funds: sdk.NewCoins(sdk.NewCoin("ALX", sdk.NewInt(2)), sdk.NewCoin("BLX", sdk.NewInt(3))),
+ },
+ },
+ "migrate ": {
+ src: `
+{
+ "title": "foo",
+ "description": "bar",
+ "code_id": 1,
+ "contract": "myContractAddr",
+ "msg": {},
+ "run_as": "myRunAsAddress"
+}`,
+ got: &MigrateContractProposal{},
+ exp: &MigrateContractProposal{
+ Title: "foo",
+ Description: "bar",
+ Contract: "myContractAddr",
+ CodeID: 1,
+ Msg: []byte("{}"),
+ },
+ },
+ }
+ for name, spec := range specs {
+ t.Run(name, func(t *testing.T) {
+ require.NoError(t, json.Unmarshal([]byte(spec.src), spec.got))
+ assert.Equal(t, spec.exp, spec.got)
+ })
+ }
+}
+
+func TestProposalJsonSignBytes(t *testing.T) {
+ const myInnerMsg = `{"foo":"bar"}`
+ specs := map[string]struct {
+ src v1beta1.Content
+ exp string
+ }{
+ "instantiate contract": {
+ src: &InstantiateContractProposal{Msg: RawContractMessage(myInnerMsg)},
+ exp: `
+{
+ "type":"cosmos-sdk/MsgSubmitProposal",
+ "value":{"content":{"type":"wasm/InstantiateContractProposal","value":{"funds":[],"msg":{"foo":"bar"}}},"initial_deposit":[]}
+}`,
+ },
+ "migrate contract": {
+ src: &MigrateContractProposal{Msg: RawContractMessage(myInnerMsg)},
+ exp: `
+{
+ "type":"cosmos-sdk/MsgSubmitProposal",
+ "value":{"content":{"type":"wasm/MigrateContractProposal","value":{"msg":{"foo":"bar"}}},"initial_deposit":[]}
+}`,
+ },
+ }
+ for name, spec := range specs {
+ t.Run(name, func(t *testing.T) {
+ msg, err := v1beta1.NewMsgSubmitProposal(spec.src, sdk.NewCoins(), []byte{})
+ require.NoError(t, err)
+
+ bz := msg.GetSignBytes()
+ assert.JSONEq(t, spec.exp, string(bz), "exp %s\n got: %s\n", spec.exp, string(bz))
+ })
+ }
+}
diff --git a/x/wasm/types/test_fixtures.go b/x/wasm/types/test_fixtures.go
index 79892a68c2..7f021813d6 100644
--- a/x/wasm/types/test_fixtures.go
+++ b/x/wasm/types/test_fixtures.go
@@ -1,7 +1,10 @@
package types
import (
+ "bytes"
_ "embed"
+ "encoding/hex"
+ "encoding/json"
"math/rand"
wasmvm "github.com/CosmWasm/wasmvm"
@@ -199,3 +202,250 @@ func MsgExecuteContractFixture(mutators ...func(*MsgExecuteContract)) *MsgExecut
}
return r
}
+
+func StoreCodeProposalFixture(mutators ...func(*StoreCodeProposal)) *StoreCodeProposal {
+ const anyAddress = "cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4"
+ wasm := []byte{0x0}
+ // got the value from shell sha256sum
+ codeHash, err := hex.DecodeString("6E340B9CFFB37A989CA544E6BB780A2C78901D3FB33738768511A30617AFA01D")
+ if err != nil {
+ panic(err)
+ }
+
+ p := &StoreCodeProposal{
+ Title: "Foo",
+ Description: "Bar",
+ RunAs: anyAddress,
+ WASMByteCode: wasm,
+ Source: "https://example.com/",
+ Builder: "cosmwasm/workspace-optimizer:v0.12.8",
+ CodeHash: codeHash,
+ }
+ for _, m := range mutators {
+ m(p)
+ }
+ return p
+}
+
+func InstantiateContractProposalFixture(mutators ...func(p *InstantiateContractProposal)) *InstantiateContractProposal {
+ var (
+ anyValidAddress sdk.AccAddress = bytes.Repeat([]byte{0x1}, ContractAddrLen)
+
+ initMsg = struct {
+ Verifier sdk.AccAddress `json:"verifier"`
+ Beneficiary sdk.AccAddress `json:"beneficiary"`
+ }{
+ Verifier: anyValidAddress,
+ Beneficiary: anyValidAddress,
+ }
+ )
+ const anyAddress = "cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4"
+
+ initMsgBz, err := json.Marshal(initMsg)
+ if err != nil {
+ panic(err)
+ }
+ p := &InstantiateContractProposal{
+ Title: "Foo",
+ Description: "Bar",
+ RunAs: anyAddress,
+ Admin: anyAddress,
+ CodeID: 1,
+ Label: "testing",
+ Msg: initMsgBz,
+ Funds: nil,
+ }
+
+ for _, m := range mutators {
+ m(p)
+ }
+ return p
+}
+
+func InstantiateContract2ProposalFixture(mutators ...func(p *InstantiateContract2Proposal)) *InstantiateContract2Proposal {
+ var (
+ anyValidAddress sdk.AccAddress = bytes.Repeat([]byte{0x1}, ContractAddrLen)
+
+ initMsg = struct {
+ Verifier sdk.AccAddress `json:"verifier"`
+ Beneficiary sdk.AccAddress `json:"beneficiary"`
+ }{
+ Verifier: anyValidAddress,
+ Beneficiary: anyValidAddress,
+ }
+ )
+ const (
+ anyAddress = "cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4"
+ mySalt = "myDefaultSalt"
+ )
+
+ initMsgBz, err := json.Marshal(initMsg)
+ if err != nil {
+ panic(err)
+ }
+ p := &InstantiateContract2Proposal{
+ Title: "Foo",
+ Description: "Bar",
+ RunAs: anyAddress,
+ Admin: anyAddress,
+ CodeID: 1,
+ Label: "testing",
+ Msg: initMsgBz,
+ Funds: nil,
+ Salt: []byte(mySalt),
+ FixMsg: false,
+ }
+
+ for _, m := range mutators {
+ m(p)
+ }
+ return p
+}
+
+func StoreAndInstantiateContractProposalFixture(mutators ...func(p *StoreAndInstantiateContractProposal)) *StoreAndInstantiateContractProposal {
+ var (
+ anyValidAddress sdk.AccAddress = bytes.Repeat([]byte{0x1}, ContractAddrLen)
+
+ initMsg = struct {
+ Verifier sdk.AccAddress `json:"verifier"`
+ Beneficiary sdk.AccAddress `json:"beneficiary"`
+ }{
+ Verifier: anyValidAddress,
+ Beneficiary: anyValidAddress,
+ }
+ )
+ const anyAddress = "cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4"
+ wasm := []byte{0x0}
+ // got the value from shell sha256sum
+ codeHash, err := hex.DecodeString("6E340B9CFFB37A989CA544E6BB780A2C78901D3FB33738768511A30617AFA01D")
+ if err != nil {
+ panic(err)
+ }
+
+ initMsgBz, err := json.Marshal(initMsg)
+ if err != nil {
+ panic(err)
+ }
+ p := &StoreAndInstantiateContractProposal{
+ Title: "Foo",
+ Description: "Bar",
+ RunAs: anyAddress,
+ WASMByteCode: wasm,
+ Source: "https://example.com/",
+ Builder: "cosmwasm/workspace-optimizer:v0.12.9",
+ CodeHash: codeHash,
+ Admin: anyAddress,
+ Label: "testing",
+ Msg: initMsgBz,
+ Funds: nil,
+ }
+
+ for _, m := range mutators {
+ m(p)
+ }
+ return p
+}
+
+func MigrateContractProposalFixture(mutators ...func(p *MigrateContractProposal)) *MigrateContractProposal {
+ var (
+ anyValidAddress sdk.AccAddress = bytes.Repeat([]byte{0x1}, ContractAddrLen)
+
+ migMsg = struct {
+ Verifier sdk.AccAddress `json:"verifier"`
+ }{Verifier: anyValidAddress}
+ )
+
+ migMsgBz, err := json.Marshal(migMsg)
+ if err != nil {
+ panic(err)
+ }
+ const (
+ contractAddr = "cosmos14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9s4hmalr"
+ anyAddress = "cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4"
+ )
+ p := &MigrateContractProposal{
+ Title: "Foo",
+ Description: "Bar",
+ Contract: contractAddr,
+ CodeID: 1,
+ Msg: migMsgBz,
+ }
+
+ for _, m := range mutators {
+ m(p)
+ }
+ return p
+}
+
+func SudoContractProposalFixture(mutators ...func(p *SudoContractProposal)) *SudoContractProposal {
+ const (
+ contractAddr = "cosmos14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9s4hmalr"
+ )
+
+ p := &SudoContractProposal{
+ Title: "Foo",
+ Description: "Bar",
+ Contract: contractAddr,
+ Msg: []byte(`{"do":"something"}`),
+ }
+
+ for _, m := range mutators {
+ m(p)
+ }
+ return p
+}
+
+func ExecuteContractProposalFixture(mutators ...func(p *ExecuteContractProposal)) *ExecuteContractProposal {
+ const (
+ contractAddr = "cosmos14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9s4hmalr"
+ anyAddress = "cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4"
+ )
+
+ p := &ExecuteContractProposal{
+ Title: "Foo",
+ Description: "Bar",
+ Contract: contractAddr,
+ RunAs: anyAddress,
+ Msg: []byte(`{"do":"something"}`),
+ Funds: sdk.Coins{{
+ Denom: "stake",
+ Amount: sdk.NewInt(1),
+ }},
+ }
+
+ for _, m := range mutators {
+ m(p)
+ }
+ return p
+}
+
+func UpdateAdminProposalFixture(mutators ...func(p *UpdateAdminProposal)) *UpdateAdminProposal {
+ const (
+ contractAddr = "cosmos14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9s4hmalr"
+ anyAddress = "cosmos1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs2m6sx4"
+ )
+
+ p := &UpdateAdminProposal{
+ Title: "Foo",
+ Description: "Bar",
+ NewAdmin: anyAddress,
+ Contract: contractAddr,
+ }
+ for _, m := range mutators {
+ m(p)
+ }
+ return p
+}
+
+func ClearAdminProposalFixture(mutators ...func(p *ClearAdminProposal)) *ClearAdminProposal {
+ const contractAddr = "cosmos14hj2tavq8fpesdwxxcu44rty3hh90vhujrvcmstl4zr3txmfvw9s4hmalr"
+ p := &ClearAdminProposal{
+ Title: "Foo",
+ Description: "Bar",
+ Contract: contractAddr,
+ }
+ for _, m := range mutators {
+ m(p)
+ }
+ return p
+}
diff --git a/x/wasm/types/tx.pb.go b/x/wasm/types/tx.pb.go
index 40ae2a613c..aee5c4869d 100644
--- a/x/wasm/types/tx.pb.go
+++ b/x/wasm/types/tx.pb.go
@@ -703,53 +703,6 @@ func (m *MsgClearAdminResponse) XXX_DiscardUnknown() {
var xxx_messageInfo_MsgClearAdminResponse proto.InternalMessageInfo
-// AccessConfigUpdate contains the code id and the access config to be
-// applied.
-type AccessConfigUpdate struct {
- // CodeID is the reference to the stored WASM code to be updated
- CodeID uint64 `protobuf:"varint,1,opt,name=code_id,json=codeId,proto3" json:"code_id,omitempty"`
- // InstantiatePermission to apply to the set of code ids
- InstantiatePermission AccessConfig `protobuf:"bytes,2,opt,name=instantiate_permission,json=instantiatePermission,proto3" json:"instantiate_permission"`
-}
-
-func (m *AccessConfigUpdate) Reset() { *m = AccessConfigUpdate{} }
-func (m *AccessConfigUpdate) String() string { return proto.CompactTextString(m) }
-func (*AccessConfigUpdate) ProtoMessage() {}
-func (*AccessConfigUpdate) Descriptor() ([]byte, []int) {
- return fileDescriptor_4f74d82755520264, []int{14}
-}
-
-func (m *AccessConfigUpdate) XXX_Unmarshal(b []byte) error {
- return m.Unmarshal(b)
-}
-
-func (m *AccessConfigUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- if deterministic {
- return xxx_messageInfo_AccessConfigUpdate.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 *AccessConfigUpdate) XXX_Merge(src proto.Message) {
- xxx_messageInfo_AccessConfigUpdate.Merge(m, src)
-}
-
-func (m *AccessConfigUpdate) XXX_Size() int {
- return m.Size()
-}
-
-func (m *AccessConfigUpdate) XXX_DiscardUnknown() {
- xxx_messageInfo_AccessConfigUpdate.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_AccessConfigUpdate proto.InternalMessageInfo
-
// MsgUpdateInstantiateConfig updates instantiate config for a smart contract
type MsgUpdateInstantiateConfig struct {
// Sender is the that actor that signed the messages
@@ -764,7 +717,7 @@ func (m *MsgUpdateInstantiateConfig) Reset() { *m = MsgUpdateInstantiate
func (m *MsgUpdateInstantiateConfig) String() string { return proto.CompactTextString(m) }
func (*MsgUpdateInstantiateConfig) ProtoMessage() {}
func (*MsgUpdateInstantiateConfig) Descriptor() ([]byte, []int) {
- return fileDescriptor_4f74d82755520264, []int{15}
+ return fileDescriptor_4f74d82755520264, []int{14}
}
func (m *MsgUpdateInstantiateConfig) XXX_Unmarshal(b []byte) error {
@@ -805,7 +758,7 @@ func (m *MsgUpdateInstantiateConfigResponse) Reset() { *m = MsgUpdateIns
func (m *MsgUpdateInstantiateConfigResponse) String() string { return proto.CompactTextString(m) }
func (*MsgUpdateInstantiateConfigResponse) ProtoMessage() {}
func (*MsgUpdateInstantiateConfigResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_4f74d82755520264, []int{16}
+ return fileDescriptor_4f74d82755520264, []int{15}
}
func (m *MsgUpdateInstantiateConfigResponse) XXX_Unmarshal(b []byte) error {
@@ -855,7 +808,7 @@ func (m *MsgUpdateParams) Reset() { *m = MsgUpdateParams{} }
func (m *MsgUpdateParams) String() string { return proto.CompactTextString(m) }
func (*MsgUpdateParams) ProtoMessage() {}
func (*MsgUpdateParams) Descriptor() ([]byte, []int) {
- return fileDescriptor_4f74d82755520264, []int{17}
+ return fileDescriptor_4f74d82755520264, []int{16}
}
func (m *MsgUpdateParams) XXX_Unmarshal(b []byte) error {
@@ -899,7 +852,7 @@ func (m *MsgUpdateParamsResponse) Reset() { *m = MsgUpdateParamsResponse
func (m *MsgUpdateParamsResponse) String() string { return proto.CompactTextString(m) }
func (*MsgUpdateParamsResponse) ProtoMessage() {}
func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_4f74d82755520264, []int{18}
+ return fileDescriptor_4f74d82755520264, []int{17}
}
func (m *MsgUpdateParamsResponse) XXX_Unmarshal(b []byte) error {
@@ -949,7 +902,7 @@ func (m *MsgSudoContract) Reset() { *m = MsgSudoContract{} }
func (m *MsgSudoContract) String() string { return proto.CompactTextString(m) }
func (*MsgSudoContract) ProtoMessage() {}
func (*MsgSudoContract) Descriptor() ([]byte, []int) {
- return fileDescriptor_4f74d82755520264, []int{19}
+ return fileDescriptor_4f74d82755520264, []int{18}
}
func (m *MsgSudoContract) XXX_Unmarshal(b []byte) error {
@@ -996,7 +949,7 @@ func (m *MsgSudoContractResponse) Reset() { *m = MsgSudoContractResponse
func (m *MsgSudoContractResponse) String() string { return proto.CompactTextString(m) }
func (*MsgSudoContractResponse) ProtoMessage() {}
func (*MsgSudoContractResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_4f74d82755520264, []int{20}
+ return fileDescriptor_4f74d82755520264, []int{19}
}
func (m *MsgSudoContractResponse) XXX_Unmarshal(b []byte) error {
@@ -1044,7 +997,7 @@ func (m *MsgPinCodes) Reset() { *m = MsgPinCodes{} }
func (m *MsgPinCodes) String() string { return proto.CompactTextString(m) }
func (*MsgPinCodes) ProtoMessage() {}
func (*MsgPinCodes) Descriptor() ([]byte, []int) {
- return fileDescriptor_4f74d82755520264, []int{21}
+ return fileDescriptor_4f74d82755520264, []int{20}
}
func (m *MsgPinCodes) XXX_Unmarshal(b []byte) error {
@@ -1088,7 +1041,7 @@ func (m *MsgPinCodesResponse) Reset() { *m = MsgPinCodesResponse{} }
func (m *MsgPinCodesResponse) String() string { return proto.CompactTextString(m) }
func (*MsgPinCodesResponse) ProtoMessage() {}
func (*MsgPinCodesResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_4f74d82755520264, []int{22}
+ return fileDescriptor_4f74d82755520264, []int{21}
}
func (m *MsgPinCodesResponse) XXX_Unmarshal(b []byte) error {
@@ -1136,7 +1089,7 @@ func (m *MsgUnpinCodes) Reset() { *m = MsgUnpinCodes{} }
func (m *MsgUnpinCodes) String() string { return proto.CompactTextString(m) }
func (*MsgUnpinCodes) ProtoMessage() {}
func (*MsgUnpinCodes) Descriptor() ([]byte, []int) {
- return fileDescriptor_4f74d82755520264, []int{23}
+ return fileDescriptor_4f74d82755520264, []int{22}
}
func (m *MsgUnpinCodes) XXX_Unmarshal(b []byte) error {
@@ -1180,7 +1133,7 @@ func (m *MsgUnpinCodesResponse) Reset() { *m = MsgUnpinCodesResponse{} }
func (m *MsgUnpinCodesResponse) String() string { return proto.CompactTextString(m) }
func (*MsgUnpinCodesResponse) ProtoMessage() {}
func (*MsgUnpinCodesResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_4f74d82755520264, []int{24}
+ return fileDescriptor_4f74d82755520264, []int{23}
}
func (m *MsgUnpinCodesResponse) XXX_Unmarshal(b []byte) error {
@@ -1251,7 +1204,7 @@ func (m *MsgStoreAndInstantiateContract) Reset() { *m = MsgStoreAndInsta
func (m *MsgStoreAndInstantiateContract) String() string { return proto.CompactTextString(m) }
func (*MsgStoreAndInstantiateContract) ProtoMessage() {}
func (*MsgStoreAndInstantiateContract) Descriptor() ([]byte, []int) {
- return fileDescriptor_4f74d82755520264, []int{25}
+ return fileDescriptor_4f74d82755520264, []int{24}
}
func (m *MsgStoreAndInstantiateContract) XXX_Unmarshal(b []byte) error {
@@ -1302,7 +1255,7 @@ func (m *MsgStoreAndInstantiateContractResponse) Reset() {
func (m *MsgStoreAndInstantiateContractResponse) String() string { return proto.CompactTextString(m) }
func (*MsgStoreAndInstantiateContractResponse) ProtoMessage() {}
func (*MsgStoreAndInstantiateContractResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_4f74d82755520264, []int{26}
+ return fileDescriptor_4f74d82755520264, []int{25}
}
func (m *MsgStoreAndInstantiateContractResponse) XXX_Unmarshal(b []byte) error {
@@ -1348,7 +1301,7 @@ func (m *MsgAddCodeUploadParamsAddresses) Reset() { *m = MsgAddCodeUploa
func (m *MsgAddCodeUploadParamsAddresses) String() string { return proto.CompactTextString(m) }
func (*MsgAddCodeUploadParamsAddresses) ProtoMessage() {}
func (*MsgAddCodeUploadParamsAddresses) Descriptor() ([]byte, []int) {
- return fileDescriptor_4f74d82755520264, []int{27}
+ return fileDescriptor_4f74d82755520264, []int{26}
}
func (m *MsgAddCodeUploadParamsAddresses) XXX_Unmarshal(b []byte) error {
@@ -1392,7 +1345,7 @@ func (m *MsgAddCodeUploadParamsAddressesResponse) Reset() {
func (m *MsgAddCodeUploadParamsAddressesResponse) String() string { return proto.CompactTextString(m) }
func (*MsgAddCodeUploadParamsAddressesResponse) ProtoMessage() {}
func (*MsgAddCodeUploadParamsAddressesResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_4f74d82755520264, []int{28}
+ return fileDescriptor_4f74d82755520264, []int{27}
}
func (m *MsgAddCodeUploadParamsAddressesResponse) XXX_Unmarshal(b []byte) error {
@@ -1438,7 +1391,7 @@ func (m *MsgRemoveCodeUploadParamsAddresses) Reset() { *m = MsgRemoveCod
func (m *MsgRemoveCodeUploadParamsAddresses) String() string { return proto.CompactTextString(m) }
func (*MsgRemoveCodeUploadParamsAddresses) ProtoMessage() {}
func (*MsgRemoveCodeUploadParamsAddresses) Descriptor() ([]byte, []int) {
- return fileDescriptor_4f74d82755520264, []int{29}
+ return fileDescriptor_4f74d82755520264, []int{28}
}
func (m *MsgRemoveCodeUploadParamsAddresses) XXX_Unmarshal(b []byte) error {
@@ -1485,7 +1438,7 @@ func (m *MsgRemoveCodeUploadParamsAddressesResponse) String() string {
}
func (*MsgRemoveCodeUploadParamsAddressesResponse) ProtoMessage() {}
func (*MsgRemoveCodeUploadParamsAddressesResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_4f74d82755520264, []int{30}
+ return fileDescriptor_4f74d82755520264, []int{29}
}
func (m *MsgRemoveCodeUploadParamsAddressesResponse) XXX_Unmarshal(b []byte) error {
@@ -1540,7 +1493,7 @@ func (m *MsgStoreAndMigrateContract) Reset() { *m = MsgStoreAndMigrateCo
func (m *MsgStoreAndMigrateContract) String() string { return proto.CompactTextString(m) }
func (*MsgStoreAndMigrateContract) ProtoMessage() {}
func (*MsgStoreAndMigrateContract) Descriptor() ([]byte, []int) {
- return fileDescriptor_4f74d82755520264, []int{31}
+ return fileDescriptor_4f74d82755520264, []int{30}
}
func (m *MsgStoreAndMigrateContract) XXX_Unmarshal(b []byte) error {
@@ -1591,7 +1544,7 @@ func (m *MsgStoreAndMigrateContractResponse) Reset() { *m = MsgStoreAndM
func (m *MsgStoreAndMigrateContractResponse) String() string { return proto.CompactTextString(m) }
func (*MsgStoreAndMigrateContractResponse) ProtoMessage() {}
func (*MsgStoreAndMigrateContractResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_4f74d82755520264, []int{32}
+ return fileDescriptor_4f74d82755520264, []int{31}
}
func (m *MsgStoreAndMigrateContractResponse) XXX_Unmarshal(b []byte) error {
@@ -1639,7 +1592,7 @@ func (m *MsgUpdateContractLabel) Reset() { *m = MsgUpdateContractLabel{}
func (m *MsgUpdateContractLabel) String() string { return proto.CompactTextString(m) }
func (*MsgUpdateContractLabel) ProtoMessage() {}
func (*MsgUpdateContractLabel) Descriptor() ([]byte, []int) {
- return fileDescriptor_4f74d82755520264, []int{33}
+ return fileDescriptor_4f74d82755520264, []int{32}
}
func (m *MsgUpdateContractLabel) XXX_Unmarshal(b []byte) error {
@@ -1680,7 +1633,7 @@ func (m *MsgUpdateContractLabelResponse) Reset() { *m = MsgUpdateContrac
func (m *MsgUpdateContractLabelResponse) String() string { return proto.CompactTextString(m) }
func (*MsgUpdateContractLabelResponse) ProtoMessage() {}
func (*MsgUpdateContractLabelResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_4f74d82755520264, []int{34}
+ return fileDescriptor_4f74d82755520264, []int{33}
}
func (m *MsgUpdateContractLabelResponse) XXX_Unmarshal(b []byte) error {
@@ -1729,7 +1682,6 @@ func init() {
proto.RegisterType((*MsgUpdateAdminResponse)(nil), "cosmwasm.wasm.v1.MsgUpdateAdminResponse")
proto.RegisterType((*MsgClearAdmin)(nil), "cosmwasm.wasm.v1.MsgClearAdmin")
proto.RegisterType((*MsgClearAdminResponse)(nil), "cosmwasm.wasm.v1.MsgClearAdminResponse")
- proto.RegisterType((*AccessConfigUpdate)(nil), "cosmwasm.wasm.v1.AccessConfigUpdate")
proto.RegisterType((*MsgUpdateInstantiateConfig)(nil), "cosmwasm.wasm.v1.MsgUpdateInstantiateConfig")
proto.RegisterType((*MsgUpdateInstantiateConfigResponse)(nil), "cosmwasm.wasm.v1.MsgUpdateInstantiateConfigResponse")
proto.RegisterType((*MsgUpdateParams)(nil), "cosmwasm.wasm.v1.MsgUpdateParams")
@@ -1755,115 +1707,114 @@ func init() {
func init() { proto.RegisterFile("cosmwasm/wasm/v1/tx.proto", fileDescriptor_4f74d82755520264) }
var fileDescriptor_4f74d82755520264 = []byte{
- // 1724 bytes of a gzipped FileDescriptorProto
- 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x19, 0x4d, 0x6c, 0x1b, 0xc5,
- 0x3a, 0x1b, 0x3b, 0x8e, 0x3d, 0xc9, 0x6b, 0xd3, 0xad, 0x9b, 0x38, 0xdb, 0xd6, 0x76, 0xb7, 0x3f,
- 0x71, 0xf3, 0x52, 0x3b, 0xf1, 0xeb, 0xeb, 0x7b, 0x35, 0x5c, 0xe2, 0x14, 0x89, 0x54, 0x18, 0xa2,
- 0x8d, 0xd2, 0x0a, 0x54, 0xc9, 0xac, 0xbd, 0x93, 0xcd, 0xaa, 0xde, 0x5d, 0xe3, 0x59, 0xe7, 0xe7,
- 0xc0, 0x05, 0x24, 0x24, 0x10, 0x07, 0x2e, 0x9c, 0x38, 0x23, 0x01, 0x17, 0x7a, 0xe0, 0xc0, 0xb1,
- 0x27, 0x54, 0x01, 0x42, 0x15, 0x27, 0x2e, 0x18, 0x48, 0x91, 0xca, 0x0d, 0xa9, 0x47, 0x4e, 0x68,
- 0x67, 0x76, 0xd7, 0xe3, 0xf5, 0xec, 0xda, 0x49, 0x5a, 0x81, 0xc4, 0x25, 0xd9, 0x99, 0xf9, 0xbe,
- 0x6f, 0xbe, 0xff, 0x9f, 0x31, 0x98, 0xad, 0x9b, 0x48, 0xdf, 0x91, 0x91, 0x5e, 0xc0, 0x7f, 0xb6,
- 0x97, 0x0a, 0xd6, 0x6e, 0xbe, 0xd9, 0x32, 0x2d, 0x93, 0x9f, 0x72, 0x8f, 0xf2, 0xf8, 0xcf, 0xf6,
- 0x92, 0x90, 0xb6, 0x77, 0x4c, 0x54, 0xa8, 0xc9, 0x08, 0x16, 0xb6, 0x97, 0x6a, 0xd0, 0x92, 0x97,
- 0x0a, 0x75, 0x53, 0x33, 0x08, 0x86, 0x30, 0xe3, 0x9c, 0xeb, 0x48, 0xb5, 0x29, 0xe9, 0x48, 0x75,
- 0x0e, 0x92, 0xaa, 0xa9, 0x9a, 0xf8, 0xb3, 0x60, 0x7f, 0x39, 0xbb, 0x67, 0xfa, 0xef, 0xde, 0x6b,
- 0x42, 0xe4, 0x9c, 0xce, 0x12, 0x62, 0x55, 0x82, 0x46, 0x16, 0xce, 0xd1, 0x09, 0x59, 0xd7, 0x0c,
- 0xb3, 0x80, 0xff, 0x92, 0x2d, 0xf1, 0x57, 0x0e, 0x4c, 0x56, 0x90, 0xba, 0x6e, 0x99, 0x2d, 0xb8,
- 0x62, 0x2a, 0x90, 0x9f, 0x06, 0x31, 0x04, 0x0d, 0x05, 0xb6, 0x52, 0x5c, 0x96, 0xcb, 0x25, 0x24,
- 0x67, 0xc5, 0x5f, 0x03, 0xc7, 0xec, 0xdb, 0xaa, 0xb5, 0x3d, 0x0b, 0x56, 0xeb, 0xa6, 0x02, 0x53,
- 0xa3, 0x59, 0x2e, 0x37, 0x59, 0x9e, 0xda, 0xef, 0x64, 0x26, 0x6f, 0x2f, 0xaf, 0x57, 0xca, 0x7b,
- 0x16, 0xa6, 0x20, 0x4d, 0xda, 0x70, 0xee, 0x8a, 0xdf, 0x00, 0xd3, 0x9a, 0x81, 0x2c, 0xd9, 0xb0,
- 0x34, 0xd9, 0x82, 0xd5, 0x26, 0x6c, 0xe9, 0x1a, 0x42, 0x9a, 0x69, 0xa4, 0xc6, 0xb2, 0x5c, 0x6e,
- 0xa2, 0x98, 0xce, 0xfb, 0xd5, 0x95, 0x5f, 0xae, 0xd7, 0x21, 0x42, 0x2b, 0xa6, 0xb1, 0xa9, 0xa9,
- 0xd2, 0x29, 0x0a, 0x7b, 0xcd, 0x43, 0x2e, 0x9d, 0x7b, 0xeb, 0xf1, 0xbd, 0x79, 0x87, 0xb7, 0xf7,
- 0x1e, 0xdf, 0x9b, 0x3f, 0x81, 0x55, 0x41, 0x4b, 0x72, 0x33, 0x1a, 0x8f, 0x4c, 0x45, 0x6f, 0x46,
- 0xe3, 0xd1, 0xa9, 0x31, 0xf1, 0x36, 0x48, 0xd2, 0x67, 0x12, 0x44, 0x4d, 0xd3, 0x40, 0x90, 0x3f,
- 0x0f, 0xc6, 0x6d, 0x59, 0xaa, 0x9a, 0x82, 0xc5, 0x8d, 0x96, 0xc1, 0x7e, 0x27, 0x13, 0xb3, 0x41,
- 0x56, 0x6f, 0x48, 0x31, 0xfb, 0x68, 0x55, 0xe1, 0x05, 0x10, 0xaf, 0x6f, 0xc1, 0xfa, 0x5d, 0xd4,
- 0xd6, 0x89, 0xd0, 0x92, 0xb7, 0x16, 0xef, 0x8f, 0x82, 0xe9, 0x0a, 0x52, 0x57, 0xbb, 0x4c, 0xae,
- 0x98, 0x86, 0xd5, 0x92, 0xeb, 0x56, 0xa0, 0x26, 0x93, 0x60, 0x4c, 0x56, 0x74, 0xcd, 0xc0, 0xb4,
- 0x12, 0x12, 0x59, 0xd0, 0x9c, 0x44, 0x02, 0x39, 0x49, 0x82, 0xb1, 0x86, 0x5c, 0x83, 0x8d, 0x54,
- 0x94, 0xa0, 0xe2, 0x05, 0x9f, 0x03, 0x11, 0x1d, 0xa9, 0x58, 0x9f, 0x93, 0xe5, 0xe9, 0x3f, 0x3a,
- 0x19, 0x5e, 0x92, 0x77, 0x5c, 0x36, 0x2a, 0x10, 0x21, 0x59, 0x85, 0x92, 0x0d, 0xc2, 0x6f, 0x82,
- 0xb1, 0xcd, 0xb6, 0xa1, 0xa0, 0x54, 0x2c, 0x1b, 0xc9, 0x4d, 0x14, 0x67, 0xf3, 0x8e, 0x7b, 0xd8,
- 0x8e, 0x99, 0x77, 0x1c, 0x33, 0xbf, 0x62, 0x6a, 0x46, 0xf9, 0xbf, 0x0f, 0x3a, 0x99, 0x91, 0xcf,
- 0x7e, 0xca, 0xe4, 0x54, 0xcd, 0xda, 0x6a, 0xd7, 0xf2, 0x75, 0x53, 0x77, 0x7c, 0xc9, 0xf9, 0x77,
- 0x05, 0x29, 0x77, 0x1d, 0xbf, 0xb3, 0x11, 0xd0, 0x27, 0x8f, 0xef, 0xcd, 0x73, 0x12, 0x21, 0x5f,
- 0xfa, 0xb7, 0xcf, 0x3a, 0xa7, 0x5d, 0xeb, 0x30, 0xf4, 0x24, 0xbe, 0x0c, 0xd2, 0xec, 0x13, 0xcf,
- 0x4a, 0x29, 0x30, 0x2e, 0x2b, 0x4a, 0x0b, 0x22, 0xe4, 0xa8, 0xd2, 0x5d, 0xf2, 0x3c, 0x88, 0x2a,
- 0xb2, 0x25, 0x3b, 0x66, 0xc1, 0xdf, 0xe2, 0xef, 0xa3, 0x60, 0x86, 0x4d, 0xb0, 0xf8, 0x0f, 0xb6,
- 0x89, 0xad, 0x2a, 0x24, 0x37, 0xac, 0xd4, 0x38, 0x51, 0x95, 0xfd, 0xcd, 0xcf, 0x80, 0xf1, 0x4d,
- 0x6d, 0xb7, 0x6a, 0x73, 0x1a, 0xcf, 0x72, 0xb9, 0xb8, 0x14, 0xdb, 0xd4, 0x76, 0x2b, 0x48, 0x2d,
- 0x2d, 0xf8, 0x0c, 0x78, 0x26, 0xc4, 0x80, 0x45, 0xf1, 0x15, 0x90, 0x09, 0x38, 0x3a, 0xa4, 0x09,
- 0xdf, 0x1e, 0x05, 0x7c, 0x05, 0xa9, 0x2f, 0xec, 0xc2, 0x7a, 0x7b, 0x88, 0x88, 0xb2, 0x03, 0xd4,
- 0x81, 0x71, 0x0c, 0xe8, 0xad, 0x5d, 0x43, 0x44, 0x0e, 0x60, 0x88, 0xb1, 0x67, 0x1b, 0x1c, 0x73,
- 0x3e, 0xdd, 0xce, 0xb8, 0xba, 0xf5, 0x89, 0x2b, 0x2e, 0x02, 0xa1, 0x7f, 0xd7, 0xd3, 0xa8, 0xab,
- 0x37, 0x8e, 0xd2, 0xdb, 0x7d, 0x0e, 0xeb, 0xad, 0xa2, 0xa9, 0x2d, 0xf9, 0x88, 0x7a, 0x1b, 0xca,
- 0xf7, 0x1d, 0xe5, 0x46, 0x07, 0x2a, 0x37, 0x58, 0x68, 0x1f, 0xaf, 0x8e, 0xd0, 0xbe, 0xdd, 0x50,
- 0xa1, 0xdf, 0xe1, 0xc0, 0xb1, 0x0a, 0x52, 0x37, 0x9a, 0x8a, 0x6c, 0xc1, 0x65, 0x1c, 0xb8, 0x41,
- 0x02, 0x9f, 0x06, 0x09, 0x03, 0xee, 0x54, 0xe9, 0x50, 0x8f, 0x1b, 0x70, 0x87, 0x20, 0xd1, 0xda,
- 0x88, 0xf4, 0x6a, 0xa3, 0x74, 0xde, 0xc7, 0xfe, 0x49, 0x97, 0x7d, 0xea, 0x56, 0x31, 0x85, 0x4b,
- 0x01, 0xb5, 0xe3, 0xb2, 0x2d, 0xaa, 0xe0, 0x5f, 0x15, 0xa4, 0xae, 0x34, 0xa0, 0xdc, 0x0a, 0x67,
- 0x30, 0x8c, 0x07, 0xd1, 0xc7, 0x03, 0xef, 0xf2, 0xd0, 0xa5, 0x2b, 0xce, 0x80, 0x53, 0x3d, 0x1b,
- 0x1e, 0x07, 0x1f, 0x71, 0x80, 0xa7, 0xeb, 0x2a, 0xe1, 0x72, 0xb8, 0xfa, 0xf7, 0x7a, 0x60, 0x09,
- 0x1f, 0x1d, 0xa6, 0x84, 0x97, 0x13, 0x76, 0xb8, 0x90, 0x10, 0x60, 0x57, 0x73, 0xf1, 0x37, 0x0e,
- 0x5b, 0x9d, 0x30, 0xd5, 0x9b, 0x47, 0x36, 0x35, 0x35, 0x50, 0x5b, 0x14, 0xf7, 0xa3, 0x81, 0xdc,
- 0xdf, 0x01, 0x82, 0x6d, 0xf3, 0x00, 0x09, 0x22, 0x43, 0x35, 0x21, 0x29, 0x03, 0xee, 0xac, 0x32,
- 0xfb, 0x90, 0x82, 0xcf, 0x28, 0x99, 0x5e, 0xc7, 0xe8, 0x93, 0x45, 0xbc, 0x00, 0xc4, 0xe0, 0x53,
- 0xcf, 0x5c, 0x9f, 0x73, 0xe0, 0xb8, 0x07, 0xb6, 0x26, 0xb7, 0x64, 0x1d, 0xf1, 0xd7, 0x40, 0x42,
- 0x6e, 0x5b, 0x5b, 0x66, 0x4b, 0xb3, 0xf6, 0x88, 0x22, 0xca, 0xa9, 0xef, 0xbf, 0xb8, 0x92, 0x74,
- 0xd2, 0xd4, 0x32, 0xc9, 0xa7, 0xeb, 0x56, 0x4b, 0x33, 0x54, 0xa9, 0x0b, 0xca, 0x3f, 0x07, 0x62,
- 0x4d, 0x4c, 0xc1, 0x31, 0x57, 0xaa, 0x5f, 0x58, 0x72, 0x03, 0x6d, 0x28, 0x07, 0x85, 0xc4, 0x6d,
- 0x97, 0x98, 0x2d, 0x62, 0xb2, 0x57, 0x44, 0x82, 0x2b, 0xce, 0xe2, 0xa2, 0x4b, 0x6f, 0x79, 0xc2,
- 0x7c, 0x49, 0x84, 0x59, 0x6f, 0x2b, 0xa6, 0x97, 0x92, 0x0e, 0x2b, 0xcc, 0x53, 0x49, 0xf5, 0xa1,
- 0x52, 0xd1, 0x6c, 0x8a, 0x57, 0xb0, 0x54, 0xf4, 0x56, 0x68, 0x2a, 0xfa, 0x98, 0x03, 0x13, 0x15,
- 0xa4, 0xae, 0x69, 0x86, 0xed, 0x84, 0x87, 0x37, 0xd9, 0x75, 0x5b, 0x4a, 0xec, 0xd8, 0xb6, 0xd1,
- 0x22, 0xb9, 0x68, 0x39, 0xbd, 0xdf, 0xc9, 0x8c, 0x13, 0xcf, 0x46, 0x4f, 0x3a, 0x99, 0xe3, 0x7b,
- 0xb2, 0xde, 0x28, 0x89, 0x2e, 0x90, 0x28, 0x8d, 0x13, 0x6f, 0x47, 0x24, 0x53, 0xf5, 0x8a, 0x36,
- 0xe5, 0x8a, 0xe6, 0xf2, 0x25, 0x9e, 0x02, 0x27, 0xa9, 0xa5, 0x67, 0xa8, 0x4f, 0x39, 0x9c, 0xa7,
- 0x36, 0x8c, 0xe6, 0x5f, 0x28, 0xc0, 0xc5, 0x7e, 0x01, 0xbc, 0x4c, 0xd7, 0xe5, 0xcc, 0xc9, 0x74,
- 0xdd, 0x0d, 0x4f, 0x88, 0x6f, 0xa2, 0xb8, 0x9f, 0xc4, 0xbd, 0xfe, 0xb2, 0xa1, 0xb0, 0x3a, 0xf3,
- 0xc3, 0x4a, 0xd5, 0x3f, 0x03, 0x45, 0x8e, 0x38, 0x03, 0x45, 0x8f, 0x30, 0x03, 0xf1, 0x67, 0x01,
- 0x68, 0xdb, 0xf2, 0x13, 0x56, 0xc6, 0x70, 0x03, 0x97, 0x68, 0xbb, 0x1a, 0xe9, 0xf6, 0xb4, 0x31,
- 0xba, 0xa7, 0xf5, 0xda, 0xd5, 0x71, 0x46, 0xbb, 0x1a, 0x3f, 0x40, 0x97, 0x94, 0x78, 0xb6, 0xed,
- 0xaa, 0x9d, 0xf3, 0xcd, 0x76, 0xab, 0x0e, 0x53, 0xc0, 0xc9, 0xf9, 0x78, 0x65, 0x37, 0x92, 0xb5,
- 0xb6, 0xd6, 0xb0, 0x8b, 0xc1, 0x04, 0x69, 0x24, 0x9d, 0xa5, 0x5d, 0xdc, 0xb1, 0x3b, 0x6d, 0xc9,
- 0x68, 0x2b, 0x35, 0xe9, 0xcc, 0x69, 0xa6, 0x02, 0x5f, 0x94, 0xd1, 0x56, 0xe9, 0x5a, 0xbf, 0x57,
- 0x9d, 0xef, 0x19, 0x19, 0xd9, 0xae, 0x22, 0xde, 0x02, 0x97, 0xc2, 0x21, 0x0e, 0xd9, 0xe1, 0x7e,
- 0xc5, 0xe1, 0x9e, 0x79, 0x59, 0x51, 0x6c, 0x5b, 0x6d, 0x34, 0x1b, 0xa6, 0xac, 0x90, 0xb4, 0xe9,
- 0x78, 0xdf, 0x11, 0x82, 0xaf, 0x08, 0x12, 0xb2, 0x4b, 0x04, 0x47, 0x5f, 0xa2, 0x9c, 0x7c, 0xd2,
- 0xc9, 0x4c, 0x91, 0x90, 0xf3, 0x8e, 0x44, 0xa9, 0x0b, 0x56, 0xfa, 0x5f, 0xbf, 0x7e, 0x2e, 0xb8,
- 0xfa, 0x09, 0x63, 0x52, 0xbc, 0x0c, 0xe6, 0x06, 0x80, 0x78, 0x91, 0xf9, 0x2d, 0x87, 0x6b, 0x9f,
- 0x04, 0x75, 0x73, 0x1b, 0xfe, 0x3d, 0xc4, 0x2e, 0xf5, 0x8b, 0x3d, 0xe7, 0x8a, 0x3d, 0x80, 0x4f,
- 0x71, 0x01, 0xcc, 0x0f, 0x86, 0xf2, 0x84, 0xff, 0x71, 0x14, 0xb7, 0x38, 0xae, 0x27, 0xf9, 0x5b,
- 0xf4, 0xa7, 0x97, 0x92, 0x8e, 0xfa, 0x2c, 0x13, 0x39, 0x4a, 0x4a, 0xa2, 0xcb, 0x73, 0x94, 0x5d,
- 0x9e, 0x07, 0x8f, 0xc4, 0xa5, 0x62, 0xbf, 0x55, 0x32, 0xfe, 0x60, 0xf5, 0xcf, 0x0d, 0x7b, 0xd8,
- 0xb7, 0x02, 0x4e, 0x9f, 0xda, 0x7b, 0x8f, 0x17, 0xcb, 0x11, 0x2a, 0x96, 0xbf, 0xe6, 0xa8, 0xc6,
- 0xdf, 0xbd, 0xf2, 0x25, 0x9c, 0x57, 0x17, 0x7b, 0x3b, 0xd7, 0x10, 0x9b, 0xfa, 0x46, 0x14, 0x92,
- 0xa3, 0xbb, 0x23, 0x0a, 0x21, 0x77, 0xd5, 0x3f, 0x1e, 0x84, 0x10, 0xec, 0x0e, 0x0e, 0x81, 0xaf,
- 0x31, 0x0c, 0x8e, 0xc5, 0x2c, 0xae, 0x9e, 0x8c, 0x13, 0x57, 0x87, 0xc5, 0xef, 0x8e, 0x81, 0x48,
- 0x05, 0xa9, 0xfc, 0x3a, 0x48, 0x74, 0x9f, 0x0d, 0x19, 0xfe, 0x42, 0x3f, 0xb8, 0x09, 0x97, 0xc2,
- 0xcf, 0x3d, 0x03, 0xbd, 0x01, 0x4e, 0xb2, 0x2a, 0x76, 0x8e, 0x89, 0xce, 0x80, 0x14, 0x16, 0x87,
- 0x85, 0xf4, 0xae, 0xb4, 0x40, 0x92, 0xf9, 0x56, 0x74, 0x79, 0x58, 0x4a, 0x45, 0x61, 0x69, 0x68,
- 0x50, 0xef, 0x56, 0x08, 0x8e, 0xfb, 0x9f, 0x37, 0x2e, 0x30, 0xa9, 0xf8, 0xa0, 0x84, 0x85, 0x61,
- 0xa0, 0xe8, 0x6b, 0xfc, 0xa9, 0x86, 0x7d, 0x8d, 0x0f, 0x2a, 0xe0, 0x9a, 0xa0, 0xb8, 0x7a, 0x15,
- 0x4c, 0xd0, 0xf3, 0x77, 0x96, 0x89, 0x4c, 0x41, 0x08, 0xb9, 0x41, 0x10, 0x1e, 0xe9, 0x5b, 0x00,
- 0x50, 0x83, 0x73, 0x86, 0x89, 0xd7, 0x05, 0x10, 0xe6, 0x06, 0x00, 0x78, 0x74, 0xdf, 0x04, 0x33,
- 0x41, 0xf3, 0xe6, 0x42, 0x08, 0x73, 0x7d, 0xd0, 0xc2, 0xd5, 0x83, 0x40, 0x7b, 0xd7, 0xdf, 0x01,
- 0x93, 0x3d, 0xd3, 0xdd, 0xb9, 0x10, 0x2a, 0x04, 0x44, 0xb8, 0x3c, 0x10, 0x84, 0xa6, 0xde, 0x33,
- 0x6e, 0xb1, 0xa9, 0xd3, 0x20, 0x01, 0xd4, 0x99, 0xa3, 0xcf, 0x1a, 0x88, 0x7b, 0x23, 0xce, 0x59,
- 0x26, 0x9a, 0x7b, 0x2c, 0x5c, 0x0c, 0x3d, 0xa6, 0x8d, 0x4c, 0x4d, 0x1d, 0x6c, 0x23, 0x77, 0x01,
- 0x02, 0x8c, 0xdc, 0x3f, 0x0c, 0xf0, 0xef, 0x72, 0xe0, 0x74, 0xd8, 0x24, 0xb0, 0x18, 0x9c, 0x96,
- 0xd8, 0x18, 0xc2, 0xff, 0x0f, 0x8a, 0xe1, 0xf1, 0xf2, 0x21, 0x07, 0x32, 0x83, 0x7a, 0x1f, 0xb6,
- 0x2f, 0x0d, 0xc0, 0x12, 0x9e, 0x3f, 0x0c, 0x96, 0xc7, 0xd7, 0xfb, 0x1c, 0x38, 0x13, 0xda, 0x87,
- 0xb2, 0xb3, 0x5b, 0x18, 0x8a, 0x70, 0xfd, 0xc0, 0x28, 0x74, 0x5c, 0x06, 0x35, 0x49, 0x0b, 0xa1,
- 0xba, 0xf7, 0x67, 0xb0, 0xab, 0x07, 0x81, 0xa6, 0x0b, 0x10, 0xab, 0x90, 0x87, 0xe5, 0xab, 0x1e,
- 0xc8, 0x80, 0x02, 0x14, 0x52, 0x50, 0xcb, 0x37, 0x1e, 0xfc, 0x92, 0x1e, 0x79, 0xb0, 0x9f, 0xe6,
- 0x1e, 0xee, 0xa7, 0xb9, 0x9f, 0xf7, 0xd3, 0xdc, 0x07, 0x8f, 0xd2, 0x23, 0x0f, 0x1f, 0xa5, 0x47,
- 0x7e, 0x78, 0x94, 0x1e, 0x79, 0xed, 0x12, 0x35, 0x3e, 0xad, 0x98, 0x48, 0xbf, 0xed, 0xfe, 0xf0,
- 0xa7, 0x14, 0x76, 0xc9, 0x0f, 0x80, 0x78, 0x84, 0xaa, 0xc5, 0xf0, 0x0f, 0x7a, 0xff, 0xf9, 0x33,
- 0x00, 0x00, 0xff, 0xff, 0x86, 0x50, 0x9c, 0xc9, 0x9a, 0x1c, 0x00, 0x00,
+ // 1701 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x19, 0xcb, 0x6f, 0x1b, 0xc5,
+ 0x3b, 0x1b, 0x3b, 0x8e, 0x3d, 0xc9, 0xaf, 0x4d, 0xb7, 0x6e, 0xe2, 0x6c, 0x5b, 0xdb, 0xdd, 0x3e,
+ 0xe2, 0xe6, 0x97, 0xda, 0x89, 0x29, 0x85, 0x1a, 0x2e, 0x71, 0x8a, 0x44, 0x2a, 0x0c, 0xd1, 0x46,
+ 0x69, 0x05, 0xaa, 0x64, 0xad, 0xbd, 0x93, 0xcd, 0xaa, 0xde, 0x5d, 0xe3, 0x59, 0xe7, 0x71, 0xe0,
+ 0x02, 0x12, 0x12, 0x88, 0x03, 0x17, 0xfe, 0x04, 0x24, 0xe0, 0x42, 0x0f, 0x1c, 0x38, 0xf6, 0x84,
+ 0x2a, 0x40, 0xa8, 0xe2, 0xc4, 0x05, 0x03, 0x29, 0x52, 0xb9, 0x21, 0xf5, 0xc8, 0x09, 0xed, 0xcc,
+ 0xee, 0x7a, 0xbc, 0x9e, 0x5d, 0x3b, 0x49, 0x2b, 0x90, 0xb8, 0x24, 0x3b, 0x33, 0xdf, 0xf7, 0xcd,
+ 0xf7, 0x7e, 0x8c, 0xc1, 0x6c, 0xdd, 0x44, 0xfa, 0x8e, 0x8c, 0xf4, 0x02, 0xfe, 0xb3, 0xbd, 0x54,
+ 0xb0, 0x76, 0xf3, 0xcd, 0x96, 0x69, 0x99, 0xfc, 0x94, 0x7b, 0x94, 0xc7, 0x7f, 0xb6, 0x97, 0x84,
+ 0xb4, 0xbd, 0x63, 0xa2, 0x42, 0x4d, 0x46, 0xb0, 0xb0, 0xbd, 0x54, 0x83, 0x96, 0xbc, 0x54, 0xa8,
+ 0x9b, 0x9a, 0x41, 0x30, 0x84, 0x19, 0xe7, 0x5c, 0x47, 0xaa, 0x4d, 0x49, 0x47, 0xaa, 0x73, 0x90,
+ 0x54, 0x4d, 0xd5, 0xc4, 0x9f, 0x05, 0xfb, 0xcb, 0xd9, 0x3d, 0xd3, 0x7f, 0xf7, 0x5e, 0x13, 0x22,
+ 0xe7, 0x74, 0x96, 0x10, 0xab, 0x12, 0x34, 0xb2, 0x70, 0x8e, 0x4e, 0xc8, 0xba, 0x66, 0x98, 0x05,
+ 0xfc, 0x97, 0x6c, 0x89, 0xbf, 0x73, 0x60, 0xb2, 0x82, 0xd4, 0x75, 0xcb, 0x6c, 0xc1, 0x15, 0x53,
+ 0x81, 0xfc, 0x34, 0x88, 0x21, 0x68, 0x28, 0xb0, 0x95, 0xe2, 0xb2, 0x5c, 0x2e, 0x21, 0x39, 0x2b,
+ 0xfe, 0x1a, 0x38, 0x66, 0xdf, 0x56, 0xad, 0xed, 0x59, 0xb0, 0x5a, 0x37, 0x15, 0x98, 0x1a, 0xcd,
+ 0x72, 0xb9, 0xc9, 0xf2, 0xd4, 0x7e, 0x27, 0x33, 0x79, 0x7b, 0x79, 0xbd, 0x52, 0xde, 0xb3, 0x30,
+ 0x05, 0x69, 0xd2, 0x86, 0x73, 0x57, 0xfc, 0x06, 0x98, 0xd6, 0x0c, 0x64, 0xc9, 0x86, 0xa5, 0xc9,
+ 0x16, 0xac, 0x36, 0x61, 0x4b, 0xd7, 0x10, 0xd2, 0x4c, 0x23, 0x35, 0x96, 0xe5, 0x72, 0x13, 0xc5,
+ 0x74, 0xde, 0xaf, 0xae, 0xfc, 0x72, 0xbd, 0x0e, 0x11, 0x5a, 0x31, 0x8d, 0x4d, 0x4d, 0x95, 0x4e,
+ 0x51, 0xd8, 0x6b, 0x1e, 0x72, 0xe9, 0xdc, 0xbb, 0x8f, 0xef, 0xcd, 0x3b, 0xbc, 0x7d, 0xf8, 0xf8,
+ 0xde, 0xfc, 0x09, 0xac, 0x0a, 0x5a, 0x92, 0x9b, 0xd1, 0x78, 0x64, 0x2a, 0x7a, 0x33, 0x1a, 0x8f,
+ 0x4e, 0x8d, 0x89, 0xb7, 0x41, 0x92, 0x3e, 0x93, 0x20, 0x6a, 0x9a, 0x06, 0x82, 0xfc, 0x79, 0x30,
+ 0x6e, 0xcb, 0x52, 0xd5, 0x14, 0x2c, 0x6e, 0xb4, 0x0c, 0xf6, 0x3b, 0x99, 0x98, 0x0d, 0xb2, 0x7a,
+ 0x43, 0x8a, 0xd9, 0x47, 0xab, 0x0a, 0x2f, 0x80, 0x78, 0x7d, 0x0b, 0xd6, 0xef, 0xa2, 0xb6, 0x4e,
+ 0x84, 0x96, 0xbc, 0xb5, 0x78, 0x7f, 0x14, 0x4c, 0x57, 0x90, 0xba, 0xda, 0x65, 0x72, 0xc5, 0x34,
+ 0xac, 0x96, 0x5c, 0xb7, 0x02, 0x35, 0x99, 0x04, 0x63, 0xb2, 0xa2, 0x6b, 0x06, 0xa6, 0x95, 0x90,
+ 0xc8, 0x82, 0xe6, 0x24, 0x12, 0xc8, 0x49, 0x12, 0x8c, 0x35, 0xe4, 0x1a, 0x6c, 0xa4, 0xa2, 0x04,
+ 0x15, 0x2f, 0xf8, 0x1c, 0x88, 0xe8, 0x48, 0xc5, 0xfa, 0x9c, 0x2c, 0x4f, 0xff, 0xd5, 0xc9, 0xf0,
+ 0x92, 0xbc, 0xe3, 0xb2, 0x51, 0x81, 0x08, 0xc9, 0x2a, 0x94, 0x6c, 0x10, 0x7e, 0x13, 0x8c, 0x6d,
+ 0xb6, 0x0d, 0x05, 0xa5, 0x62, 0xd9, 0x48, 0x6e, 0xa2, 0x38, 0x9b, 0x77, 0xdc, 0xc3, 0x76, 0xcc,
+ 0xbc, 0xe3, 0x98, 0xf9, 0x15, 0x53, 0x33, 0xca, 0xcf, 0x3f, 0xe8, 0x64, 0x46, 0xbe, 0xf8, 0x25,
+ 0x93, 0x53, 0x35, 0x6b, 0xab, 0x5d, 0xcb, 0xd7, 0x4d, 0xdd, 0xf1, 0x25, 0xe7, 0xdf, 0x15, 0xa4,
+ 0xdc, 0x75, 0xfc, 0xce, 0x46, 0x40, 0x9f, 0x3d, 0xbe, 0x37, 0xcf, 0x49, 0x84, 0x7c, 0xe9, 0xff,
+ 0x3e, 0xeb, 0x9c, 0x76, 0xad, 0xc3, 0xd0, 0x93, 0xf8, 0x3a, 0x48, 0xb3, 0x4f, 0x3c, 0x2b, 0xa5,
+ 0xc0, 0xb8, 0xac, 0x28, 0x2d, 0x88, 0x90, 0xa3, 0x4a, 0x77, 0xc9, 0xf3, 0x20, 0xaa, 0xc8, 0x96,
+ 0xec, 0x98, 0x05, 0x7f, 0x8b, 0x7f, 0x8e, 0x82, 0x19, 0x36, 0xc1, 0xe2, 0x7f, 0xd8, 0x26, 0xb6,
+ 0xaa, 0x90, 0xdc, 0xb0, 0x52, 0xe3, 0x44, 0x55, 0xf6, 0x37, 0x3f, 0x03, 0xc6, 0x37, 0xb5, 0xdd,
+ 0xaa, 0xcd, 0x69, 0x3c, 0xcb, 0xe5, 0xe2, 0x52, 0x6c, 0x53, 0xdb, 0xad, 0x20, 0xb5, 0xb4, 0xe0,
+ 0x33, 0xe0, 0x99, 0x10, 0x03, 0x16, 0xc5, 0x37, 0x40, 0x26, 0xe0, 0xe8, 0x90, 0x26, 0x7c, 0x6f,
+ 0x14, 0xf0, 0x15, 0xa4, 0xbe, 0xb2, 0x0b, 0xeb, 0xed, 0x21, 0x22, 0xca, 0x0e, 0x50, 0x07, 0xc6,
+ 0x31, 0xa0, 0xb7, 0x76, 0x0d, 0x11, 0x39, 0x80, 0x21, 0xc6, 0x9e, 0x6d, 0x70, 0xcc, 0xf9, 0x74,
+ 0x3b, 0xe3, 0xea, 0xd6, 0x27, 0xae, 0xb8, 0x08, 0x84, 0xfe, 0x5d, 0x4f, 0xa3, 0xae, 0xde, 0x38,
+ 0x4a, 0x6f, 0xf7, 0x39, 0xac, 0xb7, 0x8a, 0xa6, 0xb6, 0xe4, 0x23, 0xea, 0x6d, 0x28, 0xdf, 0x77,
+ 0x94, 0x1b, 0x1d, 0xa8, 0xdc, 0x60, 0xa1, 0x7d, 0xbc, 0x3a, 0x42, 0xfb, 0x76, 0x43, 0x85, 0x7e,
+ 0x9f, 0x03, 0xc7, 0x2a, 0x48, 0xdd, 0x68, 0x2a, 0xb2, 0x05, 0x97, 0x71, 0xe0, 0x06, 0x09, 0x7c,
+ 0x1a, 0x24, 0x0c, 0xb8, 0x53, 0xa5, 0x43, 0x3d, 0x6e, 0xc0, 0x1d, 0x82, 0x44, 0x6b, 0x23, 0xd2,
+ 0xab, 0x8d, 0xd2, 0x79, 0x1f, 0xfb, 0x27, 0x5d, 0xf6, 0xa9, 0x5b, 0xc5, 0x14, 0x2e, 0x05, 0xd4,
+ 0x8e, 0xcb, 0xb6, 0xa8, 0x82, 0xff, 0x55, 0x90, 0xba, 0xd2, 0x80, 0x72, 0x2b, 0x9c, 0xc1, 0x30,
+ 0x1e, 0x44, 0x1f, 0x0f, 0xbc, 0xcb, 0x43, 0x97, 0xae, 0x38, 0x03, 0x4e, 0xf5, 0x6c, 0x78, 0x1c,
+ 0xfc, 0xc1, 0x61, 0xbd, 0x12, 0xe6, 0x7a, 0x23, 0x75, 0x53, 0x53, 0x03, 0xf9, 0xa1, 0xbc, 0x60,
+ 0x34, 0xd0, 0x0b, 0xee, 0x00, 0xc1, 0xd6, 0x6a, 0x40, 0x99, 0x8f, 0x0c, 0x55, 0xe6, 0x53, 0x06,
+ 0xdc, 0x59, 0x65, 0x56, 0xfa, 0x82, 0x4f, 0xec, 0x4c, 0xaf, 0xea, 0xfb, 0x64, 0x11, 0x2f, 0x00,
+ 0x31, 0xf8, 0xd4, 0x53, 0xc8, 0x97, 0x1c, 0x38, 0xee, 0x81, 0xad, 0xc9, 0x2d, 0x59, 0x47, 0xfc,
+ 0x35, 0x90, 0x90, 0xdb, 0xd6, 0x96, 0xd9, 0xd2, 0xac, 0x3d, 0xa2, 0x88, 0x72, 0xea, 0xc7, 0xaf,
+ 0xae, 0x24, 0x9d, 0x44, 0xb0, 0x4c, 0x32, 0xd6, 0xba, 0xd5, 0xd2, 0x0c, 0x55, 0xea, 0x82, 0xf2,
+ 0x2f, 0x81, 0x58, 0x13, 0x53, 0xc0, 0x4a, 0x9a, 0x28, 0xa6, 0xfa, 0x85, 0x25, 0x37, 0x94, 0x13,
+ 0x76, 0xe6, 0x20, 0xd9, 0xc0, 0x41, 0x21, 0x91, 0xd1, 0x25, 0x66, 0x8b, 0x98, 0xec, 0x15, 0x91,
+ 0xe0, 0x8a, 0xb3, 0xb8, 0xac, 0xd1, 0x5b, 0x9e, 0x30, 0x5f, 0x13, 0x61, 0xd6, 0xdb, 0x8a, 0xe9,
+ 0x05, 0xfd, 0x61, 0x85, 0x79, 0x2a, 0xc9, 0x34, 0x54, 0x2a, 0x9a, 0x4d, 0xf1, 0x0a, 0x96, 0x8a,
+ 0xde, 0x0a, 0x0d, 0xf6, 0x4f, 0x39, 0x30, 0x51, 0x41, 0xea, 0x9a, 0x66, 0xd8, 0x4e, 0x78, 0x78,
+ 0x93, 0x5d, 0xb7, 0xa5, 0xc4, 0x8e, 0x6d, 0x1b, 0x2d, 0x92, 0x8b, 0x96, 0xd3, 0xfb, 0x9d, 0xcc,
+ 0x38, 0xf1, 0x6c, 0xf4, 0xa4, 0x93, 0x39, 0xbe, 0x27, 0xeb, 0x8d, 0x92, 0xe8, 0x02, 0x89, 0xd2,
+ 0x38, 0xf1, 0x76, 0x44, 0x72, 0x41, 0xaf, 0x68, 0x53, 0xae, 0x68, 0x2e, 0x5f, 0xe2, 0x29, 0x70,
+ 0x92, 0x5a, 0x7a, 0x86, 0xfa, 0x9c, 0xc3, 0x99, 0x60, 0xc3, 0x68, 0xfe, 0x83, 0x02, 0x5c, 0xec,
+ 0x17, 0xc0, 0xcb, 0x25, 0x5d, 0xce, 0x9c, 0x5c, 0xd2, 0xdd, 0xf0, 0x84, 0xf8, 0x2e, 0x8a, 0x3b,
+ 0x36, 0xdc, 0x4d, 0x2f, 0x1b, 0x0a, 0xab, 0xf7, 0x3d, 0xac, 0x54, 0xfd, 0x53, 0x46, 0xe4, 0x88,
+ 0x53, 0x46, 0xf4, 0x08, 0x53, 0x06, 0x7f, 0x16, 0x80, 0xb6, 0x2d, 0x3f, 0x61, 0x65, 0x0c, 0xb7,
+ 0x48, 0x89, 0xb6, 0xab, 0x91, 0x6e, 0xd7, 0x18, 0xa3, 0xbb, 0x46, 0xaf, 0x21, 0x1c, 0x67, 0x34,
+ 0x84, 0xf1, 0x03, 0xf4, 0x21, 0x89, 0x67, 0xdb, 0x10, 0xda, 0x39, 0xdf, 0x6c, 0xb7, 0xea, 0x30,
+ 0x05, 0x9c, 0x9c, 0x8f, 0x57, 0x76, 0xab, 0x56, 0x6b, 0x6b, 0x0d, 0xbb, 0x18, 0x4c, 0x90, 0x56,
+ 0xcd, 0x59, 0xda, 0xe5, 0x13, 0xbb, 0xd3, 0x96, 0x8c, 0xb6, 0x52, 0x93, 0xce, 0x24, 0x64, 0x2a,
+ 0xf0, 0x55, 0x19, 0x6d, 0x95, 0xae, 0xf5, 0x7b, 0xd5, 0xf9, 0x9e, 0xa1, 0x8c, 0xed, 0x2a, 0xe2,
+ 0x2d, 0x70, 0x29, 0x1c, 0xe2, 0x90, 0x3d, 0xe4, 0x37, 0x1c, 0xee, 0x4a, 0x97, 0x15, 0xc5, 0xb6,
+ 0xd5, 0x46, 0xb3, 0x61, 0xca, 0x0a, 0x49, 0x9b, 0x8e, 0xf7, 0x1d, 0x21, 0xf8, 0x8a, 0x20, 0x21,
+ 0xbb, 0x44, 0x70, 0xf4, 0x25, 0xca, 0xc9, 0x27, 0x9d, 0xcc, 0x14, 0x09, 0x39, 0xef, 0x48, 0x94,
+ 0xba, 0x60, 0xa5, 0x17, 0xfa, 0xf5, 0x73, 0xc1, 0xd5, 0x4f, 0x18, 0x93, 0xe2, 0x65, 0x30, 0x37,
+ 0x00, 0xc4, 0x8b, 0xcc, 0xef, 0x39, 0x5c, 0xfb, 0x24, 0xa8, 0x9b, 0xdb, 0xf0, 0xdf, 0x21, 0x76,
+ 0xa9, 0x5f, 0xec, 0x39, 0x57, 0xec, 0x01, 0x7c, 0x8a, 0x0b, 0x60, 0x7e, 0x30, 0x94, 0x27, 0xfc,
+ 0xcf, 0xa3, 0xb8, 0xc5, 0x71, 0x3d, 0xc9, 0xdf, 0x04, 0x3f, 0xbd, 0x94, 0x74, 0xd4, 0x87, 0x8f,
+ 0xc8, 0x51, 0x52, 0x12, 0x5d, 0x9e, 0xa3, 0xec, 0xf2, 0x3c, 0x78, 0xe8, 0x2c, 0x15, 0xfb, 0xad,
+ 0x92, 0xf1, 0x07, 0xab, 0xbf, 0x33, 0xdf, 0xc3, 0xbe, 0x15, 0x70, 0xfa, 0xd4, 0x5e, 0x54, 0xbc,
+ 0x58, 0x8e, 0x50, 0xb1, 0xfc, 0x2d, 0x47, 0xb5, 0xd6, 0xee, 0x95, 0xaf, 0xe1, 0xbc, 0xba, 0xd8,
+ 0xdb, 0xb9, 0x86, 0xd8, 0xd4, 0x37, 0x04, 0x90, 0x1c, 0xdd, 0x1d, 0x02, 0x08, 0xb9, 0xab, 0xfe,
+ 0x06, 0x3c, 0x84, 0x60, 0xb7, 0x35, 0x0f, 0x7c, 0xef, 0x60, 0x70, 0x2c, 0x66, 0x71, 0xf5, 0x64,
+ 0x9c, 0xb8, 0x3a, 0x2c, 0xfe, 0x70, 0x0c, 0x44, 0x2a, 0x48, 0xe5, 0xd7, 0x41, 0xa2, 0xfb, 0x30,
+ 0xc7, 0xf0, 0x17, 0xfa, 0x49, 0x4b, 0xb8, 0x14, 0x7e, 0xee, 0x19, 0xe8, 0x6d, 0x70, 0x92, 0x55,
+ 0xb1, 0x73, 0x4c, 0x74, 0x06, 0xa4, 0xb0, 0x38, 0x2c, 0xa4, 0x77, 0xa5, 0x05, 0x92, 0xcc, 0xd7,
+ 0x98, 0xcb, 0xc3, 0x52, 0x2a, 0x0a, 0x4b, 0x43, 0x83, 0x7a, 0xb7, 0x42, 0x70, 0xdc, 0xff, 0x80,
+ 0x70, 0x81, 0x49, 0xc5, 0x07, 0x25, 0x2c, 0x0c, 0x03, 0x45, 0x5f, 0xe3, 0x4f, 0x35, 0xec, 0x6b,
+ 0x7c, 0x50, 0x01, 0xd7, 0x04, 0xc5, 0xd5, 0x9b, 0x60, 0x82, 0x9e, 0x70, 0xb3, 0x4c, 0x64, 0x0a,
+ 0x42, 0xc8, 0x0d, 0x82, 0xf0, 0x48, 0xdf, 0x02, 0x80, 0x1a, 0x4d, 0x33, 0x4c, 0xbc, 0x2e, 0x80,
+ 0x30, 0x37, 0x00, 0xc0, 0xa3, 0xfb, 0x0e, 0x98, 0x09, 0x9a, 0x37, 0x17, 0x42, 0x98, 0xeb, 0x83,
+ 0x16, 0xae, 0x1e, 0x04, 0xda, 0xbb, 0xfe, 0x0e, 0x98, 0xec, 0x99, 0xee, 0xce, 0x85, 0x50, 0x21,
+ 0x20, 0xc2, 0xe5, 0x81, 0x20, 0x34, 0xf5, 0x9e, 0x71, 0x8b, 0x4d, 0x9d, 0x06, 0x09, 0xa0, 0xce,
+ 0x1c, 0x7d, 0xd6, 0x40, 0xdc, 0x1b, 0x71, 0xce, 0x32, 0xd1, 0xdc, 0x63, 0xe1, 0x62, 0xe8, 0x31,
+ 0x6d, 0x64, 0x6a, 0xea, 0x60, 0x1b, 0xb9, 0x0b, 0x10, 0x60, 0xe4, 0xfe, 0x61, 0x80, 0xff, 0x80,
+ 0x03, 0xa7, 0xc3, 0x26, 0x81, 0xc5, 0xe0, 0xb4, 0xc4, 0xc6, 0x10, 0x5e, 0x3c, 0x28, 0x86, 0xc7,
+ 0xcb, 0x27, 0x1c, 0xc8, 0x0c, 0xea, 0x7d, 0xd8, 0xbe, 0x34, 0x00, 0x4b, 0x78, 0xf9, 0x30, 0x58,
+ 0x1e, 0x5f, 0x1f, 0x71, 0xe0, 0x4c, 0x68, 0x1f, 0xca, 0xce, 0x6e, 0x61, 0x28, 0xc2, 0xf5, 0x03,
+ 0xa3, 0xd0, 0x71, 0x19, 0xd4, 0x24, 0x2d, 0x84, 0xea, 0xde, 0x9f, 0xc1, 0xae, 0x1e, 0x04, 0x9a,
+ 0x2e, 0x40, 0xac, 0x42, 0x1e, 0x96, 0xaf, 0x7a, 0x20, 0x03, 0x0a, 0x50, 0x48, 0x41, 0x2d, 0xdf,
+ 0x78, 0xf0, 0x5b, 0x7a, 0xe4, 0xc1, 0x7e, 0x9a, 0x7b, 0xb8, 0x9f, 0xe6, 0x7e, 0xdd, 0x4f, 0x73,
+ 0x1f, 0x3f, 0x4a, 0x8f, 0x3c, 0x7c, 0x94, 0x1e, 0xf9, 0xe9, 0x51, 0x7a, 0xe4, 0xad, 0x4b, 0xd4,
+ 0xf8, 0xb4, 0x62, 0x22, 0xfd, 0xb6, 0xfb, 0xd3, 0x9a, 0x52, 0xd8, 0x25, 0x3f, 0xb1, 0xe1, 0x11,
+ 0xaa, 0x16, 0xc3, 0x3f, 0x99, 0x3d, 0xf7, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd8, 0x6a, 0x38,
+ 0xdb, 0xfc, 0x1b, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@@ -3234,44 +3185,6 @@ func (m *MsgClearAdminResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
-func (m *AccessConfigUpdate) 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 *AccessConfigUpdate) MarshalTo(dAtA []byte) (int, error) {
- size := m.Size()
- return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *AccessConfigUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
- i := len(dAtA)
- _ = i
- var l int
- _ = l
- {
- size, err := m.InstantiatePermission.MarshalToSizedBuffer(dAtA[:i])
- if err != nil {
- return 0, err
- }
- i -= size
- i = encodeVarintTx(dAtA, i, uint64(size))
- }
- i--
- dAtA[i] = 0x12
- if m.CodeID != 0 {
- i = encodeVarintTx(dAtA, i, uint64(m.CodeID))
- i--
- dAtA[i] = 0x8
- }
- return len(dAtA) - i, nil
-}
-
func (m *MsgUpdateInstantiateConfig) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@@ -3500,20 +3413,20 @@ func (m *MsgPinCodes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
var l int
_ = l
if len(m.CodeIDs) > 0 {
- dAtA6 := make([]byte, len(m.CodeIDs)*10)
- var j5 int
+ dAtA5 := make([]byte, len(m.CodeIDs)*10)
+ var j4 int
for _, num := range m.CodeIDs {
for num >= 1<<7 {
- dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80)
+ dAtA5[j4] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
- j5++
+ j4++
}
- dAtA6[j5] = uint8(num)
- j5++
+ dAtA5[j4] = uint8(num)
+ j4++
}
- i -= j5
- copy(dAtA[i:], dAtA6[:j5])
- i = encodeVarintTx(dAtA, i, uint64(j5))
+ i -= j4
+ copy(dAtA[i:], dAtA5[:j4])
+ i = encodeVarintTx(dAtA, i, uint64(j4))
i--
dAtA[i] = 0x12
}
@@ -3571,20 +3484,20 @@ func (m *MsgUnpinCodes) MarshalToSizedBuffer(dAtA []byte) (int, error) {
var l int
_ = l
if len(m.CodeIDs) > 0 {
- dAtA8 := make([]byte, len(m.CodeIDs)*10)
- var j7 int
+ dAtA7 := make([]byte, len(m.CodeIDs)*10)
+ var j6 int
for _, num := range m.CodeIDs {
for num >= 1<<7 {
- dAtA8[j7] = uint8(uint64(num)&0x7f | 0x80)
+ dAtA7[j6] = uint8(uint64(num)&0x7f | 0x80)
num >>= 7
- j7++
+ j6++
}
- dAtA8[j7] = uint8(num)
- j7++
+ dAtA7[j6] = uint8(num)
+ j6++
}
- i -= j7
- copy(dAtA[i:], dAtA8[:j7])
- i = encodeVarintTx(dAtA, i, uint64(j7))
+ i -= j6
+ copy(dAtA[i:], dAtA7[:j6])
+ i = encodeVarintTx(dAtA, i, uint64(j6))
i--
dAtA[i] = 0x12
}
@@ -4360,20 +4273,6 @@ func (m *MsgClearAdminResponse) Size() (n int) {
return n
}
-func (m *AccessConfigUpdate) Size() (n int) {
- if m == nil {
- return 0
- }
- var l int
- _ = l
- if m.CodeID != 0 {
- n += 1 + sovTx(uint64(m.CodeID))
- }
- l = m.InstantiatePermission.Size()
- n += 1 + l + sovTx(uint64(l))
- return n
-}
-
func (m *MsgUpdateInstantiateConfig) Size() (n int) {
if m == nil {
return 0
@@ -6631,109 +6530,6 @@ func (m *MsgClearAdminResponse) Unmarshal(dAtA []byte) error {
return nil
}
-func (m *AccessConfigUpdate) 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: AccessConfigUpdate: wiretype end group for non-group")
- }
- if fieldNum <= 0 {
- return fmt.Errorf("proto: AccessConfigUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
- }
- switch fieldNum {
- case 1:
- if wireType != 0 {
- return fmt.Errorf("proto: wrong wireType = %d for field CodeID", wireType)
- }
- m.CodeID = 0
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowTx
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- m.CodeID |= uint64(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- case 2:
- if wireType != 2 {
- return fmt.Errorf("proto: wrong wireType = %d for field InstantiatePermission", wireType)
- }
- var msglen int
- for shift := uint(0); ; shift += 7 {
- if shift >= 64 {
- return ErrIntOverflowTx
- }
- if iNdEx >= l {
- return io.ErrUnexpectedEOF
- }
- b := dAtA[iNdEx]
- iNdEx++
- msglen |= int(b&0x7F) << shift
- if b < 0x80 {
- break
- }
- }
- if msglen < 0 {
- return ErrInvalidLengthTx
- }
- postIndex := iNdEx + msglen
- if postIndex < 0 {
- return ErrInvalidLengthTx
- }
- if postIndex > l {
- return io.ErrUnexpectedEOF
- }
- if err := m.InstantiatePermission.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
- return err
- }
- iNdEx = postIndex
- default:
- iNdEx = preIndex
- skippy, err := skipTx(dAtA[iNdEx:])
- if err != nil {
- return err
- }
- if (skippy < 0) || (iNdEx+skippy) < 0 {
- return ErrInvalidLengthTx
- }
- if (iNdEx + skippy) > l {
- return io.ErrUnexpectedEOF
- }
- iNdEx += skippy
- }
- }
-
- if iNdEx > l {
- return io.ErrUnexpectedEOF
- }
- return nil
-}
-
func (m *MsgUpdateInstantiateConfig) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0