@tastytrade/api 0.0.1

package/lib/account-streamer.ts

@@ -0,0 +1,394 @@
+import _ from 'lodash'
+import type { JsonMap, JsonValue } from './utils/json-util'
+import { JsonBuilder } from './utils/json-util'
+import TastytradeSession from './models/tastytrade-session'
+
+export enum STREAMER_STATE {
+  Open = 0,
+  Closed = 1,
+  Error = 2
+}
+
+enum MessageAction {
+  ACCOUNT_SUBSCRIBE = 'account-subscribe',
+  CONNECT = 'connect', // Send this instead of `account-subscribe`
+  HEARTBEAT = 'heartbeat',
+  PUBLIC_WATCHLISTS_SUBSCRIBE = 'public-watchlists-subscribe',
+  QUOTE_ALERTS_SUBSCRIBE = 'quote-alerts-subscribe',
+  USER_MESSAGE_SUBSCRIBE = 'user-message-subscribe'
+}
+
+const HEARTBEAT_INTERVAL = 20000 // 20 seconds
+
+const SOURCE = 'tastytrade-api-js-sdk'
+
+export type Disposer = () => void
+
+export type StreamerStateObserver = (streamerState: STREAMER_STATE) => void
+
+export type StreamerMessageObserver = (messageType: string, action: string, status: string) => void
+
+const REQUEST_ID = 'request-id'
+
+function removeElement<T>(array: T[], element: T): void {
+  const index = array.indexOf(element)
+  if (index < 0) {
+    return
+  }
+
+  array.splice(index, 1)
+}
+
+export class AccountStreamer {
+  private websocket: WebSocket | null = null
+  private startResolve: ((result: boolean) => void) | null = null
+  private startReject: ((reason?: any) => void) | null = null
+  private requestCounter: number = 0
+  private queued: string[] = []
+
+  private heartbeatTimerId: number | NodeJS.Timeout | null = null
+
+  lastCloseEvent: any = null
+  lastErrorEvent: any = null
+  private _streamerState: STREAMER_STATE = STREAMER_STATE.Closed
+
+  private readonly streamerStateObservers: StreamerStateObserver[] = []
+
+  private readonly streamerMessageObservers: StreamerMessageObserver[] = []
+
+  private startPromise: Promise<boolean> | null = null
+
+  private readonly requestPromises: Map<
+    number,
+    [(status: string) => void, (error: string) => void]
+  > = new Map()
+
+  private readonly logger = console
+
+  /**
+   * 
+   * @param url Url of the account streamer service
+   */
+  constructor(private readonly url: string, private readonly session: TastytradeSession) {}
+
+  get streamerState(): STREAMER_STATE {
+    return this._streamerState
+  }
+
+  set streamerState(streamerState: STREAMER_STATE) {
+    this._streamerState = streamerState
+
+    this.streamerStateObservers.forEach(observer => {
+      observer(streamerState)
+    })
+  }
+
+  private get authToken() {
+    return this.session.authToken
+  }
+
+  /**
+   * Adds a custom callback that fires when the streamer state changes
+   * @param observer 
+   * @returns 
+   */
+  addStreamerStateObserver(observer: StreamerStateObserver): Disposer {
+    this.streamerStateObservers.push(observer)
+
+    return () => {
+      removeElement(this.streamerStateObservers, observer)
+    }
+  }
+
+  get isOpen(): boolean {
+    return this.streamerState === STREAMER_STATE.Open
+  }
+
+  get isClosed(): boolean {
+    return this.streamerState === STREAMER_STATE.Closed
+  }
+
+  get isError(): boolean {
+    return this.streamerState === STREAMER_STATE.Error
+  }
+
+  /**
+   * Entrypoint for beginning a websocket session
+   * You must have a valid tastytrade authToken before calling this method
+   * @returns Promise that resolves when the "opened" message is received (see handleOpen)
+   */
+  async start(): Promise<boolean> {
+    if (this.startPromise !== null) {
+      return this.startPromise
+    }
+
+    const websocket = (this.websocket = new WebSocket(this.url))
+    this.lastCloseEvent = null
+    this.lastErrorEvent = null
+    websocket.addEventListener('open', this.handleOpen)
+    websocket.addEventListener('close', this.handleClose)
+    websocket.addEventListener('error', this.handleError)
+    websocket.addEventListener('message', this.handleMessage)
+
+    this.logger.info('AccountStreamer - starting')
+    this.startPromise = new Promise<boolean>((resolve, reject) => {
+      this.startResolve = resolve
+      this.startReject = reject
+    })
+
+    return this.startPromise
+  }
+
+  stop() {
+    this.teardown()
+  }
+
+  private teardown() {
+    const websocket = this.websocket
+    if (websocket === null) {
+      return
+    }
+
+    this.startPromise = null
+
+    this.cancelHeartbeatTimer()
+
+    websocket.close()
+    websocket.removeEventListener('open', this.handleOpen)
+    websocket.removeEventListener('close', this.handleClose)
+    websocket.removeEventListener('message', this.handleMessage)
+    websocket.removeEventListener('error', this.handleError)
+
+    this.websocket = null
+
+    this.logger.info('AccountStreamer - teardown')
+    this.streamerState = STREAMER_STATE.Closed // Manually update status for convenience
+  }
+
+  readonly sendHeartbeat = () => {
+    this.clearHeartbeatTimerId()
+    this.send(new JsonBuilder({ action: MessageAction.HEARTBEAT }))
+  }
+
+  private scheduleHeartbeatTimer() {
+    if (this.isHeartbeatScheduled) {
+      // Heartbeat already scheduled
+      return
+    }
+
+    this.logger.info('Scheduling heartbeat with interval: ', HEARTBEAT_INTERVAL)
+    const scheduler = typeof window === 'undefined' ? setTimeout : window.setTimeout
+    this.heartbeatTimerId = scheduler(
+      this.sendHeartbeat,
+      HEARTBEAT_INTERVAL
+    )
+  }
+
+  get isHeartbeatScheduled() {
+    return !_.isNil(this.heartbeatTimerId)
+  }
+
+  private cancelHeartbeatTimer() {
+    if (!this.isHeartbeatScheduled) {
+      return // Nothing to cancel
+    }
+
+    if (typeof window === 'undefined') {
+      clearTimeout(this.heartbeatTimerId! as number)
+    } else {
+      clearTimeout(this.heartbeatTimerId! as NodeJS.Timeout)
+    }
+
+    this.clearHeartbeatTimerId()
+  }
+
+  private clearHeartbeatTimerId() {
+    this.heartbeatTimerId = null
+  }
+
+  /**
+   * Send a message via websocket
+   * @param json JsonBuilder
+   * @param includeSessionToken Attaches session token to message if true
+   * @returns 
+   */
+  send(json: JsonBuilder, includeSessionToken = true): number {
+    this.requestCounter += 1
+    json.add(REQUEST_ID, this.requestCounter)
+    json.add('source', SOURCE)
+
+    if (includeSessionToken) {
+      const sessionToken = this.authToken
+      if (!sessionToken) {
+        throw new Error('sessionToken not set')
+      }
+
+      json.add('auth-token', sessionToken)
+    }
+
+    const message = JSON.stringify(json.json)
+    const websocket = this.websocket
+    if (websocket === null) {
+      // Queue up and send on open
+      this.queued.push(message)
+    } else {
+      websocket.send(message)
+    }
+
+    return this.requestCounter
+  }
+
+  /**
+   * Used by other methods to send a specific `action` message
+   * @param action 
+   * @param value 
+   * @returns 
+   */
+  public subscribeTo(action: string, value?: JsonValue): number {
+    const json = new JsonBuilder()
+    json.add('action', action)
+    if (!_.isUndefined(value)) {
+      json.add('value', value)
+    }
+    return this.send(json)
+  }
+
+  /**
+   * Subscribes to all user-level messages for given user external id
+   * @param userExternalId "external-id" from login response
+   * @returns Promise that resolves when ack is received
+   */
+  public subscribeToUser(userExternalId: string) {
+    if (!userExternalId) {
+      return
+    }
+
+    this.subscribeTo(MessageAction.USER_MESSAGE_SUBSCRIBE, userExternalId)
+  }
+
+  /**
+   * Subscribes to all account-level messages for given account numbers
+   * @param accountNumbers List of account numbers to subscribe to
+   * @returns Promise that resolves when an ack is received
+   */
+  public async subscribeToAccounts(accountNumbers: string[]): Promise<string> {
+    if (accountNumbers.length === 0) {
+      return Promise.reject('no account numbers')
+    }
+
+    const value: JsonValue =
+      accountNumbers.length > 1 ? accountNumbers : accountNumbers[0]
+    const requestId = this.subscribeTo(MessageAction.CONNECT, value)
+
+    return new Promise<string>((resolve, reject) => {
+      this.requestPromises.set(requestId, [resolve, reject])
+    })
+  }
+
+  private sendQueuedMessages() {
+    const queued = this.queued
+    if (queued.length === 0 || this.websocket === null) {
+      return
+    }
+
+    const websocket = this.websocket
+    queued.forEach(msg => {
+      websocket.send(msg)
+    })
+
+    this.queued = []
+  }
+
+  private readonly handleOpen = (event: Event) => {
+    if (this.startResolve === null) {
+      return
+    }
+
+    this.logger.info('AccountStreamer opened', event)
+
+    this.startResolve(true)
+    this.startResolve = this.startReject = null
+
+    this.streamerState = STREAMER_STATE.Open
+    this.sendQueuedMessages()
+    this.scheduleHeartbeatTimer()
+  }
+
+  private readonly handleClose = (event: CloseEvent) => {
+    this.logger.info('AccountStreamer closed', event)
+    if (this.websocket === null) {
+      return
+    }
+
+    this.lastCloseEvent = event
+    this.streamerState = STREAMER_STATE.Closed
+    this.teardown()
+  }
+
+  private readonly handleError = (event: Event) => {
+    if (this.websocket === null) {
+      return
+    }
+
+    this.logger.warn('AccountStreamer error', event)
+
+    this.lastErrorEvent = event
+    this.streamerState = STREAMER_STATE.Error
+
+    if (this.startReject !== null) {
+      this.startReject(new Error('Failed to connect'))
+      this.startReject = this.startResolve = null
+    }
+
+    this.teardown()
+  }
+
+  private readonly handleMessage = (event: MessageEvent) => {
+    const json = JSON.parse(event.data as string) as JsonMap
+
+    if (json.results !== undefined) {
+      const results: JsonValue[] = json.results as JsonValue[]
+      for (const result of results) {
+        this.handleOneMessage(result as JsonMap)
+      }
+    } else {
+      this.handleOneMessage(json)
+    }
+  }
+
+  addMessageObserver(observer: StreamerMessageObserver): Disposer {
+    this.streamerMessageObservers.push(observer)
+
+    return () => {
+      removeElement(this.streamerMessageObservers, observer)
+    }
+  }
+
+  private readonly handleOneMessage = (json: JsonMap) => {
+    this.logger.info(json)
+
+    const action = json.action as string
+    this.streamerMessageObservers.forEach(observer => observer(json.type as string, action, json.status as string))
+    if (action) {
+      if (action === MessageAction.HEARTBEAT) {
+        // schedule next heartbeat
+        this.scheduleHeartbeatTimer()
+      }
+
+      const promiseCallbacks = this.requestPromises.get(
+        json[REQUEST_ID] as number
+      )
+      if (promiseCallbacks) {
+        const [resolve, reject] = promiseCallbacks
+        const status = json.status as string
+        if (status === 'ok') {
+          resolve(json.action as string)
+        } else {
+          reject(json.message as string)
+        }
+      }
+
+      return
+    }
+  }
+}

package/lib/models/tastytrade-session.ts

@@ -0,0 +1,13 @@
+import _ from 'lodash'
+
+export default class TastytradeSession { 
+    authToken: string | null = null
+
+    get isValid() {
+      return !_.isNil(this.authToken)
+    }
+
+    clear() {
+        this.authToken = null
+    }
+}

package/lib/quote-streamer.ts

@@ -0,0 +1,40 @@
+import Feed, { EventType, IEvent } from '@dxfeed/api'
+import _ from 'lodash'
+
+export const SupportedEventTypes = [
+  EventType.Quote,
+  EventType.Trade,
+  EventType.Summary,
+  EventType.Greeks,
+  EventType.Profile
+]
+
+export default class QuoteStreamer {
+  private feed: Feed | null = null
+
+  constructor(private readonly token: string, private readonly url: string) {}
+
+  connect() {
+    this.feed = new Feed()
+    this.feed.setAuthToken(this.token)
+    this.feed.connect(this.url)
+  }
+
+  disconnect() {
+    if (!_.isNil(this.feed)) {
+      this.feed.disconnect()
+    }
+  }
+
+  subscribe(dxfeedSymbol: string, eventHandler: (event: IEvent) => void): () => void {
+    if (_.isNil(this.feed)) {
+      return _.noop
+    }
+
+    return this.feed.subscribe(
+      SupportedEventTypes,
+      [dxfeedSymbol],
+      eventHandler
+    )
+  }
+}

package/lib/services/account-status-service.ts

@@ -0,0 +1,15 @@
+import extractResponseData from "../utils/response-util";
+import TastytradeHttpClient from "./tastytrade-http-client";
+
+// create the central class that aggregates all services from dmoss
+export default class AccountStatusService {
+    constructor(private httpClient: TastytradeHttpClient) {
+    }
+
+    //Trading Status: Allows an API client to request information about the basic trade status of an account. This includes information about the strategies an account can trade. 
+    async getAccountStatus(accountNumber: string){
+        //Returns current trading status for an account.
+        const accountStatus =  (await this.httpClient.getData(`/accounts/${accountNumber}/trading-status`, {}, {}))
+        return extractResponseData(accountStatus)
+    }
+}

package/lib/services/accounts-and-customers-service.ts

@@ -0,0 +1,35 @@
+import extractResponseData from "../utils/response-util";
+import TastytradeHttpClient from "./tastytrade-http-client";
+
+export default class AccountsAndCustomersService {
+    constructor(private httpClient: TastytradeHttpClient) {
+    }
+    async getCustomerAccounts(){
+        const accountNumber = (await this.httpClient.getData('/customers/me/accounts', {}, {}))
+        return extractResponseData(accountNumber)
+    }
+
+    //Customers: Operations about customers
+    async getCustomerResource(customerId: string){
+        //Get a full customer resource.
+        const customerResource = (await this.httpClient.getData(`/customers/${customerId}`, {}, {}))
+        return extractResponseData(customerResource)
+    }
+    async getCustomerAccountResources(customerId: string){
+        //Get a list of all the customer account resources attached to the current customer.
+        const customerAccountResources = (await this.httpClient.getData(`/customers/${customerId}/accounts`, {}, {}))
+        return extractResponseData(customerAccountResources)
+    }
+    async getFullCustomerAccountResource(customerId: string, accountNumber: string){
+        //Get a full customer account resource.
+        const fullCustomerAccountResource = (await this.httpClient.getData(`/customers/${customerId}/accounts/${accountNumber}`, {}, {}))
+        return extractResponseData(fullCustomerAccountResource)
+    }
+
+    //Quote-streamer-tokens: Operations about quote-streamer-tokens
+    async getQuoteStreamerTokens(){
+        //Returns the appropriate quote streamer endpoint, level and identification token for the current customer to receive market data.
+        const quoteStreamerTokens = (await this.httpClient.getData('/quote-streamer-tokens', {}, {}))
+        return extractResponseData(quoteStreamerTokens)
+    }
+}

package/lib/services/balances-and-positions-service.ts

@@ -0,0 +1,29 @@
+import extractResponseData from "../utils/response-util";
+import TastytradeHttpClient from "./tastytrade-http-client";
+
+export default class BalancesAndPositionsService {
+    constructor(private httpClient: TastytradeHttpClient) {
+    }
+    
+    //Positions: Operations about positions
+    async getPositionsList(accountNumber: string, queryParams = {}){
+        //Returns a list of the account's positions.
+        //Can be filtered by symbol, underlying_symbol
+        const positionsList = (await this.httpClient.getData(`/accounts/${accountNumber}/positions`, {}, queryParams))
+        return extractResponseData(positionsList)
+    }
+
+    //Accounts: Operations about accounts
+    async getAccountBalanceValues(accountNumber: string){
+        //Returns the current balance values for an account
+        const accountBalanceValues = (await this.httpClient.getData(`/accounts/${accountNumber}/balances`, {}, {}))
+        return extractResponseData(accountBalanceValues)
+    }
+
+    //Balance-snapshots Operations about balance-snapshots
+    async getBalanceSnapshots(accountNumber: string, queryParams = {}){
+        //Returns most recent snapshot and current balance for an account
+        const balanceSnapshot = (await this.httpClient.getData(`/accounts/${accountNumber}/balance-snapshots`, {}, queryParams))
+        return extractResponseData(balanceSnapshot)
+    }
+}

package/lib/services/instruments-service.ts

@@ -0,0 +1,138 @@
+import extractResponseData from "../utils/response-util";
+import TastytradeHttpClient from "./tastytrade-http-client";
+import _ from 'lodash'
+
+export default class InstrumentsService {
+    constructor(private httpClient: TastytradeHttpClient) {
+    }
+
+    //Instruments: Allows an API client to fetch data about instruments.
+    async getCryptocurrencies(symbols: string[] = []){
+        //Retrieve a set of cryptocurrencies given an array of one or more symbols.
+        const queryParams = { symbol: symbols }
+        const cryptocurrencies = (await this.httpClient.getData(`/instruments/cryptocurrencies`, {}, queryParams))
+        return extractResponseData(cryptocurrencies)
+    }
+    async getSingleCryptocurrency(symbol: string){
+        //Retrieve a cryptocurrency given a symbol.
+        const encodedSymbol = encodeURIComponent(symbol)
+        const singleCryptocurrency = (await this.httpClient.getData(`/instruments/cryptocurrencies/${encodedSymbol}`, {}, {}))
+        return extractResponseData(singleCryptocurrency)
+    }
+    async getActiveEquities(queryParams = {}){
+        //Returns all active equities in a paginated fashion
+        const activeEquities = (await this.httpClient.getData(`/instruments/equities/active`, {}, queryParams))
+        return extractResponseData(activeEquities)
+    }
+    async getEquityDefinitions(queryParams = {}){
+        //Returns a set of equity definitions given an array of one or more symbols
+        const equityDefinitions = (await this.httpClient.getData(`/instruments/equities`, {}, queryParams))
+        return extractResponseData(equityDefinitions)
+    }
+    async getSingleEquity(symbol: string){
+        //Returns a single equity definition for the provided symbol
+        const singleEquity = (await this.httpClient.getData(`/instruments/equities/${symbol}`, {}, {}))
+        return extractResponseData(singleEquity)
+    }
+    async getEquityOptions(symbols: string[], active = true, withExpired = false) {
+        if (_.isEmpty(symbols)) {
+          throw new Error('Symbols are required for InstrumentService.getEquityOptions')
+        }
+
+        //Returns a set of equity options given one or more symbols
+        const queryParams = { symbols, active, withExpired }
+        const equityOptions = (await this.httpClient.getData(`/instruments/equity-options`, {}, queryParams))
+        return extractResponseData(equityOptions)
+    }
+    async getSingleEquityOption(symbol: string, queryParams = {}){
+        //Get equity option by symbol
+        const singleOption = await this.httpClient.getData(`/instruments/equity-options/${symbol}`, {}, queryParams)
+        return extractResponseData(singleOption)
+    }
+    async getFutures(queryParams = {}){
+        //Returns a set of outright futures given an array of one or more symbols.
+        const futures = (await this.httpClient.getData(`/instruments/futures`, {}, queryParams))
+        return extractResponseData(futures)
+    }
+    async getSingleFuture(symbol: string){
+        //Returns an outright future given a symbol.
+        const singleFuture = await this.httpClient.getData(`/instruments/futures/${symbol}`, {}, {})
+        return extractResponseData(singleFuture)
+    }
+    async getFutureOptionsProducts(){
+        //Returns metadata for all supported future option products
+        const futureOptionsProducts = (await this.httpClient.getData(`/instruments/future-option-products`, {}, {}))
+        return extractResponseData(futureOptionsProducts)
+    }
+    async getSingleFutureOptionProduct(exchange: string, rootSymbol: string){
+        //Get a future option product by exchange and root symbol
+        const singleFutureOptionProduct = (await this.httpClient.getData(`/instruments/future-option-products/${exchange}/${rootSymbol}`, {}, {}))
+        return extractResponseData(singleFutureOptionProduct)
+    }
+    async getFutureOptions(queryParams = {}){
+        //Returns a set of future option(s) given an array of one or more symbols.
+        //Uses TW symbology: [./ESZ9 EW4U9 190927P2975]
+        const futureOptions = (await this.httpClient.getData(`/instruments/future-options`, {}, queryParams))
+        return extractResponseData(futureOptions)
+    }
+    async getSingleFutureOption(symbol: string){
+        //Returns a future option given a symbol. Uses TW symbology: ./ESZ9 EW4U9 190927P2975
+        const singleFutureOption = await this.httpClient.getData(`/instruments/future-options/${symbol}`, {}, {})
+        return extractResponseData(singleFutureOption)
+    }
+    async getFuturesProducts(){
+        //Returns metadata for all supported futures products
+        const futuresProducts = (await this.httpClient.getData(`/instruments/future-products`, {}, {}))
+        return extractResponseData(futuresProducts)
+    }
+    async getSingleFutureProduct(exchange: string, code: string){
+        //Get future product from exchange and product code
+        const singleFutureProduct = (await this.httpClient.getData(`/instruments/future-products/${exchange}/${code}`, {}, {}))
+        return extractResponseData(singleFutureProduct)
+    }
+    async getQuantityDecimalPrecisions(){
+        //Retrieve all quantity decimal precisions.
+        const quantityDecimalPrecisions = (await this.httpClient.getData(`/instruments/quantity-decimal-precisions`, {}, {}))
+        return extractResponseData(quantityDecimalPrecisions)
+    }
+    async getWarrants(queryParams = {}){
+        //Returns a set of warrant definitions that can be filtered by parameters
+        const warrants = (await this.httpClient.getData(`/instruments/warrants`, {}, queryParams))
+        return extractResponseData(warrants)
+    }
+    async getSingleWarrant(symbol: string){
+        //Returns a single warrant definition for the provided symbol
+        const singleWarrant = (await this.httpClient.getData(`/instruments/warrants/${symbol}`, {}, {}))
+        return extractResponseData(singleWarrant)
+    }
+
+    //Futures-option-chains: Allows an API client to fetch futures option chains.
+    async getNestedFutureOptionChains(symbol: string){
+        //Returns a futures option chain given a futures product code in a nested form to minimize redundant processing
+        const nestedFutureOptionChains = (await this.httpClient.getData(`/futures-option-chains/${symbol}/nested`, {}, {}))
+        return extractResponseData(nestedFutureOptionChains)
+    }
+    async getFutureOptionChain(symbol: string){
+        //Returns a futures option chain given a futures product code, i.e. ES
+        const futureOptionChain = (await this.httpClient.getData(`/futures-option-chains/${symbol}`, {}, {}))
+        return extractResponseData(futureOptionChain)
+    }
+
+    //Option-chains: Allows an API client to fetch futures option chains.
+    async getNestedOptionChain(symbol: string){
+        //Returns an option chain given an underlying symbol,
+        //i.e. AAPL in a nested form to minimize redundant processing
+        const nestedOptionChain = (await this.httpClient.getData(`/option-chains/${symbol}/nested`, {}, {}))
+        return extractResponseData(nestedOptionChain)
+    }
+    async getCompactOptionChain(symbol: string){
+        //Returns an option chain given an underlying symbol, i.e. AAPL in a compact form to minimize content size
+        const compactOptionChain = (await this.httpClient.getData(`/option-chains/${symbol}/compact`, {}, {}))
+        return extractResponseData(compactOptionChain)
+    }
+    async getOptionChain(symbol: string){
+        //Returns an option chain given an underlying symbol, i.e. AAPL
+        const optionChain = (await this.httpClient.getData(`/option-chains/${symbol}`, {}, {}))
+        return extractResponseData(optionChain)
+    }
+}

package/lib/services/margin-requirements-service.ts

@@ -0,0 +1,19 @@
+import extractResponseData from "../utils/response-util";
+import TastytradeHttpClient from "./tastytrade-http-client";
+
+export default class MarginRequirementsService {
+    constructor(private httpClient: TastytradeHttpClient) {
+    }
+
+    //Margin-requirements: Allows a client to fetch margin-requirements for positions and orders
+    async getMarginRequirements(accountNumber: string){
+        //Fetch current margin/captial requirements report for an account
+        const marginRequirements = (await this.httpClient.getData(`/margin/accounts/${accountNumber}/requirements`))
+        return extractResponseData(marginRequirements)
+    }
+    async postMarginRequirements(accountNumber: string, order: object){
+        //Estimate margin requirements for an order given an account
+        const marginRequirements = (await this.httpClient.postData(`/margin/accounts/${accountNumber}/dry-run`, order, {}))
+        return extractResponseData(marginRequirements)
+    }
+}