Improve validation of address with VerifyAddressFormat (#677)

* Improve parsing addresses with VerifyAddressFormat

* Add state filter cli tests and modify owner validation in filters

integration/deployment_test.go

@@ -35,7 +35,8 @@ func TestDeployment(t *testing.T) {
 	tests.WaitForNextNBlocksTM(1, f.Port)
 
 	// test query deployments
-	deployments := f.QueryDeployments()
+	deployments, err := f.QueryDeployments()
+	require.NoError(t, err)
 	require.Len(t, deployments, 1, "Deployment Create Failed")
 	require.Equal(t, fooAddr.String(), deployments[0].Deployment.DeploymentID.Owner.String())
 
@@ -44,21 +45,37 @@ func TestDeployment(t *testing.T) {
 	deployment := f.QueryDeployment(createdDep.Deployment.DeploymentID)
 	require.Equal(t, createdDep, deployment)
 
+	// test query deployments with owner filter
+	deployments, err = f.QueryDeployments(fmt.Sprintf("--owner=%s", fooAddr.String()))
+	require.NoError(t, err, "Error when fetching deployments with owner filter")
+	require.Len(t, deployments, 1)
+
+	// test query deployments with wrong owner value
+	deployments, err = f.QueryDeployments("--owner=cosmos102ruvpv2srmunfffxavttxnhezln6fnc3pf7tt")
+	require.Error(t, err)
+
 	// test query deployments with filters
-	deployments = f.QueryDeployments("--state=closed")
+	deployments, err = f.QueryDeployments("--state=closed")
+	require.NoError(t, err)
 	require.Len(t, deployments, 0)
 
+	// test query deployments with wrong state filter
+	deployments, err = f.QueryDeployments("--state=hello")
+	require.Error(t, err)
+
 	// Close deployment
 	f.TxCloseDeployment(fmt.Sprintf("--from=%s --dseq=%v", keyFoo, createdDep.Deployment.DeploymentID.DSeq), "-y")
 	tests.WaitForNextNBlocksTM(1, f.Port)
 
 	// test query deployments
-	deployments = f.QueryDeployments()
+	deployments, err = f.QueryDeployments()
+	require.NoError(t, err)
 	require.Len(t, deployments, 1)
 	require.Equal(t, dtypes.DeploymentClosed, deployments[0].Deployment.State, "Deployment Close Failed")
 
 	// test query deployments with state filter closed
-	deployments = f.QueryDeployments("--state=closed")
+	deployments, err = f.QueryDeployments("--state=closed")
+	require.NoError(t, err)
 	require.Len(t, deployments, 1)
 
 	f.Cleanup()

integration/market_test.go

@@ -35,12 +35,14 @@ func TestMarket(t *testing.T) {
 	tests.WaitForNextNBlocksTM(1, f.Port)
 
 	// test query deployments
-	deployments := f.QueryDeployments()
+	deployments, err := f.QueryDeployments()
+	require.NoError(t, err)
 	require.Len(t, deployments, 1, "Deployment Creation Failed in TestMarket")
 	require.Equal(t, fooAddr.String(), deployments[0].Deployment.DeploymentID.Owner.String())
 
 	// test query orders
-	orders := f.QueryOrders()
+	orders, err := f.QueryOrders()
+	require.NoError(t, err)
 	require.Len(t, orders, 1)
 	require.Equal(t, fooAddr.String(), orders[0].OrderID.Owner.String())
 
@@ -49,6 +51,24 @@ func TestMarket(t *testing.T) {
 	order := f.QueryOrder(createdOrder.OrderID)
 	require.Equal(t, createdOrder, order)
 
+	// test query orders with owner filter
+	orders, err = f.QueryOrders(fmt.Sprintf("--owner=%s", fooAddr.String()))
+	require.NoError(t, err, "Error when fetching orders with owner filter")
+	require.Len(t, orders, 1)
+
+	// test query orders with wrong owner value
+	orders, err = f.QueryOrders("--owner=cosmos102ruvpv2srmunfffxavttxnhezln6fnc3pf7tt")
+	require.Error(t, err)
+
+	// test query orders with filters
+	orders, err = f.QueryOrders("--state=closed")
+	require.NoError(t, err)
+	require.Len(t, orders, 0)
+
+	// test query orders with wrong state filter
+	orders, err = f.QueryOrders("--state=hello")
+	require.Error(t, err)
+
 	// Create provider
 	f.TxCreateProvider(fmt.Sprintf("--from=%s", keyBar), "-y")
 	tests.WaitForNextNBlocksTM(1, f.Port)
@@ -63,7 +83,8 @@ func TestMarket(t *testing.T) {
 	tests.WaitForNextNBlocksTM(3, f.Port)
 
 	// test query bids
-	bids := f.QueryBids()
+	bids, err := f.QueryBids()
+	require.NoError(t, err)
 	require.Len(t, bids, 1, "Creating bid failed")
 	require.Equal(t, barAddr.String(), bids[0].Provider.String())
 
@@ -72,46 +93,78 @@ func TestMarket(t *testing.T) {
 	bid := f.QueryBid(createdBid.BidID)
 	require.Equal(t, createdBid, bid)
 
+	// test query bids with owner filter
+	bids, err = f.QueryBids(fmt.Sprintf("--owner=%s", fooAddr.String()))
+	require.NoError(t, err, "Error when fetching bids with owner filter")
+	require.Len(t, bids, 1)
+
+	// test query bids with wrong owner value
+	bids, err = f.QueryBids("--owner=cosmos102ruvpv2srmunfffxavttxnhezln6fnc3pf7tt")
+	require.Error(t, err)
+
 	// test query leases
-	leases := f.QueryLeases()
+	leases, err := f.QueryLeases()
+	require.NoError(t, err)
 	require.Len(t, leases, 1)
 
 	// test query order
 	createdLease := leases[0]
 	lease := f.QueryLease(createdLease.LeaseID)
 	require.Equal(t, createdLease, lease)
 
+	// test query leases with owner filter
+	leases, err = f.QueryLeases(fmt.Sprintf("--owner=%s", fooAddr.String()))
+	require.NoError(t, err, "Error when fetching leases with owner filter")
+	require.Len(t, leases, 1)
+
+	// test query leases with wrong owner value
+	leases, err = f.QueryLeases("--owner=cosmos102ruvpv2srmunfffxavttxnhezln6fnc3pf7tt")
+	require.Error(t, err)
+
 	// Close Bid
 	f.TxCloseBid(createdOrder.OrderID, fmt.Sprintf("--from=%s", keyBar), "-y")
 	tests.WaitForNextNBlocksTM(3, f.Port)
 
 	// test query bids with filter
-	closedBids := f.QueryBids("--state=closed")
+	closedBids, err := f.QueryBids("--state=closed")
+	require.NoError(t, err)
 	require.Len(t, closedBids, 1, "Closing bid failed")
 	require.Equal(t, barAddr.String(), closedBids[0].Provider.String())
 
 	// test query leases with filter
-	closedLeases := f.QueryLeases("--state=closed")
+	closedLeases, err := f.QueryLeases("--state=closed")
+	require.NoError(t, err)
 	require.Len(t, closedLeases, 1)
 
 	// test query orders with filter state open
-	openedOrders := f.QueryOrders("--state=open")
+	openedOrders, err := f.QueryOrders("--state=open")
+	require.NoError(t, err)
 	require.Len(t, openedOrders, 1)
 
 	// Creating bid again for new order
 	f.TxCreateBid(openedOrders[0].OrderID, sdk.NewInt64Coin(denom, 20), fmt.Sprintf("--from=%s", keyBar), "-y")
 	tests.WaitForNextNBlocksTM(3, f.Port)
 
 	// test query bids
-	matchedBids := f.QueryBids("--state=matched")
+	matchedBids, err := f.QueryBids("--state=matched")
+	require.NoError(t, err)
 	require.Len(t, matchedBids, 1, "Creating bid failed second time")
 
+	// test query bids with wrong state filter
+	bids, err = f.QueryBids("--state=hello")
+	require.Error(t, err)
+
+	// test query leases with wrong state filter
+	leases, err = f.QueryLeases("--state=hello")
+	require.Error(t, err)
+
 	// Close Order
 	f.TxCloseOrder(openedOrders[0].OrderID, fmt.Sprintf("--from=%s", keyFoo), "-y")
 	tests.WaitForNextNBlocksTM(1, f.Port)
 
 	// test query orders with filter state closed
-	closedOrders := f.QueryOrders("--state=closed")
+	closedOrders, err := f.QueryOrders("--state=closed")
+	require.NoError(t, err)
 	require.Len(t, closedOrders, 2, "Closing Order failed")
 
 	f.Cleanup()

integration/test_helpers.go

@@ -365,17 +365,16 @@ func (f *Fixtures) TxCloseDeployment(flags ...string) (bool, string, string) {
 // akash query deployment
 
 // QueryDeployments is akash query deployments
-func (f *Fixtures) QueryDeployments(flags ...string) dquery.Deployments {
+func (f *Fixtures) QueryDeployments(flags ...string) (dquery.Deployments, error) {
 	cmd := fmt.Sprintf("%s query deployment list %v", f.AkashBinary, f.Flags())
 	out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
 
 	var deployments dquery.Deployments
 
 	cdc := app.MakeCodec()
 	err := cdc.UnmarshalJSON([]byte(out), &deployments)
-	require.NoError(f.T, err, "out %v\n, err %v", out, err)
 
-	return deployments
+	return deployments, err
 }
 
 // QueryDeployment is akash query deployment
@@ -421,17 +420,16 @@ func (f *Fixtures) TxCloseOrder(oid mtypes.OrderID, flags ...string) (bool, stri
 // akash query market
 
 // QueryOrders is akash query orders
-func (f *Fixtures) QueryOrders(flags ...string) []mtypes.Order {
+func (f *Fixtures) QueryOrders(flags ...string) ([]mtypes.Order, error) {
 	cmd := fmt.Sprintf("%s query market order list %v", f.AkashBinary, f.Flags())
 	out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
 
 	var orders []mtypes.Order
 
 	cdc := app.MakeCodec()
 	err := cdc.UnmarshalJSON([]byte(out), &orders)
-	require.NoError(f.T, err, "out %v\n, err %v", out, err)
 
-	return orders
+	return orders, err
 }
 
 // QueryOrder is akash query order
@@ -450,17 +448,16 @@ func (f *Fixtures) QueryOrder(orderID mtypes.OrderID, flags ...string) mtypes.Or
 }
 
 // QueryBids is akash query bids
-func (f *Fixtures) QueryBids(flags ...string) []mtypes.Bid {
+func (f *Fixtures) QueryBids(flags ...string) ([]mtypes.Bid, error) {
 	cmd := fmt.Sprintf("%s query market bid list %v", f.AkashBinary, f.Flags())
 	out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
 
 	var bids []mtypes.Bid
 
 	cdc := app.MakeCodec()
 	err := cdc.UnmarshalJSON([]byte(out), &bids)
-	require.NoError(f.T, err, "out %v\n, err %v", out, err)
 
-	return bids
+	return bids, err
 }
 
 // QueryBid is akash query bid
@@ -481,17 +478,16 @@ func (f *Fixtures) QueryBid(bidID mtypes.BidID, flags ...string) mtypes.Bid {
 }
 
 // QueryLeases is akash query leases
-func (f *Fixtures) QueryLeases(flags ...string) []mtypes.Lease {
+func (f *Fixtures) QueryLeases(flags ...string) ([]mtypes.Lease, error) {
 	cmd := fmt.Sprintf("%s query market lease list %v", f.AkashBinary, f.Flags())
 	out, _ := tests.ExecuteT(f.T, addFlags(cmd, flags), "")
 
 	var leases []mtypes.Lease
 
 	cdc := app.MakeCodec()
 	err := cdc.UnmarshalJSON([]byte(out), &leases)
-	require.NoError(f.T, err, "out %v\n, err %v", out, err)
 
-	return leases
+	return leases, err
 }
 
 // QueryLease is akash query lease

x/deployment/query/path.go

@@ -18,6 +18,7 @@ const (
 
 var (
 	ErrInvalidPath = errors.New("query: invalid path")
+	ErrOwnerValue  = errors.New("query: invalid owner value")
 	ErrStateValue  = errors.New("query: invalid state value")
 )
 
@@ -71,6 +72,10 @@ func parseDepFiltersPath(parts []string) (DeploymentFilters, bool, error) {
 		return DeploymentFilters{}, false, err
 	}
 
+	if !owner.Empty() && sdk.VerifyAddressFormat(owner) != nil {
+		return DeploymentFilters{}, false, ErrOwnerValue
+	}
+
 	state, ok := types.DeploymentStateMap[parts[1]]
 
 	if !ok && (parts[1] != "") {

x/deployment/query/types.go

@@ -18,6 +18,7 @@ type DeploymentFilters struct {
 	State types.DeploymentState
 }
 
+// Accept returns whether deployment filters valid or not
 func (filters DeploymentFilters) Accept(obj types.Deployment, isValidState bool) bool {
 	if (filters.Owner.Empty() && !isValidState) ||
 		(filters.Owner.Empty() && (obj.State == filters.State)) ||

x/deployment/types/id.go

@@ -18,8 +18,9 @@ func (id DeploymentID) Equals(other DeploymentID) bool {
 
 // Validate method for DeploymentID and returns nil
 func (id DeploymentID) Validate() error {
+	err := sdk.VerifyAddressFormat(id.Owner)
 	switch {
-	case id.Owner.Empty():
+	case err != nil:
 		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "DeploymentID: Invalid Owner Address")
 	case id.DSeq == 0:
 		return sdkerrors.Wrap(sdkerrors.ErrInvalidSequence, "DeploymentID: Invalid Deployment Sequence")

x/deployment/types/msgs.go

@@ -63,7 +63,7 @@ func (msg MsgUpdateDeployment) ValidateBasic() error {
 		return err
 	}
 
-	if msg.Version.Empty() {
+	if err := sdk.VerifyAddressFormat(msg.Version); err != nil {
 		return ErrEmptyVersion
 	}
 

x/market/query/path.go

@@ -22,6 +22,7 @@ const (
 
 var (
 	ErrInvalidPath = errors.New("query: invalid path")
+	ErrOwnerValue  = errors.New("query: invalid owner value")
 	ErrStateValue  = errors.New("query: invalid state value")
 )
 
@@ -91,6 +92,10 @@ func parseOrderFiltersPath(parts []string) (OrderFilters, bool, error) {
 		return OrderFilters{}, false, err
 	}
 
+	if !owner.Empty() && sdk.VerifyAddressFormat(owner) != nil {
+		return OrderFilters{}, false, ErrOwnerValue
+	}
+
 	state, ok := types.OrderStateMap[parts[1]]
 
 	if !ok && (parts[1] != "") {
@@ -136,6 +141,10 @@ func parseBidFiltersPath(parts []string) (BidFilters, bool, error) {
 		return BidFilters{}, false, err
 	}
 
+	if !owner.Empty() && sdk.VerifyAddressFormat(owner) != nil {
+		return BidFilters{}, false, ErrOwnerValue
+	}
+
 	state, ok := types.BidStateMap[parts[1]]
 
 	if !ok && (parts[1] != "") {
@@ -172,6 +181,10 @@ func parseLeaseFiltersPath(parts []string) (LeaseFilters, bool, error) {
 		return LeaseFilters{}, false, err
 	}
 
+	if !owner.Empty() && sdk.VerifyAddressFormat(owner) != nil {
+		return LeaseFilters{}, false, ErrOwnerValue
+	}
+
 	state, ok := types.LeaseStateMap[parts[1]]
 
 	if !ok && (parts[1] != "") {

x/market/types/id.go

@@ -113,7 +113,7 @@ func (id BidID) Validate() error {
 	if err := id.OrderID().Validate(); err != nil {
 		return sdkerrors.Wrap(err, "BidID: Invalid OrderID")
 	}
-	if id.Provider.Empty() {
+	if err := sdk.VerifyAddressFormat(id.Provider); err != nil {
 		return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "BidID: Invalid Provider Address")
 	}
 	return nil

x/market/types/msgs.go

@@ -39,7 +39,7 @@ func (msg MsgCreateBid) ValidateBasic() error {
 		return err
 	}
 
-	if msg.Provider.Empty() {
+	if err := sdk.VerifyAddressFormat(msg.Provider); err != nil {
 		return ErrEmptyProvider
 	}