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: 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: bool,
    pub currency_code: String,
    pub quote_id: Option<String>,
    pub trailing_stop: Option<bool>,
    pub trailing_stop_increment: Option<f64>,
}

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: bool

Whether to use a guaranteed stop

stop_level: Option<f64>

Price level for stop loss

stop_distance: Option<f64>

Stop loss distance

limit_level: Option<f64>

Price level for take profit

limit_distance: Option<f64>

Take profit distance

expiry: Option<String>

Expiry date for the order

deal_reference: Option<String>

Client-generated reference for the deal

force_open: bool

Whether to force open a new position

currency_code: String

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

quote_id: Option<String>

Quote identifier for the order

trailing_stop: Option<bool>

Trailing stop enabled

trailing_stop_increment: Option<f64>

Trailing stop increment (only if trailingStop is true)

Implementations

impl CreateOrderRequest

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

Creates a new market order, typically used for CFD (Contract for Difference) accounts

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

Creates a new limit order, typically used for CFD (Contract for Difference) accounts

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(DEFAULT_ORDER_SELL_SIZE).
• guaranteed_stop: Set to false.
• stop_level: Set to None.
• stop_distance: Set to None.
• limit_level: Set to None.
• limit_distance: Set to None.
• expiry: Set based on input or None.
• deal_reference: Auto-generated if not provided.
• force_open: Set to true.
• currency_code: Defaults to "EUR" if not provided.

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: 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 String that specifies the EPIC (Exchanged Product Information Code) of the instrument for which the sell order is created.
• size: A f64 that represents the size of the sell order. The size is rounded to two decimal places.
• expiry: An optional 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 that contains a reference or identifier for the deal. Can be used for tracking purposes.
• currency_code: An optional String representing the currency code. Defaults to "EUR" if not provided.
• force_open: A bool that specifies whether to force open the position. When 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 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 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(DEFAULT_ORDER_BUY_SIZE).
• force_open is set to 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: 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 representing the unique identifier of the instrument to be traded.
• size - A f64 value that represents the size of the order.
• expiry - An optional String representing the expiry date of the option.
• deal_reference - An optional String for the deal reference identifier.
• currency_code - An optional String representing the currency in which the order is denominated. Defaults to “EUR” if not provided.
• force_open - A bool 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.

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_trailing_stop_loss(self, trailing_stop_increment: f64) -> Self

Adds a trailing stop loss to the order

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

Adds a reference to the order

pub fn with_stop_distance(self, stop_distance: f64) -> Self

Adds a stop distance to the order

pub fn with_limit_distance(self, limit_distance: f64) -> Self

Adds a limit distance to the order

pub fn with_guaranteed_stop(self, guaranteed: bool) -> Self

Adds a guaranteed stop 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.