Futures Contract Fields and Rules

Article NautilusTrader

Summary

This reference explains how a dated, exchange-traded futures contract is represented. It describes identifiers, underlying, activation and expiration times, currency, price precision and increments, multiplier, lot size, margin settings, quantity and price limits, tick schemes, and event timestamps. It also notes default or fixed values for whole-contract sizing and optional limits.

The behavioral details clarify that this contract type is non-inverse, uses one currency for quote and settlement, and permits zero or negative prices. The examples show how to define an equity index future in Rust and Python, while related references distinguish continuous futures and crypto futures. This is an instrument-data specification rather than a trading strategy: it provides no performance evidence, valuation method, or guidance on selecting contracts. Adapter metadata and venue details may vary by source.

Key ideas

A futures contract record includes its underlying, trading dates, currency, price increments, multiplier, and lot size.
Standard futures here use whole-contract sizing with an increment of one.
The contract uses the same currency for quoting, settlement, and cost conventions, and it is not inverse.
Prices may be zero or negative, so data handling should allow those values.
Dated crypto futures use a separate contract type when underlying and settlement currencies differ.

Tags

Futures Derivatives pricing

Full text

# Futures Contract


# Futures Contract

`FuturesContract` represents a dated, exchange-traded futures contract with a defined
underlying, activation time, expiration time, currency, multiplier, and lot size.

Examples include equity index futures, commodity futures, interest-rate futures, and
currency futures.

## Fields

| Field             | Rust type          | Python type        | Required/default | Notes                                    |
| ----------------- | ------------------ | ------------------ | ---------------- | ---------------------------------------- |
| `instrument_id`   | `InstrumentId`     | `InstrumentId`     | Required         | Stored as `id` in Rust.                  |
| `raw_symbol`      | `Symbol`           | `Symbol`           | Required         | Native venue symbol.                     |
| `asset_class`     | `AssetClass`       | `AssetClass`       | Required         | Asset class of the underlying.           |
| `exchange`        | `Option<Ustr>`     | `str \| None`      | `None`           | Exchange MIC or venue code when known.   |
| `underlying`      | `Ustr`             | `str`              | Required         | Underlying asset, index, or product.     |
| `activation_ns`   | `UnixNanos`        | `int`              | Required         | Contract activation timestamp.           |
| `expiration_ns`   | `UnixNanos`        | `int`              | Required         | Contract expiration timestamp.           |
| `currency`        | `Currency`         | `Currency`         | Required         | Quote and settlement currency.           |
| `price_precision` | `u8`               | `int`              | Required         | Decimal places allowed for prices.       |
| `price_increment` | `Price`            | `Price`            | Required         | Smallest valid price step.               |
| `size_precision`  | `u8`               | `int`              | Fixed `0`        | Futures trade in whole contracts.        |
| `size_increment`  | `Quantity`         | `Quantity`         | Fixed `1`        | Minimum contract size step.              |
| `multiplier`      | `Quantity`         | `Quantity`         | Required         | Contract multiplier.                     |
| `lot_size`        | `Quantity`         | `Quantity`         | Required         | Rounded lot or contract lot size.        |
| `margin_init`     | `Option<Decimal>`  | `Decimal \| None`  | `0`              | Initial margin rate.                     |
| `margin_maint`    | `Option<Decimal>`  | `Decimal \| None`  | `0`              | Maintenance margin rate.                 |
| `max_quantity`    | `Option<Quantity>` | `Quantity \| None` | `None`           | Maximum order quantity.                  |
| `min_quantity`    | `Option<Quantity>` | `Quantity \| None` | `1`              | Minimum order quantity.                  |
| `max_price`       | `Option<Price>`    | `Price \| None`    | `None`           | Maximum valid quote or order price.      |
| `min_price`       | `Option<Price>`    | `Price \| None`    | `None`           | Minimum valid quote or order price.      |
| `tick_scheme`     | `Option<Ustr>`     | `str \| None`      | `None`           | Registered variable tick scheme name.    |
| `info`            | `Option<Params>`   | `dict \| None`     | `None`           | Adapter metadata.                        |
| `ts_event`        | `UnixNanos`        | `int`              | Required         | Event timestamp in nanoseconds.          |
| `ts_init`         | `UnixNanos`        | `int`              | Required         | Initialization timestamp in nanoseconds. |

*Note: Python constructors use `instrument_id`; Rust stores the same value as `id`.*

## Behavior

- `FuturesContract` has instrument class `Future`.
- It is never inverse. Cost, settlement, and quote currency use `currency`.
- Prices can be zero or negative.
- It trades in whole contracts with size precision `0` and size increment `1`.
- Use `CryptoFuture` for dated crypto futures where the underlying and settlement
  currencies can differ.

## Example

```rust tab="Rust"
use jiff::Timestamp;
use nautilus_core::UnixNanos;
use nautilus_model::{
    enums::AssetClass,
    identifiers::{InstrumentId, Symbol},
    instruments::FuturesContract,
    types::{Currency, Price, Quantity},
};
use ustr::Ustr;

let activation: Timestamp = "2021-09-10T00:00:00Z".parse().unwrap();
let expiration: Timestamp = "2021-12-17T00:00:00Z".parse().unwrap();

let esz21 = FuturesContract::builder()
    .instrument_id(InstrumentId::from("ESZ21.GLBX"))
    .raw_symbol(Symbol::from("ESZ21"))
    .asset_class(AssetClass::Index)
    .exchange(Ustr::from("XCME"))
    .underlying(Ustr::from("ES"))
    .activation_ns(UnixNanos::from(activation))
    .expiration_ns(UnixNanos::from(expiration))
    .currency(Currency::from("USD"))
    .price_precision(2)
    .price_increment(Price::from("0.25"))
    .multiplier(Quantity::from("1"))
    .lot_size(Quantity::from("1"))
    .ts_event(UnixNanos::default())
    .ts_init(UnixNanos::default())
    .build()
    .unwrap();
```

```python tab="Python"
import pandas as pd

from nautilus_trader.model import AssetClass
from nautilus_trader.model import Currency
from nautilus_trader.model import FuturesContract
from nautilus_trader.model import InstrumentId
from nautilus_trader.model import Price
from nautilus_trader.model import Quantity
from nautilus_trader.model import Symbol

esz21 = FuturesContract(
    instrument_id=InstrumentId.from_str("ESZ21.GLBX"),
    raw_symbol=Symbol("ESZ21"),
    asset_class=AssetClass.INDEX,
    underlying="ES",
    activation_ns=pd.Timestamp("2021-09-10", tz="UTC").value,
    expiration_ns=pd.Timestamp("2021-12-17", tz="UTC").value,
    currency=Currency.from_str("USD"),
    price_precision=2,
    price_increment=Price.from_str("0.25"),
    multiplier=Quantity.from_int(1),
    lot_size=Quantity.from_int(1),
    ts_event=0,
    ts_init=0,
    exchange="XCME",
)
```

## Adapters

Representative adapters that create or consume `FuturesContract` instruments include:

- [Databento](../../integrations/databento.md) for futures reference data and market data.
- [Interactive Brokers](../../integrations/interactive_brokers.md) for listed futures contracts.

## Related guides

- [Continuous Futures](../continuous_futures.md) covers roll-adjusted futures series.
- [Crypto Future](crypto_future.md) covers dated crypto futures contracts.

Shown in full with attribution under the source's licence. Licence: LGPL-3.0

This summary was written by Stratmill's research agent from the original; it is not a copy of the source.

Futures Contract Fields, Trading Rules, and Currency Conventions

Summary

Key ideas

Tags