Merge pull request #93 from planetmint/75-pop

add get machine by address capabilities and block proposer check

app/ante/ante.go

@@ -29,7 +29,7 @@ func (cm CheckMachineDecorator) AnteHandle(ctx sdk.Context, tx sdk.Tx, simulate
 		case "/planetmintgo.asset.MsgNotarizeAsset":
 			notarizeMsg, ok := msg.(*assettypes.MsgNotarizeAsset)
 			if ok {
-				_, found := cm.mk.GetMachineIndex(ctx, notarizeMsg.PubKey)
+				_, found := cm.mk.GetMachineIndexByPubKey(ctx, notarizeMsg.PubKey)
 				if !found {
 					return ctx, errorsmod.Wrapf(machinetypes.ErrMachineNotFound, "error during CheckTx or ReCheckTx")
 				}

app/ante/expected_keepers.go

@@ -8,7 +8,7 @@ import (
 )
 
 type MachineKeeper interface {
-	GetMachineIndex(ctx sdk.Context, pubKey string) (val types.MachineIndex, found bool)
+	GetMachineIndexByPubKey(ctx sdk.Context, pubKey string) (val types.MachineIndex, found bool)
 	GetTrustAnchor(ctx sdk.Context, pubKey string) (val types.TrustAnchor, activated bool, found bool)
 }
 

app/app.go

@@ -313,7 +313,7 @@ func New(
 		feegrant.StoreKey, evidencetypes.StoreKey, ibctransfertypes.StoreKey, icahosttypes.StoreKey,
 		capabilitytypes.StoreKey, group.StoreKey, icacontrollertypes.StoreKey, consensusparamtypes.StoreKey,
 		machinemoduletypes.StoreKey, machinemoduletypes.TAIndexKey, machinemoduletypes.IssuerPlanetmintIndexKey, machinemoduletypes.IssuerLiquidIndexKey,
-		machinemoduletypes.TrustAnchorKey,
+		machinemoduletypes.TrustAnchorKey, machinemoduletypes.AddressIndexKey,
 		assetmoduletypes.StoreKey,
 		daomoduletypes.StoreKey,
 		// this line is used by starport scaffolding # stargate/app/storeKey
@@ -545,6 +545,7 @@ func New(
 		keys[machinemoduletypes.IssuerPlanetmintIndexKey],
 		keys[machinemoduletypes.IssuerLiquidIndexKey],
 		keys[machinemoduletypes.TrustAnchorKey],
+		keys[machinemoduletypes.AddressIndexKey],
 		keys[machinemoduletypes.MemStoreKey],
 		app.GetSubspace(machinemoduletypes.ModuleName),
 	)

config/config.go

@@ -2,6 +2,8 @@ package config
 
 import (
 	"encoding/json"
+	"os/user"
+	"path/filepath"
 	"sync"
 )
 
@@ -17,6 +19,7 @@ watchmen-port = {{ .PlmntConfig.WatchmenPort }}
 token-denom = "{{ .PlmntConfig.TokenDenom }}"
 stake-denom = "{{ .PlmntConfig.StakeDenom }}"
 fee-denom = "{{ .PlmntConfig.FeeDenom }}"
+config-root-dir = "{{ .PlmntConfig.ConfigRootDir }}"
 `
 
 // Config defines Planetmint's top level configuration
@@ -27,6 +30,7 @@ type Config struct {
 	TokenDenom       string `mapstructure:"token-denom" json:"token-denom"`
 	StakeDenom       string `mapstructure:"stake-denom" json:"stake-denom"`
 	FeeDenom         string `mapstructure:"fee-denom" json:"fee-denom"`
+	ConfigRootDir    string `mapstructure:"config-root-dir" json:"config-root-dir"`
 }
 
 // cosmos-sdk wide global singleton
@@ -37,6 +41,11 @@ var (
 
 // DefaultConfig returns planetmint's default configuration.
 func DefaultConfig() *Config {
+	currentUser, err := user.Current()
+	if err != nil {
+		panic(err)
+	}
+
 	return &Config{
 		OSCServicePort:   8766,
 		WatchmenEndpoint: "lab.r3c.network",
@@ -44,6 +53,7 @@ func DefaultConfig() *Config {
 		TokenDenom:       "plmnt",
 		StakeDenom:       "plmntstake",
 		FeeDenom:         "plmnt",
+		ConfigRootDir:    filepath.Join(currentUser.HomeDir, ".planetmint-go"),
 	}
 }
 

docs/static/openapi.yml

@@ -46558,6 +46558,8 @@ paths:
                     format: int64
                   machineIdSignature:
                     type: string
+                  address:
+                    type: string
         default:
           description: An unexpected error response.
           schema:
@@ -46658,6 +46660,82 @@ paths:
                   additionalProperties: {}
       tags:
         - Query
+  /planetmint-go/machine/get_machine_by_address/{address}:
+    get:
+      summary: Queries a list of GetMachineByAddress items.
+      operationId: PlanetmintgoMachineGetMachineByAddress
+      responses:
+        '200':
+          description: A successful response.
+          schema:
+            type: object
+            properties:
+              machine:
+                type: object
+                properties:
+                  name:
+                    type: string
+                  ticker:
+                    type: string
+                  domain:
+                    type: string
+                  reissue:
+                    type: boolean
+                  amount:
+                    type: string
+                    format: uint64
+                  precision:
+                    type: string
+                    format: uint64
+                  issuerPlanetmint:
+                    type: string
+                  issuerLiquid:
+                    type: string
+                  machineId:
+                    type: string
+                  metadata:
+                    type: object
+                    properties:
+                      gps:
+                        type: string
+                      device:
+                        type: string
+                      assetDefinition:
+                        type: string
+                      additionalDataCID:
+                        type: string
+                  type:
+                    type: integer
+                    format: int64
+                  machineIdSignature:
+                    type: string
+                  address:
+                    type: string
+        default:
+          description: An unexpected error response.
+          schema:
+            type: object
+            properties:
+              code:
+                type: integer
+                format: int32
+              message:
+                type: string
+              details:
+                type: array
+                items:
+                  type: object
+                  properties:
+                    '@type':
+                      type: string
+                  additionalProperties: {}
+      parameters:
+        - name: address
+          in: path
+          required: true
+          type: string
+      tags:
+        - Query
 definitions:
   cosmos.auth.v1beta1.AddressBytesToStringResponse:
     type: object
@@ -75458,6 +75536,8 @@ definitions:
         format: int64
       machineIdSignature:
         type: string
+      address:
+        type: string
   planetmintgo.machine.Metadata:
     type: object
     properties:
@@ -75476,6 +75556,50 @@ definitions:
   planetmintgo.machine.Params:
     type: object
     description: Params defines the parameters for the module.
+  planetmintgo.machine.QueryGetMachineByAddressResponse:
+    type: object
+    properties:
+      machine:
+        type: object
+        properties:
+          name:
+            type: string
+          ticker:
+            type: string
+          domain:
+            type: string
+          reissue:
+            type: boolean
+          amount:
+            type: string
+            format: uint64
+          precision:
+            type: string
+            format: uint64
+          issuerPlanetmint:
+            type: string
+          issuerLiquid:
+            type: string
+          machineId:
+            type: string
+          metadata:
+            type: object
+            properties:
+              gps:
+                type: string
+              device:
+                type: string
+              assetDefinition:
+                type: string
+              additionalDataCID:
+                type: string
+          type:
+            type: integer
+            format: int64
+          machineIdSignature:
+            type: string
+          address:
+            type: string
   planetmintgo.machine.QueryGetMachineByPublicKeyResponse:
     type: object
     properties:
@@ -75518,6 +75642,8 @@ definitions:
             format: int64
           machineIdSignature:
             type: string
+          address:
+            type: string
   planetmintgo.machine.QueryGetTrustAnchorStatusResponse:
     type: object
     properties:

proto/planetmintgo/machine/machine.proto

@@ -17,6 +17,7 @@ message Machine {
   Metadata metadata = 10; 
   uint32 type = 11;
   string machineIdSignature = 12;
+  string address = 13;
 }
 
 message Metadata {
@@ -31,4 +32,5 @@ message MachineIndex {
   string machineId = 1;
   string issuerPlanetmint = 2; 
   string issuerLiquid = 3; 
+  string address = 4;
 }

proto/planetmintgo/machine/query.proto

@@ -30,6 +30,12 @@ service Query {
     option (google.api.http).get = "/github.com/planetmint/planetmint-go/machine/get_trust_anchor_status/{machineid}";
   
   }
+  
+  // Queries a list of GetMachineByAddress items.
+  rpc GetMachineByAddress (QueryGetMachineByAddressRequest) returns (QueryGetMachineByAddressResponse) {
+    option (google.api.http).get = "/planetmint-go/machine/get_machine_by_address/{address}";
+  
+  }
 }
 // QueryParamsRequest is request type for the Query/Params RPC method.
 message QueryParamsRequest {}
@@ -58,3 +64,11 @@ message QueryGetTrustAnchorStatusResponse {
   bool   isactivated = 2;
 }
 
+message QueryGetMachineByAddressRequest {
+  string address = 1;
+}
+
+message QueryGetMachineByAddressResponse {
+  Machine machine = 1;
+}
+

tests/e2e/machine/rest.go

@@ -38,6 +38,7 @@ func (s *E2ETestSuite) TestAttestMachineREST() {
 
 	// Create Attest Machine TX
 	machine := sample.Machine(sample.Name, pubKey, prvKey)
+	machine.Address = addr.String()
 	msg := machinetypes.MsgAttestMachine{
 		Creator: addr.String(),
 		Machine: &machine,

testutil/keeper/asset.go

@@ -52,9 +52,9 @@ func AssetKeeper(t testing.TB) (*keeper.Keeper, sdk.Context) {
 	_, ppk := sample.ExtendedKeyPair(config.PlmntNetParams)
 	_, lpk := sample.ExtendedKeyPair(config.LiquidNetParams)
 	id := sample.MachineIndex(pk, ppk, lpk)
-	mk.EXPECT().GetMachineIndex(ctx, pk).Return(id, true).AnyTimes()
+	mk.EXPECT().GetMachineIndexByPubKey(ctx, pk).Return(id, true).AnyTimes()
-	mk.EXPECT().GetMachineIndex(ctx, ppk).Return(id, true).AnyTimes()
+	mk.EXPECT().GetMachineIndexByPubKey(ctx, ppk).Return(id, true).AnyTimes()
-	mk.EXPECT().GetMachineIndex(ctx, sk).Return(id, false).AnyTimes()
+	mk.EXPECT().GetMachineIndexByPubKey(ctx, sk).Return(id, false).AnyTimes()
 	mk.EXPECT().GetMachine(ctx, id).Return(sample.Machine(pk, pk, sk), true).AnyTimes()
 	mk.EXPECT().GetMachine(ctx, sk).Return(sample.Machine(pk, pk, sk), false).AnyTimes()
 

testutil/keeper/machine.go

@@ -24,6 +24,7 @@ func MachineKeeper(t testing.TB) (*keeper.Keeper, sdk.Context) {
 	issuerPlanetmintIndexStoreKey := sdk.NewKVStoreKey(types.IssuerPlanetmintIndexKey)
 	issuerLiquidIndexStoreKey := sdk.NewKVStoreKey(types.IssuerLiquidIndexKey)
 	trustAnchorStoreKey := sdk.NewKVStoreKey(types.TrustAnchorKey)
+	addressStoreKey := sdk.NewKVStoreKey(types.AddressIndexKey)
 	memStoreKey := storetypes.NewMemoryStoreKey(types.MemStoreKey)
 
 	db := tmdb.NewMemDB()
@@ -33,6 +34,7 @@ func MachineKeeper(t testing.TB) (*keeper.Keeper, sdk.Context) {
 	stateStore.MountStoreWithDB(issuerPlanetmintIndexStoreKey, storetypes.StoreTypeIAVL, db)
 	stateStore.MountStoreWithDB(issuerLiquidIndexStoreKey, storetypes.StoreTypeIAVL, db)
 	stateStore.MountStoreWithDB(trustAnchorStoreKey, storetypes.StoreTypeIAVL, db)
+	stateStore.MountStoreWithDB(addressStoreKey, storetypes.StoreTypeIAVL, db)
 	stateStore.MountStoreWithDB(memStoreKey, storetypes.StoreTypeMemory, nil)
 	require.NoError(t, stateStore.LoadLatestVersion())
 
@@ -53,6 +55,7 @@ func MachineKeeper(t testing.TB) (*keeper.Keeper, sdk.Context) {
 		issuerPlanetmintIndexStoreKey,
 		issuerLiquidIndexStoreKey,
 		trustAnchorStoreKey,
+		addressStoreKey,
 		memStoreKey,
 		paramsSubspace,
 	)

testutil/sample/sample.go

@@ -59,6 +59,7 @@ func Secp256k1AccAddress() sdk.AccAddress {
 	return sdk.AccAddress(addr)
 }
 
+// TODO: make address deterministic for test cases
 func Machine(name, pubKey string, prvKey string) machinetypes.Machine {
 	metadata := Metadata()
 	_, liquidPubKey := ExtendedKeyPair(config.LiquidNetParams)
@@ -70,6 +71,8 @@ func Machine(name, pubKey string, prvKey string) machinetypes.Machine {
 	sign, _ := sk.Sign(pubKeyBytes)
 	signatureHex := hex.EncodeToString(sign)
 
+	addr := Secp256k1AccAddress()
+
 	m := machinetypes.Machine{
 		Name:               name,
 		Ticker:             name + "_ticker",
@@ -83,6 +86,7 @@ func Machine(name, pubKey string, prvKey string) machinetypes.Machine {
 		Metadata:           &metadata,
 		Type:               1,
 		MachineIdSignature: signatureHex,
+		Address:            addr.String(),
 	}
 	return m
 }

x/asset/keeper/msg_server_notarize_asset.go

@@ -13,7 +13,7 @@ import (
 func (k msgServer) NotarizeAsset(goCtx context.Context, msg *types.MsgNotarizeAsset) (*types.MsgNotarizeAssetResponse, error) {
 	ctx := sdk.UnwrapSDKContext(goCtx)
 
-	_, found := k.machineKeeper.GetMachineIndex(ctx, msg.PubKey)
+	_, found := k.machineKeeper.GetMachineIndexByPubKey(ctx, msg.PubKey)
 
 	if !found {
 		return nil, errors.New("machine not found")

x/asset/testutil/expected_keepers_mock.go

@@ -125,17 +125,17 @@ func (mr *MockMachineKeeperMockRecorder) GetMachine(ctx, index interface{}) *gom
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMachine", reflect.TypeOf((*MockMachineKeeper)(nil).GetMachine), ctx, index)
 }
 
-// GetMachineIndex mocks base method.
+// GetMachineIndexByPubKey mocks base method.
-func (m *MockMachineKeeper) GetMachineIndex(ctx types.Context, pubKey string) (types1.MachineIndex, bool) {
+func (m *MockMachineKeeper) GetMachineIndexByPubKey(ctx types.Context, pubKey string) (types1.MachineIndex, bool) {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetMachineIndex", ctx, pubKey)
+	ret := m.ctrl.Call(m, "GetMachineIndexByPubKey", ctx, pubKey)
 	ret0, _ := ret[0].(types1.MachineIndex)
 	ret1, _ := ret[1].(bool)
 	return ret0, ret1
 }
 
-// GetMachineIndex indicates an expected call of GetMachineIndex.
+// GetMachineIndexByPubKey indicates an expected call of GetMachineIndexByPubKey.
-func (mr *MockMachineKeeperMockRecorder) GetMachineIndex(ctx, pubKey interface{}) *gomock.Call {
+func (mr *MockMachineKeeperMockRecorder) GetMachineIndexByPubKey(ctx, pubKey interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMachineIndex", reflect.TypeOf((*MockMachineKeeper)(nil).GetMachineIndex), ctx, pubKey)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMachineIndexByPubKey", reflect.TypeOf((*MockMachineKeeper)(nil).GetMachineIndexByPubKey), ctx, pubKey)
 }

x/asset/types/expected_keepers.go

@@ -10,7 +10,7 @@ import (
 type MachineKeeper interface {
 	// Methods imported from machine should be defined here
 	GetMachine(ctx sdk.Context, index machinetypes.MachineIndex) (val machinetypes.Machine, found bool)
-	GetMachineIndex(ctx sdk.Context, pubKey string) (val machinetypes.MachineIndex, found bool)
+	GetMachineIndexByPubKey(ctx sdk.Context, pubKey string) (val machinetypes.MachineIndex, found bool)
 }
 
 // AccountKeeper defines the expected account keeper used for simulations (noalias)

x/dao/abci.go

@@ -1,12 +1,70 @@
 package dao
 
 import (
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/planetmint/planetmint-go/config"
 	"github.com/planetmint/planetmint-go/x/dao/keeper"
 
 	abci "github.com/cometbft/cometbft/abci/types"
+	cometcfg "github.com/cometbft/cometbft/config"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 )
 
+type Key struct {
+	Type  string `json:"type"`
+	Value string `json:"value"`
+}
+
+type KeyFile struct {
+	Address string `json:"address"`
+	PubKey  Key    `json:"pub_key"`
+	PrivKey Key    `json:"priv_key"`
+}
+
+func BeginBlocker(ctx sdk.Context, req abci.RequestBeginBlock, k keeper.Keeper) {
+	proposerAddress := req.Header.GetProposerAddress()
+
+	// Check if node is block proposer
+	if isValidatorBlockProposer(ctx, proposerAddress) {
+		// TODO: implement PoP trigger
+		fmt.Println("TODO: implement PoP trigger")
+	}
+}
+
+func isValidatorBlockProposer(ctx sdk.Context, proposerAddress []byte) bool {
+	logger := ctx.Logger()
+	conf := config.GetConfig()
+
+	cfg := cometcfg.DefaultConfig()
+	jsonFilePath := filepath.Join(conf.ConfigRootDir, cfg.PrivValidatorKey)
+
+	hexProposerAddress := hex.EncodeToString(proposerAddress)
+
+	jsonFile, err := os.Open(jsonFilePath)
+	if err != nil {
+		logger.Error("error while opening config", err)
+	}
+	jsonBytes, err := io.ReadAll(jsonFile)
+	if err != nil {
+		logger.Error("error while reading file", err)
+	}
+
+	var keyFile KeyFile
+	err = json.Unmarshal(jsonBytes, &keyFile)
+	if err != nil {
+		logger.Error("error while unmarshaling key file", err)
+	}
+
+	return hexProposerAddress == strings.ToLower(keyFile.Address)
+}
+
 func EndBlocker(ctx sdk.Context, req abci.RequestEndBlock, k keeper.Keeper) {
 	k.DistributeCollectedFees(ctx)
 }

x/dao/module.go

@@ -143,7 +143,9 @@ func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.Raw
 func (AppModule) ConsensusVersion() uint64 { return 1 }
 
 // BeginBlock contains the logic that is automatically triggered at the beginning of each block
-func (am AppModule) BeginBlock(_ sdk.Context, _ abci.RequestBeginBlock) {}
+func (am AppModule) BeginBlock(ctx sdk.Context, req abci.RequestBeginBlock) {
+	BeginBlocker(ctx, req, am.keeper)
+}
 
 // EndBlock contains the logic that is automatically triggered at the end of each block
 func (am AppModule) EndBlock(ctx sdk.Context, req abci.RequestEndBlock) []abci.ValidatorUpdate {

x/dao/types/expected_keepers.go

@@ -18,5 +18,6 @@ type BankKeeper interface {
 	SpendableCoins(ctx sdk.Context, addr sdk.AccAddress) sdk.Coins
 	SendCoinsFromModuleToAccount(ctx sdk.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) error
 	BlockedAddr(addr sdk.AccAddress) bool
+	MintCoins(ctx sdk.Context, moduleName string, amt sdk.Coins) error
 	// Methods imported from bank should be defined here
 }

x/machine/client/cli/query.go

@@ -28,6 +28,7 @@ func GetQueryCmd(queryRoute string) *cobra.Command {
 	cmd.AddCommand(CmdGetMachineByPublicKey())
 
 	cmd.AddCommand(CmdGetTrustAnchorStatus())
+	cmd.AddCommand(CmdGetMachineByAddress())
 
 	// this line is used by starport scaffolding # 1
 

x/machine/client/cli/query_get_machine_by_address.go

@@ -0,0 +1,46 @@
+package cli
+
+import (
+	"strconv"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/planetmint/planetmint-go/x/machine/types"
+	"github.com/spf13/cobra"
+)
+
+var _ = strconv.Itoa(0)
+
+func CmdGetMachineByAddress() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "get-machine-by-address [address]",
+		Short: "Query get-machine-by-address",
+		Args:  cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) (err error) {
+			reqAddress := args[0]
+
+			clientCtx, err := client.GetClientQueryContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			queryClient := types.NewQueryClient(clientCtx)
+
+			params := &types.QueryGetMachineByAddressRequest{
+
+				Address: reqAddress,
+			}
+
+			res, err := queryClient.GetMachineByAddress(cmd.Context(), params)
+			if err != nil {
+				return err
+			}
+
+			return clientCtx.PrintProto(res)
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+
+	return cmd
+}

x/machine/keeper/keeper.go

@@ -20,6 +20,7 @@ type (
 		issuerPlanetmintIndexStoreKey storetypes.StoreKey
 		issuerLiquidIndexStoreKey     storetypes.StoreKey
 		taStoreKey                    storetypes.StoreKey
+		addressIndexStoreKey          storetypes.StoreKey
 		memKey                        storetypes.StoreKey
 		paramstore                    paramtypes.Subspace
 	}
@@ -32,6 +33,7 @@ func NewKeeper(
 	issuerPlanetmintIndexStoreKey,
 	issuerLiquidIndexStoreKey,
 	taStoreKey,
+	addressIndexStoreKey,
 	memKey storetypes.StoreKey,
 	ps paramtypes.Subspace,
 ) *Keeper {
@@ -47,6 +49,7 @@ func NewKeeper(
 		issuerPlanetmintIndexStoreKey: issuerPlanetmintIndexStoreKey,
 		issuerLiquidIndexStoreKey:     issuerLiquidIndexStoreKey,
 		taStoreKey:                    taStoreKey,
+		addressIndexStoreKey:          addressIndexStoreKey,
 		memKey:                        memKey,
 		paramstore:                    ps,
 	}

x/machine/keeper/machine.go

@@ -30,23 +30,27 @@ func (k Keeper) StoreMachineIndex(ctx sdk.Context, machine types.Machine) {
 	taIndexStore := prefix.NewStore(ctx.KVStore(k.taIndexStoreKey), types.KeyPrefix(types.TAIndexKey))
 	issuerPlanetmintIndexStore := prefix.NewStore(ctx.KVStore(k.issuerPlanetmintIndexStoreKey), types.KeyPrefix(types.IssuerPlanetmintIndexKey))
 	issuerLiquidIndexStore := prefix.NewStore(ctx.KVStore(k.issuerLiquidIndexStoreKey), types.KeyPrefix(types.IssuerLiquidIndexKey))
+	addressIndexStore := prefix.NewStore(ctx.KVStore(k.addressIndexStoreKey), types.KeyPrefix(types.AddressIndexKey))
 
 	index := types.MachineIndex{
 		MachineId:        machine.MachineId,
 		IssuerPlanetmint: machine.IssuerPlanetmint,
 		IssuerLiquid:     machine.IssuerLiquid,
+		Address:          machine.Address,
 	}
 
 	machineIdIndexKey := GetMachineBytes(machine.MachineId)
 	issuerPlanetmintIndexKey := GetMachineBytes(machine.IssuerPlanetmint)
 	issuerLiquidIndexKey := GetMachineBytes(machine.IssuerLiquid)
+	addressIndexKey := GetMachineBytes(machine.Address)
 	indexAppendValue := k.cdc.MustMarshal(&index)
 	taIndexStore.Set(machineIdIndexKey, indexAppendValue)
 	issuerPlanetmintIndexStore.Set(issuerPlanetmintIndexKey, indexAppendValue)
 	issuerLiquidIndexStore.Set(issuerLiquidIndexKey, indexAppendValue)
+	addressIndexStore.Set(addressIndexKey, indexAppendValue)
 }
 
-func (k Keeper) GetMachineIndex(ctx sdk.Context, pubKey string) (val types.MachineIndex, found bool) {
+func (k Keeper) GetMachineIndexByPubKey(ctx sdk.Context, pubKey string) (val types.MachineIndex, found bool) {
 	taIndexStore := prefix.NewStore(ctx.KVStore(k.taIndexStoreKey), types.KeyPrefix(types.TAIndexKey))
 	issuerPlanetmintIndexStore := prefix.NewStore(ctx.KVStore(k.issuerPlanetmintIndexStoreKey), types.KeyPrefix(types.IssuerPlanetmintIndexKey))
 	issuerLiquidIndexStore := prefix.NewStore(ctx.KVStore(k.issuerLiquidIndexStoreKey), types.KeyPrefix(types.IssuerLiquidIndexKey))
@@ -80,6 +84,22 @@ func (k Keeper) GetMachineIndex(ctx sdk.Context, pubKey string) (val types.Machi
 	return val, false
 }
 
+func (k Keeper) GetMachineIndexByAddress(ctx sdk.Context, address string) (val types.MachineIndex, found bool) {
+	addressIndexStore := prefix.NewStore(ctx.KVStore(k.addressIndexStoreKey), types.KeyPrefix(types.AddressIndexKey))
+
+	keyBytes := GetMachineBytes(address)
+
+	adIndex := addressIndexStore.Get(keyBytes)
+	if adIndex != nil {
+		if err := k.cdc.Unmarshal(adIndex, &val); err != nil {
+			return val, false
+		}
+		return val, true
+	}
+
+	return val, false
+}
+
 func GetMachineBytes(pubKey string) []byte {
 	return []byte(pubKey)
 }

x/machine/keeper/machine_test.go

@@ -18,6 +18,7 @@ func createNMachine(keeper *keeper.Keeper, ctx sdk.Context, n int) []types.Machi
 		items[i].MachineId = fmt.Sprintf("machineId%v", i)
 		items[i].IssuerPlanetmint = fmt.Sprintf("issuerPlanetmint%v", i)
 		items[i].IssuerLiquid = fmt.Sprintf("issuerLiquid%v", i)
+		items[i].Address = fmt.Sprintf("address%v", i)
 		keeper.StoreMachine(ctx, items[i])
 		keeper.StoreMachineIndex(ctx, items[i])
 	}
@@ -32,6 +33,7 @@ func TestGetMachine(t *testing.T) {
 			MachineId:        item.MachineId,
 			IssuerPlanetmint: item.IssuerPlanetmint,
 			IssuerLiquid:     item.IssuerLiquid,
+			Address:          item.Address,
 		}
 		machineById, found := keeper.GetMachine(ctx, index)
 		assert.True(t, found)
@@ -39,7 +41,7 @@ func TestGetMachine(t *testing.T) {
 	}
 }
 
-func TestGetMachineIndex(t *testing.T) {
+func TestGetMachineIndexByPubKey(t *testing.T) {
 	keeper, ctx := keepertest.MachineKeeper(t)
 	items := createNMachine(keeper, ctx, 10)
 	for _, item := range items {
@@ -47,8 +49,9 @@ func TestGetMachineIndex(t *testing.T) {
 			MachineId:        item.MachineId,
 			IssuerPlanetmint: item.IssuerPlanetmint,
 			IssuerLiquid:     item.IssuerLiquid,
+			Address:          item.Address,
 		}
-		index, found := keeper.GetMachineIndex(ctx, item.MachineId)
+		index, found := keeper.GetMachineIndexByPubKey(ctx, item.MachineId)
 		assert.True(t, found)
 		assert.Equal(t, expectedIndex, index)
 	}

x/machine/keeper/query_get_machine_by_address.go

@@ -0,0 +1,31 @@
+package keeper
+
+import (
+	"context"
+
+	"github.com/planetmint/planetmint-go/x/machine/types"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+func (k Keeper) GetMachineByAddress(goCtx context.Context, req *types.QueryGetMachineByAddressRequest) (*types.QueryGetMachineByAddressResponse, error) {
+	if req == nil {
+		return nil, status.Error(codes.InvalidArgument, "invalid request")
+	}
+
+	ctx := sdk.UnwrapSDKContext(goCtx)
+
+	machineIndex, found := k.GetMachineIndexByAddress(ctx, req.Address)
+	if !found {
+		return nil, status.Error(codes.NotFound, "machine not found")
+	}
+
+	machine, found := k.GetMachine(ctx, machineIndex)
+	if !found {
+		return nil, status.Error(codes.Internal, "error while fetching machine")
+	}
+
+	return &types.QueryGetMachineByAddressResponse{Machine: &machine}, nil
+}

x/machine/keeper/query_get_machine_by_address_test.go

@@ -0,0 +1,44 @@
+package keeper_test
+
+import (
+	"testing"
+
+	keepertest "github.com/planetmint/planetmint-go/testutil/keeper"
+	"github.com/planetmint/planetmint-go/x/machine/types"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/stretchr/testify/require"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+func TestGetMachineByAddress(t *testing.T) {
+	keeper, ctx := keepertest.MachineKeeper(t)
+	wctx := sdk.WrapSDKContext(ctx)
+	msgs := createNMachine(keeper, ctx, 1)
+	for _, tc := range []struct {
+		desc     string
+		request  *types.QueryGetMachineByAddressRequest
+		response *types.QueryGetMachineByAddressResponse
+		err      error
+	}{
+		{
+			desc:     "GetMachineByAddress",
+			request:  &types.QueryGetMachineByAddressRequest{Address: msgs[0].Address},
+			response: &types.QueryGetMachineByAddressResponse{Machine: &msgs[0]},
+		}, {
+			desc:    "MachineNotFound",
+			request: &types.QueryGetMachineByAddressRequest{Address: "invalid address"},
+			err:     status.Error(codes.NotFound, "machine not found"),
+		},
+	} {
+		t.Run(tc.desc, func(t *testing.T) {
+			response, err := keeper.GetMachineByAddress(wctx, tc.request)
+			if tc.err != nil {
+				require.ErrorIs(t, err, tc.err)
+			} else {
+				require.Equal(t, tc.response, response)
+			}
+		})
+	}
+}

x/machine/keeper/query_get_machine_by_public_key.go

@@ -17,12 +17,15 @@ func (k Keeper) GetMachineByPublicKey(goCtx context.Context, req *types.QueryGet
 
 	ctx := sdk.UnwrapSDKContext(goCtx)
 
-	machineIndex, found := k.GetMachineIndex(ctx, req.PublicKey)
+	machineIndex, found := k.GetMachineIndexByPubKey(ctx, req.PublicKey)
 	if !found {
 		return nil, status.Error(codes.NotFound, "machine not found")
 	}
 
-	machine, _ := k.GetMachine(ctx, machineIndex)
+	machine, found := k.GetMachine(ctx, machineIndex)
+	if !found {
+		return nil, status.Error(codes.Internal, "error while fetching machine")
+	}
 
 	return &types.QueryGetMachineByPublicKeyResponse{Machine: &machine}, nil
 }

x/machine/types/keys.go

@@ -22,6 +22,8 @@ const (
 	IssuerLiquidIndexKey = "Machine/IssuerLiquidIndex/"
 
 	TrustAnchorKey = "Machine/trustAnchor/"
+
+	AddressIndexKey = "Machine/address"
 )
 
 func KeyPrefix(p string) []byte {

x/machine/types/machine.pb.go

@@ -35,6 +35,7 @@ type Machine struct {
 	Metadata           *Metadata `protobuf:"bytes,10,opt,name=metadata,proto3" json:"metadata,omitempty"`
 	Type               uint32    `protobuf:"varint,11,opt,name=type,proto3" json:"type,omitempty"`
 	MachineIdSignature string    `protobuf:"bytes,12,opt,name=machineIdSignature,proto3" json:"machineIdSignature,omitempty"`
+	Address            string    `protobuf:"bytes,13,opt,name=address,proto3" json:"address,omitempty"`
 }
 
 func (m *Machine) Reset()         { *m = Machine{} }
@@ -154,6 +155,13 @@ func (m *Machine) GetMachineIdSignature() string {
 	return ""
 }
 
+func (m *Machine) GetAddress() string {
+	if m != nil {
+		return m.Address
+	}
+	return ""
+}
+
 type Metadata struct {
 	Gps               string `protobuf:"bytes,1,opt,name=gps,proto3" json:"gps,omitempty"`
 	Device            string `protobuf:"bytes,2,opt,name=device,proto3" json:"device,omitempty"`
@@ -226,6 +234,7 @@ type MachineIndex struct {
 	MachineId        string `protobuf:"bytes,1,opt,name=machineId,proto3" json:"machineId,omitempty"`
 	IssuerPlanetmint string `protobuf:"bytes,2,opt,name=issuerPlanetmint,proto3" json:"issuerPlanetmint,omitempty"`
 	IssuerLiquid     string `protobuf:"bytes,3,opt,name=issuerLiquid,proto3" json:"issuerLiquid,omitempty"`
+	Address          string `protobuf:"bytes,4,opt,name=address,proto3" json:"address,omitempty"`
 }
 
 func (m *MachineIndex) Reset()         { *m = MachineIndex{} }
@@ -282,6 +291,13 @@ func (m *MachineIndex) GetIssuerLiquid() string {
 	return ""
 }
 
+func (m *MachineIndex) GetAddress() string {
+	if m != nil {
+		return m.Address
+	}
+	return ""
+}
+
 func init() {
 	proto.RegisterType((*Machine)(nil), "planetmintgo.machine.Machine")
 	proto.RegisterType((*Metadata)(nil), "planetmintgo.machine.Metadata")
@@ -293,34 +309,35 @@ func init() {
 }
 
 var fileDescriptor_1bb279745bef7c4b = []byte{
-	// 423 bytes of a gzipped FileDescriptorProto
+	// 443 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0x3f, 0x8f, 0xd3, 0x30,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x53, 0xbd, 0x8e, 0xd3, 0x40,
-	0x1c, 0xad, 0x9b, 0xd2, 0x26, 0xbf, 0x16, 0x51, 0x2c, 0x84, 0x3c, 0xa0, 0x28, 0xca, 0x14, 0x21,
+	0x18, 0xcc, 0x5e, 0x42, 0x7e, 0xbe, 0xcb, 0x89, 0x63, 0x85, 0xd0, 0x16, 0xc8, 0xb2, 0x5c, 0x59,
-	0x48, 0x25, 0xba, 0x31, 0x42, 0x97, 0x4a, 0x54, 0x42, 0x61, 0x63, 0x73, 0x13, 0x93, 0x5a, 0x34,
+	0x08, 0x1c, 0x89, 0xeb, 0x28, 0x21, 0x4d, 0x24, 0x22, 0x21, 0xd3, 0xd1, 0xed, 0x79, 0x3f, 0x7c,
-	0x76, 0x48, 0x1c, 0x54, 0x24, 0xbe, 0xc1, 0xdd, 0x70, 0x1f, 0xeb, 0xc6, 0x8e, 0x37, 0x9e, 0xda,
+	0x2b, 0xce, 0xbb, 0xc6, 0xbb, 0x46, 0xc7, 0x3b, 0x50, 0x50, 0xf1, 0x06, 0xbc, 0x0b, 0xe5, 0x95,
-	0x2f, 0x72, 0x8a, 0xf3, 0xa7, 0x7f, 0x87, 0x9b, 0xf2, 0xde, 0xfb, 0x3d, 0xdb, 0xc9, 0x7b, 0x31,
+	0x94, 0x28, 0x79, 0x11, 0xb4, 0x6b, 0x3b, 0x3f, 0x77, 0x2e, 0xae, 0xca, 0xcc, 0x7c, 0xb3, 0xf9,
-	0xb8, 0xe9, 0x9a, 0x0a, 0xa6, 0x12, 0x2e, 0x54, 0x2c, 0x27, 0x09, 0x0d, 0x57, 0x5c, 0xb0, 0xe6,
+	0xec, 0x19, 0x2f, 0x44, 0xe5, 0x35, 0x57, 0x68, 0x0b, 0xa9, 0x6c, 0xae, 0x17, 0x05, 0xcf, 0xae,
-	0xe9, 0xa7, 0x99, 0x54, 0x12, 0xbf, 0x39, 0xf6, 0xf8, 0xf5, 0xcc, 0xbd, 0x31, 0x60, 0xb0, 0xa8,
+	0xa4, 0xc2, 0xee, 0x37, 0x29, 0x2b, 0x6d, 0x35, 0x7d, 0x7a, 0xe8, 0x49, 0xda, 0x59, 0xf4, 0x7b,
-	0x30, 0xc6, 0xd0, 0x13, 0x34, 0x61, 0x04, 0x39, 0xc8, 0xb3, 0x02, 0x8d, 0xf1, 0x5b, 0xe8, 0x2b,
+	0x08, 0x93, 0x75, 0x83, 0x29, 0x85, 0x91, 0xe2, 0x05, 0x32, 0x12, 0x92, 0x78, 0x96, 0x7a, 0x4c,
-	0x1e, 0xfe, 0x66, 0x19, 0xe9, 0x6a, 0xb5, 0x66, 0xa5, 0x1e, 0xc9, 0x84, 0x72, 0x41, 0x8c, 0x4a,
+	0x9f, 0xc1, 0xd8, 0xca, 0xec, 0x0b, 0x56, 0xec, 0xc4, 0xab, 0x2d, 0x73, 0xba, 0xd0, 0x05, 0x97,
-	0xaf, 0x18, 0x26, 0x30, 0xc8, 0x18, 0xcf, 0xf3, 0x82, 0x91, 0x9e, 0x83, 0x3c, 0x33, 0x68, 0x68,
+	0x8a, 0x0d, 0x1b, 0xbd, 0x61, 0x94, 0xc1, 0xa4, 0x42, 0x69, 0x4c, 0x8d, 0x6c, 0x14, 0x92, 0x78,
-	0xb9, 0x82, 0x26, 0xb2, 0x10, 0x8a, 0xbc, 0x70, 0x90, 0xd7, 0x0b, 0x6a, 0x86, 0xdf, 0x81, 0x95,
+	0x9a, 0x76, 0xd4, 0x9d, 0xe0, 0x85, 0xae, 0x95, 0x65, 0x8f, 0x42, 0x12, 0x8f, 0xd2, 0x96, 0xd1,
-	0x66, 0x2c, 0xe4, 0x39, 0x97, 0x82, 0xf4, 0xf5, 0xe8, 0x20, 0xe0, 0xf7, 0x30, 0xd6, 0xcb, 0xb3,
+	0xe7, 0x30, 0x2b, 0x2b, 0xcc, 0xa4, 0x91, 0x5a, 0xb1, 0xb1, 0x1f, 0xed, 0x05, 0xfa, 0x02, 0xce,
-	0xef, 0xed, 0xdb, 0x93, 0x81, 0x3e, 0xf1, 0x42, 0xc7, 0x2e, 0x8c, 0x2a, 0xed, 0x1b, 0xff, 0x53,
+	0xfd, 0xf1, 0xea, 0xc3, 0xee, 0xe9, 0xd9, 0xc4, 0x6f, 0xbc, 0xa7, 0xd3, 0x08, 0xe6, 0x8d, 0xf6,
-	0xf0, 0x88, 0x98, 0xda, 0x77, 0xa2, 0x95, 0xa7, 0xd5, 0x9f, 0x3e, 0x8f, 0x88, 0xa5, 0x0d, 0x07,
+	0x5e, 0x7e, 0xad, 0xa5, 0x60, 0x53, 0xef, 0x3b, 0xd2, 0xdc, 0xb6, 0xf6, 0xd5, 0x57, 0x82, 0xcd,
-	0x01, 0x7f, 0x06, 0x33, 0x61, 0x8a, 0x46, 0x54, 0x51, 0x02, 0x0e, 0xf2, 0x86, 0x9f, 0x6c, 0xff,
+	0xbc, 0x61, 0x2f, 0xd0, 0x37, 0x30, 0x2d, 0xd0, 0x72, 0xc1, 0x2d, 0x67, 0x10, 0x92, 0xf8, 0xf4,
-	0x5a, 0x6c, 0xfe, 0xa2, 0x76, 0x05, 0xad, 0xbf, 0x4c, 0x4f, 0xfd, 0x4b, 0x19, 0x19, 0x3a, 0xc8,
+	0x75, 0x90, 0xf4, 0xc5, 0x96, 0xac, 0x5b, 0x57, 0xba, 0xf3, 0xbb, 0xf4, 0xec, 0xf7, 0x12, 0xd9,
-	0x7b, 0x19, 0x68, 0x8c, 0x7d, 0xc0, 0xed, 0xe6, 0x3f, 0x78, 0x2c, 0xa8, 0x2a, 0x32, 0x46, 0x46,
+	0x69, 0x48, 0xe2, 0xb3, 0xd4, 0x63, 0x9a, 0x00, 0xdd, 0xfd, 0xf9, 0x47, 0x99, 0x2b, 0x6e, 0xeb,
-	0xfa, 0xd8, 0x2b, 0x13, 0xf7, 0x16, 0x81, 0xd9, 0x6c, 0x8d, 0xc7, 0x60, 0xc4, 0x69, 0x5e, 0xb7,
+	0x0a, 0xd9, 0xdc, 0xaf, 0xed, 0x99, 0xb8, 0xf4, 0xb8, 0x10, 0x15, 0x1a, 0xc3, 0xce, 0xbc, 0xa9,
-	0x51, 0x42, 0x1d, 0x3a, 0xfb, 0xcb, 0x43, 0xd6, 0x94, 0x51, 0x31, 0xec, 0xc1, 0x2b, 0x9a, 0xe7,
+	0xa3, 0xd1, 0x0f, 0x02, 0xd3, 0x6e, 0x29, 0x3d, 0x87, 0x61, 0x5e, 0x9a, 0xb6, 0x27, 0x07, 0x7d,
-	0x4c, 0xcd, 0xd8, 0x2f, 0x2e, 0xb8, 0x2a, 0x83, 0xac, 0x5a, 0x39, 0x97, 0xf1, 0x07, 0x78, 0x4d,
+	0x1d, 0xf8, 0x4d, 0x66, 0xd8, 0xd5, 0xd4, 0x30, 0x1a, 0xc3, 0x63, 0x6e, 0x0c, 0xda, 0x25, 0x7e,
-	0xa3, 0x48, 0x63, 0xba, 0x9e, 0x51, 0x45, 0xbf, 0xce, 0x67, 0xba, 0x28, 0x2b, 0xb8, 0x1c, 0xb8,
+	0x96, 0x4a, 0x5a, 0x17, 0x71, 0xd3, 0xd7, 0x5d, 0x99, 0xbe, 0x84, 0x27, 0x5c, 0x08, 0x8f, 0xf9,
-	0xff, 0x61, 0x54, 0xff, 0x1b, 0x73, 0x11, 0xb1, 0xcd, 0x69, 0x78, 0xe8, 0x3c, 0xbc, 0x6b, 0x55,
+	0xf5, 0x92, 0x5b, 0xfe, 0x6e, 0xb5, 0xf4, 0x15, 0xce, 0xd2, 0xfb, 0x83, 0xe8, 0x17, 0x81, 0x79,
-	0x75, 0x9f, 0x59, 0x95, 0x71, 0x59, 0xd5, 0x97, 0xc5, 0xfd, 0xce, 0x46, 0xdb, 0x9d, 0x8d, 0x1e,
+	0xfb, 0xd9, 0xac, 0x94, 0xc0, 0x9b, 0xe3, 0x5c, 0xc9, 0xdd, 0x5c, 0xfb, 0x5a, 0x3c, 0x79, 0x60,
-	0x77, 0x36, 0xba, 0xdb, 0xdb, 0x9d, 0xed, 0xde, 0xee, 0x3c, 0xec, 0xed, 0xce, 0xcf, 0x69, 0xcc,
+	0x8b, 0xc3, 0x9e, 0x16, 0x0f, 0x72, 0x1a, 0x1d, 0xe5, 0xf4, 0x76, 0xfd, 0x67, 0x13, 0x90, 0xdb,
-	0xd5, 0xaa, 0x58, 0xfa, 0xa1, 0x4c, 0x26, 0x87, 0x7a, 0x8e, 0xe0, 0xc7, 0x58, 0x4e, 0x36, 0xed,
+	0x4d, 0x40, 0xfe, 0x6d, 0x02, 0xf2, 0x73, 0x1b, 0x0c, 0x6e, 0xb7, 0xc1, 0xe0, 0xef, 0x36, 0x18,
-	0x3d, 0x28, 0xab, 0xc8, 0x97, 0x7d, 0x7d, 0x0d, 0xa6, 0x4f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xe7,
+	0x7c, 0xba, 0xc8, 0xa5, 0xbd, 0xaa, 0x2f, 0x93, 0x4c, 0x17, 0x8b, 0x7d, 0xa7, 0x07, 0xf0, 0x55,
-	0xdd, 0x90, 0x62, 0x2c, 0x03, 0x00, 0x00,
+	0xae, 0x17, 0x37, 0xbb, 0xcb, 0xe3, 0xfa, 0x33, 0x97, 0x63, 0x7f, 0x77, 0x2e, 0xfe, 0x07, 0x00,
+	0x00, 0xff, 0xff, 0x44, 0x7f, 0xea, 0x9d, 0x61, 0x03, 0x00, 0x00,
 }
 
 func (m *Machine) Marshal() (dAtA []byte, err error) {
@@ -343,6 +360,13 @@ func (m *Machine) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	if len(m.Address) > 0 {
+		i -= len(m.Address)
+		copy(dAtA[i:], m.Address)
+		i = encodeVarintMachine(dAtA, i, uint64(len(m.Address)))
+		i--
+		dAtA[i] = 0x6a
+	}
 	if len(m.MachineIdSignature) > 0 {
 		i -= len(m.MachineIdSignature)
 		copy(dAtA[i:], m.MachineIdSignature)
@@ -503,6 +527,13 @@ func (m *MachineIndex) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
+	if len(m.Address) > 0 {
+		i -= len(m.Address)
+		copy(dAtA[i:], m.Address)
+		i = encodeVarintMachine(dAtA, i, uint64(len(m.Address)))
+		i--
+		dAtA[i] = 0x22
+	}
 	if len(m.IssuerLiquid) > 0 {
 		i -= len(m.IssuerLiquid)
 		copy(dAtA[i:], m.IssuerLiquid)
@@ -588,6 +619,10 @@ func (m *Machine) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovMachine(uint64(l))
 	}
+	l = len(m.Address)
+	if l > 0 {
+		n += 1 + l + sovMachine(uint64(l))
+	}
 	return n
 }
 
@@ -634,6 +669,10 @@ func (m *MachineIndex) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovMachine(uint64(l))
 	}
+	l = len(m.Address)
+	if l > 0 {
+		n += 1 + l + sovMachine(uint64(l))
+	}
 	return n
 }
 
@@ -1009,6 +1048,38 @@ func (m *Machine) Unmarshal(dAtA []byte) error {
 			}
 			m.MachineIdSignature = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
+		case 13:
+			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 ErrIntOverflowMachine
+				}
+				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 ErrInvalidLengthMachine
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthMachine
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Address = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipMachine(dAtA[iNdEx:])
@@ -1333,6 +1404,38 @@ func (m *MachineIndex) Unmarshal(dAtA []byte) error {
 			}
 			m.IssuerLiquid = string(dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
+		case 4:
+			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 ErrIntOverflowMachine
+				}
+				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 ErrInvalidLengthMachine
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthMachine
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Address = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipMachine(dAtA[iNdEx:])

x/machine/types/query.pb.go

@@ -297,6 +297,94 @@ func (m *QueryGetTrustAnchorStatusResponse) GetIsactivated() bool {
 	return false
 }
 
+type QueryGetMachineByAddressRequest struct {
+	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
+}
+
+func (m *QueryGetMachineByAddressRequest) Reset()         { *m = QueryGetMachineByAddressRequest{} }
+func (m *QueryGetMachineByAddressRequest) String() string { return proto.CompactTextString(m) }
+func (*QueryGetMachineByAddressRequest) ProtoMessage()    {}
+func (*QueryGetMachineByAddressRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_bf7841d43d757203, []int{6}
+}
+func (m *QueryGetMachineByAddressRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryGetMachineByAddressRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryGetMachineByAddressRequest.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 *QueryGetMachineByAddressRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryGetMachineByAddressRequest.Merge(m, src)
+}
+func (m *QueryGetMachineByAddressRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryGetMachineByAddressRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryGetMachineByAddressRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryGetMachineByAddressRequest proto.InternalMessageInfo
+
+func (m *QueryGetMachineByAddressRequest) GetAddress() string {
+	if m != nil {
+		return m.Address
+	}
+	return ""
+}
+
+type QueryGetMachineByAddressResponse struct {
+	Machine *Machine `protobuf:"bytes,1,opt,name=machine,proto3" json:"machine,omitempty"`
+}
+
+func (m *QueryGetMachineByAddressResponse) Reset()         { *m = QueryGetMachineByAddressResponse{} }
+func (m *QueryGetMachineByAddressResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryGetMachineByAddressResponse) ProtoMessage()    {}
+func (*QueryGetMachineByAddressResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_bf7841d43d757203, []int{7}
+}
+func (m *QueryGetMachineByAddressResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *QueryGetMachineByAddressResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_QueryGetMachineByAddressResponse.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 *QueryGetMachineByAddressResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_QueryGetMachineByAddressResponse.Merge(m, src)
+}
+func (m *QueryGetMachineByAddressResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *QueryGetMachineByAddressResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_QueryGetMachineByAddressResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryGetMachineByAddressResponse proto.InternalMessageInfo
+
+func (m *QueryGetMachineByAddressResponse) GetMachine() *Machine {
+	if m != nil {
+		return m.Machine
+	}
+	return nil
+}
+
 func init() {
 	proto.RegisterType((*QueryParamsRequest)(nil), "planetmintgo.machine.QueryParamsRequest")
 	proto.RegisterType((*QueryParamsResponse)(nil), "planetmintgo.machine.QueryParamsResponse")
@@ -304,45 +392,52 @@ func init() {
 	proto.RegisterType((*QueryGetMachineByPublicKeyResponse)(nil), "planetmintgo.machine.QueryGetMachineByPublicKeyResponse")
 	proto.RegisterType((*QueryGetTrustAnchorStatusRequest)(nil), "planetmintgo.machine.QueryGetTrustAnchorStatusRequest")
 	proto.RegisterType((*QueryGetTrustAnchorStatusResponse)(nil), "planetmintgo.machine.QueryGetTrustAnchorStatusResponse")
+	proto.RegisterType((*QueryGetMachineByAddressRequest)(nil), "planetmintgo.machine.QueryGetMachineByAddressRequest")
+	proto.RegisterType((*QueryGetMachineByAddressResponse)(nil), "planetmintgo.machine.QueryGetMachineByAddressResponse")
 }
 
 func init() { proto.RegisterFile("planetmintgo/machine/query.proto", fileDescriptor_bf7841d43d757203) }
 
 var fileDescriptor_bf7841d43d757203 = []byte{
-	// 524 bytes of a gzipped FileDescriptorProto
+	// 593 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0xcf, 0x6a, 0xd4, 0x40,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0x41, 0x6b, 0x13, 0x41,
-	0x1c, 0xde, 0x94, 0x5a, 0xed, 0xf4, 0x36, 0xae, 0x50, 0xc2, 0x1a, 0xd3, 0x39, 0xad, 0x82, 0x19,
+	0x18, 0xcd, 0x16, 0x4d, 0xed, 0xf4, 0x36, 0x8d, 0x10, 0x96, 0xb8, 0x4d, 0xe7, 0x14, 0x05, 0x33,
-	0xda, 0x45, 0x57, 0xf4, 0x62, 0xf7, 0xe2, 0x41, 0x0a, 0xdb, 0xd8, 0x83, 0x14, 0x24, 0x4c, 0xd2,
+	0xb4, 0xa1, 0x8d, 0xda, 0x83, 0x26, 0x17, 0x0f, 0x52, 0x48, 0xd7, 0x1e, 0xa4, 0x22, 0xcb, 0xec,
-	0x21, 0x3b, 0xb8, 0x99, 0x49, 0x33, 0x93, 0x62, 0x28, 0xbd, 0xf8, 0x04, 0x82, 0x37, 0x9f, 0xa8,
+	0x66, 0xd8, 0x2c, 0x26, 0x3b, 0xdb, 0x9d, 0xd9, 0xe2, 0x12, 0x72, 0xf1, 0x17, 0x08, 0xde, 0xfc,
-	0xc7, 0x82, 0x17, 0x4f, 0xa2, 0xbb, 0xe2, 0xdd, 0x37, 0x90, 0x9d, 0x4c, 0x76, 0x57, 0x1a, 0x43,
+	0x27, 0xfe, 0x00, 0xa1, 0xc7, 0x82, 0x17, 0x4f, 0xa2, 0x89, 0xf8, 0x3b, 0x24, 0xb3, 0xb3, 0x49,
-	0xf7, 0x94, 0xe1, 0x97, 0xef, 0xf7, 0xfd, 0xc9, 0x7c, 0x04, 0xb8, 0xe9, 0x98, 0x70, 0xaa, 0x12,
+	0x4a, 0xd6, 0x90, 0xa5, 0xa7, 0x4c, 0xbe, 0xbc, 0xf7, 0xbe, 0xf7, 0x66, 0xbe, 0x2f, 0xa0, 0x1a,
-	0xc6, 0x55, 0x2c, 0x70, 0x42, 0xa2, 0x11, 0xe3, 0x14, 0x9f, 0xe6, 0x34, 0x2b, 0xbc, 0x34, 0x13,
+	0xf4, 0x89, 0x4f, 0xc5, 0xc0, 0xf3, 0x85, 0xcb, 0xf0, 0x80, 0x38, 0x3d, 0xcf, 0xa7, 0xf8, 0x22,
-	0x4a, 0xc0, 0xf6, 0x32, 0xc2, 0x33, 0x08, 0xbb, 0x1d, 0x8b, 0x58, 0x68, 0x00, 0x9e, 0x9d, 0x4a,
+	0xa2, 0x61, 0x5c, 0x0f, 0x42, 0x26, 0x18, 0x2c, 0x2d, 0x22, 0xea, 0x0a, 0xa1, 0x97, 0x5c, 0xe6,
-	0xac, 0xdd, 0x89, 0x85, 0x88, 0xc7, 0x14, 0x93, 0x94, 0x61, 0xc2, 0xb9, 0x50, 0x44, 0x31, 0xc1,
+	0x32, 0x09, 0xc0, 0xd3, 0x53, 0x82, 0xd5, 0x2b, 0x2e, 0x63, 0x6e, 0x9f, 0x62, 0x12, 0x78, 0x98,
-	0xa5, 0x79, 0xfb, 0x28, 0x12, 0x32, 0x11, 0x12, 0x87, 0x44, 0x1a, 0x09, 0x7c, 0xb6, 0x1b, 0x52,
+	0xf8, 0x3e, 0x13, 0x44, 0x78, 0xcc, 0xe7, 0xea, 0xd7, 0x47, 0x0e, 0xe3, 0x03, 0xc6, 0xb1, 0x4d,
-	0x45, 0x76, 0x71, 0x4a, 0x62, 0xc6, 0x35, 0xd8, 0x60, 0x77, 0x6a, 0x7d, 0xa5, 0x24, 0x23, 0x49,
+	0xb8, 0x6a, 0x81, 0x2f, 0xf7, 0x6d, 0x2a, 0xc8, 0x3e, 0x0e, 0x88, 0xeb, 0xf9, 0x12, 0xac, 0xb0,
-	0x45, 0x87, 0x6a, 0x21, 0xe6, 0x59, 0x62, 0x50, 0x1b, 0xc0, 0xc3, 0x99, 0xd0, 0x50, 0x2f, 0xfa,
+	0x7b, 0x99, 0xbe, 0x02, 0x12, 0x92, 0x41, 0x2a, 0x87, 0x32, 0x21, 0xea, 0x33, 0xc1, 0xa0, 0x12,
-	0xf4, 0x34, 0xa7, 0x52, 0xa1, 0x43, 0x70, 0xf7, 0x9f, 0xa9, 0x4c, 0x05, 0x97, 0x14, 0x3e, 0x07,
+	0x80, 0xa7, 0xd3, 0x46, 0x1d, 0x49, 0x34, 0xe9, 0x45, 0x44, 0xb9, 0x40, 0xa7, 0x60, 0xe7, 0x46,
-	0x1b, 0xa5, 0xc0, 0xb6, 0xe5, 0x5a, 0xdd, 0xad, 0xbd, 0x8e, 0x57, 0x17, 0xdd, 0x2b, 0xb7, 0x06,
+	0x95, 0x07, 0xcc, 0xe7, 0x14, 0x3e, 0x03, 0xc5, 0xa4, 0x41, 0x59, 0xab, 0x6a, 0xb5, 0xed, 0x83,
-	0xeb, 0x97, 0xdf, 0x1f, 0xb4, 0x7c, 0xb3, 0x81, 0xf6, 0xc1, 0x8e, 0xa6, 0x7c, 0x45, 0xd5, 0x41,
+	0x4a, 0x3d, 0x2b, 0x7a, 0x3d, 0x61, 0xb5, 0xef, 0x5c, 0xfd, 0xdc, 0x2d, 0x98, 0x8a, 0x81, 0x5a,
-	0x89, 0x1b, 0x14, 0xc3, 0x3c, 0x1c, 0xb3, 0xe8, 0x35, 0x2d, 0x8c, 0x2e, 0xec, 0x80, 0xcd, 0xb4,
+	0x60, 0x4f, 0x4a, 0xbe, 0xa4, 0xe2, 0x24, 0xc1, 0xb5, 0xe3, 0x4e, 0x64, 0xf7, 0x3d, 0xe7, 0x15,
-	0x9a, 0x69, 0x8d, 0x4d, 0x7f, 0x31, 0x40, 0xef, 0x00, 0x6a, 0xa2, 0x30, 0x26, 0xfb, 0xe0, 0xb6,
+	0x8d, 0x55, 0x5f, 0x58, 0x01, 0x5b, 0x41, 0x5a, 0x93, 0x3d, 0xb6, 0xcc, 0x79, 0x01, 0xbd, 0x03,
-	0x31, 0x62, 0x5c, 0xde, 0xaf, 0x77, 0x69, 0x28, 0xfc, 0x0a, 0x8d, 0x5e, 0x02, 0xb7, 0xa2, 0x3f,
+	0x68, 0x95, 0x84, 0x32, 0xd9, 0x04, 0x9b, 0xca, 0x88, 0x72, 0xf9, 0x20, 0xdb, 0xa5, 0x92, 0x30,
-	0xca, 0x72, 0xa9, 0xf6, 0x79, 0x34, 0x12, 0xd9, 0x1b, 0x45, 0x54, 0x2e, 0x97, 0x0c, 0x1a, 0x38,
+	0x53, 0x34, 0x7a, 0x01, 0xaa, 0xa9, 0xfc, 0x59, 0x18, 0x71, 0xd1, 0xf2, 0x9d, 0x1e, 0x0b, 0x5f,
-	0x3b, 0xa9, 0x0c, 0xce, 0x07, 0x28, 0x5a, 0x64, 0xac, 0x61, 0x30, 0xfe, 0x1a, 0x29, 0xa0, 0x0b,
+	0x0b, 0x22, 0x22, 0xbe, 0x60, 0x50, 0xc1, 0xbd, 0x6e, 0x6a, 0x70, 0x56, 0x40, 0xce, 0x3c, 0x63,
-	0xb6, 0x98, 0x24, 0x91, 0x62, 0x67, 0x44, 0xd1, 0x93, 0xed, 0x35, 0xd7, 0xea, 0xde, 0xf1, 0x97,
+	0x86, 0x82, 0xf2, 0xb7, 0x52, 0x02, 0x56, 0xc1, 0xb6, 0xc7, 0x89, 0x23, 0xbc, 0x4b, 0x22, 0x68,
-	0x47, 0x7b, 0x7f, 0xd6, 0xc1, 0x2d, 0xad, 0x02, 0xbf, 0x58, 0x60, 0xa3, 0xfc, 0xd6, 0xb0, 0x5b,
+	0xb7, 0xbc, 0x51, 0xd5, 0x6a, 0xf7, 0xcc, 0xc5, 0x12, 0x3a, 0x06, 0xbb, 0x4b, 0xb7, 0xd0, 0xea,
-	0x9f, 0xf1, 0xfa, 0xd5, 0xda, 0x0f, 0x6f, 0x80, 0x2c, 0x9d, 0xa2, 0x17, 0x1f, 0xbf, 0xfe, 0xfa,
+	0x76, 0x43, 0xca, 0x67, 0x2e, 0xcb, 0x60, 0x93, 0x24, 0x15, 0xd5, 0x20, 0xfd, 0x8a, 0xde, 0xce,
-	0xbc, 0xf6, 0x04, 0xf6, 0x70, 0xcc, 0xd4, 0x28, 0x0f, 0xbd, 0x48, 0x24, 0x78, 0xb1, 0xbd, 0x74,
+	0x33, 0x2e, 0x93, 0x6f, 0x79, 0x81, 0x07, 0x5f, 0x8b, 0xe0, 0xae, 0x54, 0x87, 0x5f, 0x34, 0x50,
-	0x7c, 0x7c, 0xad, 0x82, 0xf0, 0xb7, 0x05, 0xee, 0xd5, 0x5e, 0x14, 0xec, 0x37, 0x38, 0x68, 0x6a,
+	0x4c, 0xa6, 0x00, 0xd6, 0xb2, 0xc9, 0xcb, 0x43, 0xa7, 0x3f, 0x5c, 0x03, 0x99, 0x58, 0x44, 0xc7,
-	0x87, 0xfd, 0x6c, 0xf5, 0x45, 0x93, 0xe4, 0x58, 0x27, 0x39, 0x82, 0xfe, 0x4a, 0x49, 0x62, 0xaa,
+	0x1f, 0xbf, 0xff, 0xf9, 0xbc, 0x71, 0x08, 0x1b, 0xd8, 0xf5, 0x44, 0x2f, 0xb2, 0xeb, 0x0e, 0x1b,
-	0x02, 0x73, 0x0e, 0xc2, 0x22, 0x28, 0x8b, 0x18, 0xbc, 0xa7, 0x05, 0x3e, 0x9f, 0x97, 0xf2, 0x02,
+	0xe0, 0x39, 0x7b, 0xe1, 0xf8, 0x78, 0x69, 0x39, 0xe0, 0x5f, 0x0d, 0xdc, 0xcf, 0x1c, 0x21, 0xd8,
-	0xfe, 0xb4, 0x40, 0xbb, 0xee, 0xc2, 0xe1, 0xd3, 0x66, 0xbb, 0xff, 0xeb, 0x98, 0xdd, 0x5f, 0x79,
+	0x5c, 0xe1, 0x60, 0xd5, 0xdc, 0xea, 0x4f, 0xf2, 0x13, 0x55, 0x92, 0x73, 0x99, 0xe4, 0x0c, 0x9a,
-	0xcf, 0xa4, 0x7c, 0xab, 0x53, 0xfa, 0x70, 0xb8, 0x72, 0x4a, 0x35, 0xe3, 0x0c, 0x88, 0x26, 0x0d,
+	0xb9, 0x92, 0xb8, 0x54, 0x58, 0xea, 0x6c, 0xd9, 0xb1, 0x95, 0xac, 0x88, 0xf5, 0x9e, 0xc6, 0x78,
-	0xa4, 0x66, 0xc5, 0xe7, 0xf3, 0x52, 0x5e, 0x0c, 0x0e, 0x2e, 0x27, 0x8e, 0x75, 0x35, 0x71, 0xac,
+	0x38, 0x5b, 0x97, 0x11, 0xfc, 0xad, 0x81, 0x52, 0xd6, 0x28, 0xc2, 0xa3, 0xd5, 0x76, 0xff, 0x37,
-	0x1f, 0x13, 0xc7, 0xfa, 0x34, 0x75, 0x5a, 0x57, 0x53, 0xa7, 0xf5, 0x6d, 0xea, 0xb4, 0x8e, 0x7b,
+	0xfd, 0x7a, 0x33, 0x37, 0x4f, 0xa5, 0x7c, 0x23, 0x53, 0x9a, 0xb0, 0x93, 0x3b, 0xa5, 0x98, 0x6a,
-	0x37, 0x91, 0xfa, 0x30, 0x17, 0x53, 0x45, 0x4a, 0x65, 0xb8, 0xa1, 0xff, 0x3d, 0xbd, 0xbf, 0x01,
+	0x5a, 0x44, 0x8a, 0x5a, 0x5c, 0xaa, 0xe2, 0xe1, 0x6c, 0x5d, 0x46, 0xf0, 0x9b, 0x06, 0x76, 0x32,
-	0x00, 0x00, 0xff, 0xff, 0xc0, 0xb6, 0xdb, 0x5a, 0x5c, 0x05, 0x00, 0x00,
+	0x86, 0x19, 0x1e, 0xae, 0xf9, 0x22, 0x37, 0x37, 0x47, 0x3f, 0xca, 0x4b, 0x53, 0x01, 0x9f, 0xcb,
+	0x80, 0x4f, 0x61, 0x73, 0xbd, 0x07, 0x53, 0xeb, 0x88, 0x87, 0xea, 0x30, 0x6a, 0x9f, 0x5c, 0x8d,
+	0x0d, 0xed, 0x7a, 0x6c, 0x68, 0xbf, 0xc6, 0x86, 0xf6, 0x69, 0x62, 0x14, 0xae, 0x27, 0x46, 0xe1,
+	0xc7, 0xc4, 0x28, 0x9c, 0x37, 0xd6, 0xb9, 0xb2, 0x0f, 0xb3, 0x4e, 0x22, 0x0e, 0x28, 0xb7, 0x8b,
+	0xf2, 0xdf, 0xbd, 0xf1, 0x2f, 0x00, 0x00, 0xff, 0xff, 0x26, 0xcc, 0xd3, 0xe4, 0xbe, 0x06, 0x00,
+	0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -363,6 +458,8 @@ type QueryClient interface {
 	GetMachineByPublicKey(ctx context.Context, in *QueryGetMachineByPublicKeyRequest, opts ...grpc.CallOption) (*QueryGetMachineByPublicKeyResponse, error)
 	// Queries a list of GetTrustAnchorStatus items.
 	GetTrustAnchorStatus(ctx context.Context, in *QueryGetTrustAnchorStatusRequest, opts ...grpc.CallOption) (*QueryGetTrustAnchorStatusResponse, error)
+	// Queries a list of GetMachineByAddress items.
+	GetMachineByAddress(ctx context.Context, in *QueryGetMachineByAddressRequest, opts ...grpc.CallOption) (*QueryGetMachineByAddressResponse, error)
 }
 
 type queryClient struct {
@@ -400,6 +497,15 @@ func (c *queryClient) GetTrustAnchorStatus(ctx context.Context, in *QueryGetTrus
 	return out, nil
 }
 
+func (c *queryClient) GetMachineByAddress(ctx context.Context, in *QueryGetMachineByAddressRequest, opts ...grpc.CallOption) (*QueryGetMachineByAddressResponse, error) {
+	out := new(QueryGetMachineByAddressResponse)
+	err := c.cc.Invoke(ctx, "/planetmintgo.machine.Query/GetMachineByAddress", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // QueryServer is the server API for Query service.
 type QueryServer interface {
 	// Parameters queries the parameters of the module.
@@ -408,6 +514,8 @@ type QueryServer interface {
 	GetMachineByPublicKey(context.Context, *QueryGetMachineByPublicKeyRequest) (*QueryGetMachineByPublicKeyResponse, error)
 	// Queries a list of GetTrustAnchorStatus items.
 	GetTrustAnchorStatus(context.Context, *QueryGetTrustAnchorStatusRequest) (*QueryGetTrustAnchorStatusResponse, error)
+	// Queries a list of GetMachineByAddress items.
+	GetMachineByAddress(context.Context, *QueryGetMachineByAddressRequest) (*QueryGetMachineByAddressResponse, error)
 }
 
 // UnimplementedQueryServer can be embedded to have forward compatible implementations.
@@ -423,6 +531,9 @@ func (*UnimplementedQueryServer) GetMachineByPublicKey(ctx context.Context, req
 func (*UnimplementedQueryServer) GetTrustAnchorStatus(ctx context.Context, req *QueryGetTrustAnchorStatusRequest) (*QueryGetTrustAnchorStatusResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method GetTrustAnchorStatus not implemented")
 }
+func (*UnimplementedQueryServer) GetMachineByAddress(ctx context.Context, req *QueryGetMachineByAddressRequest) (*QueryGetMachineByAddressResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetMachineByAddress not implemented")
+}
 
 func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
 	s.RegisterService(&_Query_serviceDesc, srv)
@@ -482,6 +593,24 @@ func _Query_GetTrustAnchorStatus_Handler(srv interface{}, ctx context.Context, d
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Query_GetMachineByAddress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(QueryGetMachineByAddressRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(QueryServer).GetMachineByAddress(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/planetmintgo.machine.Query/GetMachineByAddress",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(QueryServer).GetMachineByAddress(ctx, req.(*QueryGetMachineByAddressRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _Query_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "planetmintgo.machine.Query",
 	HandlerType: (*QueryServer)(nil),
@@ -498,6 +627,10 @@ var _Query_serviceDesc = grpc.ServiceDesc{
 			MethodName: "GetTrustAnchorStatus",
 			Handler:    _Query_GetTrustAnchorStatus_Handler,
 		},
+		{
+			MethodName: "GetMachineByAddress",
+			Handler:    _Query_GetMachineByAddress_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "planetmintgo/machine/query.proto",
@@ -694,6 +827,71 @@ func (m *QueryGetTrustAnchorStatusResponse) MarshalToSizedBuffer(dAtA []byte) (i
 	return len(dAtA) - i, nil
 }
 
+func (m *QueryGetMachineByAddressRequest) 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 *QueryGetMachineByAddressRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryGetMachineByAddressRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	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 *QueryGetMachineByAddressResponse) 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 *QueryGetMachineByAddressResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryGetMachineByAddressResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Machine != nil {
+		{
+			size, err := m.Machine.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintQuery(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
 func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
 	offset -= sovQuery(v)
 	base := offset
@@ -780,6 +978,32 @@ func (m *QueryGetTrustAnchorStatusResponse) Size() (n int) {
 	return n
 }
 
+func (m *QueryGetMachineByAddressRequest) 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))
+	}
+	return n
+}
+
+func (m *QueryGetMachineByAddressResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Machine != nil {
+		l = m.Machine.Size()
+		n += 1 + l + sovQuery(uint64(l))
+	}
+	return n
+}
+
 func sovQuery(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -1271,6 +1495,174 @@ func (m *QueryGetTrustAnchorStatusResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *QueryGetMachineByAddressRequest) 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: QueryGetMachineByAddressRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryGetMachineByAddressRequest: 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
+		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 *QueryGetMachineByAddressResponse) 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: QueryGetMachineByAddressResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: QueryGetMachineByAddressResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Machine", 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 m.Machine == nil {
+				m.Machine = &Machine{}
+			}
+			if err := m.Machine.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 skipQuery(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0

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

@@ -159,6 +159,60 @@ func local_request_Query_GetTrustAnchorStatus_0(ctx context.Context, marshaler r
 
 }
 
+func request_Query_GetMachineByAddress_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryGetMachineByAddressRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["address"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "address")
+	}
+
+	protoReq.Address, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "address", err)
+	}
+
+	msg, err := client.GetMachineByAddress(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+
+}
+
+func local_request_Query_GetMachineByAddress_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var protoReq QueryGetMachineByAddressRequest
+	var metadata runtime.ServerMetadata
+
+	var (
+		val string
+		ok  bool
+		err error
+		_   = err
+	)
+
+	val, ok = pathParams["address"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "address")
+	}
+
+	protoReq.Address, err = runtime.String(val)
+
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "address", err)
+	}
+
+	msg, err := server.GetMachineByAddress(ctx, &protoReq)
+	return msg, metadata, err
+
+}
+
 // RegisterQueryHandlerServer registers the http handlers for service Query to "mux".
 // UnaryRPC     :call QueryServer directly.
 // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
@@ -234,6 +288,29 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
 
 	})
 
+	mux.Handle("GET", pattern_Query_GetMachineByAddress_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_GetMachineByAddress_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_GetMachineByAddress_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	return nil
 }
 
@@ -335,6 +412,26 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
 
 	})
 
+	mux.Handle("GET", pattern_Query_GetMachineByAddress_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_GetMachineByAddress_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_GetMachineByAddress_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+	})
+
 	return nil
 }
 
@@ -344,6 +441,8 @@ var (
 	pattern_Query_GetMachineByPublicKey_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"github.com", "planetmint", "planetmint-go", "machine", "get_machine_by_public_key", "publicKey"}, "", runtime.AssumeColonVerbOpt(true)))
 
 	pattern_Query_GetTrustAnchorStatus_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"github.com", "planetmint", "planetmint-go", "machine", "get_trust_anchor_status", "machineid"}, "", runtime.AssumeColonVerbOpt(true)))
+
+	pattern_Query_GetMachineByAddress_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"planetmint-go", "machine", "get_machine_by_address", "address"}, "", runtime.AssumeColonVerbOpt(true)))
 )
 
 var (
@@ -352,4 +451,6 @@ var (
 	forward_Query_GetMachineByPublicKey_0 = runtime.ForwardResponseMessage
 
 	forward_Query_GetTrustAnchorStatus_0 = runtime.ForwardResponseMessage
+
+	forward_Query_GetMachineByAddress_0 = runtime.ForwardResponseMessage
 )