Struct CreateOrderRequest

pub struct CreateOrderRequest {

    pub epic: String,
    pub direction: Direction,
    pub size: f64,
    pub order_type: OrderType,
    pub time_in_force: TimeInForce,
    pub level: Option<f64>,
    pub guaranteed_stop: Option<bool>,
    pub stop_level: Option<f64>,
    pub stop_distance: Option<f64>,
    pub limit_level: Option<f64>,
    pub limit_distance: Option<f64>,
    pub expiry: Option<String>,
    pub deal_reference: Option<String>,
    pub force_open: Option<bool>,
    pub currency_code: Option<String>,
}

Model for creating a new order

Fields

epic: String

Instrument EPIC identifier

direction: Direction

Order direction (buy or sell)

size: f64

Order size/quantity

order_type: OrderType

Type of order (market, limit, etc.)

time_in_force: TimeInForce

Order duration (how long the order remains valid)

level: Option<f64>

Price level for limit orders

guaranteed_stop: Option<bool>

Whether to use a guaranteed stop

stop_level: Option<f64>

Price level for stop loss

stop_distance: Option<f64>

Distance for stop loss

limit_level: Option<f64>

Price level for take profit

limit_distance: Option<f64>

Distance for take profit

expiry: Option<String>

Expiry date for the order

deal_reference: Option<String>

Client-generated reference for the deal

force_open: Option<bool>

Whether to force open a new position

currency_code: Option<String>

Currency code for the order (e.g., “USD”, “EUR”)

Implementations

impl CreateOrderRequest

pub fn market(epic: String, direction: Direction, size: f64) -> Self

Creates a new market order

pub fn limit(epic: String, direction: Direction, size: f64, level: f64) -> Self

Creates a new limit order

pub fn sell_option_to_market( epic: &String, size: &f64, expiry: &Option<String>, deal_reference: &Option<String>, currency_code: &Option<String>, ) -> Self

Creates a new instance of a market sell option with predefined parameters.

This function sets up a sell option to the market for a given asset (epic) with the specified size. It configures the order with default values for attributes such as direction, order type, and time-in-force.

Parameters

• epic: A String that represents the epic (unique identifier or code) of the instrument being traded.
• size: A f64 value representing the size or quantity of the order.

Returns

An instance of Self (the type implementing this function), containing the specified epic and size, along with default values for other parameters:

• direction: Set to Direction::Sell.
• order_type: Set to OrderType::Limit.
• time_in_force: Set to TimeInForce::FillOrKill.
• level: Set to Some(0.1).
• guaranteed_stop: Set to None.
• stop_level: Set to None.
• stop_distance: Set to None.
• limit_level: Set to None.
• limit_distance: Set to None.
• expiry: Set to None.
• deal_reference: Set to None.
• force_open: Set to Some(true).
• currency_code: Set to None.

Note that this function allows for minimal input (the instrument and size), while other fields are provided default values. If further customization is required, you can modify the returned instance as needed.

pub fn sell_option_to_market_w_force( epic: &String, size: &f64, expiry: &Option<String>, deal_reference: &Option<String>, currency_code: &Option<String>, force_open: Option<bool>, ) -> Self

Constructs and returns a new instance of the Self struct representing a sell option to the market with specific parameters for execution.

Parameters

• epic: A reference to a string slice (&String) that specifies the EPIC (Exchanged Product Information Code) of the instrument for which the sell order is created.
• size: A reference to a floating-point number (&f64) that represents the size of the sell order. The size is rounded to two decimal places.
• expiry: An optional string (Option<String>) that indicates the expiry date or period for the sell order. If None, no expiry date will be set for the order.
• deal_reference: An optional string (Option<String>) that contains a reference or identifier for the deal. Can be used for tracking purposes.
• currency_code: An optional string (Option<String>) representing the currency code. Defaults to "EUR" if not provided.
• force_open: An optional boolean (Option<bool>) that specifies whether to force open the position. When Some(true), a new position is opened even if an existing position for the same instrument and direction is available.

Returns

• Self: A new instance populated with the provided parameters, including the following default properties:
  • direction: Set to Direction::Sell to designate the sell operation.
  • order_type: Set to OrderType::Limit to signify the type of the order.
  • time_in_force: Set to TimeInForce::FillOrKill indicating the order should be fully executed or canceled.
  • level: Set to a constant value DEFAULT_ORDER_SELL_SIZE.
  • guaranteed_stop: Set to Some(false) indicating no guaranteed stop.
  • Other optional levels/distance fields (stop_level, stop_distance, limit_level, limit_distance): Set to None by default.

Notes

• The #[allow(clippy::ptr_arg)] attribute suppresses the lint warning for using &String instead of &str. Consider updating the function signature to use &str instead of &String for better idiomatic Rust code.
• The input size is automatically rounded down to two decimal places before being stored.

pub fn buy_option_to_market( epic: &String, size: &f64, expiry: &Option<String>, deal_reference: &Option<String>, currency_code: &Option<String>, ) -> Self

Creates a new instance of an order to buy an option in the market with specified parameters.

This method initializes an order with the following default values:

• direction is set to Buy.
• order_type is set to Limit.
• time_in_force is set to FillOrKill.
• level is set to Some(10000.0).
• force_open is set to Some(true). Other optional parameters, such as stop levels, distances, expiry, and currency code, are left as None.

Parameters

• epic (String): The identifier for the market or instrument to trade.
• size (f64): The size or quantity of the order to be executed.

Returns

A new instance of Self that represents the configured buy option for the given market.

Note

Ensure the epic and size values provided are valid and match required market conditions.

pub fn buy_option_to_market_w_force( epic: &String, size: &f64, expiry: &Option<String>, deal_reference: &Option<String>, currency_code: &Option<String>, force_open: Option<bool>, ) -> Self

Constructs a new instance of an order to buy an option in the market with optional force_open behavior.

Parameters

• epic - A string slice representing the unique identifier of the instrument to be traded.
• size - A reference to a 64-bit floating-point number that represents the size of the order.
• expiry - An optional string reference representing the expiry date of the option.
• deal_reference - An optional string reference for the deal reference identifier.
• currency_code - An optional string reference representing the currency in which the order is denominated. Defaults to “EUR” if not provided.
• force_open - An optional boolean indicating whether to force open a new position regardless of existing positions.

Returns

Returns a new instance of Self, representing the constructed order with the provided parameters.

Behavior

• The size of the order will be rounded down to two decimal places for precision.
• If a currency_code is not provided, the default currency code “EUR” is used.
• Other parameters are directly mapped into the returned instance.

Notes

• This function assumes that other order-related fields such as level, stop_level, stop_distance, etc., are set to their defaults or require specific business logic, such as DEFAULT_ORDER_BUY_SIZE for the initial buy size.
• The Clippy lint for clippy::ptr_arg is explicitly allowed for the epic parameter, where using a reference to String is intentional.

pub fn with_stop_loss(self, stop_level: f64) -> Self

Adds a stop loss to the order

pub fn with_take_profit(self, limit_level: f64) -> Self

Adds a take profit to the order

pub fn with_reference(self, reference: String) -> Self

Adds a reference to the order

Trait Implementations

impl Clone for CreateOrderRequest

fn clone(&self) -> CreateOrderRequest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CreateOrderRequest

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CreateOrderRequest

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for CreateOrderRequest

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Serialize for CreateOrderRequest

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.