Add CodeInfo rpc query (#1943)

* Add CodeInfo rpc query

* Fix typos

* Add QueryCodeInfoResponse type

* Inline fields in QueryCodeInfoResponse

* Fix comments

benchmarks/app_test.go

@@ -33,7 +33,6 @@ import (
 )
 
 func setup(db dbm.DB, withGenesis bool) (*app.WasmApp, app.GenesisState) {
-
 	logLevel := log.LevelOption(zerolog.InfoLevel)
 
 	wasmApp := app.NewWasmApp(log.NewLogger(os.Stdout, logLevel), db, nil, true, simtestutil.EmptyAppOptions{}, nil)

docs/proto/proto-docs.md

@@ -63,6 +63,8 @@
     - [QueryAllContractStateResponse](#cosmwasm.wasm.v1.QueryAllContractStateResponse)
     - [QueryBuildAddressRequest](#cosmwasm.wasm.v1.QueryBuildAddressRequest)
     - [QueryBuildAddressResponse](#cosmwasm.wasm.v1.QueryBuildAddressResponse)
+    - [QueryCodeInfoRequest](#cosmwasm.wasm.v1.QueryCodeInfoRequest)
+    - [QueryCodeInfoResponse](#cosmwasm.wasm.v1.QueryCodeInfoResponse)
     - [QueryCodeRequest](#cosmwasm.wasm.v1.QueryCodeRequest)
     - [QueryCodeResponse](#cosmwasm.wasm.v1.QueryCodeResponse)
     - [QueryCodesRequest](#cosmwasm.wasm.v1.QueryCodesRequest)
@@ -1066,6 +1068,39 @@ method.
 
 
 
+<a name="cosmwasm.wasm.v1.QueryCodeInfoRequest"></a>
+
+### QueryCodeInfoRequest
+QueryCodeInfoRequest is the request type for the Query/CodeInfo RPC method
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `code_id` | [uint64](#uint64) |  | grpc-gateway_out does not support Go style CodeID |
+
+
+
+
+
+
+<a name="cosmwasm.wasm.v1.QueryCodeInfoResponse"></a>
+
+### QueryCodeInfoResponse
+QueryCodeInfoResponse is the response type for the Query/CodeInfo RPC method
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `code_id` | [uint64](#uint64) |  |  |
+| `creator` | [string](#string) |  |  |
+| `checksum` | [bytes](#bytes) |  |  |
+| `instantiate_permission` | [AccessConfig](#cosmwasm.wasm.v1.AccessConfig) |  |  |
+
+
+
+
+
+
 <a name="cosmwasm.wasm.v1.QueryCodeRequest"></a>
 
 ### QueryCodeRequest
@@ -1074,7 +1109,7 @@ QueryCodeRequest is the request type for the Query/Code RPC method
 
 | Field | Type | Label | Description |
 | ----- | ---- | ----- | ----------- |
-| `code_id` | [uint64](#uint64) |  | grpc-gateway_out does not support Go style CodID |
+| `code_id` | [uint64](#uint64) |  | grpc-gateway_out does not support Go style CodeID |
 
 
 
@@ -1204,7 +1239,7 @@ RPC method
 
 | Field | Type | Label | Description |
 | ----- | ---- | ----- | ----------- |
-| `code_id` | [uint64](#uint64) |  | grpc-gateway_out does not support Go style CodID |
+| `code_id` | [uint64](#uint64) |  | grpc-gateway_out does not support Go style CodeID |
 | `pagination` | [cosmos.base.query.v1beta1.PageRequest](#cosmos.base.query.v1beta1.PageRequest) |  | pagination defines an optional pagination for the request. |
 
 
@@ -1406,8 +1441,9 @@ Query provides defines the gRPC querier service
 | `AllContractState` | [QueryAllContractStateRequest](#cosmwasm.wasm.v1.QueryAllContractStateRequest) | [QueryAllContractStateResponse](#cosmwasm.wasm.v1.QueryAllContractStateResponse) | AllContractState gets all raw store data for a single contract | GET|/cosmwasm/wasm/v1/contract/{address}/state|
 | `RawContractState` | [QueryRawContractStateRequest](#cosmwasm.wasm.v1.QueryRawContractStateRequest) | [QueryRawContractStateResponse](#cosmwasm.wasm.v1.QueryRawContractStateResponse) | RawContractState gets single key from the raw store data of a contract | GET|/cosmwasm/wasm/v1/contract/{address}/raw/{query_data}|
 | `SmartContractState` | [QuerySmartContractStateRequest](#cosmwasm.wasm.v1.QuerySmartContractStateRequest) | [QuerySmartContractStateResponse](#cosmwasm.wasm.v1.QuerySmartContractStateResponse) | SmartContractState get smart query result from the contract | GET|/cosmwasm/wasm/v1/contract/{address}/smart/{query_data}|
-| `Code` | [QueryCodeRequest](#cosmwasm.wasm.v1.QueryCodeRequest) | [QueryCodeResponse](#cosmwasm.wasm.v1.QueryCodeResponse) | Code gets the binary code and metadata for a singe wasm code | GET|/cosmwasm/wasm/v1/code/{code_id}|
+| `Code` | [QueryCodeRequest](#cosmwasm.wasm.v1.QueryCodeRequest) | [QueryCodeResponse](#cosmwasm.wasm.v1.QueryCodeResponse) | Code gets the binary code and metadata for a single wasm code | GET|/cosmwasm/wasm/v1/code/{code_id}|
 | `Codes` | [QueryCodesRequest](#cosmwasm.wasm.v1.QueryCodesRequest) | [QueryCodesResponse](#cosmwasm.wasm.v1.QueryCodesResponse) | Codes gets the metadata for all stored wasm codes | GET|/cosmwasm/wasm/v1/code|
+| `CodeInfo` | [QueryCodeInfoRequest](#cosmwasm.wasm.v1.QueryCodeInfoRequest) | [QueryCodeInfoResponse](#cosmwasm.wasm.v1.QueryCodeInfoResponse) | CodeInfo gets the metadata for a single wasm code | GET|/cosmwasm/wasm/v1/code-info/{code_id}|
 | `PinnedCodes` | [QueryPinnedCodesRequest](#cosmwasm.wasm.v1.QueryPinnedCodesRequest) | [QueryPinnedCodesResponse](#cosmwasm.wasm.v1.QueryPinnedCodesResponse) | PinnedCodes gets the pinned code ids | GET|/cosmwasm/wasm/v1/codes/pinned|
 | `Params` | [QueryParamsRequest](#cosmwasm.wasm.v1.QueryParamsRequest) | [QueryParamsResponse](#cosmwasm.wasm.v1.QueryParamsResponse) | Params gets the module params | GET|/cosmwasm/wasm/v1/codes/params|
 | `ContractsByCreator` | [QueryContractsByCreatorRequest](#cosmwasm.wasm.v1.QueryContractsByCreatorRequest) | [QueryContractsByCreatorResponse](#cosmwasm.wasm.v1.QueryContractsByCreatorResponse) | ContractsByCreator gets the contracts by creator | GET|/cosmwasm/wasm/v1/contracts/creator/{creator_address}|

proto/cosmwasm/wasm/v1/query.proto

@@ -53,7 +53,7 @@ service Query {
     option (google.api.http).get =
         "/cosmwasm/wasm/v1/contract/{address}/smart/{query_data}";
   }
-  // Code gets the binary code and metadata for a singe wasm code
+  // Code gets the binary code and metadata for a single wasm code
   rpc Code(QueryCodeRequest) returns (QueryCodeResponse) {
     option (cosmos.query.v1.module_query_safe) = true;
     option (google.api.http).get = "/cosmwasm/wasm/v1/code/{code_id}";
@@ -64,6 +64,12 @@ service Query {
     option (google.api.http).get = "/cosmwasm/wasm/v1/code";
   }
 
+  // CodeInfo gets the metadata for a single wasm code
+  rpc CodeInfo(QueryCodeInfoRequest) returns (QueryCodeInfoResponse) {
+    option (cosmos.query.v1.module_query_safe) = true;
+    option (google.api.http).get = "/cosmwasm/wasm/v1/code-info/{code_id}";
+  }
+
   // PinnedCodes gets the pinned code ids
   rpc PinnedCodes(QueryPinnedCodesRequest) returns (QueryPinnedCodesResponse) {
     option (cosmos.query.v1.module_query_safe) = true;
@@ -134,7 +140,7 @@ message QueryContractHistoryResponse {
 // QueryContractsByCodeRequest is the request type for the Query/ContractsByCode
 // RPC method
 message QueryContractsByCodeRequest {
-  uint64 code_id = 1; // grpc-gateway_out does not support Go style CodID
+  uint64 code_id = 1; // grpc-gateway_out does not support Go style CodeID
   // pagination defines an optional pagination for the request.
   cosmos.base.query.v1beta1.PageRequest pagination = 2;
 }
@@ -207,7 +213,24 @@ message QuerySmartContractStateResponse {
 
 // QueryCodeRequest is the request type for the Query/Code RPC method
 message QueryCodeRequest {
-  uint64 code_id = 1; // grpc-gateway_out does not support Go style CodID
+  uint64 code_id = 1; // grpc-gateway_out does not support Go style CodeID
+}
+
+// QueryCodeInfoRequest is the request type for the Query/CodeInfo RPC method
+message QueryCodeInfoRequest {
+  uint64 code_id = 1; // grpc-gateway_out does not support Go style CodeID
+}
+
+// QueryCodeInfoResponse is the response type for the Query/CodeInfo RPC method
+message QueryCodeInfoResponse {
+  option (gogoproto.equal) = true;
+
+  uint64 code_id = 1 [ (gogoproto.customname) = "CodeID" ];
+  string creator = 2 [ (cosmos_proto.scalar) = "cosmos.AddressString" ];
+  bytes checksum = 3 [ (gogoproto.casttype) =
+                           "github.com/cometbft/cometbft/libs/bytes.HexBytes" ];
+  AccessConfig instantiate_permission = 4
+      [ (gogoproto.nullable) = false, (amino.dont_omitempty) = true ];
 }
 
 // CodeInfoResponse contains code meta data from CodeInfo

x/wasm/client/cli/query.go

@@ -252,20 +252,17 @@ func GetCmdQueryCodeInfo() *cobra.Command {
 			}
 
 			queryClient := types.NewQueryClient(clientCtx)
-			res, err := queryClient.Code(
+			res, err := queryClient.CodeInfo(
 				context.Background(),
-				&types.QueryCodeRequest{
+				&types.QueryCodeInfoRequest{
 					CodeId: codeID,
 				},
 			)
 			if err != nil {
 				return err
 			}
-			if res.CodeInfoResponse == nil {
-				return fmt.Errorf("contract not found")
-			}
 
-			return clientCtx.PrintProto(res.CodeInfoResponse)
+			return clientCtx.PrintProto(res)
 		},
 		SilenceUsage: true,
 	}

x/wasm/keeper/querier.go

@@ -285,6 +285,25 @@ func (q GrpcQuerier) Codes(c context.Context, req *types.QueryCodesRequest) (*ty
 	return &types.QueryCodesResponse{CodeInfos: r, Pagination: pageRes}, nil
 }
 
+func (q GrpcQuerier) CodeInfo(c context.Context, req *types.QueryCodeInfoRequest) (*types.QueryCodeInfoResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "empty request")
+	}
+	if req.CodeId == 0 {
+		return nil, errorsmod.Wrap(types.ErrInvalid, "code id")
+	}
+	info := queryCodeInfo(sdk.UnwrapSDKContext(c), req.CodeId, q.keeper)
+	if info == nil {
+		return nil, types.ErrNoSuchCodeFn(req.CodeId).Wrapf("code id %d", req.CodeId)
+	}
+	return &types.QueryCodeInfoResponse{
+		CodeID:                info.CodeID,
+		Creator:               info.Creator,
+		Checksum:              info.DataHash,
+		InstantiatePermission: info.InstantiatePermission,
+	}, nil
+}
+
 func queryContractInfo(ctx sdk.Context, addr sdk.AccAddress, keeper types.ViewKeeper) (*types.QueryContractInfoResponse, error) {
 	info := keeper.GetContractInfo(ctx, addr)
 	if info == nil {
@@ -298,27 +317,35 @@ func queryContractInfo(ctx sdk.Context, addr sdk.AccAddress, keeper types.ViewKe
 }
 
 func queryCode(ctx sdk.Context, codeID uint64, keeper types.ViewKeeper) (*types.QueryCodeResponse, error) {
-	if codeID == 0 {
-		return nil, nil
-	}
-	res := keeper.GetCodeInfo(ctx, codeID)
-	if res == nil {
+	info := queryCodeInfo(ctx, codeID, keeper)
+	if info == nil {
 		// nil, nil leads to 404 in rest handler
 		return nil, nil
 	}
-	info := types.CodeInfoResponse{
-		CodeID:                codeID,
-		Creator:               res.Creator,
-		DataHash:              res.CodeHash,
-		InstantiatePermission: res.InstantiateConfig,
-	}
 
 	code, err := keeper.GetByteCode(ctx, codeID)
 	if err != nil {
 		return nil, errorsmod.Wrap(err, "loading wasm code")
 	}
 
-	return &types.QueryCodeResponse{CodeInfoResponse: &info, Data: code}, nil
+	return &types.QueryCodeResponse{CodeInfoResponse: info, Data: code}, nil
+}
+
+func queryCodeInfo(ctx sdk.Context, codeID uint64, keeper types.ViewKeeper) *types.CodeInfoResponse {
+	if codeID == 0 {
+		return nil
+	}
+	res := keeper.GetCodeInfo(ctx, codeID)
+	if res == nil {
+		return nil
+	}
+	info := types.CodeInfoResponse{
+		CodeID:                codeID,
+		Creator:               res.Creator,
+		DataHash:              res.CodeHash,
+		InstantiatePermission: res.InstantiateConfig,
+	}
+	return &info
 }
 
 func (q GrpcQuerier) PinnedCodes(c context.Context, req *types.QueryPinnedCodesRequest) (*types.QueryPinnedCodesResponse, error) {

x/wasm/keeper/querier_test.go

@@ -781,6 +781,58 @@ func TestQueryCodeInfo(t *testing.T) {
 	ctx, keepers := CreateTestInput(t, false, AvailableCapabilities)
 	keeper := keepers.WasmKeeper
 
+	anyAddress, err := sdk.AccAddressFromBech32("cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz")
+	require.NoError(t, err)
+	specs := map[string]struct {
+		codeID       uint64
+		accessConfig types.AccessConfig
+	}{
+		"everybody": {
+			codeID:       1,
+			accessConfig: types.AllowEverybody,
+		},
+		"nobody": {
+			codeID:       10,
+			accessConfig: types.AllowNobody,
+		},
+		"with_address": {
+			codeID:       20,
+			accessConfig: types.AccessTypeAnyOfAddresses.With(anyAddress),
+		},
+	}
+	for msg, spec := range specs {
+		t.Run(msg, func(t *testing.T) {
+			codeInfo := types.CodeInfoFixture(types.WithSHA256CodeHash(wasmCode))
+			codeInfo.InstantiateConfig = spec.accessConfig
+			require.NoError(t, keeper.importCode(ctx, spec.codeID,
+				codeInfo,
+				wasmCode),
+			)
+
+			q := Querier(keeper)
+			got, err := q.CodeInfo(ctx, &types.QueryCodeInfoRequest{
+				CodeId: spec.codeID,
+			})
+			require.NoError(t, err)
+			expectedResponse := &types.QueryCodeInfoResponse{
+				CodeID:                spec.codeID,
+				Creator:               codeInfo.Creator,
+				Checksum:              codeInfo.CodeHash,
+				InstantiatePermission: spec.accessConfig,
+			}
+			require.NotNil(t, got)
+			require.EqualValues(t, expectedResponse, got)
+		})
+	}
+}
+
+func TestQueryCode(t *testing.T) {
+	wasmCode, err := os.ReadFile("./testdata/hackatom.wasm")
+	require.NoError(t, err)
+
+	ctx, keepers := CreateTestInput(t, false, AvailableCapabilities)
+	keeper := keepers.WasmKeeper
+
 	anyAddress, err := sdk.AccAddressFromBech32("cosmos100dejzacpanrldpjjwksjm62shqhyss44jf5xz")
 	require.NoError(t, err)
 	specs := map[string]struct {

x/wasm/types/query.pb.go

@@ -633,6 +633,95 @@ func (m *QueryCodeRequest) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_QueryCodeRequest proto.InternalMessageInfo
 
+// QueryCodeInfoRequest is the request type for the Query/CodeInfo RPC method
+type QueryCodeInfoRequest struct {
+	CodeId uint64 `protobuf:"varint,1,opt,name=code_id,json=codeId,proto3" json:"code_id,omitempty"`
+}
+
+func (m *QueryCodeInfoRequest) Reset()         { *m = QueryCodeInfoRequest{} }
+func (m *QueryCodeInfoRequest) String() string { return proto.CompactTextString(m) }
+func (*QueryCodeInfoRequest) ProtoMessage()    {}
+func (*QueryCodeInfoRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_9677c207036b9f2b, []int{13}
+}
+
+func (m *QueryCodeInfoRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+
+func (m *QueryCodeInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryCodeInfoRequest.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 *QueryCodeInfoRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryCodeInfoRequest.Merge(m, src)
+}
+
+func (m *QueryCodeInfoRequest) XXX_Size() int {
+	return m.Size()
+}
+
+func (m *QueryCodeInfoRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryCodeInfoRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryCodeInfoRequest proto.InternalMessageInfo
+
+// QueryCodeInfoResponse is the response type for the Query/CodeInfo RPC method
+type QueryCodeInfoResponse struct {
+	CodeID                uint64                                           `protobuf:"varint,1,opt,name=code_id,json=codeId,proto3" json:"code_id,omitempty"`
+	Creator               string                                           `protobuf:"bytes,2,opt,name=creator,proto3" json:"creator,omitempty"`
+	Checksum              github_com_cometbft_cometbft_libs_bytes.HexBytes `protobuf:"bytes,3,opt,name=checksum,proto3,casttype=github.com/cometbft/cometbft/libs/bytes.HexBytes" json:"checksum,omitempty"`
+	InstantiatePermission AccessConfig                                     `protobuf:"bytes,4,opt,name=instantiate_permission,json=instantiatePermission,proto3" json:"instantiate_permission"`
+}
+
+func (m *QueryCodeInfoResponse) Reset()         { *m = QueryCodeInfoResponse{} }
+func (m *QueryCodeInfoResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryCodeInfoResponse) ProtoMessage()    {}
+func (*QueryCodeInfoResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_9677c207036b9f2b, []int{14}
+}
+
+func (m *QueryCodeInfoResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+
+func (m *QueryCodeInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryCodeInfoResponse.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 *QueryCodeInfoResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryCodeInfoResponse.Merge(m, src)
+}
+
+func (m *QueryCodeInfoResponse) XXX_Size() int {
+	return m.Size()
+}
+
+func (m *QueryCodeInfoResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryCodeInfoResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryCodeInfoResponse proto.InternalMessageInfo
+
 // CodeInfoResponse contains code meta data from CodeInfo
 type CodeInfoResponse struct {
 	CodeID                uint64                                           `protobuf:"varint,1,opt,name=code_id,json=codeId,proto3" json:"id"`
@@ -645,7 +734,7 @@ func (m *CodeInfoResponse) Reset()         { *m = CodeInfoResponse{} }
 func (m *CodeInfoResponse) String() string { return proto.CompactTextString(m) }
 func (*CodeInfoResponse) ProtoMessage()    {}
 func (*CodeInfoResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9677c207036b9f2b, []int{13}
+	return fileDescriptor_9677c207036b9f2b, []int{15}
 }
 
 func (m *CodeInfoResponse) XXX_Unmarshal(b []byte) error {
@@ -689,7 +778,7 @@ func (m *QueryCodeResponse) Reset()         { *m = QueryCodeResponse{} }
 func (m *QueryCodeResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryCodeResponse) ProtoMessage()    {}
 func (*QueryCodeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9677c207036b9f2b, []int{14}
+	return fileDescriptor_9677c207036b9f2b, []int{16}
 }
 
 func (m *QueryCodeResponse) XXX_Unmarshal(b []byte) error {
@@ -733,7 +822,7 @@ func (m *QueryCodesRequest) Reset()         { *m = QueryCodesRequest{} }
 func (m *QueryCodesRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryCodesRequest) ProtoMessage()    {}
 func (*QueryCodesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9677c207036b9f2b, []int{15}
+	return fileDescriptor_9677c207036b9f2b, []int{17}
 }
 
 func (m *QueryCodesRequest) XXX_Unmarshal(b []byte) error {
@@ -778,7 +867,7 @@ func (m *QueryCodesResponse) Reset()         { *m = QueryCodesResponse{} }
 func (m *QueryCodesResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryCodesResponse) ProtoMessage()    {}
 func (*QueryCodesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9677c207036b9f2b, []int{16}
+	return fileDescriptor_9677c207036b9f2b, []int{18}
 }
 
 func (m *QueryCodesResponse) XXX_Unmarshal(b []byte) error {
@@ -823,7 +912,7 @@ func (m *QueryPinnedCodesRequest) Reset()         { *m = QueryPinnedCodesRequest
 func (m *QueryPinnedCodesRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryPinnedCodesRequest) ProtoMessage()    {}
 func (*QueryPinnedCodesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9677c207036b9f2b, []int{17}
+	return fileDescriptor_9677c207036b9f2b, []int{19}
 }
 
 func (m *QueryPinnedCodesRequest) XXX_Unmarshal(b []byte) error {
@@ -869,7 +958,7 @@ func (m *QueryPinnedCodesResponse) Reset()         { *m = QueryPinnedCodesRespon
 func (m *QueryPinnedCodesResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryPinnedCodesResponse) ProtoMessage()    {}
 func (*QueryPinnedCodesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9677c207036b9f2b, []int{18}
+	return fileDescriptor_9677c207036b9f2b, []int{20}
 }
 
 func (m *QueryPinnedCodesResponse) XXX_Unmarshal(b []byte) error {
@@ -910,7 +999,7 @@ func (m *QueryParamsRequest) Reset()         { *m = QueryParamsRequest{} }
 func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryParamsRequest) ProtoMessage()    {}
 func (*QueryParamsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9677c207036b9f2b, []int{19}
+	return fileDescriptor_9677c207036b9f2b, []int{21}
 }
 
 func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error {
@@ -954,7 +1043,7 @@ func (m *QueryParamsResponse) Reset()         { *m = QueryParamsResponse{} }
 func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryParamsResponse) ProtoMessage()    {}
 func (*QueryParamsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9677c207036b9f2b, []int{20}
+	return fileDescriptor_9677c207036b9f2b, []int{22}
 }
 
 func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error {
@@ -1001,7 +1090,7 @@ func (m *QueryContractsByCreatorRequest) Reset()         { *m = QueryContractsBy
 func (m *QueryContractsByCreatorRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryContractsByCreatorRequest) ProtoMessage()    {}
 func (*QueryContractsByCreatorRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9677c207036b9f2b, []int{21}
+	return fileDescriptor_9677c207036b9f2b, []int{23}
 }
 
 func (m *QueryContractsByCreatorRequest) XXX_Unmarshal(b []byte) error {
@@ -1048,7 +1137,7 @@ func (m *QueryContractsByCreatorResponse) Reset()         { *m = QueryContractsB
 func (m *QueryContractsByCreatorResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryContractsByCreatorResponse) ProtoMessage()    {}
 func (*QueryContractsByCreatorResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9677c207036b9f2b, []int{22}
+	return fileDescriptor_9677c207036b9f2b, []int{24}
 }
 
 func (m *QueryContractsByCreatorResponse) XXX_Unmarshal(b []byte) error {
@@ -1100,7 +1189,7 @@ func (m *QueryBuildAddressRequest) Reset()         { *m = QueryBuildAddressReque
 func (m *QueryBuildAddressRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryBuildAddressRequest) ProtoMessage()    {}
 func (*QueryBuildAddressRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9677c207036b9f2b, []int{23}
+	return fileDescriptor_9677c207036b9f2b, []int{25}
 }
 
 func (m *QueryBuildAddressRequest) XXX_Unmarshal(b []byte) error {
@@ -1145,7 +1234,7 @@ func (m *QueryBuildAddressResponse) Reset()         { *m = QueryBuildAddressResp
 func (m *QueryBuildAddressResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryBuildAddressResponse) ProtoMessage()    {}
 func (*QueryBuildAddressResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9677c207036b9f2b, []int{24}
+	return fileDescriptor_9677c207036b9f2b, []int{26}
 }
 
 func (m *QueryBuildAddressResponse) XXX_Unmarshal(b []byte) error {
@@ -1193,6 +1282,8 @@ func init() {
 	proto.RegisterType((*QuerySmartContractStateRequest)(nil), "cosmwasm.wasm.v1.QuerySmartContractStateRequest")
 	proto.RegisterType((*QuerySmartContractStateResponse)(nil), "cosmwasm.wasm.v1.QuerySmartContractStateResponse")
 	proto.RegisterType((*QueryCodeRequest)(nil), "cosmwasm.wasm.v1.QueryCodeRequest")
+	proto.RegisterType((*QueryCodeInfoRequest)(nil), "cosmwasm.wasm.v1.QueryCodeInfoRequest")
+	proto.RegisterType((*QueryCodeInfoResponse)(nil), "cosmwasm.wasm.v1.QueryCodeInfoResponse")
 	proto.RegisterType((*CodeInfoResponse)(nil), "cosmwasm.wasm.v1.CodeInfoResponse")
 	proto.RegisterType((*QueryCodeResponse)(nil), "cosmwasm.wasm.v1.QueryCodeResponse")
 	proto.RegisterType((*QueryCodesRequest)(nil), "cosmwasm.wasm.v1.QueryCodesRequest")
@@ -1210,102 +1301,107 @@ func init() {
 func init() { proto.RegisterFile("cosmwasm/wasm/v1/query.proto", fileDescriptor_9677c207036b9f2b) }
 
 var fileDescriptor_9677c207036b9f2b = []byte{
-	// 1508 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x98, 0xcf, 0x6f, 0x1b, 0x45,
-	0x14, 0xc7, 0x3d, 0xa9, 0xe3, 0xd8, 0x93, 0x40, 0x9d, 0xa1, 0xb4, 0xae, 0xdb, 0xda, 0xd1, 0xb6,
-	0x84, 0xd4, 0x6d, 0xbd, 0x4d, 0x4a, 0xa9, 0x5a, 0x0e, 0xc8, 0x4e, 0x4b, 0xd3, 0x8a, 0xd2, 0xd4,
-	0x95, 0x40, 0x02, 0x21, 0x33, 0xb6, 0x27, 0xce, 0x22, 0x7b, 0xd7, 0xdd, 0x99, 0x34, 0x8d, 0xa2,
-	0xf4, 0xd0, 0x13, 0x12, 0x17, 0x10, 0x07, 0x44, 0x91, 0x80, 0x03, 0x87, 0xa2, 0x82, 0x54, 0x09,
-	0x24, 0x2a, 0x24, 0xee, 0x39, 0x56, 0x70, 0xe1, 0x64, 0x41, 0x8a, 0x54, 0xd4, 0x3f, 0xa1, 0x27,
-	0xb4, 0xf3, 0xc3, 0xbb, 0x6b, 0x7b, 0x6d, 0x27, 0xf8, 0xc0, 0x25, 0x5a, 0xef, 0xbe, 0x37, 0xf3,
-	0x99, 0xef, 0xbc, 0x79, 0xef, 0x4d, 0xe0, 0xc1, 0xb2, 0x45, 0xeb, 0xab, 0x98, 0xd6, 0x75, 0xfe,
-	0xe7, 0xe6, 0xac, 0x7e, 0x63, 0x85, 0xd8, 0x6b, 0xd9, 0x86, 0x6d, 0x31, 0x0b, 0xc5, 0xd5, 0xd7,
-	0x2c, 0xff, 0x73, 0x73, 0x36, 0xb9, 0xa7, 0x6a, 0x55, 0x2d, 0xfe, 0x51, 0x77, 0x9e, 0x84, 0x5d,
-	0xb2, 0x73, 0x14, 0xb6, 0xd6, 0x20, 0x54, 0x7d, 0xad, 0x5a, 0x56, 0xb5, 0x46, 0x74, 0xdc, 0x30,
-	0x74, 0x6c, 0x9a, 0x16, 0xc3, 0xcc, 0xb0, 0x4c, 0xf5, 0x35, 0xe3, 0xf8, 0x5a, 0x54, 0x2f, 0x61,
-	0x4a, 0xc4, 0xe4, 0xfa, 0xcd, 0xd9, 0x12, 0x61, 0x78, 0x56, 0x6f, 0xe0, 0xaa, 0x61, 0x72, 0x63,
-	0x69, 0x7b, 0x40, 0xda, 0x2a, 0x33, 0x2f, 0x6c, 0x72, 0x12, 0xd7, 0x0d, 0xd3, 0xd2, 0xf9, 0x5f,
-	0xf9, 0x6a, 0xbf, 0xb0, 0x2f, 0x0a, 0x60, 0xf1, 0x43, 0x7c, 0xd2, 0xde, 0x82, 0x89, 0x6b, 0x8e,
-	0xf3, 0xbc, 0x65, 0x32, 0x1b, 0x97, 0xd9, 0x25, 0x73, 0xc9, 0x2a, 0x90, 0x1b, 0x2b, 0x84, 0x32,
-	0x34, 0x07, 0xc7, 0x70, 0xa5, 0x62, 0x13, 0x4a, 0x13, 0x60, 0x0a, 0xcc, 0xc4, 0xf2, 0x89, 0xdf,
-	0x7e, 0x3a, 0xb1, 0x47, 0xba, 0xe7, 0xc4, 0x97, 0xeb, 0xcc, 0x36, 0xcc, 0x6a, 0x41, 0x19, 0x6a,
-	0x3f, 0x00, 0xb8, 0xbf, 0xcb, 0x80, 0xb4, 0x61, 0x99, 0x94, 0xec, 0x64, 0x44, 0xf4, 0x36, 0x7c,
-	0xae, 0x2c, 0xc7, 0x2a, 0x1a, 0xe6, 0x92, 0x95, 0x18, 0x99, 0x02, 0x33, 0xe3, 0x73, 0xa9, 0x6c,
-	0xfb, 0xa6, 0x64, 0xbd, 0x53, 0xe6, 0x27, 0x37, 0x9b, 0xe9, 0xd0, 0xa3, 0x66, 0x1a, 0x3c, 0x6d,
-	0xa6, 0x43, 0xf7, 0x9e, 0x3c, 0xc8, 0x80, 0xc2, 0x44, 0xd9, 0x63, 0x70, 0x2e, 0xfc, 0xcf, 0x37,
-	0x69, 0xa0, 0x7d, 0x01, 0xe0, 0x01, 0x1f, 0xef, 0x82, 0x41, 0x99, 0x65, 0xaf, 0xfd, 0x07, 0x0d,
-	0xd0, 0x1b, 0x10, 0xba, 0x5b, 0x26, 0x71, 0xa7, 0xb3, 0xd2, 0xc7, 0xd9, 0xdf, 0xac, 0xd8, 0x2f,
-	0xb9, 0xbf, 0xd9, 0x45, 0x5c, 0x25, 0x72, 0xbe, 0x82, 0xc7, 0x53, 0x7b, 0x08, 0xe0, 0xc1, 0xee,
-	0x6c, 0x52, 0xce, 0xab, 0x70, 0x8c, 0x98, 0xcc, 0x36, 0x88, 0x03, 0xb7, 0x6b, 0x66, 0x7c, 0x2e,
-	0x13, 0x2c, 0xca, 0xbc, 0x55, 0x21, 0xd2, 0xff, 0x82, 0xc9, 0xec, 0xb5, 0x7c, 0x6c, 0xb3, 0x25,
-	0x8c, 0x1a, 0x05, 0x5d, 0xec, 0x42, 0xfe, 0x72, 0x5f, 0x72, 0x41, 0xe3, 0x43, 0xbf, 0xdd, 0xa6,
-	0x2a, 0xcd, 0xaf, 0x39, 0x00, 0x4a, 0xd5, 0x7d, 0x70, 0xac, 0x6c, 0x55, 0x48, 0xd1, 0xa8, 0x70,
-	0x55, 0xc3, 0x85, 0x88, 0xf3, 0xf3, 0x52, 0x65, 0x68, 0xd2, 0x7d, 0xdd, 0x2e, 0x5d, 0x0b, 0x40,
-	0x4a, 0xf7, 0x2a, 0x8c, 0xa9, 0x68, 0x10, 0xe2, 0xf5, 0xda, 0x59, 0xd7, 0x74, 0x78, 0x0a, 0xdd,
-	0x55, 0x84, 0xb9, 0x5a, 0x4d, 0x41, 0x5e, 0x67, 0x98, 0x91, 0xff, 0x43, 0xe4, 0x7d, 0x0b, 0xe0,
-	0xa1, 0x00, 0x38, 0xa9, 0xdf, 0x39, 0x18, 0xa9, 0x5b, 0x15, 0x52, 0x53, 0x91, 0xb7, 0xaf, 0x33,
-	0xf2, 0xae, 0x38, 0xdf, 0xbd, 0x61, 0x26, 0x3d, 0x86, 0xa7, 0xe1, 0x0d, 0x29, 0x61, 0x01, 0xaf,
-	0x0e, 0x4d, 0xc2, 0x43, 0x10, 0xf2, 0xd9, 0x8b, 0x15, 0xcc, 0x30, 0x87, 0x9b, 0x28, 0xc4, 0xf8,
-	0x9b, 0xf3, 0x98, 0x61, 0xed, 0x94, 0x14, 0xa6, 0x73, 0x4a, 0x29, 0x0c, 0x82, 0x61, 0xee, 0x09,
-	0xb8, 0x27, 0x7f, 0xd6, 0xbe, 0x04, 0x30, 0xc5, 0xbd, 0xae, 0xd7, 0xb1, 0xcd, 0x86, 0x86, 0x7a,
-	0xa1, 0x13, 0x35, 0x3f, 0xfd, 0xac, 0x99, 0x46, 0x1e, 0xb8, 0x2b, 0x84, 0x52, 0x5c, 0x25, 0x77,
-	0x9f, 0x3c, 0xc8, 0x8c, 0x1b, 0x66, 0xcd, 0x30, 0x49, 0xf1, 0x43, 0x6a, 0x99, 0xde, 0x25, 0xbd,
-	0x0f, 0xd3, 0x81, 0x70, 0xad, 0xdd, 0xf6, 0x2c, 0x6a, 0xe0, 0x39, 0xc4, 0xe2, 0x8f, 0xc1, 0xb8,
-	0x3c, 0x89, 0xfd, 0xcf, 0xbf, 0xf6, 0x70, 0x04, 0xc6, 0x1d, 0x43, 0x5f, 0xd5, 0x38, 0xda, 0x66,
-	0x9d, 0x8f, 0x6f, 0x35, 0xd3, 0x11, 0x6e, 0x76, 0xfe, 0x69, 0x33, 0x3d, 0x62, 0x54, 0x5a, 0xf9,
-	0x63, 0x0e, 0x8e, 0x95, 0x6d, 0x82, 0x99, 0x65, 0x73, 0x3d, 0x7a, 0xca, 0x28, 0x0d, 0xd1, 0x35,
-	0x18, 0x73, 0x40, 0x8b, 0xcb, 0x98, 0x2e, 0x27, 0x76, 0xf1, 0x15, 0xbe, 0xf2, 0xac, 0x99, 0x3e,
-	0x59, 0x35, 0xd8, 0xf2, 0x4a, 0x29, 0x5b, 0xb6, 0xea, 0x7a, 0xd9, 0xaa, 0x13, 0x56, 0x5a, 0x62,
-	0xee, 0x43, 0xcd, 0x28, 0x51, 0xbd, 0xb4, 0xc6, 0x08, 0xcd, 0x2e, 0x90, 0x5b, 0x79, 0xe7, 0xa1,
-	0x10, 0x75, 0x86, 0x59, 0xc0, 0x74, 0x19, 0x7d, 0x00, 0xf7, 0x1a, 0x26, 0x65, 0xd8, 0x64, 0x06,
-	0x66, 0xa4, 0xd8, 0x20, 0x76, 0xdd, 0xa0, 0xd4, 0x89, 0xf6, 0x48, 0x50, 0xf1, 0xca, 0x95, 0xcb,
-	0x84, 0xd2, 0x79, 0xcb, 0x5c, 0x32, 0xaa, 0xde, 0x43, 0xf3, 0xa2, 0x67, 0xa0, 0xc5, 0xd6, 0x38,
-	0xa2, 0x7a, 0x5d, 0x0e, 0x47, 0xc3, 0xf1, 0xd1, 0xcb, 0xe1, 0xe8, 0x68, 0x3c, 0xa2, 0xdd, 0x01,
-	0x70, 0xd2, 0x23, 0xb4, 0xd4, 0xee, 0x92, 0x93, 0xe7, 0x1c, 0xed, 0x9c, 0xca, 0x09, 0xf8, 0xe4,
-	0x5a, 0xb7, 0x22, 0xe1, 0x97, 0x3c, 0x1f, 0x55, 0x95, 0xb3, 0x10, 0x2d, 0xcb, 0x6f, 0xe8, 0xa0,
-	0x0c, 0x02, 0x11, 0x68, 0xd1, 0xa7, 0xcd, 0x34, 0xff, 0x2d, 0xb6, 0x59, 0x96, 0xd3, 0xf7, 0x3c,
-	0x0c, 0x54, 0xed, 0xb6, 0x3f, 0x2b, 0x81, 0x1d, 0x67, 0xa5, 0xfb, 0x00, 0x22, 0xef, 0xe8, 0x72,
-	0x89, 0x6f, 0x42, 0xd8, 0x5a, 0xa2, 0x4a, 0x47, 0x83, 0xac, 0xd1, 0x23, 0x72, 0x4c, 0x2d, 0x72,
-	0x88, 0xc9, 0x09, 0xc3, 0x7d, 0x1c, 0x76, 0xd1, 0x30, 0x4d, 0x52, 0xe9, 0x21, 0xc8, 0xce, 0xd3,
-	0xf4, 0xc7, 0x40, 0x76, 0x6f, 0xbe, 0x39, 0xa4, 0x2c, 0xd3, 0x30, 0x2a, 0x4f, 0x8d, 0x10, 0x25,
-	0x9c, 0x1f, 0xdf, 0x6a, 0xa6, 0xc7, 0xc4, 0xb1, 0xa1, 0x85, 0x31, 0x71, 0x62, 0x86, 0xb8, 0xe0,
-	0x3d, 0x72, 0x77, 0x16, 0xb1, 0x8d, 0xeb, 0x6a, 0xad, 0x5a, 0x01, 0xbe, 0xe0, 0x7b, 0x2b, 0xe9,
-	0x5e, 0x83, 0x91, 0x06, 0x7f, 0x23, 0xe3, 0x21, 0xd1, 0xb9, 0x61, 0xc2, 0xc3, 0x57, 0x40, 0x84,
-	0x8b, 0x13, 0x08, 0xa9, 0x8e, 0xea, 0x2e, 0x4e, 0xb3, 0x92, 0x38, 0x07, 0x77, 0xcb, 0xf3, 0x5d,
-	0x1c, 0x34, 0xaf, 0x3e, 0x2f, 0x1d, 0x72, 0x43, 0x2e, 0xa6, 0x3f, 0x02, 0x99, 0x60, 0xbb, 0xd1,
-	0x4a, 0x39, 0x2e, 0x42, 0xd4, 0x6a, 0x72, 0x25, 0x2f, 0xe9, 0xdf, 0x97, 0x4c, 0x2a, 0x9f, 0x9c,
-	0x72, 0x19, 0xde, 0x6e, 0xde, 0x57, 0xb1, 0x95, 0x5f, 0x31, 0x6a, 0x15, 0x39, 0x81, 0x52, 0xf7,
-	0x80, 0xcc, 0x2a, 0x3c, 0x65, 0x72, 0x5d, 0x45, 0x9e, 0xe0, 0xc9, 0xaf, 0x8b, 0xf4, 0x23, 0xdb,
-	0x94, 0x1e, 0xc1, 0x30, 0xc5, 0x35, 0xc6, 0xb3, 0x71, 0xac, 0xc0, 0x9f, 0x9d, 0x39, 0x0d, 0xd3,
-	0x60, 0x45, 0x6c, 0x57, 0x69, 0x22, 0xcc, 0xab, 0x6b, 0xd4, 0x79, 0x91, 0xb3, 0xab, 0x54, 0xbb,
-	0x2a, 0x6f, 0x1d, 0x7e, 0xd8, 0x9d, 0xdf, 0x3a, 0xe6, 0x3e, 0xdf, 0x0d, 0x47, 0xf9, 0x88, 0xe8,
-	0x2e, 0x80, 0x13, 0xde, 0x9b, 0x05, 0xea, 0xd2, 0x64, 0x07, 0x5d, 0xa1, 0x92, 0xc7, 0x06, 0xb2,
-	0x15, 0x9c, 0xda, 0xec, 0x47, 0x4e, 0x94, 0xdf, 0xf9, 0xfd, 0xef, 0xcf, 0x46, 0xa6, 0xd1, 0x11,
-	0xbd, 0xe3, 0x32, 0xa9, 0x76, 0x5b, 0x5f, 0x97, 0x94, 0x1b, 0xe8, 0x3e, 0x80, 0xbb, 0xdb, 0x6e,
-	0x07, 0xe8, 0x44, 0x9f, 0x39, 0xfd, 0x37, 0x9c, 0x64, 0x76, 0x50, 0x73, 0x49, 0x79, 0xd6, 0xa5,
-	0xcc, 0xa2, 0xe3, 0x83, 0x50, 0xea, 0xcb, 0x92, 0xec, 0x3b, 0x0f, 0xad, 0x6c, 0xc8, 0xfb, 0xd2,
-	0xfa, 0x6f, 0x0e, 0x7d, 0x69, 0xdb, 0xfa, 0x7c, 0xed, 0x8c, 0x4b, 0x7b, 0x1c, 0x65, 0xba, 0xd1,
-	0x56, 0x88, 0xbe, 0x2e, 0x13, 0xe5, 0x86, 0xee, 0x36, 0xfa, 0xdf, 0x03, 0x18, 0x6f, 0xef, 0x7e,
-	0x51, 0xd0, 0xec, 0x01, 0x3d, 0x7c, 0x52, 0x1f, 0xd8, 0x7e, 0x60, 0xdc, 0x0e, 0x71, 0x29, 0x27,
-	0xfb, 0x19, 0xc0, 0x78, 0x7b, 0x4f, 0x1a, 0x88, 0x1b, 0xd0, 0x2f, 0x07, 0xe2, 0x06, 0x35, 0xbb,
-	0x5a, 0xde, 0xc5, 0x3d, 0x83, 0x4e, 0x0f, 0x84, 0x6b, 0xe3, 0x55, 0x7d, 0xdd, 0x6d, 0x5b, 0x37,
-	0xd0, 0x2f, 0x00, 0xa2, 0xce, 0xd6, 0x13, 0x9d, 0x0c, 0x60, 0x09, 0x6c, 0xa1, 0x93, 0xb3, 0xdb,
-	0xf0, 0x90, 0xfc, 0xaf, 0x73, 0xf4, 0xb3, 0xe8, 0xcc, 0x60, 0x4a, 0x3b, 0x03, 0xf9, 0xe1, 0x6f,
-	0xc3, 0x30, 0x8f, 0x62, 0x2d, 0x30, 0x2c, 0xdd, 0xd0, 0x3d, 0xdc, 0xd3, 0x46, 0x12, 0x9d, 0x70,
-	0x15, 0xd5, 0xd0, 0x54, 0xbf, 0x78, 0x45, 0xab, 0x70, 0x94, 0x57, 0x7d, 0xd4, 0x6b, 0x70, 0x95,
-	0xb6, 0x93, 0x47, 0x7a, 0x1b, 0x49, 0x84, 0xc3, 0x2e, 0x42, 0x02, 0xed, 0xed, 0x8e, 0x80, 0x3e,
-	0x05, 0x70, 0xdc, 0xd3, 0x75, 0xa0, 0xa3, 0x01, 0x43, 0x77, 0x76, 0x3f, 0xc9, 0xcc, 0x20, 0xa6,
-	0x92, 0xe5, 0x98, 0xcb, 0x32, 0x85, 0x52, 0xdd, 0x59, 0xa8, 0xde, 0xe0, 0x9e, 0xe8, 0x0e, 0x80,
-	0x11, 0xd1, 0x34, 0xa0, 0xa0, 0x95, 0xfa, 0x7a, 0x93, 0xe4, 0x4b, 0x7d, 0xac, 0xb6, 0x07, 0x21,
-	0x66, 0xfe, 0x15, 0x40, 0xd4, 0x59, 0xe8, 0x03, 0xc3, 0x39, 0xb0, 0x83, 0x09, 0x0c, 0xe7, 0xe0,
-	0x2e, 0x62, 0xe0, 0xe3, 0x48, 0x75, 0x59, 0x6f, 0xf5, 0xf5, 0xb6, 0x4a, 0xbd, 0x81, 0xbe, 0x02,
-	0x70, 0xc2, 0x5b, 0x45, 0x03, 0xcb, 0x5d, 0x97, 0xbe, 0x20, 0xb0, 0xdc, 0x75, 0x2b, 0xcb, 0xda,
-	0x69, 0x97, 0x36, 0x83, 0x66, 0x7a, 0x9c, 0xc0, 0x92, 0xe3, 0xad, 0x08, 0xf3, 0x0b, 0x9b, 0x7f,
-	0xa5, 0x42, 0xf7, 0xb6, 0x52, 0xa1, 0xcd, 0xad, 0x14, 0x78, 0xb4, 0x95, 0x02, 0x7f, 0x6e, 0xa5,
-	0xc0, 0x27, 0x8f, 0x53, 0xa1, 0x47, 0x8f, 0x53, 0xa1, 0x3f, 0x1e, 0xa7, 0x42, 0xef, 0x4e, 0x7b,
-	0x6e, 0x6e, 0xf3, 0x16, 0xad, 0xbf, 0xa3, 0x46, 0xad, 0xe8, 0xb7, 0xc4, 0xe8, 0xfc, 0xdf, 0xb2,
-	0xa5, 0x08, 0xff, 0x17, 0xe8, 0xa9, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x4c, 0xae, 0x50, 0x98,
-	0xfd, 0x15, 0x00, 0x00,
+	// 1585 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x98, 0xcd, 0x6f, 0x13, 0xc7,
+	0x1b, 0xc7, 0x3d, 0xc1, 0x71, 0xec, 0x27, 0xf9, 0xfd, 0x70, 0xa6, 0x01, 0x8c, 0x01, 0x3b, 0x5a,
+	0x20, 0x04, 0x43, 0xbc, 0x24, 0x94, 0x22, 0xe8, 0xa1, 0xb2, 0x03, 0x25, 0xa0, 0x52, 0x82, 0x91,
+	0x5a, 0xa9, 0x55, 0xe5, 0x8e, 0xed, 0x89, 0xb3, 0xad, 0xbd, 0x6b, 0x76, 0x26, 0x84, 0x28, 0x0a,
+	0x07, 0x4e, 0x95, 0x7a, 0x68, 0xab, 0x9e, 0x4a, 0xa5, 0xb6, 0x87, 0x1e, 0xa0, 0xb4, 0x12, 0x52,
+	0x2b, 0x15, 0x55, 0xea, 0x3d, 0x47, 0xd4, 0x5e, 0x7a, 0xb2, 0xda, 0x50, 0x89, 0x8a, 0x3f, 0x81,
+	0x53, 0xb5, 0xb3, 0xb3, 0xde, 0xf5, 0xcb, 0xda, 0x26, 0xf8, 0xd0, 0x8b, 0xb5, 0xbb, 0xf3, 0x3c,
+	0xcf, 0x7c, 0xe6, 0x3b, 0x6f, 0xcf, 0x63, 0xd8, 0x5f, 0x34, 0x58, 0x75, 0x95, 0xb0, 0xaa, 0x2a,
+	0x7e, 0x6e, 0xcc, 0xaa, 0xd7, 0x57, 0xa8, 0xb9, 0x96, 0xae, 0x99, 0x06, 0x37, 0x70, 0xd4, 0x69,
+	0x4d, 0x8b, 0x9f, 0x1b, 0xb3, 0xf1, 0x89, 0xb2, 0x51, 0x36, 0x44, 0xa3, 0x6a, 0x3d, 0xd9, 0x76,
+	0xf1, 0xf6, 0x28, 0x7c, 0xad, 0x46, 0x99, 0xd3, 0x5a, 0x36, 0x8c, 0x72, 0x85, 0xaa, 0xa4, 0xa6,
+	0xa9, 0x44, 0xd7, 0x0d, 0x4e, 0xb8, 0x66, 0xe8, 0x4e, 0x6b, 0xca, 0xf2, 0x35, 0x98, 0x5a, 0x20,
+	0x8c, 0xda, 0x9d, 0xab, 0x37, 0x66, 0x0b, 0x94, 0x93, 0x59, 0xb5, 0x46, 0xca, 0x9a, 0x2e, 0x8c,
+	0xa5, 0xed, 0x3e, 0x69, 0xeb, 0x98, 0x79, 0x61, 0xe3, 0xe3, 0xa4, 0xaa, 0xe9, 0x86, 0x2a, 0x7e,
+	0xe5, 0xa7, 0xbd, 0xb6, 0x7d, 0xde, 0x06, 0xb6, 0x5f, 0xec, 0x26, 0xe5, 0x4d, 0x88, 0x5d, 0xb5,
+	0x9c, 0xe7, 0x0d, 0x9d, 0x9b, 0xa4, 0xc8, 0x2f, 0xea, 0x4b, 0x46, 0x8e, 0x5e, 0x5f, 0xa1, 0x8c,
+	0xe3, 0x39, 0x18, 0x21, 0xa5, 0x92, 0x49, 0x19, 0x8b, 0xa1, 0x49, 0x34, 0x1d, 0xc9, 0xc6, 0x7e,
+	0xfb, 0x69, 0x66, 0x42, 0xba, 0x67, 0xec, 0x96, 0x6b, 0xdc, 0xd4, 0xf4, 0x72, 0xce, 0x31, 0x54,
+	0x7e, 0x40, 0xb0, 0xb7, 0x43, 0x40, 0x56, 0x33, 0x74, 0x46, 0xb7, 0x13, 0x11, 0xbf, 0x05, 0xff,
+	0x2b, 0xca, 0x58, 0x79, 0x4d, 0x5f, 0x32, 0x62, 0x43, 0x93, 0x68, 0x7a, 0x74, 0x2e, 0x91, 0x6e,
+	0x9d, 0x94, 0xb4, 0xb7, 0xcb, 0xec, 0xf8, 0x66, 0x3d, 0x19, 0x78, 0x54, 0x4f, 0xa2, 0xa7, 0xf5,
+	0x64, 0xe0, 0xee, 0x93, 0x07, 0x29, 0x94, 0x1b, 0x2b, 0x7a, 0x0c, 0xce, 0x06, 0xff, 0xf9, 0x26,
+	0x89, 0x94, 0x2f, 0x10, 0xec, 0x6b, 0xe2, 0x5d, 0xd0, 0x18, 0x37, 0xcc, 0xb5, 0x17, 0xd0, 0x00,
+	0xbf, 0x0e, 0xe0, 0x4e, 0x99, 0xc4, 0x9d, 0x4a, 0x4b, 0x1f, 0x6b, 0x7e, 0xd3, 0xf6, 0x7c, 0xc9,
+	0xf9, 0x4d, 0x2f, 0x92, 0x32, 0x95, 0xfd, 0xe5, 0x3c, 0x9e, 0xca, 0x43, 0x04, 0xfb, 0x3b, 0xb3,
+	0x49, 0x39, 0xaf, 0xc0, 0x08, 0xd5, 0xb9, 0xa9, 0x51, 0x0b, 0x6e, 0xc7, 0xf4, 0xe8, 0x5c, 0xca,
+	0x5f, 0x94, 0x79, 0xa3, 0x44, 0xa5, 0xff, 0x79, 0x9d, 0x9b, 0x6b, 0xd9, 0xc8, 0x66, 0x43, 0x18,
+	0x27, 0x0a, 0xbe, 0xd0, 0x81, 0xfc, 0x48, 0x4f, 0x72, 0x9b, 0xa6, 0x09, 0xfd, 0x56, 0x8b, 0xaa,
+	0x2c, 0xbb, 0x66, 0x01, 0x38, 0xaa, 0xee, 0x81, 0x91, 0xa2, 0x51, 0xa2, 0x79, 0xad, 0x24, 0x54,
+	0x0d, 0xe6, 0x42, 0xd6, 0xeb, 0xc5, 0xd2, 0xc0, 0xa4, 0xfb, 0xba, 0x55, 0xba, 0x06, 0x80, 0x94,
+	0xee, 0x15, 0x88, 0x38, 0xab, 0xc1, 0x16, 0xaf, 0xdb, 0xcc, 0xba, 0xa6, 0x83, 0x53, 0xe8, 0x8e,
+	0x43, 0x98, 0xa9, 0x54, 0x1c, 0xc8, 0x6b, 0x9c, 0x70, 0xfa, 0x5f, 0x58, 0x79, 0xdf, 0x22, 0x38,
+	0xe0, 0x03, 0x27, 0xf5, 0x3b, 0x0b, 0xa1, 0xaa, 0x51, 0xa2, 0x15, 0x67, 0xe5, 0xed, 0x69, 0x5f,
+	0x79, 0x97, 0xad, 0x76, 0xef, 0x32, 0x93, 0x1e, 0x83, 0xd3, 0xf0, 0xba, 0x94, 0x30, 0x47, 0x56,
+	0x07, 0x26, 0xe1, 0x01, 0x00, 0xd1, 0x7b, 0xbe, 0x44, 0x38, 0x11, 0x70, 0x63, 0xb9, 0x88, 0xf8,
+	0x72, 0x8e, 0x70, 0xa2, 0x9c, 0x94, 0xc2, 0xb4, 0x77, 0x29, 0x85, 0xc1, 0x10, 0x14, 0x9e, 0x48,
+	0x78, 0x8a, 0x67, 0xe5, 0x4b, 0x04, 0x09, 0xe1, 0x75, 0xad, 0x4a, 0x4c, 0x3e, 0x30, 0xd4, 0xf3,
+	0xed, 0xa8, 0xd9, 0xa9, 0x67, 0xf5, 0x24, 0xf6, 0xc0, 0x5d, 0xa6, 0x8c, 0x91, 0x32, 0xbd, 0xf3,
+	0xe4, 0x41, 0x6a, 0x54, 0xd3, 0x2b, 0x9a, 0x4e, 0xf3, 0x1f, 0x30, 0x43, 0xf7, 0x0e, 0xe9, 0x3d,
+	0x48, 0xfa, 0xc2, 0x35, 0x66, 0xdb, 0x33, 0xa8, 0xbe, 0xfb, 0xb0, 0x07, 0x7f, 0x0c, 0xa2, 0x72,
+	0x27, 0xf6, 0xde, 0xff, 0x8a, 0x0a, 0x13, 0x0d, 0x63, 0xef, 0x55, 0xe4, 0xeb, 0xf0, 0xdd, 0x10,
+	0xec, 0x6a, 0xf1, 0x90, 0xcc, 0x07, 0x5b, 0x5c, 0xb2, 0xb0, 0x55, 0x4f, 0x86, 0x84, 0xd9, 0xb9,
+	0xc6, 0x79, 0x33, 0x07, 0x23, 0x45, 0x93, 0x12, 0x6e, 0x98, 0x42, 0xbf, 0xae, 0xb2, 0x4b, 0x43,
+	0xbc, 0x08, 0xe1, 0xe2, 0x32, 0x2d, 0x7e, 0xc8, 0x56, 0xaa, 0xb1, 0x1d, 0x42, 0x90, 0x97, 0x9f,
+	0xd5, 0x93, 0x27, 0xca, 0x1a, 0x5f, 0x5e, 0x29, 0xa4, 0x8b, 0x46, 0x55, 0x2d, 0x1a, 0x55, 0xca,
+	0x0b, 0x4b, 0xdc, 0x7d, 0xa8, 0x68, 0x05, 0xa6, 0x16, 0xd6, 0x38, 0x65, 0xe9, 0x05, 0x7a, 0x33,
+	0x6b, 0x3d, 0xe4, 0x1a, 0x51, 0xf0, 0xfb, 0xb0, 0x5b, 0xd3, 0x19, 0x27, 0x3a, 0xd7, 0x08, 0xa7,
+	0xf9, 0x1a, 0x35, 0xab, 0x1a, 0x63, 0xd6, 0xe6, 0x08, 0xfa, 0xdd, 0x75, 0x99, 0x62, 0x91, 0x32,
+	0x36, 0x6f, 0xe8, 0x4b, 0x5a, 0xd9, 0xbb, 0xc7, 0x76, 0x79, 0x02, 0x2d, 0x36, 0xe2, 0xc8, 0xcb,
+	0xee, 0xe1, 0x10, 0x44, 0xdb, 0x74, 0x3a, 0xda, 0xaa, 0x53, 0xd4, 0xd5, 0xe9, 0x69, 0x3d, 0x39,
+	0xa4, 0x95, 0x5e, 0x48, 0xad, 0xab, 0x10, 0xb1, 0x96, 0x41, 0x7e, 0x99, 0xb0, 0xe5, 0x17, 0x93,
+	0xcb, 0x0a, 0xb3, 0x40, 0xd8, 0x72, 0x17, 0xb9, 0x42, 0x83, 0x94, 0xeb, 0x52, 0x30, 0x1c, 0x8c,
+	0x0e, 0x5f, 0x0a, 0x86, 0x87, 0xa3, 0x21, 0xe5, 0x36, 0x82, 0x71, 0xcf, 0x32, 0x96, 0xda, 0x5d,
+	0xb4, 0x6e, 0x11, 0x4b, 0x3b, 0x2b, 0x2f, 0x41, 0xa2, 0x73, 0xa5, 0xd3, 0x15, 0xdc, 0x2c, 0x79,
+	0x36, 0xec, 0xe4, 0x25, 0xb9, 0x70, 0x51, 0xb6, 0xe1, 0xfd, 0x72, 0x8b, 0xd9, 0xdb, 0x38, 0xfc,
+	0xb4, 0x9e, 0x14, 0xef, 0xf6, 0x26, 0x92, 0xf3, 0xf7, 0xae, 0x87, 0x81, 0x39, 0x5b, 0xa3, 0xf9,
+	0xcc, 0x47, 0xdb, 0x3e, 0xf3, 0xef, 0x23, 0xc0, 0xde, 0xe8, 0x72, 0x88, 0x6f, 0x00, 0x34, 0x86,
+	0xe8, 0x1c, 0xf6, 0xfd, 0x8c, 0xd1, 0x23, 0x72, 0xc4, 0x19, 0xe4, 0x00, 0x8f, 0x7e, 0x02, 0x7b,
+	0x04, 0xec, 0xa2, 0xa6, 0xeb, 0xb4, 0xd4, 0x45, 0x90, 0xed, 0x5f, 0x82, 0x1f, 0x23, 0x99, 0x1b,
+	0x37, 0xf5, 0x21, 0x65, 0x99, 0x82, 0xb0, 0xdc, 0x35, 0xb6, 0x28, 0xc1, 0xec, 0xe8, 0x56, 0x3d,
+	0x39, 0x62, 0x6f, 0x1b, 0x96, 0x1b, 0xb1, 0x77, 0xcc, 0x00, 0x07, 0x3c, 0x21, 0x67, 0x67, 0x91,
+	0x98, 0xa4, 0xea, 0x8c, 0x55, 0xc9, 0xc1, 0x4b, 0x4d, 0x5f, 0x25, 0xdd, 0xab, 0x10, 0xaa, 0x89,
+	0x2f, 0x72, 0x3d, 0xc4, 0xda, 0x27, 0xcc, 0xf6, 0x68, 0xba, 0x9e, 0x6d, 0x17, 0x6b, 0x21, 0x24,
+	0xda, 0x72, 0x27, 0x7b, 0x37, 0x3b, 0x12, 0x67, 0x60, 0xa7, 0xdc, 0xdf, 0xf9, 0x7e, 0x6f, 0xad,
+	0xff, 0x4b, 0x87, 0xcc, 0x80, 0x53, 0x95, 0x1f, 0x91, 0xbc, 0xbe, 0x3a, 0xd1, 0x4a, 0x39, 0x2e,
+	0x00, 0x6e, 0x94, 0x10, 0x92, 0x97, 0xf6, 0xce, 0xfa, 0xc6, 0x1d, 0x9f, 0x8c, 0xe3, 0x32, 0xb8,
+	0xd9, 0xbc, 0xef, 0xac, 0xad, 0xec, 0x8a, 0x56, 0x29, 0xc9, 0x0e, 0x1c, 0x75, 0xf7, 0xc9, 0x53,
+	0x45, 0x1c, 0x99, 0x42, 0x57, 0xfb, 0x9c, 0x10, 0x87, 0x5f, 0x07, 0xe9, 0x87, 0x9e, 0x53, 0x7a,
+	0x0c, 0x41, 0x46, 0x2a, 0x5c, 0x9c, 0xc6, 0x91, 0x9c, 0x78, 0xb6, 0xfa, 0xd4, 0x74, 0x8d, 0xe7,
+	0x89, 0x59, 0x66, 0xe2, 0xd6, 0x19, 0xcb, 0x85, 0xad, 0x0f, 0x19, 0xb3, 0xcc, 0x94, 0x2b, 0xb2,
+	0xa6, 0x6b, 0x86, 0xdd, 0x7e, 0x4d, 0x37, 0x77, 0x2f, 0x0a, 0xc3, 0x22, 0x22, 0xbe, 0x83, 0x60,
+	0xcc, 0x5b, 0xb7, 0xe1, 0x0e, 0x25, 0x8c, 0x5f, 0x81, 0x1a, 0x3f, 0xd6, 0x97, 0xad, 0xcd, 0xa9,
+	0xcc, 0x7e, 0x64, 0xad, 0xf2, 0xdb, 0xbf, 0xff, 0xfd, 0xf9, 0xd0, 0x14, 0x3e, 0xa4, 0xb6, 0x95,
+	0xea, 0xce, 0x6c, 0xab, 0xeb, 0x92, 0x72, 0x03, 0xdf, 0x47, 0xb0, 0xb3, 0xa5, 0xf6, 0xc2, 0x33,
+	0x3d, 0xfa, 0x6c, 0xae, 0x1f, 0xe3, 0xe9, 0x7e, 0xcd, 0x25, 0xe5, 0x19, 0x97, 0x32, 0x8d, 0x8f,
+	0xf7, 0x43, 0xa9, 0x2e, 0x4b, 0xb2, 0x7b, 0x1e, 0x5a, 0x59, 0xee, 0xf4, 0xa4, 0x6d, 0xae, 0xcb,
+	0x7a, 0xd2, 0xb6, 0x54, 0x51, 0xca, 0x69, 0x97, 0xf6, 0x38, 0x4e, 0x75, 0xa2, 0x2d, 0x51, 0x75,
+	0x5d, 0x1e, 0x94, 0x1b, 0xaa, 0x5b, 0x46, 0x7d, 0x8f, 0x20, 0xda, 0x5a, 0x5b, 0x60, 0xbf, 0xde,
+	0x7d, 0x2a, 0xa4, 0xb8, 0xda, 0xb7, 0x7d, 0xdf, 0xb8, 0x6d, 0xe2, 0x32, 0x41, 0xf6, 0x33, 0x82,
+	0x68, 0x6b, 0xc6, 0xef, 0x8b, 0xeb, 0x53, 0x8d, 0xf8, 0xe2, 0xfa, 0x95, 0x12, 0x4a, 0xd6, 0xc5,
+	0x3d, 0x8d, 0x4f, 0xf5, 0x85, 0x6b, 0x92, 0x55, 0x75, 0xdd, 0x2d, 0x0a, 0x36, 0xf0, 0x2f, 0x08,
+	0x70, 0x7b, 0x62, 0x8f, 0x4f, 0xf8, 0xb0, 0xf8, 0x16, 0x28, 0xf1, 0xd9, 0xe7, 0xf0, 0x90, 0xfc,
+	0xaf, 0x09, 0xf4, 0x33, 0xf8, 0x74, 0x7f, 0x4a, 0x5b, 0x81, 0x9a, 0xe1, 0x6f, 0x41, 0x50, 0xac,
+	0x62, 0xc5, 0x77, 0x59, 0xba, 0x4b, 0xf7, 0x60, 0x57, 0x1b, 0x49, 0x34, 0xe3, 0x2a, 0xaa, 0xe0,
+	0xc9, 0x5e, 0xeb, 0x15, 0xaf, 0xc2, 0xb0, 0xb8, 0xf5, 0x71, 0xb7, 0xe0, 0xce, 0xb1, 0x1d, 0x3f,
+	0xd4, 0xdd, 0x48, 0x22, 0x1c, 0x74, 0x11, 0x62, 0x78, 0x77, 0x67, 0x04, 0xfc, 0x09, 0x82, 0xb0,
+	0x93, 0x51, 0xe1, 0xa9, 0x2e, 0x71, 0xbd, 0xa7, 0xe1, 0x91, 0x9e, 0x76, 0x12, 0x61, 0xce, 0x45,
+	0x38, 0x82, 0x0f, 0x77, 0x46, 0x98, 0xb1, 0xf2, 0x3d, 0x8f, 0x14, 0x9f, 0x21, 0x18, 0xf5, 0xe4,
+	0x41, 0xf8, 0xa8, 0x4f, 0x67, 0xed, 0xf9, 0x58, 0x3c, 0xd5, 0x8f, 0xa9, 0x44, 0x3b, 0xe6, 0xa2,
+	0x4d, 0xe2, 0x44, 0x67, 0x34, 0xa6, 0xd6, 0x84, 0x27, 0xbe, 0x8d, 0x20, 0x64, 0xa7, 0x31, 0xd8,
+	0x4f, 0xfb, 0xa6, 0x6c, 0x29, 0x7e, 0xb8, 0x87, 0xd5, 0xf3, 0x41, 0xd8, 0x3d, 0xff, 0x8a, 0x00,
+	0xb7, 0xa7, 0x1e, 0xbe, 0x1b, 0xcc, 0x37, 0xa7, 0xf2, 0xdd, 0x60, 0xfe, 0x79, 0x4d, 0xdf, 0x07,
+	0x04, 0x53, 0x65, 0x06, 0xa0, 0xae, 0xb7, 0xe4, 0x0e, 0x1b, 0xf8, 0x2b, 0x04, 0x63, 0xde, 0x7b,
+	0xdd, 0xf7, 0x02, 0xee, 0x90, 0xa9, 0xf8, 0x5e, 0xc0, 0x9d, 0x12, 0x05, 0xe5, 0x94, 0x4b, 0x9b,
+	0xc2, 0xd3, 0x5d, 0xce, 0x84, 0x82, 0xe5, 0xed, 0x10, 0x66, 0x17, 0x36, 0xff, 0x4a, 0x04, 0xee,
+	0x6e, 0x25, 0x02, 0x9b, 0x5b, 0x09, 0xf4, 0x68, 0x2b, 0x81, 0xfe, 0xdc, 0x4a, 0xa0, 0x4f, 0x1f,
+	0x27, 0x02, 0x8f, 0x1e, 0x27, 0x02, 0x7f, 0x3c, 0x4e, 0x04, 0xde, 0x99, 0xf2, 0xd4, 0x92, 0xf3,
+	0x06, 0xab, 0xbe, 0xed, 0x44, 0x2d, 0xa9, 0x37, 0xed, 0xe8, 0xe2, 0x6f, 0xf8, 0x42, 0x48, 0xfc,
+	0xe5, 0x7d, 0xf2, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x93, 0x29, 0xae, 0x95, 0xed, 0x17, 0x00,
+	0x00,
 }
 
 func (this *QueryContractInfoResponse) Equal(that interface{}) bool {
@@ -1336,6 +1432,40 @@ func (this *QueryContractInfoResponse) Equal(that interface{}) bool {
 	return true
 }
 
+func (this *QueryCodeInfoResponse) Equal(that interface{}) bool {
+	if that == nil {
+		return this == nil
+	}
+
+	that1, ok := that.(*QueryCodeInfoResponse)
+	if !ok {
+		that2, ok := that.(QueryCodeInfoResponse)
+		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.Creator != that1.Creator {
+		return false
+	}
+	if !bytes.Equal(this.Checksum, that1.Checksum) {
+		return false
+	}
+	if !this.InstantiatePermission.Equal(&that1.InstantiatePermission) {
+		return false
+	}
+	return true
+}
+
 func (this *CodeInfoResponse) Equal(that interface{}) bool {
 	if that == nil {
 		return this == nil
@@ -1424,10 +1554,12 @@ type QueryClient interface {
 	RawContractState(ctx context.Context, in *QueryRawContractStateRequest, opts ...grpc.CallOption) (*QueryRawContractStateResponse, error)
 	// SmartContractState get smart query result from the contract
 	SmartContractState(ctx context.Context, in *QuerySmartContractStateRequest, opts ...grpc.CallOption) (*QuerySmartContractStateResponse, error)
-	// Code gets the binary code and metadata for a singe wasm code
+	// Code gets the binary code and metadata for a single wasm code
 	Code(ctx context.Context, in *QueryCodeRequest, opts ...grpc.CallOption) (*QueryCodeResponse, error)
 	// Codes gets the metadata for all stored wasm codes
 	Codes(ctx context.Context, in *QueryCodesRequest, opts ...grpc.CallOption) (*QueryCodesResponse, error)
+	// CodeInfo gets the metadata for a single wasm code
+	CodeInfo(ctx context.Context, in *QueryCodeInfoRequest, opts ...grpc.CallOption) (*QueryCodeInfoResponse, error)
 	// PinnedCodes gets the pinned code ids
 	PinnedCodes(ctx context.Context, in *QueryPinnedCodesRequest, opts ...grpc.CallOption) (*QueryPinnedCodesResponse, error)
 	// Params gets the module params
@@ -1518,6 +1650,15 @@ func (c *queryClient) Codes(ctx context.Context, in *QueryCodesRequest, opts ...
 	return out, nil
 }
 
+func (c *queryClient) CodeInfo(ctx context.Context, in *QueryCodeInfoRequest, opts ...grpc.CallOption) (*QueryCodeInfoResponse, error) {
+	out := new(QueryCodeInfoResponse)
+	err := c.cc.Invoke(ctx, "/cosmwasm.wasm.v1.Query/CodeInfo", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *queryClient) PinnedCodes(ctx context.Context, in *QueryPinnedCodesRequest, opts ...grpc.CallOption) (*QueryPinnedCodesResponse, error) {
 	out := new(QueryPinnedCodesResponse)
 	err := c.cc.Invoke(ctx, "/cosmwasm.wasm.v1.Query/PinnedCodes", in, out, opts...)
@@ -1568,10 +1709,12 @@ type QueryServer interface {
 	RawContractState(context.Context, *QueryRawContractStateRequest) (*QueryRawContractStateResponse, error)
 	// SmartContractState get smart query result from the contract
 	SmartContractState(context.Context, *QuerySmartContractStateRequest) (*QuerySmartContractStateResponse, error)
-	// Code gets the binary code and metadata for a singe wasm code
+	// Code gets the binary code and metadata for a single wasm code
 	Code(context.Context, *QueryCodeRequest) (*QueryCodeResponse, error)
 	// Codes gets the metadata for all stored wasm codes
 	Codes(context.Context, *QueryCodesRequest) (*QueryCodesResponse, error)
+	// CodeInfo gets the metadata for a single wasm code
+	CodeInfo(context.Context, *QueryCodeInfoRequest) (*QueryCodeInfoResponse, error)
 	// PinnedCodes gets the pinned code ids
 	PinnedCodes(context.Context, *QueryPinnedCodesRequest) (*QueryPinnedCodesResponse, error)
 	// Params gets the module params
@@ -1617,6 +1760,10 @@ func (*UnimplementedQueryServer) Codes(ctx context.Context, req *QueryCodesReque
 	return nil, status.Errorf(codes.Unimplemented, "method Codes not implemented")
 }
 
+func (*UnimplementedQueryServer) CodeInfo(ctx context.Context, req *QueryCodeInfoRequest) (*QueryCodeInfoResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method CodeInfo not implemented")
+}
+
 func (*UnimplementedQueryServer) PinnedCodes(ctx context.Context, req *QueryPinnedCodesRequest) (*QueryPinnedCodesResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method PinnedCodes not implemented")
 }
@@ -1781,6 +1928,24 @@ func _Query_Codes_Handler(srv interface{}, ctx context.Context, dec func(interfa
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Query_CodeInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryCodeInfoRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).CodeInfo(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/cosmwasm.wasm.v1.Query/CodeInfo",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).CodeInfo(ctx, req.(*QueryCodeInfoRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Query_PinnedCodes_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(QueryPinnedCodesRequest)
 	if err := dec(in); err != nil {
@@ -1889,6 +2054,10 @@ var _Query_serviceDesc = grpc.ServiceDesc{
 			MethodName: "Codes",
 			Handler:    _Query_Codes_Handler,
 		},
+		{
+			MethodName: "CodeInfo",
+			Handler:    _Query_CodeInfo_Handler,
+		},
 		{
 			MethodName: "PinnedCodes",
 			Handler:    _Query_PinnedCodes_Handler,
@@ -2408,6 +2577,86 @@ func (m *QueryCodeRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *QueryCodeInfoRequest) 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 *QueryCodeInfoRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryCodeInfoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.CodeId != 0 {
+		i = encodeVarintQuery(dAtA, i, uint64(m.CodeId))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *QueryCodeInfoResponse) 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 *QueryCodeInfoResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryCodeInfoResponse) 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 = encodeVarintQuery(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x22
+	if len(m.Checksum) > 0 {
+		i -= len(m.Checksum)
+		copy(dAtA[i:], m.Checksum)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.Checksum)))
+		i--
+		dAtA[i] = 0x1a
+	}
+	if len(m.Creator) > 0 {
+		i -= len(m.Creator)
+		copy(dAtA[i:], m.Creator)
+		i = encodeVarintQuery(dAtA, i, uint64(len(m.Creator)))
+		i--
+		dAtA[i] = 0x12
+	}
+	if m.CodeID != 0 {
+		i = encodeVarintQuery(dAtA, i, uint64(m.CodeID))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *CodeInfoResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -2654,20 +2903,20 @@ func (m *QueryPinnedCodesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error
 		dAtA[i] = 0x12
 	}
 	if len(m.CodeIDs) > 0 {
-		dAtA15 := make([]byte, len(m.CodeIDs)*10)
-		var j14 int
+		dAtA16 := make([]byte, len(m.CodeIDs)*10)
+		var j15 int
 		for _, num := range m.CodeIDs {
 			for num >= 1<<7 {
-				dAtA15[j14] = uint8(uint64(num)&0x7f | 0x80)
+				dAtA16[j15] = uint8(uint64(num)&0x7f | 0x80)
 				num >>= 7
-				j14++
+				j15++
 			}
-			dAtA15[j14] = uint8(num)
-			j14++
+			dAtA16[j15] = uint8(num)
+			j15++
 		}
-		i -= j14
-		copy(dAtA[i:], dAtA15[:j14])
-		i = encodeVarintQuery(dAtA, i, uint64(j14))
+		i -= j15
+		copy(dAtA[i:], dAtA16[:j15])
+		i = encodeVarintQuery(dAtA, i, uint64(j15))
 		i--
 		dAtA[i] = 0xa
 	}
@@ -3116,6 +3365,40 @@ func (m *QueryCodeRequest) Size() (n int) {
 	return n
 }
 
+func (m *QueryCodeInfoRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.CodeId != 0 {
+		n += 1 + sovQuery(uint64(m.CodeId))
+	}
+	return n
+}
+
+func (m *QueryCodeInfoResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.CodeID != 0 {
+		n += 1 + sovQuery(uint64(m.CodeID))
+	}
+	l = len(m.Creator)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	l = len(m.Checksum)
+	if l > 0 {
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	l = m.InstantiatePermission.Size()
+	n += 1 + l + sovQuery(uint64(l))
+	return n
+}
+
 func (m *CodeInfoResponse) Size() (n int) {
 	if m == nil {
 		return 0
@@ -4700,6 +4983,245 @@ func (m *QueryCodeRequest) Unmarshal(dAtA []byte) error {
 	return nil
 }
 
+func (m *QueryCodeInfoRequest) 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 ErrIntOverflowQuery
+			}
+			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: QueryCodeInfoRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryCodeInfoRequest: 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 ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.CodeId |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+
+func (m *QueryCodeInfoResponse) 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 ErrIntOverflowQuery
+			}
+			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: QueryCodeInfoResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryCodeInfoResponse: 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 ErrIntOverflowQuery
+				}
+				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 Creator", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				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 ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Creator = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Checksum", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Checksum = append(m.Checksum[:0], dAtA[iNdEx:postIndex]...)
+			if m.Checksum == nil {
+				m.Checksum = []byte{}
+			}
+			iNdEx = postIndex
+		case 4:
+			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 ErrIntOverflowQuery
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthQuery
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthQuery
+			}
+			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 := skipQuery(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthQuery
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+
 func (m *CodeInfoResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0

x/wasm/types/query.pb.gw.go

@@ -52,6 +52,7 @@ func request_Query_ContractInfo_0(ctx context.Context, marshaler runtime.Marshal
 	}
 
 	protoReq.Address, err = runtime.String(val)
+
 	if err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "address", err)
 	}
@@ -77,6 +78,7 @@ func local_request_Query_ContractInfo_0(ctx context.Context, marshaler runtime.M
 	}
 
 	protoReq.Address, err = runtime.String(val)
+
 	if err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "address", err)
 	}
@@ -104,6 +106,7 @@ func request_Query_ContractHistory_0(ctx context.Context, marshaler runtime.Mars
 	}
 
 	protoReq.Address, err = runtime.String(val)
+
 	if err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "address", err)
 	}
@@ -136,6 +139,7 @@ func local_request_Query_ContractHistory_0(ctx context.Context, marshaler runtim
 	}
 
 	protoReq.Address, err = runtime.String(val)
+
 	if err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "address", err)
 	}
@@ -170,6 +174,7 @@ func request_Query_ContractsByCode_0(ctx context.Context, marshaler runtime.Mars
 	}
 
 	protoReq.CodeId, err = runtime.Uint64(val)
+
 	if err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "code_id", err)
 	}
@@ -202,6 +207,7 @@ func local_request_Query_ContractsByCode_0(ctx context.Context, marshaler runtim
 	}
 
 	protoReq.CodeId, err = runtime.Uint64(val)
+
 	if err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "code_id", err)
 	}
@@ -236,6 +242,7 @@ func request_Query_AllContractState_0(ctx context.Context, marshaler runtime.Mar
 	}
 
 	protoReq.Address, err = runtime.String(val)
+
 	if err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "address", err)
 	}
@@ -268,6 +275,7 @@ func local_request_Query_AllContractState_0(ctx context.Context, marshaler runti
 	}
 
 	protoReq.Address, err = runtime.String(val)
+
 	if err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "address", err)
 	}
@@ -300,6 +308,7 @@ func request_Query_RawContractState_0(ctx context.Context, marshaler runtime.Mar
 	}
 
 	protoReq.Address, err = runtime.String(val)
+
 	if err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "address", err)
 	}
@@ -310,6 +319,7 @@ func request_Query_RawContractState_0(ctx context.Context, marshaler runtime.Mar
 	}
 
 	protoReq.QueryData, err = runtime.Bytes(val)
+
 	if err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "query_data", err)
 	}
@@ -335,6 +345,7 @@ func local_request_Query_RawContractState_0(ctx context.Context, marshaler runti
 	}
 
 	protoReq.Address, err = runtime.String(val)
+
 	if err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "address", err)
 	}
@@ -345,6 +356,7 @@ func local_request_Query_RawContractState_0(ctx context.Context, marshaler runti
 	}
 
 	protoReq.QueryData, err = runtime.Bytes(val)
+
 	if err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "query_data", err)
 	}
@@ -370,6 +382,7 @@ func request_Query_SmartContractState_0(ctx context.Context, marshaler runtime.M
 	}
 
 	protoReq.Address, err = runtime.String(val)
+
 	if err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "address", err)
 	}
@@ -380,6 +393,7 @@ func request_Query_SmartContractState_0(ctx context.Context, marshaler runtime.M
 	}
 
 	protoReq.QueryData, err = runtime.Bytes(val)
+
 	if err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "query_data", err)
 	}
@@ -405,6 +419,7 @@ func local_request_Query_SmartContractState_0(ctx context.Context, marshaler run
 	}
 
 	protoReq.Address, err = runtime.String(val)
+
 	if err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "address", err)
 	}
@@ -415,6 +430,7 @@ func local_request_Query_SmartContractState_0(ctx context.Context, marshaler run
 	}
 
 	protoReq.QueryData, err = runtime.Bytes(val)
+
 	if err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "query_data", err)
 	}
@@ -440,6 +456,7 @@ func request_Query_Code_0(ctx context.Context, marshaler runtime.Marshaler, clie
 	}
 
 	protoReq.CodeId, err = runtime.Uint64(val)
+
 	if err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "code_id", err)
 	}
@@ -465,6 +482,7 @@ func local_request_Query_Code_0(ctx context.Context, marshaler runtime.Marshaler
 	}
 
 	protoReq.CodeId, err = runtime.Uint64(val)
+
 	if err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "code_id", err)
 	}
@@ -505,6 +523,58 @@ func local_request_Query_Codes_0(ctx context.Context, marshaler runtime.Marshale
 	return msg, metadata, err
 }
 
+func request_Query_CodeInfo_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryCodeInfoRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["code_id"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "code_id")
+	}
+
+	protoReq.CodeId, err = runtime.Uint64(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "code_id", err)
+	}
+
+	msg, err := client.CodeInfo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+}
+
+func local_request_Query_CodeInfo_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryCodeInfoRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["code_id"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "code_id")
+	}
+
+	protoReq.CodeId, err = runtime.Uint64(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "code_id", err)
+	}
+
+	msg, err := server.CodeInfo(ctx, &protoReq)
+	return msg, metadata, err
+}
+
 var filter_Query_PinnedCodes_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
 
 func request_Query_PinnedCodes_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
@@ -572,6 +642,7 @@ func request_Query_ContractsByCreator_0(ctx context.Context, marshaler runtime.M
 	}
 
 	protoReq.CreatorAddress, err = runtime.String(val)
+
 	if err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "creator_address", err)
 	}
@@ -604,6 +675,7 @@ func local_request_Query_ContractsByCreator_0(ctx context.Context, marshaler run
 	}
 
 	protoReq.CreatorAddress, err = runtime.String(val)
+
 	if err != nil {
 		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "creator_address", err)
 	}
@@ -832,6 +904,28 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 		forward_Query_Codes_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 	})
 
+	mux.Handle("GET", pattern_Query_CodeInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		var stream runtime.ServerTransportStream
+		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_Query_CodeInfo_0(rctx, inboundMarshaler, server, req, pathParams)
+		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_CodeInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+
 	mux.Handle("GET", pattern_Query_PinnedCodes_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -1112,6 +1206,25 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
 		forward_Query_Codes_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 	})
 
+	mux.Handle("GET", pattern_Query_CodeInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+		ctx, cancel := context.WithCancel(req.Context())
+		defer cancel()
+		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+		rctx, err := runtime.AnnotateContext(ctx, mux, req)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_Query_CodeInfo_0(rctx, inboundMarshaler, client, req, pathParams)
+		ctx = runtime.NewServerMetadataContext(ctx, md)
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+
+		forward_Query_CodeInfo_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+
 	mux.Handle("GET", pattern_Query_PinnedCodes_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
 		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
@@ -1208,6 +1321,8 @@ var (
 
 	pattern_Query_Codes_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"cosmwasm", "wasm", "v1", "code"}, "", runtime.AssumeColonVerbOpt(false)))
 
+	pattern_Query_CodeInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"cosmwasm", "wasm", "v1", "code-info", "code_id"}, "", runtime.AssumeColonVerbOpt(false)))
+
 	pattern_Query_PinnedCodes_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"cosmwasm", "wasm", "v1", "codes", "pinned"}, "", runtime.AssumeColonVerbOpt(false)))
 
 	pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"cosmwasm", "wasm", "v1", "codes", "params"}, "", runtime.AssumeColonVerbOpt(false)))
@@ -1234,6 +1349,8 @@ var (
 
 	forward_Query_Codes_0 = runtime.ForwardResponseMessage
 
+	forward_Query_CodeInfo_0 = runtime.ForwardResponseMessage
+
 	forward_Query_PinnedCodes_0 = runtime.ForwardResponseMessage
 
 	forward_Query_Params_0 = runtime.ForwardResponseMessage