Struct architect_api::client::Client

pub struct Client(_);

Managed client for Architect.

Implements some default behavior for setup and provides a simple and clean interface + convenient helpers for getting started without obfuscating the actual core API–that is, it should be easy to graduate from this interface as the user requirements become more complex. Think “training wheels” and not “opaque re-skin”.

That being said, the interface should be sufficient for all kinds of low-frequency, discretionary trading. Probably around >1000 open orders at any given time is the cutoff for setting things up more manually.

The lower level oms api is in orderflow, lower level qf functionality is direct from netidx.

Implementations

impl Client

pub async fn new(common: &Common) -> Result<(Self, JoinHandle<Result<()>>)>

This will initialize every api, in some cases it can take a while. It should not be necessary to have more than one of these in a process.

pub async fn initialize( common: Option<&Common> ) -> Result<(Self, JoinHandle<Result<()>>)>

This is a wrapper around new that will load the default api configuration if you don’t already have one. If you do have one, then it is the same as calling new.

pub fn common(&self) -> &Common

Return a reference to the api common config.

pub fn symbology(&self) -> &Client

Return a reference to the symbology client

pub fn orderflow(&self) -> &Client

Return a reference to the low level orderflow client. If you are using simple_orderflow directly, or ManagedOrder then it isn’t safe to receive messages directly from this client.

pub fn simple_orderflow(&self) -> &OmsQueryApi

Return a reference to the simple orderflow client. Normally you would call send_limit_order, however if you want a somewhat lower level interface you can use simple_orderflow directly.

pub fn limits(&self) -> &OmsLimitsApi

Return a reference to the limits api

pub fn secrets(&self) -> &SecretsQueryApi

Return a reference to the secrets db api

pub fn alerts(&self) -> Receiver<Pooled<Vec<Alert>>>

Return a reference to the alerts channel. You must also call subscribe_to_alerts if you want to receive system alerts.

pub fn subscribe_to_alerts(&self, path: Path, seek: Seek)

Subscribe to system alerts. To use the alerts call alerts and use the returned broadcast channel.

pub fn default_account(&self) -> Account

Return the default account

pub fn managed_product( &self, base: &str, quote: &str, venue: Venue, route: Route ) -> Result<ManagedProduct>

Subscribe to the specified product by name. Base is the product, e.g. BTC, quote is the quote currency, e.g. USD. Venue and Route are the exchange the product trades on and qf route to use for the data. For most exchanges this will be Route::get(“DIRECT”).

pub async fn managed_order(&self, order_id: OrderId) -> Arc<ManagedOrder>

Wrap an order in a managed order

pub async fn send_limit_order( &self, product: TradableProduct, account: Account, dir: Dir, price: Decimal, quantity: Decimal ) -> Result<Arc<ManagedOrder>>

Send a limit order, returning the managed order

pub async fn list_open_orders( &self, set: LimitSet, scope: LimitScope ) -> Result<Pooled<Vec<Order>>>

Return a list of open orders in the specified set and scope. E.G. to return all open orders, you’d use LimitSet::Firm, LimitScope::Global.

pub async fn list_fills( &self, set: LimitSet, scope: LimitScope ) -> Result<Pooled<Vec<Result<NormalFill, AberrantFill>>>>

return a list of fills in the specified set and scope.

However be aware that because the OMS is designed to support very high frequency trading applications it is not possible for it to keep every order forever. Filled orders are dropped after 1 day by default.

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Deref for Client

type Target = ClientInner

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.