Add ability to cancel and place orders in a single request

Author: localhuman

src/client/client.ts

@@ -184,7 +184,9 @@ import {
   Asset,
   MissingNonceError,
   InsufficientFundsError,
-  PlaceLimitOrderParams
+  PlaceLimitOrderParams,
+  OrdersPlaced,
+  OrdersCancelledAndPlaced
 } from '../types'
 import {
   ClientMode,
@@ -3924,13 +3926,62 @@ export class Client {
 
   public async placeLimitOrders(
     params: PlaceLimitOrderParams[]
-  ): Promise<OrderPlaced[]> {
+  ): Promise<OrdersPlaced> {
     await this.prefillRPoolIfNeededForAssets(
       params[0].limitPrice.currencyA,
       params[0].limitPrice.currencyB
     )
 
-    const placeLimitOrderPayloads = await Promise.all(
+    const placeLimitOrderPayloads = await this.generatePlaceOrdersParams(params)
+
+    const names = ['A', 'B', 'C', 'D', 'E', 'F'].slice(
+      0,
+      placeLimitOrderPayloads.length
+    )
+    const paramNames = names
+      .map(name => `$p${name}:PlaceLimitOrderParams!, $s${name}:Signature!`)
+      .join(',')
+    const aliases = names
+      .map(
+        name =>
+          `  ${name}: placeLimitOrder(affiliateDeveloperCode: $affiliateDeveloperCode, payload: $p${name}, signature: $s${name}) {\n  id\n  status\n  ordersTillSignState\n }`
+      )
+      .join('\n')
+    const mutationStr = `mutation placeLimitOrders($affiliateDeveloperCode: AffiliateDeveloperCode, ${paramNames}) {\n${aliases}\n}`
+    const mutation = gqlstring(mutationStr)
+
+    const variables = {
+      affiliateDeveloperCode: this.affiliateDeveloperCode
+    }
+
+    placeLimitOrderPayloads.forEach((item, index) => {
+      variables[`p${names[index]}`] = item.signedPayload
+      variables[`s${names[index]}`] = item.signature
+    })
+
+    try {
+      const result = await this.gql.mutate({
+        mutation,
+        variables
+      })
+
+      return {
+        orders: Object.keys(result.data).map(
+          k => result.data[k]
+        ) as OrderPlaced[]
+      }
+    } catch (e) {
+      return {
+        error: e,
+        orders: []
+      }
+    }
+  }
+
+  private generatePlaceOrdersParams = async (
+    params: PlaceLimitOrderParams[]
+  ): Promise<PayloadSignature[]> => {
+    return await Promise.all(
       params.map(async param => {
         const { nonceOrder, noncesFrom, noncesTo } = this.getNoncesForTrade(
           param.marketName,
@@ -3960,43 +4011,107 @@ export class Client {
         return signedPayload
       })
     )
+  }
 
-    const names = ['A', 'B', 'C', 'D', 'E', 'F'].slice(
-      0,
-      placeLimitOrderPayloads.length
+  /**
+   * Cancel a list of orders by ID.
+   *
+   * @param orderID[]
+   * @returns
+   *
+   * Example
+   * ```
+   * const cancelledOrders = await nash.cancelOrder(['11','12'])
+   * console.log(cancelledOrders)
+   * ```
+   */
+  public async cancelAndPlaceOrders(
+    orderIDs: string[],
+    marketName: string,
+    orders: PlaceLimitOrderParams[]
+  ): Promise<OrdersCancelledAndPlaced> {
+    const [a, b] = marketName.split('_')
+    await this.prefillRPoolIfNeededForAssets(
+      a as CryptoCurrency,
+      b as CryptoCurrency
     )
-    const paramNames = names
+
+    const cancelOrdersPayloads = await Promise.all(
+      orderIDs.map(async id => {
+        const cancelOrderParams = createCancelOrderParams(id, marketName)
+        const signedPayload = await this.signPayload(cancelOrderParams)
+        return signedPayload
+      })
+    )
+
+    const placeLimitOrderPayloads = await this.generatePlaceOrdersParams(orders)
+
+    const allNames = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K']
+    const cancelNames = allNames.slice(0, cancelOrdersPayloads.length)
+    const cancelParams = cancelNames
+      .map(name => `$p${name}:CancelOrderParams!, $s${name}:Signature!`)
+      .join(',')
+    const cancelAliases = cancelNames
+      .map(
+        name =>
+          `  ${name}: cancelOrder(payload: $p${name}, signature: $s${name}) { orderId }`
+      )
+      .join('\n')
+
+    const placeNames = allNames.slice(
+      cancelOrdersPayloads.length,
+      cancelOrdersPayloads.length + orders.length
+    )
+    const placeOrderParams = placeNames
       .map(name => `$p${name}:PlaceLimitOrderParams!, $s${name}:Signature!`)
       .join(',')
-    const aliases = names
+    const placeOrderAliases = placeNames
       .map(
         name =>
           `  ${name}: placeLimitOrder(affiliateDeveloperCode: $affiliateDeveloperCode, payload: $p${name}, signature: $s${name}) {\n  id\n  status\n  ordersTillSignState\n }`
       )
       .join('\n')
-    const mutationStr = `mutation placeLimitOrders($affiliateDeveloperCode: AffiliateDeveloperCode, ${paramNames}) {\n${aliases}\n}`
+
+    const mutationStr = `mutation cancelAndPlaceOrders(${cancelParams}, ${placeOrderParams}${
+      placeLimitOrderPayloads.length
+        ? ', $affiliateDeveloperCode: AffiliateDeveloperCode'
+        : ''
+    }) {\n${cancelAliases}\n${placeOrderAliases}\n}`
     const mutation = gqlstring(mutationStr)
 
-    const variables = {
-      affiliateDeveloperCode: this.affiliateDeveloperCode
+    const variables: any = {}
+    if (placeLimitOrderPayloads.length > 0) {
+      variables.affiliateDeveloperCode = this.affiliateDeveloperCode
     }
 
+    cancelOrdersPayloads.forEach((item, index) => {
+      variables[`p${cancelNames[index]}`] = item.payload
+      variables[`s${cancelNames[index]}`] = item.signature
+    })
     placeLimitOrderPayloads.forEach((item, index) => {
-      variables[`p${names[index]}`] = item.signedPayload
-      variables[`s${names[index]}`] = item.signature
+      variables[`p${placeNames[index]}`] = item.signedPayload
+      variables[`s${placeNames[index]}`] = item.signature
     })
 
     try {
       const result = await this.gql.mutate({
         mutation,
         variables
       })
-      console.info("Result: ", result)
-      return Object.keys(result.data).map(k => result.data[k]) as OrderPlaced[]
-
-    } catch(e) {
-      console.info(e)
+      return {
+        orders: Object.keys(result.data)
+          .filter(k => placeNames.indexOf(k) > -1)
+          .map(k => result.data[k]) as OrderPlaced[],
+        cancelled: Object.keys(result.data)
+          .filter(k => cancelNames.indexOf(k) > -1)
+          .map(k => result.data[k]) as CancelledOrder[]
+      }
+    } catch (e) {
+      return {
+        error: e,
+        orders: [],
+        cancelled: []
+      }
     }
-
   }
 }

src/types/order.ts

@@ -70,3 +70,14 @@ export interface PlaceLimitOrderParams {
   marketName: string
   cancelAt?: DateTime
 }
+
+export interface OrdersPlaced {
+  error?: any
+  orders: OrderPlaced[]
+}
+
+export interface OrdersCancelledAndPlaced {
+  error?: any
+  cancelled: CancelledOrder[]
+  orders: OrderPlaced[]
+}