# How the Covered Call Strategy Integrates with SpotPosition in optionstratlib > Discover how the Covered Call strategy integrates with SpotPosition in optionstratlib. Learn how asset leg data combines with short calls for profit loss analysis and break even points. - Repository: [Joaquin Bejar Garcia/optionstratlib](https://github.com/joaquinbejar/optionstratlib) - Tags: how-to-guide - Published: 2026-03-04 --- **The Covered Call strategy integrates with `SpotPosition` by storing the underlying asset leg as a `SpotPosition` struct that provides cost basis, quantity, and delta calculations, which are combined with the short call option to generate profit/loss profiles and break-even points.** The Covered Call is a foundational options strategy that requires precise tracking of the underlying asset to calculate risk metrics and profitability. In the **optionstratlib** crate, the strategy integrates with the `SpotPosition` struct to manage the long stock leg, enabling accurate cost basis tracking, delta calculations, and break-even analysis. Understanding how the Covered Call strategy integrates with `SpotPosition` is essential for implementing custom strategies or extending the library's functionality. ## Creating the Spot Position Leg ### Initialization in CoveredCall::new When constructing a Covered Call strategy, the underlying asset leg is created immediately within the `CoveredCall::new` constructor. The implementation in [`src/strategies/covered_call.rs`](https://github.com/joaquinbejar/optionstratlib/blob/main/src/strategies/covered_call.rs) (lines 69-78) calls `SpotPosition::new` to store the ticker, quantity, cost basis, side (always **Long** for Covered Calls), and associated fees. This initialization establishes the foundation for all subsequent calculations, ensuring the strategy has a concrete reference point for the underlying asset's acquisition cost and position size. ## Accessing the Underlying Leg ### The get_spot_leg() Method To provide a unified interface for strategy consumers, the `CoveredCall` struct implements `get_spot_leg()`, which wraps the internal `SpotPosition` in the generic `Leg::Spot` enum (lines 23-27 in [`src/strategies/covered_call.rs`](https://github.com/joaquinbejar/optionstratlib/blob/main/src/strategies/covered_call.rs)). This abstraction allows risk engines, visualizers, and portfolio managers to treat the spot leg uniformly with option legs (`Leg::Option`), simplifying aggregation and analysis across mixed-asset strategies. ## Core Calculations Using SpotPosition The `SpotPosition` struct serves as the primary data source for critical risk metrics in the Covered Call strategy. The implementation references `self.spot_leg` across multiple calculation domains. ### Cost Basis and Quantity The strategy exposes the underlying asset's financial parameters through direct delegation to the spot leg: - **`underlying_price()`** returns `self.spot_leg.cost_basis` (lines 47-51), representing the initial acquisition price of the shares. - **`quantity()`** returns `self.spot_leg.quantity` (lines 53-57), typically representing the number of shares (e.g., 100 shares per contract). ### Break-Even Analysis The break-even calculation integrates the spot leg's cost basis with the option premium received. The `effective_cost_basis()` method (lines 73-81) subtracts the premium per share from the spot cost basis, while `break_even_points()` (lines 80-93) uses this adjusted value to determine the price level where the strategy becomes profitable. ### Greeks and Delta Calculation For risk sensitivity analysis, the `net_delta()` method (lines 59-66) combines the spot leg's delta (always 1.0 for long stock) with the short call's delta. This aggregation provides the total directional exposure of the strategy, critical for portfolio hedging. ### Profit and Loss Computation The P&L calculation unifies both legs through `self.spot_leg.pnl_at_price` (lines 34-38), which computes the underlying asset's profit or loss at a given price point, combined with the option leg's P&L to produce the strategy's total profitability. ## Aggregating Strategy Legs The `get_legs()` method (lines 35-39) returns a `Vec` containing both the spot leg and the option leg, enabling consumers to view the complete position composition. This aggregation supports portfolio-level risk analysis and visualization tools that need to iterate over all components of a multi-leg strategy. ## Summary - The Covered Call strategy integrates with `SpotPosition` through the `CoveredCall::new` constructor, which initializes the underlying asset leg with cost basis, quantity, and fees. - The `get_spot_leg()` method wraps `SpotPosition` in the `Leg::Spot` enum, providing a unified interface for strategy aggregation. - Core calculations—including break-even points, effective cost basis, net delta, and P&L—directly reference `self.spot_leg` to combine underlying asset metrics with option premium and greeks. - The `get_legs()` method exposes both the spot and option legs as a unified vector, supporting portfolio risk engines and visualization tools. ## Frequently Asked Questions ### How is the SpotPosition initialized in a Covered Call strategy? The `SpotPosition` is created inside `CoveredCall::new` in [`src/strategies/covered_call.rs`](https://github.com/joaquinbejar/optionstratlib/blob/main/src/strategies/covered_call.rs) (lines 69-78) by calling `SpotPosition::new` with the ticker, quantity, cost basis, side set to **Long**, and transaction fees. This establishes the underlying asset leg that defines the strategy's risk profile. ### What methods use the SpotPosition for risk calculations? Key methods include `underlying_price()` and `quantity()` for basic position data, `effective_cost_basis()` and `break_even_points()` for profitability analysis, `net_delta()` for greeks aggregation, and the P&L computation which calls `self.spot_leg.pnl_at_price`. All reference `self.spot_leg` directly. ### How does the Covered Call expose the spot leg to external consumers? The `get_spot_leg()` method returns the `SpotPosition` wrapped in the `Leg::Spot` enum variant, while `get_legs()` returns a vector containing both the spot and option legs. This allows risk engines and visualization tools to treat the underlying asset uniformly with other strategy components. ### Why must the SpotPosition side always be Long in a Covered Call? By definition, a Covered Call requires owning the underlying asset to "cover" the short call option. The implementation enforces this by creating the `SpotPosition` with side **Long** in `CoveredCall::new`, ensuring the strategy has the necessary shares to fulfill potential assignment obligations.