Implementation of Exchange GetOrder through GRPC for Coinbase (#453)

* fix 440: SubmitOrder and CB-ACCESS-TIMESTAMP value

* removed gctcli executable and added it to gitignore

* implemented GetOrderInfo

* getOrder also has trades attached to an order

* getOrder also has trades attached to an order

* fix 440: SubmitOrder and CB-ACCESS-TIMESTAMP value

* removed gctcli executable and added it to gitignore

* fix 440: SubmitOrder and CB-ACCESS-TIMESTAMP value

* removed gctcli executable and added it to gitignore

* minor

* go lint fixes

* removed clutter

* fixed Amount, Executed Amount, Remaining Amount

* removed default value declarations

* removed useless nil chceck

* iteration rewritten go style from java style

* returning error if GetFills fails

* returning error if GetOrderInfo fails

* ExecutedAmont value is FilledSize

* added TODO to fix asset type

* chnages after merging #446

* range without copy value, using index

* removed useless slice initialisation

* couple of nits from code review

* fix indentation

* Update rpc.proto

Fixes indentation

Co-authored-by: Adrian Gallagher <thrasher@addictionsoftware.com>

engine/rpcserver.go

@@ -749,7 +749,43 @@ func (s *RPCServer) GetOrders(ctx context.Context, r *gctrpc.GetOrdersRequest) (
 
 // GetOrder returns order information based on exchange and order ID
 func (s *RPCServer) GetOrder(ctx context.Context, r *gctrpc.GetOrderRequest) (*gctrpc.OrderDetails, error) {
-	return &gctrpc.OrderDetails{}, common.ErrNotYetImplemented
+	exch := GetExchangeByName(r.Exchange)
+	if exch == nil {
+		return nil, errors.New("exchange is not loaded/doesn't exist")
+	}
+	result, err := exch.GetOrderInfo(r.OrderId)
+	if err != nil {
+		return nil, fmt.Errorf("error whilst trying to retrieve info for order %s: %s", r.OrderId, err)
+	}
+	var trades []*gctrpc.TradeHistory
+	for i := range result.Trades {
+		trades = append(trades, &gctrpc.TradeHistory{
+			CreationTime: result.Trades[i].Timestamp.Unix(),
+			Id:           result.Trades[i].TID,
+			Price:        result.Trades[i].Price,
+			Amount:       result.Trades[i].Amount,
+			Exchange:     result.Trades[i].Exchange,
+			AssetType:    result.Trades[i].Type.String(),
+			OrderSide:    result.Trades[i].Side.String(),
+			Fee:          result.Trades[i].Fee,
+		})
+	}
+	return &gctrpc.OrderDetails{
+		Exchange:      result.Exchange,
+		Id:            result.ID,
+		BaseCurrency:  result.Pair.Base.String(),
+		QuoteCurrency: result.Pair.Quote.String(),
+		AssetType:     result.AssetType.String(),
+		OrderSide:     result.Side.String(),
+		OrderType:     result.Type.String(),
+		CreationTime:  result.Date.Unix(),
+		Status:        result.Status.String(),
+		Price:         result.Price,
+		Amount:        result.Amount,
+		OpenVolume:    result.RemainingAmount,
+		Fee:           result.Fee,
+		Trades:        trades,
+	}, err
 }
 
 // SubmitOrder submits an order specified by exchange, currency pair and asset

exchanges/coinbasepro/coinbasepro_wrapper.go

@@ -454,8 +454,65 @@ func (c *CoinbasePro) CancelAllOrders(_ *order.Cancel) (order.CancelAllResponse,
 
 // GetOrderInfo returns information on a current open order
 func (c *CoinbasePro) GetOrderInfo(orderID string) (order.Detail, error) {
-	var orderDetail order.Detail
-	return orderDetail, common.ErrNotYetImplemented
+	genOrderDetail, errGo := c.GetOrder(orderID)
+	if errGo != nil {
+		return order.Detail{}, fmt.Errorf("error retrieving order %s : %s", orderID, errGo)
+	}
+	od, errOd := time.Parse(time.RFC3339, genOrderDetail.DoneAt)
+	if errOd != nil {
+		return order.Detail{}, fmt.Errorf("error parsing order done at time: %s", errOd)
+	}
+	os, errOs := order.StringToOrderStatus(genOrderDetail.Status)
+	if errOs != nil {
+		return order.Detail{}, fmt.Errorf("error parsing order status: %s", errOs)
+	}
+	tt, errOt := order.StringToOrderType(genOrderDetail.Type)
+	if errOt != nil {
+		return order.Detail{}, fmt.Errorf("error parsing order type: %s", errOt)
+	}
+	ss, errOss := order.StringToOrderSide(genOrderDetail.Side)
+	if errOss != nil {
+		return order.Detail{}, fmt.Errorf("error parsing order side: %s", errOss)
+	}
+	response := order.Detail{
+		Exchange:        c.GetName(),
+		ID:              genOrderDetail.ID,
+		Pair:            currency.NewPairDelimiter(genOrderDetail.ProductID, "-"),
+		Side:            ss,
+		Type:            tt,
+		Date:            od,
+		Status:          os,
+		Price:           genOrderDetail.Price,
+		Amount:          genOrderDetail.Size,
+		ExecutedAmount:  genOrderDetail.FilledSize,
+		RemainingAmount: genOrderDetail.Size - genOrderDetail.FilledSize,
+		Fee:             genOrderDetail.FillFees,
+	}
+	fillResponse, errGF := c.GetFills(orderID, genOrderDetail.ProductID)
+	if errGF != nil {
+		return response, fmt.Errorf("error retrieving the order fills: %s", errGF)
+	}
+	for i := range fillResponse {
+		trSi, errTSi := order.StringToOrderSide(fillResponse[i].Side)
+		if errTSi != nil {
+			return response, fmt.Errorf("error parsing order Side: %s", errTSi)
+		}
+		td, errTd := time.Parse(time.RFC3339, fillResponse[i].CreatedAt)
+		if errTd != nil {
+			return response, fmt.Errorf("error parsing trade created time: %s", errTd)
+		}
+		response.Trades = append(response.Trades, order.TradeHistory{
+			Timestamp: td,
+			TID:       string(fillResponse[i].TradeID),
+			Price:     fillResponse[i].Price,
+			Amount:    fillResponse[i].Size,
+			Exchange:  c.GetName(),
+			Type:      tt,
+			Side:      trSi,
+			Fee:       fillResponse[i].Fee,
+		})
+	}
+	return response, nil
 }
 
 // GetDepositAddress returns a deposit address for a specified currency

exchanges/order/order_types.go

@@ -206,6 +206,7 @@ const (
 	Expired             Status = "EXPIRED"
 	Hidden              Status = "HIDDEN"
 	UnknownStatus       Status = "UNKNOWN"
+	Open                Status = "OPEN"
 )
 
 // Type enforces a standard for order types across the code base

exchanges/order/orders.go

@@ -615,6 +615,8 @@ func StringToOrderStatus(status string) (Status, error) {
 	case strings.EqualFold(status, PartiallyCancelled.String()),
 		strings.EqualFold(status, "partially cancelled"):
 		return PartiallyCancelled, nil
+	case strings.EqualFold(status, Open.String()):
+		return Open, nil
 	case strings.EqualFold(status, Cancelled.String()):
 		return Cancelled, nil
 	case strings.EqualFold(status, PendingCancel.String()),

gctrpc/rpc.proto

@@ -301,6 +301,19 @@ message OrderDetails {
     double price = 10;
     double amount = 11;
     double open_volume = 12;
+    double fee = 13;
+    repeated TradeHistory trades = 14;
+}
+
+message TradeHistory {
+	int64  creation_time = 1;
+	string id = 2;
+	double price = 3;
+	double amount = 4;
+	string exchange = 5;
+	string asset_type = 6;
+	string order_side = 7;
+	double fee = 8;
 }
 
 message GetOrdersRequest {

gctrpc/rpc.swagger.json

@@ -2952,6 +2952,16 @@
         "open_volume": {
           "type": "number",
           "format": "double"
+        },
+        "fee": {
+          "type": "number",
+          "format": "double"
+        },
+        "trades": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/gctrpcTradeHistory"
+          }
         }
       }
     },
@@ -3242,6 +3252,39 @@
         }
       }
     },
+    "gctrpcTradeHistory": {
+      "type": "object",
+      "properties": {
+        "creation_time": {
+          "type": "string",
+          "format": "int64"
+        },
+        "id": {
+          "type": "string"
+        },
+        "price": {
+          "type": "number",
+          "format": "double"
+        },
+        "amount": {
+          "type": "number",
+          "format": "double"
+        },
+        "exchange": {
+          "type": "string"
+        },
+        "asset_type": {
+          "type": "string"
+        },
+        "order_side": {
+          "type": "string"
+        },
+        "fee": {
+          "type": "number",
+          "format": "double"
+        }
+      }
+    },
     "gctrpcWhaleBombRequest": {
       "type": "object",
       "properties": {