marginism 0.1.0__py3-none-any.whl

marginism/README.md

@@ -0,0 +1,193 @@
+# marginism
+
+Compute **NSE / NSCCL SPAN margins** directly from the exchange's daily
+CME-SPAN risk-parameter files (`.spn`, XML `fileFormat 4.00`), the same inputs a
+broker's margin calculator uses.
+
+`spanrisk.xml` in this folder is the **XSD schema** that documents the `.spn`
+format; this library implements the SPAN algorithm against files that conform to
+it (e.g. `nsccl.YYYYMMDD.s.spn`).
+
+## Why this works without an option pricer
+
+Each contract in a `.spn` file ships a **precomputed 16-scenario risk array** —
+the per-unit profit/loss under 16 combinations of price move (±1/3, ±2/3, ±3/3
+of the scan range, plus two "extreme" moves) and volatility up/down. SPAN margin
+is therefore pure arithmetic over those arrays; no Black-Scholes is needed at
+calculation time.
+
+## The SPAN calculation
+
+Per **combined commodity** (one underlying — futures + options margined
+together):
+
+```
+span_risk = max( scan_risk
+                 + calendar (intra-commodity) spread charge
+                 + spot/delivery charge          # 0 in NSCCL files
+                 - inter-commodity spread credit  # 0 in NSCCL files
+               , short_option_minimum )
+```
+
+* **Scan risk** — the largest portfolio loss across the 16 scenarios:
+  `max_j Σ (signed_qty × risk_array[j])`.
+* **Calendar spread charge** — scan assumes all expiries move together, so a
+  flat charge is added back for the basis risk of long-near / short-far
+  positions (`dSpread` definitions, method `F`).
+* **Short option minimum (SOM)** — a floor for short-option books
+  (`som_rate = 0` in these NSCCL files).
+
+A broker's **initial margin = SPAN margin + Exposure (ELM) margin**. Exposure
+margin is *not* in the SPAN file (it's an exchange % of notional), so it is
+configured in `ExposureConfig` and applied to futures and short options.
+
+## Install / layout
+
+Pure standard library (Python 3.8+), no dependencies. Drop the `marginism/`
+folder on your path (or `pip install -e .`).
+
+## Pointing to your `.spn` file
+
+You just give the path. Same folder or a different folder, macOS or Windows:
+
+```python
+# Same folder as your script
+SPN = "nsccl.20260529.s.spn"
+
+# Different folder — macOS / Linux (forward slashes)
+SPN = "/Users/you/Downloads/nsccl.20260529.s.spn"
+
+# Different folder — Windows (use a raw string r"..." or forward slashes)
+SPN = r"C:\Users\you\Downloads\nsccl.20260529.s.spn"
+SPN = "C:/Users/you/Downloads/nsccl.20260529.s.spn"
+```
+
+## Quick start
+
+```python
+from marginism import SpanCalculator, Position
+
+calc = SpanCalculator.from_file(
+    SPN,
+    symbols=["NIFTY", "RELIANCE"],   # parse only what you need (fast / light)
+)
+
+result = calc.calculate([
+    # quantity is entered DIRECTLY in units: NIFTY lot size 65 -> 65 = 1 lot,
+    # 130 = 2 lots. long +, short -
+    Position("NIFTY", "CE", quantity=-65, expiry="20260630", strike=24000),
+    Position("NIFTY", "PE", quantity=-65, expiry="20260630", strike=24000),
+])
+
+print(result.summary())
+print(result.marginism, result.exposure_margin, result.total_margin)
+```
+
+## Order-style API (single or multiple legs)
+
+`RiskEngine` accepts orders by `tradingsymbol` and returns a broker-style dict
+(per-leg + consolidated `initial`/`final` + `margin_benefit`). **Pure local
+computation — no network, no service.**
+
+```python
+from marginism import RiskEngine
+
+eng = RiskEngine.from_file(SPN)
+
+# one leg or many — a single order is just a basket of size one
+res = eng.basket([
+    {"exchange": "NFO", "tradingsymbol": "NIFTY26JUNFUT",
+     "transaction_type": "BUY", "quantity": 65},
+    {"exchange": "NFO", "tradingsymbol": "NIFTY26JUN23000PE",
+     "transaction_type": "BUY", "quantity": 65},
+])
+data = res["data"]
+print(data["final"]["total"], data["margin_benefit"])
+```
+
+`quantity` is entered **directly in units** (e.g. 65 for one NIFTY lot, 130 for
+two); `transaction_type` is `BUY`/`SELL`. The engine is exchange-agnostic — load
+an NFO, CDS, or MCX `.spn` file.
+
+### Two symbol formats, plus explicit fields
+
+A contract can be named two equivalent ways, and both resolve automatically:
+
+| Style | Future | Option |
+|---|---|---|
+| compact   | `NIFTY26JUNFUT`    | `NIFTY26JUN23700CE` (monthly), `NIFTY2660223700CE` (weekly) |
+| full-date | `NIFTY30JUN26FUT`  | `NIFTY30JUN2623700CE` |
+
+Or skip tradingsymbols and pass fields directly:
+
+```python
+eng.basket([
+    {"symbol": "NIFTY", "instrument": "CE", "expiry": "2026-06-30",
+     "strike": 23700, "transaction_type": "SELL", "quantity": 65},
+])
+```
+
+## Command line
+
+```bash
+python -m marginism <file.spn> --list                 # all symbols
+python -m marginism <file.spn> --info NIFTY            # contracts/expiries
+python -m marginism <file.spn> \
+    --pos NIFTY:FUT:-65:20260630 \
+    --pos NIFTY:CE:65:20260630:24000                     # margin for positions
+```
+
+## Important notes
+
+* **Lot sizes are not in the SPAN file.** It works in underlying units, so enter
+  `quantity` directly in units (NIFTY 65 = 1 lot, 130 = 2 lots).
+* **No exchange tokens in the file.** Instruments are keyed by *trading symbol*
+  (`cc` / `pfCode`, e.g. `RELIANCE`), with internal `pfId`/`cId` ids that are
+  **not** NSE tokens. Map a token (e.g. `2885` → `RELIANCE`) via a separate
+  instrument master before calling this library.
+* **Exposure rates** in `ExposureConfig` are NSE defaults (index 2%, stock
+  ~3.5%); override per circular via `overrides={"RELIANCE": 0.05}`.
+* **Long options** carry no exposure margin (risk capped at premium); their
+  risk array still participates in the portfolio scan so hedges net correctly.
+* `net_option_value` is the mark-to-market value of option legs (premium):
+  negative when net short (premium received), positive when net long.
+
+## Module map
+
+| Module          | Responsibility                                            |
+|-----------------|-----------------------------------------------------------|
+| `parser.py`     | streaming `iterparse` of `.spn` → data model (symbol filter) |
+| `model.py`      | dataclasses: `SpanFile`, `CombinedCommodity`, contracts, risk arrays |
+| `algorithm.py`  | SPAN math: scan risk, calendar spreads, SOM, net option value |
+| `portfolio.py`  | `Position` input + expiry normalisation                   |
+| `exposure.py`   | exposure / ELM configuration (index 2% / stock 3.5%)      |
+| `calculator.py` | `SpanCalculator` — load once, evaluate many portfolios    |
+| `symbols.py`    | tradingsymbol ⇄ SPAN contract resolution                  |
+| `api.py`        | `RiskEngine` — `basket()`/`orders()`, single or many legs |
+| `cli.py`        | `python -m marginism`                                   |
+
+100% standard library, runs fully offline — give it a `.spn` file and call a
+function.
+
+## Reference
+
+- NSE Clearing — NSCCL SPAN:
+  https://www.nseclearing.in/risk-management/equity-derivatives/nsccl-span
+
+## Disclaimer
+
+The software is provided "as is", without warranty of any kind. The author
+accepts **no responsibility or liability for any errors or inaccuracies in the
+calculations, or for any trading losses, damages, or decisions** arising from its
+use. Margins depend on the SPAN file and exposure rates you supply, may differ
+from your broker's, and must be independently verified before trading. Not
+financial advice; use at your own risk.
+
+This is an independent project built by an independent developer. It is **not
+affiliated with, sponsored by, endorsed by, or connected to** NSE, NSE Clearing
+(NSCCL), the Chicago Mercantile Exchange (CME), or any broker or exchange.
+
+SPAN® is a registered trademark of Chicago Mercantile Exchange Inc. All other
+trademarks are the property of their respective owners. Any names are used only
+for identification/descriptive purposes (nominative use) and do not imply any
+affiliation, endorsement, or license.

marginism/__init__.py

@@ -0,0 +1,62 @@
+"""marginism — compute NSE/NSCCL SPAN margins from CME-SPAN ``.spn`` files.
+
+Quick start
+-----------
+>>> from marginism import SpanCalculator, Position
+>>> calc = SpanCalculator.from_file(
+...     "nsccl.20260529.s/nsccl.20260529.s.spn", symbols=["NIFTY"])
+>>> res = calc.calculate([
+...     Position("NIFTY", "FUT", quantity=65, expiry="20260630"),
+... ])
+>>> print(res.summary())
+
+The ``.spn`` file ships precomputed 16-scenario risk arrays, so margin is pure
+arithmetic — no option pricing involved.  ``quantity`` is in underlying units
+that you enter directly (NIFTY lot size 65 -> pass 65 for one lot, 130 for two);
+long is positive, short negative.
+"""
+
+from .algorithm import CommodityResult, ResolvedPosition, compute_commodity
+from .calculator import MarginResult, PositionResult, SpanCalculator
+from .exposure import ExposureConfig
+from .model import (
+    CalendarSpread,
+    CombinedCommodity,
+    Contract,
+    FuturesContract,
+    OptionContract,
+    RiskArray,
+    SpanFile,
+    SCENARIO_LABELS,
+)
+from .parser import parse_spn
+from .portfolio import Position, normalize_expiry
+from .api import RiskEngine
+from .symbols import SymbolResolver, build_symbol_index
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "SpanCalculator",
+    "MarginResult",
+    "PositionResult",
+    "Position",
+    "ExposureConfig",
+    "RiskEngine",
+    "SymbolResolver",
+    "build_symbol_index",
+    "SpanFile",
+    "CombinedCommodity",
+    "Contract",
+    "FuturesContract",
+    "OptionContract",
+    "CalendarSpread",
+    "RiskArray",
+    "SCENARIO_LABELS",
+    "ResolvedPosition",
+    "CommodityResult",
+    "compute_commodity",
+    "parse_spn",
+    "normalize_expiry",
+    "__version__",
+]

marginism/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

marginism/algorithm.py

@@ -0,0 +1,175 @@
+"""The SPAN risk algorithm, evaluated over precomputed risk arrays.
+
+Per combined commodity the SPAN risk requirement is::
+
+    span_risk = max( scan_risk
+                     + intracommodity (calendar) spread charge
+                     + spot/delivery charge
+                     - intercommodity spread credit ,
+                     short_option_minimum )
+
+For NSCCL equity & index F&O the file carries no intercommodity credits and a
+zero spot charge, so those terms are zero unless present.  Scan risk and the
+calendar-spread charge are the active components.
+
+Inputs are *resolved positions*: each open position already matched to a
+contract's risk array, with a signed quantity in underlying units.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Tuple
+
+from .model import (
+    CalendarSpread,
+    CombinedCommodity,
+    Contract,
+    OptionContract,
+    SCENARIO_LABELS,
+)
+
+
+@dataclass
+class ResolvedPosition:
+    contract: Contract
+    quantity: float          # signed, in underlying units
+
+
+@dataclass
+class CommodityResult:
+    symbol: str
+    scan_risk: float = 0.0
+    worst_scenario: int = 0
+    worst_scenario_label: str = ""
+    calendar_spread_charge: float = 0.0
+    spot_charge: float = 0.0
+    intercommodity_credit: float = 0.0
+    short_option_minimum: float = 0.0
+    span_risk: float = 0.0           # the SPAN margin for this commodity
+    net_option_value: float = 0.0    # market value of option positions
+    scenario_losses: List[float] = field(default_factory=list)
+    notes: List[str] = field(default_factory=list)
+
+
+def _scan_risk(positions: List[ResolvedPosition]) -> Tuple[float, int, List[float]]:
+    """Largest portfolio loss across the 16 scenarios.
+
+    Returns (scan_risk, worst_scenario_index, per_scenario_losses).
+    """
+    losses = [0.0] * 16
+    for p in positions:
+        ra = p.contract.risk_array.values
+        q = p.quantity
+        for j in range(16):
+            losses[j] += q * ra[j]
+    worst = max(range(16), key=lambda j: losses[j])
+    scan = max(0.0, losses[worst])
+    return scan, worst, losses
+
+
+def _net_delta_by_expiry(positions: List[ResolvedPosition]) -> Dict[str, float]:
+    """Composite-delta-weighted net position per expiry (in delta units)."""
+    deltas: Dict[str, float] = {}
+    for p in positions:
+        pe = p.contract.expiry
+        cd = p.contract.risk_array.composite_delta
+        deltas[pe] = deltas.get(pe, 0.0) + p.quantity * cd
+    return deltas
+
+
+def _calendar_spread_charge(
+    spreads: List[CalendarSpread], net_delta: Dict[str, float]
+) -> float:
+    """Flat-rate intra-commodity (calendar) spread charge.
+
+    Spreads are evaluated in priority order.  A spread between expiry A and B
+    forms only when the two legs carry *opposite* signed delta (one net long,
+    one net short).  The number of spreads is the smaller of the two
+    ratio-adjusted leg deltas; the charge is ``spreads * rate`` (method 'F').
+    Matched delta is consumed so later spreads see the remainder.
+    """
+    remaining = dict(net_delta)
+    total = 0.0
+    for spread in spreads:
+        if spread.charge_method not in ("F", "P"):
+            # 'W' (weighted-price) not used by NSCCL files; skip if it appears.
+            continue
+        if len(spread.legs) < 2:
+            continue
+        leg_a = next((l for l in spread.legs if l.side == "A"), spread.legs[0])
+        leg_b = next((l for l in spread.legs if l.side == "B"), spread.legs[1])
+        da = remaining.get(leg_a.expiry, 0.0)
+        db = remaining.get(leg_b.expiry, 0.0)
+        if da == 0.0 or db == 0.0:
+            continue
+        # opposite signs => a genuine calendar spread
+        if (da > 0) == (db > 0):
+            continue
+        ratio_a = leg_a.ratio or 1.0
+        ratio_b = leg_b.ratio or 1.0
+        n = min(abs(da) / ratio_a, abs(db) / ratio_b)
+        if n <= 0:
+            continue
+        total += n * spread.rate
+        # consume matched delta toward zero
+        remaining[leg_a.expiry] = da - (1 if da > 0 else -1) * n * ratio_a
+        remaining[leg_b.expiry] = db - (1 if db > 0 else -1) * n * ratio_b
+    return total
+
+
+def _short_option_minimum(
+    commodity: CombinedCommodity, positions: List[ResolvedPosition]
+) -> float:
+    """SOM = som_rate * total short option units (NSCCL ships som_rate=0)."""
+    if commodity.som_rate <= 0:
+        return 0.0
+    short_units = 0.0
+    for p in positions:
+        if isinstance(p.contract, OptionContract) and p.quantity < 0:
+            short_units += abs(p.quantity)
+    return commodity.som_rate * short_units
+
+
+def _net_option_value(positions: List[ResolvedPosition]) -> float:
+    nov = 0.0
+    for p in positions:
+        if isinstance(p.contract, OptionContract):
+            nov += p.quantity * p.contract.price * p.contract.cvf
+    return nov
+
+
+def compute_commodity(
+    commodity: CombinedCommodity, positions: List[ResolvedPosition]
+) -> CommodityResult:
+    """Run the SPAN algorithm for one combined commodity."""
+    res = CommodityResult(symbol=commodity.cc)
+    if not positions:
+        return res
+
+    scan, worst, losses = _scan_risk(positions)
+    res.scan_risk = scan
+    res.worst_scenario = worst + 1  # 1-based for reporting
+    res.worst_scenario_label = SCENARIO_LABELS[worst]
+    res.scenario_losses = losses
+
+    net_delta = _net_delta_by_expiry(positions)
+    res.calendar_spread_charge = _calendar_spread_charge(
+        commodity.spreads, net_delta
+    )
+    res.short_option_minimum = _short_option_minimum(commodity, positions)
+    res.net_option_value = _net_option_value(positions)
+
+    risk = (
+        res.scan_risk
+        + res.calendar_spread_charge
+        + res.spot_charge
+        - res.intercommodity_credit
+    )
+    risk = max(risk, res.short_option_minimum)
+    # CME SPAN: Total requirement = SPAN risk - Net Option Value.
+    # NOV is negative for net-short options (premium owed) -> raises margin;
+    # positive for net-long options (premium owned) -> lowers margin toward 0,
+    # which is why long options need only the premium, not SPAN.
+    res.span_risk = max(0.0, risk - res.net_option_value)
+    return res

marginism/api.py

@@ -0,0 +1,198 @@
+"""High-level margins API — plain Python functions, computed locally.
+
+Anyone with a SPAN ``.spn`` file can compute margins offline:
+
+    from marginism import RiskEngine
+    eng = RiskEngine.from_file("nsccl.20260529.s.spn")
+    result = eng.basket([
+        {"tradingsymbol": "NIFTY26JUN23700CE", "transaction_type": "SELL",
+         "quantity": 65},
+    ])
+
+Works for a **single leg or many legs** — a single order is just a basket of
+size one. ``basket()``/``orders()`` take a list of order dicts (``exchange``,
+``tradingsymbol``, ``transaction_type``, ``quantity`` ...) and return per-leg
+figures plus consolidated ``initial``/``final`` and the hedging
+``margin_benefit``. The result dict uses a standard, broker-style field layout
+(``span``/``exposure``/``option_premium``/``additional``/``total``) so it slots
+into existing tooling — but it is pure local computation, no network, no service.
+
+The engine is exchange-agnostic: point it at any CME-SPAN ``.spn`` file
+(NFO / CDS / MCX) — the algorithm is the same; only the file differs.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from .calculator import SpanCalculator
+from .portfolio import Position
+from .symbols import SymbolResolver
+
+_EMPTY_CHARGES = {
+    "transaction_tax": 0.0,
+    "transaction_tax_type": "",
+    "exchange_turnover_charge": 0.0,
+    "sebi_turnover_charge": 0.0,
+    "brokerage": 0.0,
+    "stamp_duty": 0.0,
+    "gst": {"igst": 0.0, "cgst": 0.0, "sgst": 0.0, "total": 0.0},
+    "total": 0.0,
+}
+
+
+def _leg_block(
+    tradingsymbol: str,
+    exchange: str,
+    span: float,
+    exposure: float,
+    option_premium: float,
+    additional: float,
+    total: float,
+) -> Dict[str, Any]:
+    """One entry in the margins response (per-order or consolidated)."""
+    return {
+        "type": "equity",
+        "tradingsymbol": tradingsymbol,
+        "exchange": exchange,
+        "span": round(span, 2),
+        "exposure": round(exposure, 2),
+        "option_premium": round(option_premium, 2),
+        "additional": round(additional, 2),
+        "bo": 0.0,
+        "cash": 0.0,
+        "var": 0.0,
+        "pnl": {"realised": 0.0, "unrealised": 0.0},
+        "leverage": 1.0,
+        "charges": dict(_EMPTY_CHARGES),
+        "total": round(total, 2),
+    }
+
+
+class RiskEngine:
+    """Compute broker-style margins for baskets of orders against a SPAN file."""
+
+    def __init__(self, calculator: SpanCalculator) -> None:
+        self.calc = calculator
+        self.resolver = SymbolResolver(calculator.span_file)
+
+    @classmethod
+    def from_file(cls, spn_path: str, **kw) -> "RiskEngine":
+        return cls(SpanCalculator.from_file(spn_path, **kw))
+
+    # -- order -> internal Position ------------------------------------
+    def _to_position(self, order: Dict[str, Any]) -> Position:
+        """Accept either a tradingsymbol OR explicit (symbol, expiry, ...).
+
+        Two equivalent ways to specify a leg:
+
+          {"tradingsymbol": "NIFTY26JUN23700CE", "transaction_type": "SELL",
+           "quantity": 65}
+
+          {"symbol": "NIFTY", "instrument": "CE", "expiry": "2026-06-30",
+           "strike": 23700, "transaction_type": "SELL", "quantity": 65}
+        """
+        side = str(order.get("transaction_type", "BUY")).upper()
+        sign = -1 if side in ("SELL", "S") else 1
+        qty = abs(float(order["quantity"])) * sign  # quantity is in units
+
+        ts = order.get("tradingsymbol")
+        if ts:
+            rs = self.resolver.resolve(ts)
+            if rs is None:
+                raise KeyError(f"tradingsymbol not found in SPAN file: {ts}")
+            instr = "FUT" if rs.instrument == "FUT" else (
+                "CE" if rs.instrument == "C" else "PE"
+            )
+            return Position(rs.symbol, instr, quantity=qty,
+                            expiry=rs.expiry, strike=rs.strike)
+
+        # explicit fields (trader-friendly: symbol + expiry + strike + type)
+        symbol = order.get("symbol")
+        if not symbol:
+            raise KeyError("order needs either 'tradingsymbol' or 'symbol'")
+        instr = str(order.get("instrument") or order.get("option_type")
+                    or "FUT").upper()
+        return Position(symbol, instr, quantity=qty,
+                        expiry=order.get("expiry"),
+                        strike=float(order.get("strike", 0) or 0))
+
+    @staticmethod
+    def _label(order: Dict[str, Any]) -> str:
+        """Display name for a leg (tradingsymbol, or built from fields)."""
+        ts = order.get("tradingsymbol")
+        if ts:
+            return ts
+        parts = [str(order.get("symbol", "")), str(order.get("expiry", "")),
+                 str(order.get("strike", "") or ""),
+                 str(order.get("instrument") or order.get("option_type") or "")]
+        return " ".join(p for p in parts if p)
+
+    @staticmethod
+    def _split(result):
+        """Map a MarginResult to (span, exposure, option_premium, additional)."""
+        span = result.marginism
+        exposure = result.exposure_margin
+        additional = result.adhoc_margin
+        # premium *payable* only for net-long options (a debit, not margin)
+        option_premium = max(0.0, result.net_option_value)
+        return span, exposure, option_premium, additional
+
+    def basket(
+        self,
+        orders: List[Dict[str, Any]],
+        consider_positions: bool = True,
+    ) -> Dict[str, Any]:
+        """Consolidated basket margin with hedging benefit (1..N legs)."""
+        positions: List[Position] = []
+        leg_blocks: List[Dict[str, Any]] = []
+
+        # ---- per-leg (standalone) margins -> orders[] ----------------
+        sum_margin_only = 0.0   # span+exposure+additional, excl. premium
+        for order in orders:
+            pos = self._to_position(order)
+            positions.append(pos)
+            r = self.calc.calculate([pos])
+            span, exposure, prem, add = self._split(r)
+            # per-order: a long option's "total" is its premium payable
+            total = span + exposure + add + prem
+            leg = _leg_block(self._label(order), order.get("exchange", "NFO"),
+                             span, exposure, prem, add, total)
+            leg_blocks.append(leg)
+            sum_margin_only += span + exposure + add
+
+        # ---- consolidated basket (with hedging benefit) -> final -----
+        R = self.calc.calculate(positions)
+        c_span, c_exp, c_prem, c_add = self._split(R)
+        # Basket margin = SPAN + exposure + additional. Long-option premium is
+        # already netted into SPAN via -NOV (matches the broker basket total);
+        # it is reported separately in `option_premium`.
+        final_total = c_span + c_exp + c_add
+        final = _leg_block("", "", c_span, c_exp, c_prem, c_add, final_total)
+        initial = dict(final)  # single-snapshot file: initial == final
+
+        # Hedging benefit = margin saved vs holding each leg outright
+        # (margin-only; option premium is a cost, not a margin, so excluded).
+        margin_benefit = round(sum_margin_only - final_total, 2)
+
+        return {
+            "status": "success",
+            "data": {
+                "initial": initial,
+                "final": final,
+                "orders": leg_blocks,
+                "margin_benefit": margin_benefit,
+            },
+        }
+
+    def orders(self, orders: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """Per-order margins, no netting (each leg standalone)."""
+        out = []
+        for order in orders:
+            pos = self._to_position(order)
+            r = self.calc.calculate([pos])
+            span, exposure, prem, add = self._split(r)
+            total = span + exposure + add + prem
+            out.append(_leg_block(self._label(order), order.get("exchange", "NFO"),
+                                  span, exposure, prem, add, total))
+        return {"status": "success", "data": out}