1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
/******************************************************************************
Author: Joaquín Béjar García
Email: jb@taunais.com
Date: 24/12/25
******************************************************************************/
//! # Leg Module
//!
//! This module provides types for representing different kinds of trading legs
//! (positions) in multi-instrument strategies. It enables strategies that combine
//! options with underlying assets, futures, or perpetual contracts.
//!
//! ## Overview
//!
//! The module introduces a `Leg` enum that unifies different position types:
//!
//! - **Option** - Standard option positions (Call/Put) via existing `Position`
//! - **Spot** - Direct ownership of underlying assets
//! - **Future** - Exchange-traded futures contracts
//! - **Perpetual** - Crypto perpetual swap contracts
//!
//! ## Key Types
//!
//! - `Leg` - Unified enum for all leg types
//! - `SpotPosition` - Spot/underlying asset position
//! - `FuturePosition` - Futures contract position
//! - `PerpetualPosition` - Perpetual swap position
//! - `MarginType` - Cross vs Isolated margin mode
//!
//! ## Traits
//!
//! - `LegAble` - Common interface for all leg types
//! - `Marginable` - For positions with margin requirements
//! - `Fundable` - For positions with funding rate payments
//! - `Expirable` - For positions with expiration dates
//!
//! ## Example: Covered Call Strategy
//!
//! ```rust
//! # fn main() -> Result<(), optionstratlib::error::Error> {
//! use optionstratlib::model::leg::{Leg, SpotPosition};
//! use optionstratlib::model::Position;
//! use optionstratlib::model::types::Side;
//! use positive::{Positive, pos_or_panic};
//!
//! // Long 100 shares of stock
//! let spot = SpotPosition::long("AAPL".to_string(), Positive::HUNDRED, pos_or_panic!(150.0));
//! let spot_leg = Leg::Spot(spot);
//!
//! // The option leg would be created from a Position
//! // let call_leg = Leg::option(short_call_position);
//!
//! // Both legs can be handled uniformly via LegAble trait
//! use optionstratlib::model::leg::LegAble;
//! tracing::info!("Spot delta: {}", spot_leg.delta()?);
//! # Ok(())
//! # }
//! ```
//!
//! ## Example: Cash & Carry Arbitrage (Crypto)
//!
//! ```rust
//! # fn main() -> Result<(), optionstratlib::error::Error> {
//! use optionstratlib::model::leg::{Leg, SpotPosition, PerpetualPosition, MarginType};
//! use optionstratlib::model::types::Side;
//! use positive::{Positive, pos_or_panic};
//! use rust_decimal_macros::dec;
//! use chrono::Utc;
//!
//! // Long 1 BTC spot
//! let spot = SpotPosition::long("BTC".to_string(), Positive::ONE, pos_or_panic!(50000.0));
//!
//! // Short 1 BTC perpetual (delta neutral)
//! let perp = PerpetualPosition::short(
//! "BTC-USDT-PERP".to_string(),
//! Positive::ONE,
//! pos_or_panic!(50000.0),
//! Positive::ONE, // 1x leverage for delta neutral
//! pos_or_panic!(50000.0),
//! );
//!
//! let spot_leg = Leg::Spot(spot);
//! let perp_leg = Leg::Perpetual(perp);
//!
//! // Net delta should be approximately zero
//! use optionstratlib::model::leg::LegAble;
//! let net_delta = spot_leg.delta()? + perp_leg.delta()?;
//! assert_eq!(net_delta, rust_decimal::Decimal::ZERO);
//! # Ok(())
//! # }
//! ```
//!
//! ## Strategies Enabled
//!
//! ### Traditional Markets
//! - Covered Call (Spot + Short Call)
//! - Protective Put (Spot + Long Put)
//! - Collar (Spot + Long Put + Short Call)
//! - Synthetic positions
//!
//! ### Crypto Markets
//! - Cash & Carry (Spot + Short Perp)
//! - Basis Trade (Spot + Short Future)
//! - Delta Neutral Funding (Spot + Short Perp equal size)
//! - Hedged Perpetual (Perp + Options)
pub use FuturePosition;
pub use Leg;
pub use ;
pub use SpotPosition;
pub use ;