List contract address without other data

2021-04-23 15:07:33 +02:00 · 2021-04-23 15:07:33 +02:00 · c377d7110e
parent 8ef2d2695b
commit c377d7110e
16 changed files with 214 additions and 469 deletions
--- a/contrib/local/02-contracts.sh
+++ b/contrib/local/02-contracts.sh
@ -25,7 +25,7 @@ wasmd tx wasm instantiate "$CODE_ID" "$INIT" --admin=$(wasmd keys show validator
  --from validator --amount="100ustake" --label "local0.1.0" \
  --gas 1000000 -y --chain-id=testing -b block | jq

-CONTRACT=$(wasmd query wasm list-contract-by-code "$CODE_ID" -o json | jq -r '.contract_infos[-1].address')
+CONTRACT=$(wasmd query wasm list-contract-by-code "$CODE_ID" -o json | jq -r '.contracts[-1]')
 echo "* Contract address: $CONTRACT"
 echo "### Query all"
 RESP=$(wasmd query wasm contract-state all "$CONTRACT" -o json)
--- a/contrib/local/03-grpc-queries.sh
+++ b/contrib/local/03-grpc-queries.sh
@ -4,26 +4,28 @@ set -o errexit -o nounset -o pipefail
 DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd)"

 echo "-----------------------"
-COSMOS_SDK_DIR=${COSMOS_SDK_DIR:-$(go list -f "{{ .Dir }}" -m github.com/cosmos/cosmos-sdk)}
+PROTO_THRD="$DIR/../../third_party/proto"
+PROTO_WASMD="$DIR/../../proto"
+PROTO_WASMD_QUERY="$PROTO_WASMD/cosmwasm/wasm/v1beta1/query.proto"

 echo "### List all codes"
-RESP=$(grpcurl -plaintext -import-path $COSMOS_SDK_DIR/third_party/proto -import-path $COSMOS_SDK_DIR/proto -import-path . -proto ./x/wasm/types/query.proto \
+RESP=$(grpcurl -plaintext -import-path $PROTO_THRD -import-path $PROTO_WASMD -proto $PROTO_WASMD_QUERY \
  localhost:9090  cosmwasm.wasm.v1beta1.Query/Codes)
 echo "$RESP" | jq

 CODE_ID=$(echo "$RESP" | jq -r '.codeInfos[-1].codeId')
-echo "### List contract by code"
-RESP=$(grpcurl -plaintext -import-path $COSMOS_SDK_DIR/third_party/proto -import-path $COSMOS_SDK_DIR/proto -import-path . -proto ./x/wasm/types/query.proto \
+echo "### List contracts by code"
+RESP=$(grpcurl -plaintext -import-path $PROTO_THRD -import-path $PROTO_WASMD -proto $PROTO_WASMD_QUERY \
  -d "{\"codeId\": $CODE_ID}" localhost:9090  cosmwasm.wasm.v1beta1.Query/ContractsByCode )
 echo $RESP | jq

 echo "### Show history for contract"
-CONTRACT=$(echo $RESP | jq -r ".contractInfos[-1].address")
-grpcurl -plaintext -import-path $COSMOS_SDK_DIR/third_party/proto -import-path $COSMOS_SDK_DIR/proto -import-path . -proto ./x/wasm/types/query.proto \
+CONTRACT=$(echo $RESP | jq -r ".contracts[-1]")
+grpcurl -plaintext -import-path $PROTO_THRD -import-path $PROTO_WASMD -proto $PROTO_WASMD_QUERY \
  -d "{\"address\": \"$CONTRACT\"}" localhost:9090  cosmwasm.wasm.v1beta1.Query/ContractHistory | jq

 echo "### Show contract state"
-grpcurl -plaintext -import-path $COSMOS_SDK_DIR/third_party/proto -import-path $COSMOS_SDK_DIR/proto -import-path . -proto ./x/wasm/types/query.proto \
+grpcurl -plaintext -import-path $PROTO_THRD -import-path $PROTO_WASMD -proto $PROTO_WASMD_QUERY \
  -d "{\"address\": \"$CONTRACT\"}" localhost:9090  cosmwasm.wasm.v1beta1.Query/AllContractState | jq

 echo "Empty state due to 'burner' contract cleanup"
--- a/docs/proto/proto-docs.md
+++ b/docs/proto/proto-docs.md
@ -55,7 +55,6 @@
  
 - [cosmwasm/wasm/v1beta1/query.proto](#cosmwasm/wasm/v1beta1/query.proto)
    - [CodeInfoResponse](#cosmwasm.wasm.v1beta1.CodeInfoResponse)
-    - [ContractInfoWithAddress](#cosmwasm.wasm.v1beta1.ContractInfoWithAddress)
    - [QueryAllContractStateRequest](#cosmwasm.wasm.v1beta1.QueryAllContractStateRequest)
    - [QueryAllContractStateResponse](#cosmwasm.wasm.v1beta1.QueryAllContractStateResponse)
    - [QueryCodeRequest](#cosmwasm.wasm.v1beta1.QueryCodeRequest)
@ -814,23 +813,6 @@ CodeInfoResponse contains code meta data from CodeInfo



-<a name="cosmwasm.wasm.v1beta1.ContractInfoWithAddress"></a>
-
-### ContractInfoWithAddress
-ContractInfoWithAddress adds the address (key) to the ContractInfo
-representation
-
-
-| Field | Type | Label | Description |
-| ----- | ---- | ----- | ----------- |
-| `address` | [string](#string) |  |  |
-| `contract_info` | [ContractInfo](#cosmwasm.wasm.v1beta1.ContractInfo) |  |  |
-
-
-
-
-
-
 <a name="cosmwasm.wasm.v1beta1.QueryAllContractStateRequest"></a>

 ### QueryAllContractStateRequest
@ -1020,7 +1002,7 @@ Query/ContractsByCode RPC method

 | Field | Type | Label | Description |
 | ----- | ---- | ----- | ----------- |
-| `contract_infos` | [ContractInfoWithAddress](#cosmwasm.wasm.v1beta1.ContractInfoWithAddress) | repeated |  |
+| `contracts` | [string](#string) | repeated | contracts are a set of contract addresses |
 | `pagination` | [cosmos.base.query.v1beta1.PageResponse](#cosmos.base.query.v1beta1.PageResponse) |  | pagination defines the pagination in the response. |


--- a/proto/cosmwasm/wasm/v1beta1/query.proto
+++ b/proto/cosmwasm/wasm/v1beta1/query.proto
@ -100,23 +100,12 @@ message QueryContractsByCodeRequest {
  cosmos.base.query.v1beta1.PageRequest pagination = 2;
 }

-// ContractInfoWithAddress adds the address (key) to the ContractInfo
-// representation
-message ContractInfoWithAddress {
-  option (gogoproto.equal) = true;
-
-  string address = 1;
-  ContractInfo contract_info = 2 [
-    (gogoproto.embed) = true,
-    (gogoproto.nullable) = false,
-    (gogoproto.jsontag) = ""
-  ];
-}
 // QueryContractsByCodeResponse is the response type for the
 // Query/ContractsByCode RPC method
 message QueryContractsByCodeResponse {
-  repeated ContractInfoWithAddress contract_infos = 1
-      [ (gogoproto.nullable) = false ];
+  // contracts are a set of contract addresses
+  repeated string contracts = 1;
+
  // pagination defines the pagination in the response.
  cosmos.base.query.v1beta1.PageResponse pagination = 2;
 }
--- a/x/wasm/alias.go
+++ b/x/wasm/alias.go
@ -125,7 +125,6 @@ type (
 	ContractInfo                   = types.ContractInfo
 	CreatedAt                      = types.AbsoluteTxPosition
 	Config                         = types.WasmConfig
-	ContractInfoWithAddress        = types.ContractInfoWithAddress
 	CodeInfoResponse               = types.CodeInfoResponse
 	MessageHandler                 = keeper.SDKMessageHandler
 	BankEncoder                    = keeper.BankEncoder
--- a/x/wasm/keeper/genesis_test.go
+++ b/x/wasm/keeper/genesis_test.go
@ -6,20 +6,14 @@ import (
 	"encoding/base64"
 	"errors"
 	"fmt"
-	prefix2 "github.com/cosmos/cosmos-sdk/store/prefix"
-	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
-	"io/ioutil"
-	"math/rand"
-	"os"
-	"testing"
-	"time"
-
 	"github.com/CosmWasm/wasmd/x/wasm/types"
 	wasmTypes "github.com/CosmWasm/wasmd/x/wasm/types"
 	"github.com/cosmos/cosmos-sdk/store"
+	"github.com/cosmos/cosmos-sdk/store/prefix"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper"
 	distributionkeeper "github.com/cosmos/cosmos-sdk/x/distribution/keeper"
+	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
 	paramskeeper "github.com/cosmos/cosmos-sdk/x/params/keeper"
 	paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
 	stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
@ -31,6 +25,11 @@ import (
 	"github.com/tendermint/tendermint/proto/tendermint/crypto"
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
 	dbm "github.com/tendermint/tm-db"
+	"io/ioutil"
+	"math/rand"
+	"os"
+	"testing"
+	"time"
 )

 const firstCodeID = 1
@ -110,9 +109,9 @@ func TestGenesisExportImport(t *testing.T) {
 	// reset contract code index in source DB for comparison with dest DB
 	wasmKeeper.IterateContractInfo(srcCtx, func(address sdk.AccAddress, info wasmTypes.ContractInfo) bool {
 		wasmKeeper.removeFromContractCodeSecondaryIndex(srcCtx, address, wasmKeeper.getLastContractHistoryEntry(srcCtx, address))
-		prefix := prefix2.NewStore(srcCtx.KVStore(wasmKeeper.storeKey), types.GetContractCodeHistoryElementPrefix(address))
-		for iter := prefix.Iterator(nil, nil); iter.Valid(); iter.Next() {
-			prefix.Delete(iter.Key())
+		prefixStore := prefix.NewStore(srcCtx.KVStore(wasmKeeper.storeKey), types.GetContractCodeHistoryElementPrefix(address))
+		for iter := prefixStore.Iterator(nil, nil); iter.Valid(); iter.Next() {
+			prefixStore.Delete(iter.Key())
 		}
 		x := &info
 		newHistory := x.ResetFromGenesis(dstCtx)
--- a/x/wasm/keeper/keeper.go
+++ b/x/wasm/keeper/keeper.go
@ -521,6 +521,17 @@ func (k Keeper) removeFromContractCodeSecondaryIndex(ctx sdk.Context, contractAd
 	ctx.KVStore(k.storeKey).Delete(types.GetContractByCreatedSecondaryIndexKey(contractAddress, entry))
 }

+// IterateContractsByCode iterates over all contracts with given codeID ASC on code update time.
+func (k Keeper) IterateContractsByCode(ctx sdk.Context, codeID uint64, cb func(address sdk.AccAddress) bool) {
+	prefixStore := prefix.NewStore(ctx.KVStore(k.storeKey), types.GetContractByCodeIDSecondaryIndexPrefix(codeID))
+	for iter := prefixStore.Iterator(nil, nil); iter.Valid(); iter.Next() {
+		key := iter.Key()
+		if cb(key[types.AbsoluteTxPositionLen:]) {
+			return
+		}
+	}
+}
+
 func (k Keeper) setContractAdmin(ctx sdk.Context, contractAddress, caller, newAdmin sdk.AccAddress, authZ AuthorizationPolicy) error {
 	contractInfo := k.GetContractInfo(ctx, contractAddress)
 	if contractInfo == nil {
@ -562,6 +573,7 @@ func (k Keeper) GetContractHistory(ctx sdk.Context, contractAddr sdk.AccAddress)
 	return r
 }

+// getLastContractHistoryEntry returns the last element from history. To be used internally only as it panics when none exists
 func (k Keeper) getLastContractHistoryEntry(ctx sdk.Context, contractAddr sdk.AccAddress) types.ContractCodeHistoryEntry {
 	prefixStore := prefix.NewStore(ctx.KVStore(k.storeKey), types.GetContractCodeHistoryElementPrefix(contractAddr))
 	iter := prefixStore.ReverseIterator(nil, nil)
--- a/x/wasm/keeper/keeper_test.go
+++ b/x/wasm/keeper/keeper_test.go
@ -1055,6 +1055,47 @@ func TestMigrateWithDispatchedMessage(t *testing.T) {
 	assert.Equal(t, deposit, balance)
 }

+func TestIterateContractsByCode(t *testing.T) {
+	ctx, keepers := CreateTestInput(t, false, SupportedFeatures)
+	k, c := keepers.WasmKeeper, keepers.ContractKeeper
+	example1 := InstantiateHackatomExampleContract(t, ctx, keepers)
+	ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1)
+	example2 := InstantiateIBCReflectContract(t, ctx, keepers)
+	ctx = ctx.WithBlockHeight(ctx.BlockHeight() + 1)
+	initMsg := HackatomExampleInitMsg{
+		Verifier:    RandomAccountAddress(t),
+		Beneficiary: RandomAccountAddress(t),
+	}.GetBytes(t)
+	contractAddr3, _, err := c.Instantiate(ctx, example1.CodeID, example1.CreatorAddr, nil, initMsg, "foo", nil)
+	require.NoError(t, err)
+	specs := map[string]struct {
+		codeID uint64
+		exp    []sdk.AccAddress
+	}{
+		"multiple results": {
+			codeID: example1.CodeID,
+			exp:    []sdk.AccAddress{example1.Contract, contractAddr3},
+		},
+		"single results": {
+			codeID: example2.CodeID,
+			exp:    []sdk.AccAddress{example2.Contract},
+		},
+		"empty results": {
+			codeID: 99999,
+		},
+	}
+	for name, spec := range specs {
+		t.Run(name, func(t *testing.T) {
+			var gotAddr []sdk.AccAddress
+			k.IterateContractsByCode(ctx, spec.codeID, func(address sdk.AccAddress) bool {
+				gotAddr = append(gotAddr, address)
+				return false
+			})
+			assert.Equal(t, spec.exp, gotAddr)
+		})
+	}
+}
+
 type sudoMsg struct {
 	// This is a tongue-in-check demo command. This is not the intended purpose of Sudo.
 	// Here we show that some priviledged Go module can make a call that should never be exposed
--- a/x/wasm/keeper/legacy_querier.go
+++ b/x/wasm/keeper/legacy_querier.go
@ -2,15 +2,12 @@ package keeper

 import (
 	"encoding/json"
-	"reflect"
-	"sort"
-	"strconv"
-	"strings"
-
 	"github.com/CosmWasm/wasmd/x/wasm/types"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	abci "github.com/tendermint/tendermint/abci/types"
+	"reflect"
+	"strconv"
 )

 const (
@ -47,7 +44,7 @@ func NewLegacyQuerier(keeper types.ViewKeeper, gasLimit sdk.Gas) sdk.Querier {
 			if err != nil {
 				return nil, sdkerrors.Wrapf(types.ErrInvalid, "code id: %s", err.Error())
 			}
-			rsp, err = queryContractListByCode(ctx, codeID, keeper)
+			rsp = queryContractListByCode(ctx, codeID, keeper)
 		case QueryGetContractState:
 			if len(path) < 3 {
 				return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, "unknown data query endpoint")
@ -145,32 +142,11 @@ func queryContractHistory(ctx sdk.Context, contractAddr sdk.AccAddress, keeper t
 	return history, nil
 }

-func queryContractListByCode(ctx sdk.Context, codeID uint64, keeper types.ViewKeeper) ([]types.ContractInfoWithAddress, error) {
-	var contracts []types.ContractInfoWithAddress
-	keeper.IterateContractInfo(ctx, func(addr sdk.AccAddress, info types.ContractInfo) bool {
-		if info.CodeID == codeID {
-			// and add the address
-			infoWithAddress := types.ContractInfoWithAddress{
-				Address:      addr.String(),
-				ContractInfo: info,
-			}
-			contracts = append(contracts, infoWithAddress)
-		}
+func queryContractListByCode(ctx sdk.Context, codeID uint64, keeper types.ViewKeeper) []string {
+	var contracts []string
+	keeper.IterateContractsByCode(ctx, codeID, func(addr sdk.AccAddress) bool {
+		contracts = append(contracts, addr.String())
 		return false
 	})
-
-	// now we sort them by AbsoluteTxPosition
-	sort.Slice(contracts, func(i, j int) bool {
-		this := contracts[i].ContractInfo.Created
-		other := contracts[j].ContractInfo.Created
-		if this.Equal(other) {
-			return strings.Compare(contracts[i].Address, contracts[j].Address) < 0
-		}
-		return this.LessThan(other)
-	})
-
-	for i := range contracts {
-		contracts[i].Created = nil
-	}
-	return contracts, nil
+	return contracts
 }
--- a/x/wasm/keeper/legacy_querier_test.go
+++ b/x/wasm/keeper/legacy_querier_test.go
@ -205,17 +205,14 @@ func TestLegacyQueryContractListByCodeOrdering(t *testing.T) {
 	res, err := q(ctx, query, data)
 	require.NoError(t, err)

-	var contracts []map[string]interface{}
+	var contracts []string
 	err = json.Unmarshal(res, &contracts)
 	require.NoError(t, err)

 	require.Equal(t, 10, len(contracts))

-	for i, contract := range contracts {
-		assert.Equal(t, fmt.Sprintf("contract %d", i), contract["label"])
-		assert.NotEmpty(t, contract["address"])
-		// ensure these are not shown
-		assert.Nil(t, contract["created"])
+	for _, contract := range contracts {
+		assert.NotEmpty(t, contract)
 	}
 }

--- a/x/wasm/keeper/querier.go
+++ b/x/wasm/keeper/querier.go
@ -43,10 +43,7 @@ func (q grpcQuerier) ContractInfo(c context.Context, req *types.QueryContractInf
 	case rsp == nil:
 		return nil, types.ErrNotFound
 	}
-	return &types.QueryContractInfoResponse{
-		Address:      rsp.Address,
-		ContractInfo: rsp.ContractInfo,
-	}, nil
+	return rsp, nil
 }

 func (q grpcQuerier) ContractHistory(c context.Context, req *types.QueryContractHistoryRequest) (*types.QueryContractHistoryResponse, error) {
@ -82,6 +79,7 @@ func (q grpcQuerier) ContractHistory(c context.Context, req *types.QueryContract
 	}, nil
 }

+// ContractsByCode lists all smart contracts for a code id
 func (q grpcQuerier) ContractsByCode(c context.Context, req *types.QueryContractsByCodeRequest) (*types.QueryContractsByCodeResponse, error) {
 	if req == nil {
 		return nil, status.Error(codes.InvalidArgument, "empty request")
@ -90,21 +88,13 @@ func (q grpcQuerier) ContractsByCode(c context.Context, req *types.QueryContract
 		return nil, sdkerrors.Wrap(types.ErrInvalid, "code id")
 	}
 	ctx := sdk.UnwrapSDKContext(c)
-	r := make([]types.ContractInfoWithAddress, 0)
+	r := make([]string, 0)

 	prefixStore := prefix.NewStore(ctx.KVStore(q.storeKey), types.GetContractByCodeIDSecondaryIndexPrefix(req.CodeId))
 	pageRes, err := query.FilteredPaginate(prefixStore, req.Pagination, func(key []byte, value []byte, accumulate bool) (bool, error) {
-		var contractAddr sdk.AccAddress = key[types.AbsoluteTxPositionLen:]
-		c := q.keeper.GetContractInfo(ctx, contractAddr)
-		if c == nil {
-			return false, types.ErrNotFound
-		}
-		c.Created = nil // redact
 		if accumulate {
-			r = append(r, types.ContractInfoWithAddress{
-				Address:      contractAddr.String(),
-				ContractInfo: *c,
-			})
+			var contractAddr sdk.AccAddress = key[types.AbsoluteTxPositionLen:]
+			r = append(r, contractAddr.String())
 		}
 		return true, nil
 	})
@ -112,8 +102,8 @@ func (q grpcQuerier) ContractsByCode(c context.Context, req *types.QueryContract
 		return nil, err
 	}
 	return &types.QueryContractsByCodeResponse{
-		ContractInfos: r,
-		Pagination:    pageRes,
+		Contracts:  r,
+		Pagination: pageRes,
 	}, nil
 }

@ -258,14 +248,14 @@ func (q grpcQuerier) Codes(c context.Context, req *types.QueryCodesRequest) (*ty
 	return &types.QueryCodesResponse{CodeInfos: r, Pagination: pageRes}, nil
 }

-func queryContractInfo(ctx sdk.Context, addr sdk.AccAddress, keeper types.ViewKeeper) (*types.ContractInfoWithAddress, error) {
+func queryContractInfo(ctx sdk.Context, addr sdk.AccAddress, keeper types.ViewKeeper) (*types.QueryContractInfoResponse, error) {
 	info := keeper.GetContractInfo(ctx, addr)
 	if info == nil {
 		return nil, types.ErrNotFound
 	}
 	// redact the Created field (just used for sorting, not part of public API)
 	info.Created = nil
-	return &types.ContractInfoWithAddress{
+	return &types.QueryContractInfoResponse{
 		Address:      addr.String(),
 		ContractInfo: *info,
 	}, nil
--- a/x/wasm/keeper/querier_test.go
+++ b/x/wasm/keeper/querier_test.go
@ -283,13 +283,13 @@ func TestQueryContractListByCodeOrdering(t *testing.T) {
 	}

 	// create 10 contracts with real block/gas setup
-	for i := range [10]int{} {
+	for i := 0; i < 10; i++ {
 		// 3 tx per block, so we ensure both comparisons work
 		if i%3 == 0 {
 			ctx = setBlock(ctx, h)
 			h++
 		}
-		_, _, err = keepers.ContractKeeper.Instantiate(ctx, codeID, creator, nil, initMsgBz, fmt.Sprintf("contract %d", i), topUp)
+		_, _, err = keepers.ContractKeeper.Instantiate(ctx, codeID, creator, nil, initMsgBz, fmt.Sprintf("contractAddr %d", i), topUp)
 		require.NoError(t, err)
 	}

@ -298,13 +298,10 @@ func TestQueryContractListByCodeOrdering(t *testing.T) {
 	res, err := q.ContractsByCode(sdk.WrapSDKContext(ctx), &types.QueryContractsByCodeRequest{CodeId: codeID})
 	require.NoError(t, err)

-	require.Equal(t, 10, len(res.ContractInfos))
+	require.Equal(t, 10, len(res.Contracts))

-	for i, contract := range res.ContractInfos {
-		assert.Equal(t, fmt.Sprintf("contract %d", i), contract.Label)
-		assert.NotEmpty(t, contract.Address)
-		// ensure these are not shown
-		assert.Nil(t, contract.Created)
+	for _, contractAddr := range res.Contracts {
+		assert.NotEmpty(t, contractAddr)
 	}
 }

--- a/x/wasm/keeper/wasmtesting/mock_engine.go
+++ b/x/wasm/keeper/wasmtesting/mock_engine.go
@ -271,10 +271,16 @@ type contractExecutable interface {
 	) (*wasmvmtypes.Response, uint64, error)
 }

-//MakeIBCInstantiable adds some noop functions to not fail when contract is used for instantiation
-func MakeIBCInstantiable(m *MockWasmer) {
+//MakeInstantiable adds some noop functions to not fail when contract is used for instantiation
+func MakeInstantiable(m *MockWasmer) {
 	m.CreateFn = HashOnlyCreateFn
 	m.InstantiateFn = NoOpInstantiateFn
+	m.AnalyzeCodeFn = WithoutIBCAnalyzeFn
+}
+
+//MakeIBCInstantiable adds some noop functions to not fail when contract is used for instantiation
+func MakeIBCInstantiable(m *MockWasmer) {
+	MakeInstantiable(m)
 	m.AnalyzeCodeFn = HasIBCAnalyzeFn
 }

--- a/x/wasm/module_test.go
+++ b/x/wasm/module_test.go
@ -509,25 +509,25 @@ func assertCodeBytes(t *testing.T, q sdk.Querier, ctx sdk.Context, codeID uint64
 	assert.EqualValues(t, codeID, res["id"])
 }

-func assertContractList(t *testing.T, q sdk.Querier, ctx sdk.Context, codeID uint64, addrs []string) {
+func assertContractList(t *testing.T, q sdk.Querier, ctx sdk.Context, codeID uint64, expContractAddrs []string) {
 	bz, sdkerr := q(ctx, []string{QueryListContractByCode, fmt.Sprintf("%d", codeID)}, abci.RequestQuery{})
 	require.NoError(t, sdkerr)

 	if len(bz) == 0 {
-		require.Equal(t, len(addrs), 0)
+		require.Equal(t, len(expContractAddrs), 0)
 		return
 	}

-	var res []ContractInfoWithAddress
+	var res []string
 	err := json.Unmarshal(bz, &res)
 	require.NoError(t, err)

 	var hasAddrs = make([]string, len(res))
 	for i, r := range res {
-		hasAddrs[i] = r.Address
+		hasAddrs[i] = r
 	}

-	assert.Equal(t, hasAddrs, addrs)
+	assert.Equal(t, expContractAddrs, hasAddrs)
 }

 func assertContractState(t *testing.T, q sdk.Querier, ctx sdk.Context, contractBech32Addr string, expected state) {
--- a/x/wasm/types/exported_keepers.go
+++ b/x/wasm/types/exported_keepers.go
@ -15,6 +15,7 @@ type ViewKeeper interface {
 	HasContractInfo(ctx sdk.Context, contractAddress sdk.AccAddress) bool
 	GetContractInfo(ctx types.Context, contractAddress types.AccAddress) *ContractInfo
 	IterateContractInfo(ctx types.Context, cb func(types.AccAddress, ContractInfo) bool)
+	IterateContractsByCode(ctx sdk.Context, codeID uint64, cb func(address sdk.AccAddress) bool)
 	GetContractState(ctx types.Context, contractAddress types.AccAddress) types.Iterator
 	GetCodeInfo(ctx types.Context, codeID uint64) *CodeInfo
 	IterateCodeInfos(ctx types.Context, cb func(uint64, CodeInfo) bool)
--- a/x/wasm/types/query.pb.go
+++ b/x/wasm/types/query.pb.go
@ -238,50 +238,11 @@ func (m *QueryContractsByCodeRequest) XXX_DiscardUnknown() {

 var xxx_messageInfo_QueryContractsByCodeRequest proto.InternalMessageInfo

-// ContractInfoWithAddress adds the address (key) to the ContractInfo
-// representation
-type ContractInfoWithAddress struct {
-	Address      string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
-	ContractInfo `protobuf:"bytes,2,opt,name=contract_info,json=contractInfo,proto3,embedded=contract_info" json:""`
-}
-
-func (m *ContractInfoWithAddress) Reset()         { *m = ContractInfoWithAddress{} }
-func (m *ContractInfoWithAddress) String() string { return proto.CompactTextString(m) }
-func (*ContractInfoWithAddress) ProtoMessage()    {}
-func (*ContractInfoWithAddress) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e8595715dfdf95d1, []int{5}
-}
-func (m *ContractInfoWithAddress) XXX_Unmarshal(b []byte) error {
-	return m.Unmarshal(b)
-}
-func (m *ContractInfoWithAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	if deterministic {
-		return xxx_messageInfo_ContractInfoWithAddress.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 *ContractInfoWithAddress) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ContractInfoWithAddress.Merge(m, src)
-}
-func (m *ContractInfoWithAddress) XXX_Size() int {
-	return m.Size()
-}
-func (m *ContractInfoWithAddress) XXX_DiscardUnknown() {
-	xxx_messageInfo_ContractInfoWithAddress.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ContractInfoWithAddress proto.InternalMessageInfo
-
 // QueryContractsByCodeResponse is the response type for the
 // Query/ContractsByCode RPC method
 type QueryContractsByCodeResponse struct {
-	ContractInfos []ContractInfoWithAddress `protobuf:"bytes,1,rep,name=contract_infos,json=contractInfos,proto3" json:"contract_infos"`
+	// contracts are a set of contract addresses
+	Contracts []string `protobuf:"bytes,1,rep,name=contracts,proto3" json:"contracts,omitempty"`
 	// pagination defines the pagination in the response.
 	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
 }
@ -290,7 +251,7 @@ func (m *QueryContractsByCodeResponse) Reset()         { *m = QueryContractsByCo
 func (m *QueryContractsByCodeResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryContractsByCodeResponse) ProtoMessage()    {}
 func (*QueryContractsByCodeResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e8595715dfdf95d1, []int{6}
+	return fileDescriptor_e8595715dfdf95d1, []int{5}
 }
 func (m *QueryContractsByCodeResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -332,7 +293,7 @@ func (m *QueryAllContractStateRequest) Reset()         { *m = QueryAllContractSt
 func (m *QueryAllContractStateRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryAllContractStateRequest) ProtoMessage()    {}
 func (*QueryAllContractStateRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e8595715dfdf95d1, []int{7}
+	return fileDescriptor_e8595715dfdf95d1, []int{6}
 }
 func (m *QueryAllContractStateRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -373,7 +334,7 @@ func (m *QueryAllContractStateResponse) Reset()         { *m = QueryAllContractS
 func (m *QueryAllContractStateResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryAllContractStateResponse) ProtoMessage()    {}
 func (*QueryAllContractStateResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e8595715dfdf95d1, []int{8}
+	return fileDescriptor_e8595715dfdf95d1, []int{7}
 }
 func (m *QueryAllContractStateResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -414,7 +375,7 @@ func (m *QueryRawContractStateRequest) Reset()         { *m = QueryRawContractSt
 func (m *QueryRawContractStateRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryRawContractStateRequest) ProtoMessage()    {}
 func (*QueryRawContractStateRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e8595715dfdf95d1, []int{9}
+	return fileDescriptor_e8595715dfdf95d1, []int{8}
 }
 func (m *QueryRawContractStateRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -454,7 +415,7 @@ func (m *QueryRawContractStateResponse) Reset()         { *m = QueryRawContractS
 func (m *QueryRawContractStateResponse) String() string { return proto.CompactTextString(m) }
 func (*QueryRawContractStateResponse) ProtoMessage()    {}
 func (*QueryRawContractStateResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e8595715dfdf95d1, []int{10}
+	return fileDescriptor_e8595715dfdf95d1, []int{9}
 }
 func (m *QueryRawContractStateResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -496,7 +457,7 @@ func (m *QuerySmartContractStateRequest) Reset()         { *m = QuerySmartContra
 func (m *QuerySmartContractStateRequest) String() string { return proto.CompactTextString(m) }
 func (*QuerySmartContractStateRequest) ProtoMessage()    {}
 func (*QuerySmartContractStateRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e8595715dfdf95d1, []int{11}
+	return fileDescriptor_e8595715dfdf95d1, []int{10}
 }
 func (m *QuerySmartContractStateRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -536,7 +497,7 @@ func (m *QuerySmartContractStateResponse) Reset()         { *m = QuerySmartContr
 func (m *QuerySmartContractStateResponse) String() string { return proto.CompactTextString(m) }
 func (*QuerySmartContractStateResponse) ProtoMessage()    {}
 func (*QuerySmartContractStateResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e8595715dfdf95d1, []int{12}
+	return fileDescriptor_e8595715dfdf95d1, []int{11}
 }
 func (m *QuerySmartContractStateResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -574,7 +535,7 @@ func (m *QueryCodeRequest) Reset()         { *m = QueryCodeRequest{} }
 func (m *QueryCodeRequest) String() string { return proto.CompactTextString(m) }
 func (*QueryCodeRequest) ProtoMessage()    {}
 func (*QueryCodeRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_e8595715dfdf95d1, []int{13}
+	return fileDescriptor_e8595715dfdf95d1, []int{12}
 }
 func (m *QueryCodeRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -616,7 +577,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_e8595715dfdf95d1, []int{14}
+	return fileDescriptor_e8595715dfdf95d1, []int{13}
 }
 func (m *CodeInfoResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -655,7 +616,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_e8595715dfdf95d1, []int{15}
+	return fileDescriptor_e8595715dfdf95d1, []int{14}
 }
 func (m *QueryCodeResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -694,7 +655,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_e8595715dfdf95d1, []int{16}
+	return fileDescriptor_e8595715dfdf95d1, []int{15}
 }
 func (m *QueryCodesRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -734,7 +695,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_e8595715dfdf95d1, []int{17}
+	return fileDescriptor_e8595715dfdf95d1, []int{16}
 }
 func (m *QueryCodesResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@ -769,7 +730,6 @@ func init() {
 	proto.RegisterType((*QueryContractHistoryRequest)(nil), "cosmwasm.wasm.v1beta1.QueryContractHistoryRequest")
 	proto.RegisterType((*QueryContractHistoryResponse)(nil), "cosmwasm.wasm.v1beta1.QueryContractHistoryResponse")
 	proto.RegisterType((*QueryContractsByCodeRequest)(nil), "cosmwasm.wasm.v1beta1.QueryContractsByCodeRequest")
-	proto.RegisterType((*ContractInfoWithAddress)(nil), "cosmwasm.wasm.v1beta1.ContractInfoWithAddress")
 	proto.RegisterType((*QueryContractsByCodeResponse)(nil), "cosmwasm.wasm.v1beta1.QueryContractsByCodeResponse")
 	proto.RegisterType((*QueryAllContractStateRequest)(nil), "cosmwasm.wasm.v1beta1.QueryAllContractStateRequest")
 	proto.RegisterType((*QueryAllContractStateResponse)(nil), "cosmwasm.wasm.v1beta1.QueryAllContractStateResponse")
@ -787,77 +747,75 @@ func init() {
 func init() { proto.RegisterFile("cosmwasm/wasm/v1beta1/query.proto", fileDescriptor_e8595715dfdf95d1) }

 var fileDescriptor_e8595715dfdf95d1 = []byte{
-	// 1111 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x97, 0xcd, 0x6f, 0x1b, 0xc5,
-	0x1b, 0xc7, 0x3d, 0xa9, 0xf3, 0xe2, 0x69, 0xfa, 0xfb, 0x85, 0x51, 0xa1, 0xc6, 0xb8, 0xbb, 0x61,
-	0x41, 0xa9, 0x5b, 0xa4, 0xdd, 0x24, 0x4e, 0x11, 0x94, 0x53, 0x9d, 0x02, 0xa9, 0x44, 0x79, 0xd9,
-	0x08, 0x22, 0xe8, 0x21, 0x1a, 0xef, 0x4e, 0xed, 0x45, 0xf6, 0x8e, 0xbb, 0x33, 0x26, 0xb1, 0xa2,
-	0x50, 0xc4, 0x85, 0x2b, 0xa8, 0x47, 0x2e, 0x1c, 0x38, 0xa0, 0x02, 0xf7, 0x1e, 0x39, 0x70, 0xc8,
-	0x31, 0x12, 0x17, 0x4e, 0x16, 0x38, 0x08, 0xa1, 0xfc, 0x09, 0x3d, 0xa1, 0x9d, 0x9d, 0x75, 0x76,
-	0x1d, 0xaf, 0xd7, 0x41, 0x16, 0x5c, 0xa2, 0x9d, 0xf8, 0x79, 0x9e, 0xf9, 0x3c, 0xdf, 0x67, 0xe6,
-	0x79, 0x76, 0xe1, 0xf3, 0x16, 0x65, 0xcd, 0x1d, 0xcc, 0x9a, 0x86, 0xf8, 0xf3, 0xc9, 0x4a, 0x95,
-	0x70, 0xbc, 0x62, 0xdc, 0x6f, 0x13, 0xaf, 0xa3, 0xb7, 0x3c, 0xca, 0x29, 0x7a, 0x3a, 0x34, 0xd1,
-	0xc5, 0x1f, 0x69, 0x52, 0xb8, 0x58, 0xa3, 0x35, 0x2a, 0x2c, 0x0c, 0xff, 0x29, 0x30, 0x2e, 0x24,
-	0xc4, 0xe3, 0x9d, 0x16, 0x61, 0xd2, 0xa4, 0x58, 0xa3, 0xb4, 0xd6, 0x20, 0x06, 0x6e, 0x39, 0x06,
-	0x76, 0x5d, 0xca, 0x31, 0x77, 0xa8, 0x1b, 0xfe, 0x7a, 0xcd, 0x0f, 0x40, 0x99, 0x51, 0xc5, 0x8c,
-	0x04, 0x18, 0xfd, 0x20, 0x2d, 0x5c, 0x73, 0x5c, 0x61, 0x1c, 0xd8, 0x6a, 0x6b, 0x30, 0xff, 0x9e,
-	0x6f, 0xb1, 0x4e, 0x5d, 0xee, 0x61, 0x8b, 0xdf, 0x76, 0xef, 0x51, 0x93, 0xdc, 0x6f, 0x13, 0xc6,
-	0x51, 0x1e, 0xce, 0x62, 0xdb, 0xf6, 0x08, 0x63, 0x79, 0xb0, 0x08, 0x4a, 0x39, 0x33, 0x5c, 0x6a,
-	0x0f, 0x01, 0x7c, 0x76, 0x88, 0x1b, 0x6b, 0x51, 0x97, 0x91, 0x64, 0x3f, 0xf4, 0x01, 0xbc, 0x60,
-	0x49, 0x8f, 0x6d, 0xc7, 0xbd, 0x47, 0xf3, 0x53, 0x8b, 0xa0, 0x74, 0x7e, 0xf5, 0x05, 0x7d, 0xa8,
-	0x3e, 0x7a, 0x34, 0x7a, 0x65, 0xfe, 0xa0, 0xab, 0x66, 0x0e, 0xbb, 0x2a, 0x38, 0xee, 0xaa, 0x19,
-	0x73, 0xde, 0x8a, 0xfc, 0x76, 0x23, 0xfb, 0xd7, 0x37, 0x2a, 0xd0, 0x1e, 0xc0, 0xe7, 0x62, 0x50,
-	0x1b, 0x0e, 0xe3, 0xd4, 0xeb, 0xa4, 0xa6, 0x83, 0xde, 0x80, 0xf0, 0x44, 0x18, 0xc9, 0xb4, 0xa4,
-	0x07, 0x2a, 0xea, 0xbe, 0x8a, 0x7a, 0x50, 0xcc, 0x90, 0xeb, 0x5d, 0x5c, 0x23, 0x32, 0xaa, 0x19,
-	0xf1, 0xd4, 0x1e, 0x03, 0x58, 0x1c, 0x4e, 0x20, 0x95, 0x79, 0x07, 0xce, 0x12, 0x97, 0x7b, 0x0e,
-	0xf1, 0x11, 0xce, 0x95, 0xce, 0xaf, 0x1a, 0x29, 0x99, 0xaf, 0x53, 0x9b, 0xc8, 0x20, 0xaf, 0xbb,
-	0xdc, 0xeb, 0x54, 0xb2, 0xbe, 0x0a, 0x66, 0x18, 0x05, 0xbd, 0x39, 0x84, 0xfc, 0x4a, 0x2a, 0x79,
-	0x40, 0x13, 0x43, 0xff, 0x74, 0x40, 0x3b, 0x56, 0xe9, 0xf8, 0x7b, 0x87, 0xda, 0x5d, 0x82, 0xb3,
-	0x16, 0xb5, 0xc9, 0xb6, 0x63, 0x0b, 0xed, 0xb2, 0xe6, 0x8c, 0xbf, 0xbc, 0x6d, 0x4f, 0x4c, 0xba,
-	0xaf, 0x00, 0xbc, 0x14, 0x2d, 0xf7, 0x96, 0xc3, 0xeb, 0x37, 0x65, 0x79, 0xfe, 0xab, 0xf3, 0xf4,
-	0xf3, 0x60, 0x39, 0xfb, 0xa2, 0xc8, 0x72, 0xde, 0x85, 0xff, 0x8b, 0x6d, 0x1f, 0x56, 0x55, 0x1f,
-	0x63, 0xff, 0x48, 0x82, 0xb2, 0xa8, 0x17, 0xa2, 0x08, 0x13, 0x2c, 0xed, 0x67, 0x61, 0x1a, 0x37,
-	0x1b, 0x8d, 0x90, 0x60, 0x93, 0x63, 0x4e, 0xfe, 0xbd, 0x8b, 0xf1, 0x2d, 0x80, 0x97, 0x13, 0x10,
-	0xa4, 0x94, 0x37, 0xe0, 0x4c, 0x93, 0xda, 0xa4, 0x11, 0x4a, 0x58, 0x4c, 0x90, 0xf0, 0x8e, 0x6f,
-	0x24, 0x05, 0x93, 0x1e, 0x93, 0x53, 0x6a, 0x4b, 0x0a, 0x65, 0xe2, 0x9d, 0x33, 0x0a, 0x75, 0x19,
-	0x42, 0xb1, 0xc7, 0xb6, 0x8d, 0x39, 0x16, 0x08, 0xf3, 0x66, 0x4e, 0xfc, 0xe7, 0x16, 0xe6, 0x58,
-	0x2b, 0xcb, 0xf4, 0x4f, 0x07, 0x96, 0xe9, 0x23, 0x98, 0x15, 0x9e, 0x40, 0x78, 0x8a, 0x67, 0xed,
-	0x43, 0xa8, 0x08, 0xa7, 0xcd, 0x26, 0xf6, 0xf8, 0x64, 0x79, 0x36, 0xa1, 0x9a, 0x18, 0x5a, 0x12,
-	0x2d, 0x47, 0x89, 0x2a, 0xc5, 0x27, 0x5d, 0x35, 0x4f, 0x5c, 0x8b, 0xda, 0x8e, 0x5b, 0x33, 0x3e,
-	0x66, 0xd4, 0xd5, 0x4d, 0xbc, 0x73, 0x87, 0x30, 0xe6, 0x6b, 0x19, 0xf0, 0xbe, 0x04, 0x17, 0xe4,
-	0x6d, 0x49, 0xef, 0x1b, 0xda, 0x9f, 0x00, 0x2e, 0xf8, 0x86, 0xb1, 0xc1, 0x71, 0x75, 0xc0, 0xba,
-	0xb2, 0xd0, 0xeb, 0xaa, 0x33, 0xc2, 0xec, 0xd6, 0x71, 0x57, 0x9d, 0x72, 0xec, 0x7e, 0xdf, 0xc9,
-	0xc3, 0x59, 0xcb, 0x23, 0x98, 0x53, 0x4f, 0x64, 0x97, 0x33, 0xc3, 0x25, 0x7a, 0x1f, 0xe6, 0x7c,
-	0x9c, 0xed, 0x3a, 0x66, 0xf5, 0xfc, 0x39, 0x41, 0xff, 0xca, 0x93, 0xae, 0xba, 0x56, 0x73, 0x78,
-	0xbd, 0x5d, 0xd5, 0x2d, 0xda, 0x34, 0x38, 0x71, 0x6d, 0xe2, 0x35, 0x1d, 0x97, 0x47, 0x1f, 0x1b,
-	0x4e, 0x95, 0x19, 0xd5, 0x0e, 0x27, 0x4c, 0xdf, 0x20, 0xbb, 0x15, 0xff, 0xc1, 0x9c, 0xf3, 0x43,
-	0x6d, 0x60, 0x56, 0x47, 0xcf, 0xc0, 0x19, 0x46, 0xdb, 0x9e, 0x45, 0xf2, 0x59, 0xb1, 0x9f, 0x5c,
-	0xf9, 0x20, 0xd5, 0xb6, 0xd3, 0xb0, 0x89, 0x97, 0x9f, 0x0e, 0x40, 0xe4, 0x52, 0x36, 0x91, 0x2f,
-	0x00, 0x7c, 0x2a, 0x22, 0x8b, 0xcc, 0xf4, 0x6d, 0x98, 0x0b, 0x32, 0xf5, 0x9b, 0x16, 0x88, 0x9c,
-	0xd8, 0x61, 0x4d, 0x23, 0xae, 0x52, 0x65, 0xae, 0xdf, 0xb4, 0xe6, 0x2c, 0xf9, 0x1b, 0x2a, 0xca,
-	0x6a, 0x89, 0x4a, 0x57, 0xe6, 0x8e, 0xbb, 0xaa, 0x58, 0x07, 0x95, 0x91, 0x24, 0x77, 0x23, 0x20,
-	0x2c, 0x2c, 0x50, 0xfc, 0x86, 0x83, 0x7f, 0x7c, 0xc3, 0xbf, 0x07, 0x10, 0x45, 0xa3, 0xcb, 0x3c,
-	0xdf, 0x82, 0xb0, 0x9f, 0x67, 0x78, 0xb5, 0xc7, 0x4e, 0x34, 0xb8, 0xe5, 0xb9, 0x30, 0xc9, 0xc9,
-	0x5d, 0xf4, 0xd5, 0x47, 0x10, 0x4e, 0x0b, 0x5a, 0xf4, 0x35, 0x80, 0xf3, 0xd1, 0xb6, 0x8c, 0x92,
-	0x26, 0x72, 0xd2, 0x5b, 0x52, 0x61, 0x79, 0x7c, 0x87, 0x80, 0x44, 0x2b, 0x7d, 0xfe, 0xcb, 0x1f,
-	0x0f, 0xa7, 0x34, 0xb4, 0x18, 0x7f, 0xc1, 0x0b, 0xdb, 0xbf, 0xb1, 0x27, 0x6f, 0xf1, 0x3e, 0xfa,
-	0x01, 0xc0, 0xff, 0x0f, 0xbc, 0x4b, 0xa0, 0xd5, 0x71, 0xf6, 0x8b, 0xbf, 0xfa, 0x14, 0xca, 0x67,
-	0xf2, 0x91, 0x98, 0xcb, 0x02, 0xf3, 0x1a, 0x2a, 0xa5, 0x61, 0x1a, 0x75, 0x89, 0xf6, 0x28, 0x82,
-	0x2b, 0x67, 0xe5, 0x78, 0xb8, 0xf1, 0xb7, 0x8d, 0xf1, 0x70, 0x07, 0x86, 0xb1, 0xa6, 0x0b, 0xdc,
-	0x12, 0x5a, 0x1a, 0xc4, 0xb5, 0x89, 0xb1, 0x27, 0xdb, 0xca, 0x7e, 0x9f, 0x9e, 0xa1, 0x1f, 0x01,
-	0x5c, 0x18, 0x1c, 0x47, 0x68, 0xe4, 0xce, 0x09, 0xf3, 0xb3, 0xb0, 0x76, 0x36, 0xa7, 0x34, 0xde,
-	0x53, 0xf2, 0x32, 0x81, 0xf6, 0x18, 0xc0, 0x85, 0xc1, 0xf9, 0x31, 0x9a, 0x37, 0x61, 0x8c, 0x8d,
-	0xe6, 0x4d, 0x1a, 0x51, 0xda, 0xab, 0x82, 0xb7, 0x8c, 0x56, 0x52, 0x79, 0x3d, 0xbc, 0x63, 0xec,
-	0x9d, 0x8c, 0x9f, 0x7d, 0xf4, 0x13, 0x80, 0xe8, 0xf4, 0xa8, 0x41, 0xd7, 0x47, 0x71, 0x24, 0x4e,
-	0xbd, 0xc2, 0xcb, 0x67, 0x75, 0x93, 0x09, 0xbc, 0x26, 0x12, 0xb8, 0x8e, 0xca, 0xe9, 0x82, 0xfb,
-	0x41, 0xe2, 0x29, 0x3c, 0x80, 0x59, 0x71, 0x9c, 0xaf, 0x8c, 0x3e, 0x9a, 0x27, 0x67, 0xb8, 0x94,
-	0x6e, 0x28, 0xb9, 0x5e, 0x14, 0x5c, 0x0a, 0x2a, 0x8e, 0x3a, 0xb8, 0x68, 0x17, 0x4e, 0x8b, 0xd6,
-	0x8a, 0x52, 0x03, 0x87, 0xbd, 0xbd, 0x70, 0x75, 0x0c, 0x4b, 0xc9, 0x50, 0x10, 0x0c, 0x17, 0x11,
-	0x3a, 0xcd, 0x50, 0xd9, 0x38, 0xf8, 0x5d, 0xc9, 0x7c, 0xd7, 0x53, 0x32, 0x07, 0x3d, 0x05, 0x1c,
-	0xf6, 0x14, 0xf0, 0x5b, 0x4f, 0x01, 0x5f, 0x1e, 0x29, 0x99, 0xc3, 0x23, 0x25, 0xf3, 0xeb, 0x91,
-	0x92, 0xf9, 0x68, 0x29, 0x32, 0x5b, 0xd7, 0x29, 0x6b, 0x6e, 0x85, 0x1f, 0xaf, 0xb6, 0xb1, 0x1b,
-	0x04, 0x14, 0x1f, 0xaf, 0xd5, 0x19, 0xf1, 0xcd, 0x59, 0xfe, 0x3b, 0x00, 0x00, 0xff, 0xff, 0x99,
-	0xbc, 0xec, 0x7a, 0x32, 0x0f, 0x00, 0x00,
+	// 1084 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x97, 0xcf, 0x6f, 0xe3, 0x44,
+	0x14, 0xc7, 0x33, 0xdd, 0xf4, 0x47, 0x66, 0x8b, 0x28, 0xa3, 0x05, 0x42, 0xc8, 0xda, 0xc5, 0xa0,
+	0x6e, 0x76, 0x91, 0xec, 0xfe, 0x5a, 0x04, 0xcb, 0x89, 0x74, 0x81, 0xae, 0xc4, 0xf2, 0xc3, 0x15,
+	0xac, 0x80, 0x43, 0x35, 0xb1, 0x67, 0x13, 0xa3, 0xc4, 0x93, 0xf5, 0x4c, 0x68, 0xa3, 0xaa, 0x2c,
+	0x42, 0x42, 0x5c, 0x91, 0xf6, 0xc8, 0x85, 0x03, 0x07, 0xb4, 0xc0, 0x7d, 0x8f, 0x1c, 0x7b, 0xac,
+	0xc4, 0x85, 0x53, 0x04, 0x29, 0x42, 0xa8, 0x7f, 0xc2, 0x9e, 0xd0, 0x8c, 0xc7, 0x89, 0x93, 0xc6,
+	0x71, 0x8a, 0x22, 0x2e, 0x91, 0x27, 0x7e, 0xef, 0xf9, 0xf3, 0xbe, 0xf3, 0xde, 0x3c, 0x1b, 0xbe,
+	0xe0, 0x50, 0xd6, 0xd8, 0xc3, 0xac, 0x61, 0xc9, 0x9f, 0xcf, 0xd7, 0x2a, 0x84, 0xe3, 0x35, 0xeb,
+	0x5e, 0x8b, 0x04, 0x6d, 0xb3, 0x19, 0x50, 0x4e, 0xd1, 0xd3, 0x91, 0x89, 0x29, 0x7f, 0x94, 0x49,
+	0xe1, 0x52, 0x95, 0x56, 0xa9, 0xb4, 0xb0, 0xc4, 0x55, 0x68, 0x5c, 0x48, 0x88, 0xc7, 0xdb, 0x4d,
+	0xc2, 0x94, 0x49, 0xb1, 0x4a, 0x69, 0xb5, 0x4e, 0x2c, 0xdc, 0xf4, 0x2c, 0xec, 0xfb, 0x94, 0x63,
+	0xee, 0x51, 0x3f, 0xba, 0x7b, 0x4d, 0x04, 0xa0, 0xcc, 0xaa, 0x60, 0x46, 0x42, 0x8c, 0x5e, 0x90,
+	0x26, 0xae, 0x7a, 0xbe, 0x34, 0x0e, 0x6d, 0x8d, 0x4d, 0x98, 0xff, 0x40, 0x58, 0x6c, 0x51, 0x9f,
+	0x07, 0xd8, 0xe1, 0xb7, 0xfc, 0xbb, 0xd4, 0x26, 0xf7, 0x5a, 0x84, 0x71, 0x94, 0x87, 0xf3, 0xd8,
+	0x75, 0x03, 0xc2, 0x58, 0x1e, 0x2c, 0x83, 0x52, 0xce, 0x8e, 0x96, 0xc6, 0x03, 0x00, 0x9f, 0x1b,
+	0xe1, 0xc6, 0x9a, 0xd4, 0x67, 0x24, 0xd9, 0x0f, 0x7d, 0x04, 0x9f, 0x70, 0x94, 0xc7, 0xae, 0xe7,
+	0xdf, 0xa5, 0xf9, 0x99, 0x65, 0x50, 0xba, 0xb8, 0xfe, 0xa2, 0x39, 0x52, 0x1f, 0x33, 0x1e, 0xbd,
+	0xbc, 0x78, 0xd4, 0xd1, 0x33, 0xc7, 0x1d, 0x1d, 0x9c, 0x76, 0xf4, 0x8c, 0xbd, 0xe8, 0xc4, 0xee,
+	0xdd, 0xc8, 0xfe, 0xf3, 0xbd, 0x0e, 0x8c, 0xfb, 0xf0, 0xf9, 0x01, 0xa8, 0x6d, 0x8f, 0x71, 0x1a,
+	0xb4, 0x53, 0xd3, 0x41, 0x6f, 0x41, 0xd8, 0x17, 0x46, 0x31, 0xad, 0x98, 0xa1, 0x8a, 0xa6, 0x50,
+	0xd1, 0x0c, 0x37, 0x33, 0xe2, 0x7a, 0x1f, 0x57, 0x89, 0x8a, 0x6a, 0xc7, 0x3c, 0x8d, 0x47, 0x00,
+	0x16, 0x47, 0x13, 0x28, 0x65, 0xde, 0x83, 0xf3, 0xc4, 0xe7, 0x81, 0x47, 0x04, 0xc2, 0x85, 0xd2,
+	0xc5, 0x75, 0x2b, 0x25, 0xf3, 0x2d, 0xea, 0x12, 0x15, 0xe4, 0x4d, 0x9f, 0x07, 0xed, 0x72, 0x56,
+	0xa8, 0x60, 0x47, 0x51, 0xd0, 0xdb, 0x23, 0xc8, 0xaf, 0xa4, 0x92, 0x87, 0x34, 0x03, 0xe8, 0x5f,
+	0x0c, 0x69, 0xc7, 0xca, 0x6d, 0xf1, 0xec, 0x48, 0xbb, 0x67, 0xe1, 0xbc, 0x43, 0x5d, 0xb2, 0xeb,
+	0xb9, 0x52, 0xbb, 0xac, 0x3d, 0x27, 0x96, 0xb7, 0xdc, 0xa9, 0x49, 0xf7, 0xf5, 0xb0, 0x74, 0x3d,
+	0x00, 0x25, 0x5d, 0x11, 0xe6, 0xa2, 0x2d, 0x0f, 0xc5, 0xcb, 0xd9, 0xfd, 0x3f, 0xa6, 0xa7, 0xc3,
+	0x97, 0x11, 0xc7, 0x1b, 0xf5, 0x7a, 0x84, 0xb2, 0xc3, 0x31, 0x27, 0xff, 0x5f, 0x15, 0xfd, 0x00,
+	0xe0, 0xe5, 0x04, 0x04, 0xa5, 0xc5, 0x0d, 0x38, 0xd7, 0xa0, 0x2e, 0xa9, 0x47, 0x55, 0x54, 0x4c,
+	0xa8, 0xa2, 0xdb, 0xc2, 0x48, 0x95, 0x8c, 0xf2, 0x98, 0x9e, 0x52, 0x77, 0x94, 0x50, 0x36, 0xde,
+	0x3b, 0xa7, 0x50, 0x97, 0x21, 0x94, 0xcf, 0xd8, 0x75, 0x31, 0xc7, 0x12, 0x61, 0xd1, 0xce, 0xc9,
+	0x7f, 0x6e, 0x62, 0x8e, 0x8d, 0x0d, 0x95, 0xfe, 0xd9, 0xc0, 0x2a, 0x7d, 0x04, 0xb3, 0xd2, 0x13,
+	0x48, 0x4f, 0x79, 0x6d, 0x7c, 0x0c, 0x35, 0xe9, 0xb4, 0xd3, 0xc0, 0x01, 0x9f, 0x2e, 0xcf, 0x0e,
+	0xd4, 0x13, 0x43, 0x2b, 0xa2, 0xd5, 0x38, 0x51, 0xb9, 0xf8, 0xb8, 0xa3, 0xe7, 0x89, 0xef, 0x50,
+	0xd7, 0xf3, 0xab, 0xd6, 0x67, 0x8c, 0xfa, 0xa6, 0x8d, 0xf7, 0x6e, 0x13, 0xc6, 0x84, 0x96, 0x21,
+	0xef, 0xcb, 0x70, 0x49, 0x95, 0x7b, 0x7a, 0x93, 0x19, 0x7f, 0x03, 0xb8, 0x24, 0x0c, 0x07, 0x4e,
+	0xd9, 0xab, 0x43, 0xd6, 0xe5, 0xa5, 0x6e, 0x47, 0x9f, 0x93, 0x66, 0x37, 0x4f, 0x3b, 0xfa, 0x8c,
+	0xe7, 0xf6, 0x9a, 0x34, 0x0f, 0xe7, 0x9d, 0x80, 0x60, 0x4e, 0x03, 0x99, 0x5d, 0xce, 0x8e, 0x96,
+	0xe8, 0x43, 0x98, 0x13, 0x38, 0xbb, 0x35, 0xcc, 0x6a, 0xf9, 0x0b, 0x92, 0xfe, 0xd5, 0xc7, 0x1d,
+	0x7d, 0xb3, 0xea, 0xf1, 0x5a, 0xab, 0x62, 0x3a, 0xb4, 0x61, 0x71, 0xe2, 0xbb, 0x24, 0x68, 0x78,
+	0x3e, 0x8f, 0x5f, 0xd6, 0xbd, 0x0a, 0xb3, 0x2a, 0x6d, 0x4e, 0x98, 0xb9, 0x4d, 0xf6, 0xcb, 0xe2,
+	0xc2, 0x5e, 0x10, 0xa1, 0xb6, 0x31, 0xab, 0xa1, 0x67, 0xe0, 0x1c, 0xa3, 0xad, 0xc0, 0x21, 0xf9,
+	0xac, 0x7c, 0x9e, 0x5a, 0x09, 0x90, 0x4a, 0xcb, 0xab, 0xbb, 0x24, 0xc8, 0xcf, 0x86, 0x20, 0x6a,
+	0xa9, 0x4e, 0xf0, 0x6f, 0x00, 0x7c, 0x2a, 0x26, 0x8b, 0xca, 0xf4, 0x5d, 0xd1, 0xfa, 0x22, 0x53,
+	0x31, 0x31, 0x40, 0xac, 0x62, 0x47, 0x9d, 0x9b, 0x83, 0x2a, 0x95, 0x17, 0x7a, 0x13, 0x63, 0xc1,
+	0x51, 0xf7, 0x50, 0x51, 0xed, 0x96, 0xdc, 0xe9, 0xf2, 0xc2, 0x69, 0x47, 0x97, 0xeb, 0x70, 0x67,
+	0x14, 0xc9, 0xa7, 0x31, 0x10, 0x16, 0x6d, 0xd0, 0x60, 0x87, 0x83, 0xff, 0xdc, 0xe1, 0x3f, 0x01,
+	0x88, 0xe2, 0xd1, 0x55, 0x9e, 0xef, 0x40, 0xd8, 0xcb, 0x33, 0x6a, 0xed, 0x89, 0x13, 0x0d, 0xbb,
+	0x3c, 0x17, 0x25, 0x39, 0xbd, 0x46, 0x5f, 0x7f, 0x08, 0xe1, 0xac, 0xa4, 0x45, 0xdf, 0x01, 0xb8,
+	0x18, 0x9f, 0xc9, 0x28, 0x69, 0x7c, 0x25, 0xbd, 0x52, 0x14, 0x56, 0x27, 0x77, 0x08, 0x49, 0x8c,
+	0xd2, 0x57, 0xbf, 0xfd, 0xf5, 0x60, 0xc6, 0x40, 0xcb, 0x83, 0x6f, 0x43, 0xd1, 0xd1, 0x6f, 0x1d,
+	0xa8, 0x2e, 0x3e, 0x44, 0x3f, 0x03, 0xf8, 0xe4, 0xd0, 0xe0, 0x45, 0xeb, 0x93, 0x3c, 0x6f, 0xf0,
+	0x3d, 0xa1, 0xb0, 0x71, 0x2e, 0x1f, 0x85, 0xb9, 0x2a, 0x31, 0xaf, 0xa1, 0x52, 0x1a, 0xa6, 0x55,
+	0x53, 0x68, 0x0f, 0x63, 0xb8, 0x6a, 0xd8, 0x4d, 0x86, 0x3b, 0x38, 0x9a, 0x27, 0xc3, 0x1d, 0x9a,
+	0xa6, 0x86, 0x29, 0x71, 0x4b, 0x68, 0x65, 0x18, 0xd7, 0x25, 0xd6, 0x81, 0x3a, 0x56, 0x0e, 0xad,
+	0xfe, 0x7c, 0xfd, 0x05, 0xc0, 0xa5, 0xe1, 0x71, 0x84, 0xc6, 0x3e, 0x39, 0x61, 0x7e, 0x16, 0x36,
+	0xcf, 0xe7, 0x94, 0xc6, 0x7b, 0x46, 0x5e, 0x26, 0xd1, 0x1e, 0x01, 0xb8, 0x34, 0x3c, 0x3f, 0xc6,
+	0xf3, 0x26, 0x8c, 0xb1, 0xf1, 0xbc, 0x49, 0x23, 0xca, 0x78, 0x4d, 0xf2, 0x6e, 0xa0, 0xb5, 0x54,
+	0xde, 0x00, 0xef, 0x59, 0x07, 0xfd, 0xf1, 0x73, 0x88, 0x7e, 0x05, 0x10, 0x9d, 0x1d, 0x35, 0xe8,
+	0xfa, 0x38, 0x8e, 0xc4, 0xa9, 0x57, 0x78, 0xe5, 0xbc, 0x6e, 0x2a, 0x81, 0xd7, 0x65, 0x02, 0xd7,
+	0xd1, 0x46, 0xba, 0xe0, 0x22, 0xc8, 0x60, 0x0a, 0xf7, 0x61, 0x56, 0x96, 0xf3, 0x95, 0xf1, 0xa5,
+	0xd9, 0xaf, 0xe1, 0x52, 0xba, 0xa1, 0xe2, 0x7a, 0x49, 0x72, 0x69, 0xa8, 0x38, 0xae, 0x70, 0xd1,
+	0x3e, 0x9c, 0x95, 0x47, 0x2b, 0x4a, 0x0d, 0x1c, 0x9d, 0xed, 0x85, 0xab, 0x13, 0x58, 0x2a, 0x86,
+	0x82, 0x64, 0xb8, 0x84, 0xd0, 0x59, 0x86, 0xf2, 0xf6, 0xd1, 0x9f, 0x5a, 0xe6, 0xc7, 0xae, 0x96,
+	0x39, 0xea, 0x6a, 0xe0, 0xb8, 0xab, 0x81, 0x3f, 0xba, 0x1a, 0xf8, 0xf6, 0x44, 0xcb, 0x1c, 0x9f,
+	0x68, 0x99, 0xdf, 0x4f, 0xb4, 0xcc, 0x27, 0x2b, 0xb1, 0xd9, 0xba, 0x45, 0x59, 0xe3, 0x4e, 0xf4,
+	0xa5, 0xe7, 0x5a, 0xfb, 0x61, 0x40, 0xf9, 0xa5, 0x57, 0x99, 0x93, 0x1f, 0x68, 0x1b, 0xff, 0x06,
+	0x00, 0x00, 0xff, 0xff, 0xcc, 0x4d, 0x4e, 0xc2, 0x5f, 0x0e, 0x00, 0x00,
 }

 func (this *QueryContractInfoResponse) Equal(that interface{}) bool {
@ -887,33 +845,6 @@ func (this *QueryContractInfoResponse) Equal(that interface{}) bool {
 	}
 	return true
 }
-func (this *ContractInfoWithAddress) Equal(that interface{}) bool {
-	if that == nil {
-		return this == nil
-	}
-
-	that1, ok := that.(*ContractInfoWithAddress)
-	if !ok {
-		that2, ok := that.(ContractInfoWithAddress)
-		if ok {
-			that1 = &that2
-		} else {
-			return false
-		}
-	}
-	if that1 == nil {
-		return this == nil
-	} else if this == nil {
-		return false
-	}
-	if this.Address != that1.Address {
-		return false
-	}
-	if !this.ContractInfo.Equal(&that1.ContractInfo) {
-		return false
-	}
-	return true
-}
 func (this *CodeInfoResponse) Equal(that interface{}) bool {
 	if that == nil {
 		return this == nil
@ -1527,46 +1458,6 @@ func (m *QueryContractsByCodeRequest) MarshalToSizedBuffer(dAtA []byte) (int, er
 	return len(dAtA) - i, nil
 }

-func (m *ContractInfoWithAddress) 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 *ContractInfoWithAddress) MarshalTo(dAtA []byte) (int, error) {
-	size := m.Size()
-	return m.MarshalToSizedBuffer(dAtA[:size])
-}
-
-func (m *ContractInfoWithAddress) MarshalToSizedBuffer(dAtA []byte) (int, error) {
-	i := len(dAtA)
-	_ = i
-	var l int
-	_ = l
-	{
-		size, err := m.ContractInfo.MarshalToSizedBuffer(dAtA[:i])
-		if err != nil {
-			return 0, err
-		}
-		i -= size
-		i = encodeVarintQuery(dAtA, i, uint64(size))
-	}
-	i--
-	dAtA[i] = 0x12
-	if len(m.Address) > 0 {
-		i -= len(m.Address)
-		copy(dAtA[i:], m.Address)
-		i = encodeVarintQuery(dAtA, i, uint64(len(m.Address)))
-		i--
-		dAtA[i] = 0xa
-	}
-	return len(dAtA) - i, nil
-}
-
 func (m *QueryContractsByCodeResponse) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@ -1599,16 +1490,11 @@ func (m *QueryContractsByCodeResponse) MarshalToSizedBuffer(dAtA []byte) (int, e
 		i--
 		dAtA[i] = 0x12
 	}
-	if len(m.ContractInfos) > 0 {
-		for iNdEx := len(m.ContractInfos) - 1; iNdEx >= 0; iNdEx-- {
-			{
-				size, err := m.ContractInfos[iNdEx].MarshalToSizedBuffer(dAtA[:i])
-				if err != nil {
-					return 0, err
-				}
-				i -= size
-				i = encodeVarintQuery(dAtA, i, uint64(size))
-			}
+	if len(m.Contracts) > 0 {
+		for iNdEx := len(m.Contracts) - 1; iNdEx >= 0; iNdEx-- {
+			i -= len(m.Contracts[iNdEx])
+			copy(dAtA[i:], m.Contracts[iNdEx])
+			i = encodeVarintQuery(dAtA, i, uint64(len(m.Contracts[iNdEx])))
 			i--
 			dAtA[i] = 0xa
 		}
@ -2142,30 +2028,15 @@ func (m *QueryContractsByCodeRequest) Size() (n int) {
 	return n
 }

-func (m *ContractInfoWithAddress) Size() (n int) {
-	if m == nil {
-		return 0
-	}
-	var l int
-	_ = l
-	l = len(m.Address)
-	if l > 0 {
-		n += 1 + l + sovQuery(uint64(l))
-	}
-	l = m.ContractInfo.Size()
-	n += 1 + l + sovQuery(uint64(l))
-	return n
-}
-
 func (m *QueryContractsByCodeResponse) Size() (n int) {
 	if m == nil {
 		return 0
 	}
 	var l int
 	_ = l
-	if len(m.ContractInfos) > 0 {
-		for _, e := range m.ContractInfos {
-			l = e.Size()
+	if len(m.Contracts) > 0 {
+		for _, s := range m.Contracts {
+			l = len(s)
 			n += 1 + l + sovQuery(uint64(l))
 		}
 	}
@ -2907,121 +2778,6 @@ func (m *QueryContractsByCodeRequest) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ContractInfoWithAddress) 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: ContractInfoWithAddress: wiretype end group for non-group")
-		}
-		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ContractInfoWithAddress: illegal tag %d (wire type %d)", fieldNum, wire)
-		}
-		switch fieldNum {
-		case 1:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = string(dAtA[iNdEx:postIndex])
-			iNdEx = postIndex
-		case 2:
-			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ContractInfo", 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.ContractInfo.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 *QueryContractsByCodeResponse) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
@ -3053,9 +2809,9 @@ func (m *QueryContractsByCodeResponse) Unmarshal(dAtA []byte) error {
 		switch fieldNum {
 		case 1:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ContractInfos", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field Contracts", wireType)
 			}
-			var msglen int
+			var stringLen uint64
 			for shift := uint(0); ; shift += 7 {
 				if shift >= 64 {
 					return ErrIntOverflowQuery
@ -3065,25 +2821,23 @@ func (m *QueryContractsByCodeResponse) Unmarshal(dAtA []byte) error {
 				}
 				b := dAtA[iNdEx]
 				iNdEx++
-				msglen |= int(b&0x7F) << shift
+				stringLen |= uint64(b&0x7F) << shift
 				if b < 0x80 {
 					break
 				}
 			}
-			if msglen < 0 {
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
 				return ErrInvalidLengthQuery
 			}
-			postIndex := iNdEx + msglen
+			postIndex := iNdEx + intStringLen
 			if postIndex < 0 {
 				return ErrInvalidLengthQuery
 			}
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.ContractInfos = append(m.ContractInfos, ContractInfoWithAddress{})
-			if err := m.ContractInfos[len(m.ContractInfos)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
-				return err
-			}
+			m.Contracts = append(m.Contracts, string(dAtA[iNdEx:postIndex]))
 			iNdEx = postIndex
 		case 2:
 			if wireType != 2 {