Order entry

• Order entry

  • Order placement

  • Order cancellation

  • Order status

  • Orderflow subscription

Order placement

timeInForce	Description	Required fields	Optional fields
GTC	Good til canceled
GTD	Good til date	goodTilDate
IOC	Immediate or cancel

Python

The send_limit_order method will wait for the order to be accepted by the exchange before returning. Depending on the time-in-force instruction, the order may require additional parameters.

from decimal import Decimal
from architect_py.scalars import OrderDir
from architect_py.graphql_client.enums import TimeInForce

order = client.send_limit_order(
    symbol="BTC Crypto/USD",
    execution_venue="COINBASE",
    account=None,                   # required for some venues
    odir=OrderDir.BUY,
    quantity=Decimal(1),
    limit_price=Decimal(10000),
    post_only=True,                 # optional
    trigger_price=None,             # optional, for stop-loss, take-profit, order types only
    time_in_force=TimeInForce.GTC,  # optional
    good_til_date=None,             # optional, for GTD orders only
)

# order.order
# order.order_state 
# order.filled_qty 
# order.avg_fill_price
# order.reject_reason

JavaScript

import { create, enums } from '@afintech/sdk';
import { config } from './_config.mjs';

const c = create(config);

const orderId = await c.createOrder({
  market: 'BTC Crypto/USD*COINBASE/DIRECT',
  dir: 'buy',
  quantity: '1',
  limitPrice: '10000',
  postOnly: true, // optional
  triggerPrice: null, // optional, for stop-loss, take-profit, order types only
  timeInForce: {
    instruction: enums.CreateTimeInForceInstruction.Gtc, // optional
    goodTilDate: null, // optional, for GTD orders only
  },
  orderType: enums.CreateOrderType.Limit,
  account: null, // required for some venues
});
console.log('orderId', orderId);

GraphQL

mutation SendOrder($order: CreateOrder!) {
  createOrder(order: $order)
}

input CreateOrder {
  market: MarketId!
  dir: Dir!
  quantity: Decimal!
  account: AccountId
  orderType: CreateOrderType!
  limitPrice: Decimal
  postOnly: Boolean
  triggerPrice: Decimal
  timeInForce: CreateTimeInForce!
  quoteId: Str
  source: OrderSource
}

enum CreateOrderType {
  LIMIT
  STOP_LOSS_LIMIT
  TAKE_PROFIT_LIMIT
}

enum CreateTimeInForceInstruction {
  GTC
  GTD
  IOC
}

Order cancellation

Orders are canceled by reference to their id.

Python

The cancel_order method does not wait for the order to be confirmed canceled before returning. A working order is only canceled when the exchange confirms the cancellation, which can be checked by polling the order status.

client.cancel_order("12345678-1234-5678-1234-567812345678")  # order id 

JavaScript

import { create } from '@afintech/sdk';
const c = create({/* config */});

await c.cancelOrder(orderId);

GraphQL

mutation CancelOrder($orderId: OrderId!) {
  cancelOrder(orderId: $orderId)
}

Order status

Orders are retrieved by reference to their id. Open orders and recently closed orders can be queried by this method. For a list of valid order states, see Orderflow subscription.

Python

order = client.get_order("12345678-1234-5678-1234-567812345678")  # order id

# order.order
# order.order_state 
# order.filled_qty 
# order.avg_fill_price
# order.reject_reason

JavaScript

import { create } from '@afintech/sdk';
const c = create({/* config */});

const order = await c.order([], "<order-id-guid>");
console.log('order', order);

GraphQL

query GetOrder($orderId: OrderId!) {
  order(orderId: $orderId) {
    ...OrderLogFields
  }
}

fragment OrderLogFields on OrderLog {
  __typename
  timestamp
  order {
    id
    market {
      ...MarketFields
    }
    dir
    quantity
    orderType {
      __typename
      ... on LimitOrderType {
        limitPrice
      }
      ... on StopLossLimitOrderType {
        limitPrice
        triggerPrice
      }
      ... on TakeProfitLimitOrderType {
        limitPrice
        triggerPrice
      }
    }
  }
  orderState
  filledQty
  avgFillPrice
  rejectReason
}

Orderflow subscription

Subscribe to all orderflow events. The lifecycle of an Architect order is designed to allow for fast order submission and defensive order status determination. Orders IDs are globally unique.

Order state is represented by a set of status flags:

• OPEN: Order is submitted and assumed to be imminently executable

• REJECTED: Order was rejected by the exchange

• ACKED: Order was accepted by the exchange

• FILLED: Order was filled, partially or fully

• CANCELING: Order was requested to be canceled

• CANCELED: Order was confirmed cancelled by the exchange

• OUT: Order is confirmed to be no longer executable by the exchange, either because it was rejected, filled fully or cancelled

• STALE: Architect couldn't determine the status of the order after some time, manual intervention is required

Any combination of flags is a possible order state, although some flag combinations expected to be extremely rare and indicative of serious counterparty fault (e.g. Open | Out). Generally, the expected order lifecycle is as follows:

Python (async)

# stream = client.subscribe_orderflow()
# async for event in stream:
#     if event.orderflow.typename__ == "Ack":
#         print(f"<!> ACK {event.orderflow.order_id}")
#     elif event.orderflow.typename__ == "Reject":
#         print(f"<!> REJECT {event.orderflow.order_id}: {event.orderflow.reason}")
#     elif event.orderflow.typename__ == "Out":
#         print(f"<!> OUT {event.orderflow.order_id}")

JavaScript

Coming soon

GraphQL

subscription SubscribeOrderflow {
  orderflow {
    __typename
    ... on Order {
      id
      marketId
      dir
      quantity
      accountId
      orderType {
        ... on LimitOrderType {
          limitPrice
          postOnly
        }
        ... on StopLossLimitOrderType {
          limitPrice
          triggerPrice
        }
        ... on TakeProfitLimitOrderType {
          limitPrice
          triggerPrice
        }
      }
      timeInForce {
        instruction
        goodTilDate
      }
      quoteId
      source
    }
    ... on Ack {
      orderId
    }
    ... on Reject {
      orderId
      reason
    }
    ... on OmsOrderUpdate {
      orderId
      orderState: state
      filledQty
      avgFillPrice
    }
    ... on Fill {
      fillOrderId: orderId
      fillKind: kind
      marketId
      dir
      price
      quantity
      tradeTime
    }
    ... on Out {
      orderId
    }
  }
}