Struct ConditionalExpiry 

pub struct ConditionalExpiry {
    pub timestamp: u128,
    pub trigger: bool,
}

Defines expiration behavior for conditional orders.

This struct specifies when a conditional order should expire and what action to take upon expiration. It provides fine-grained control over conditional order lifecycles, allowing orders to either trigger or cancel at a specific time.

Fields

• timestamp: Unix timestamp (milliseconds since epoch) when expiration occurs
• trigger: Determines action on expiry (true = trigger order, false = cancel order)

Field Aliases

• timestamp can be aliased as "expiry_timestamp" or "e"
• trigger can be aliased as "expiry_trigger" or "et"

Behavior

Trigger on Expiry (trigger: true)

When the timestamp is reached, the conditional order will be immediately triggered regardless of whether the price condition has been met. This is useful for:

• Time-based order execution
• Deadline-driven trading strategies
• Automatic order activation at specific times

Cancel on Expiry (trigger: false)

When the timestamp is reached, the conditional order will be canceled and removed from the order book. This is useful for:

• Limiting order lifetime to prevent stale executions
• Time-based risk management
• Automatic cleanup of unused conditional orders

Examples

Create expiry that triggers the order

use types::api::submit_order::ConditionalExpiry;

// Trigger order at Unix timestamp 1747313713 (regardless of price condition)
let trigger_expiry = ConditionalExpiry {
    timestamp: 1747313713,
    trigger: true,
};

// Or using convenience constructor
let trigger_expiry = ConditionalExpiry::trigger_at(1747313713);

Create expiry that cancels the order

use types::api::submit_order::ConditionalExpiry;

// Cancel order at Unix timestamp 1747313713 if not yet triggered
let cancel_expiry = ConditionalExpiry {
    timestamp: 1747313713,
    trigger: false,
};

// Or using convenience constructor
let cancel_expiry = ConditionalExpiry::cancel_at(1747313713);

Using the builder pattern

use types::api::submit_order::ConditionalExpiry;

let expiry = ConditionalExpiry::builder()
    .timestamp(1747313713)
    .trigger_on_expiry()
    .build()
    .expect("Failed to build expiry");

JSON Examples

Trigger on expiry (full field names):

{
  "expiry_timestamp": 1747313713,
  "expiry_trigger": true
}

Cancel on expiry (using aliases):

{
  "e": 1747313713,
  "et": false
}

Fields

timestamp: u128

Unix timestamp (milliseconds since epoch) when the expiration should occur.

When this timestamp is reached, the conditional order will either be triggered or canceled based on the trigger field value.

Format

• Must be a valid Unix timestamp in milliseconds
• Should be in the future relative to order submission time
• Precision is at the millisecond level

Validation

• Must be a positive integer
• Should be greater than current time when order is submitted
• System may reject timestamps too far in the future

trigger: bool

Determines the action to take when the expiration timestamp is reached.

• true: Trigger the conditional order immediately on expiry
• false: Cancel the conditional order on expiry

Trigger on Expiry (true)

The order will be immediately executed as if the trigger condition was met, bypassing the original price condition. This is useful for:

• Deadline-based execution strategies
• Ensuring order execution by a specific time
• Market close or session-end orders

Cancel on Expiry (false)

The order will be removed from the system without execution. This is useful for:

• Preventing stale order execution
• Limiting order exposure duration
• Time-based risk management

Implementations

impl ConditionalExpiry

pub fn builder() -> ConditionalExpiryBuilder

Create a new ConditionalExpiryBuilder

pub fn trigger_at(timestamp: u128) -> ConditionalExpiry

Create a ConditionalExpiry that triggers on expiry

pub fn cancel_at(timestamp: u128) -> ConditionalExpiry

Create a ConditionalExpiry that cancels on expiry

Trait Implementations

impl Clone for ConditionalExpiry

fn clone(&self) -> ConditionalExpiry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ConditionalExpiry

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ConditionalExpiry

fn deserialize<__D>( __deserializer: __D, ) -> Result<ConditionalExpiry, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for ConditionalExpiry

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

where __S: Serializer,

Serialize this value into the given Serde serializer.