QuantConnect

QuantConnect was founded in 2012 to serve quants everywhere with the best possible algorithmic trading technology. Seeking to disrupt a notoriously closed-source industry, QuantConnect takes a radically open-source approach to algorithmic trading. Through the QuantConnect web platform, more than 50,000 quants are served every month.

You don't need any special code to utilize the US Futures Security Master. It automatically loads when you request US Futures data.

The following table describes the dataset properties:

The US Futures Security Master enables you to design strategies harnessing continuous Futures contracts. Examples include the following strategies:

• Trading cyclical patterns in commodity Futures.
• Buying gold Futures as an inflation hedge with automatic contract roll overs.
• Detecting arbitrage opportunities between index Futures and Equities.

The US Futures Security Master dataset provides SymbolChangedEvent objects, which have the following attributes:

The US Futures Security Master lets you to construct continuous Futures, allowing the access of normalized historical data of the underlying assets, as well as trading the “lead” Future contracts for those assets.

Continuous Futures refer to sets of rolling lead Future contracts during their actively trading periods. Since Future contracts expire at their maturities, to analyze the historical price of a Future and to apply technical indicators, you need the continuous Future price series.

To access the continuous Future, use the Future's Symbolsymbol property.

future = self.add_future(Futures.Energies.CrudeOilWTI,
    dataNormalizationMode = DataNormalizationMode.BACKWARDS_RATIO,
    dataMappingMode = DataMappingMode.OPEN_INTEREST,
    contractDepthOffset = 0)
self.continuous_contract_symbol = future.symbol

var future = AddFuture(Futures.Energies.CrudeOilWTI,
    dataNormalizationMode: DataNormalizationMode.BackwardsRatio,
    dataMappingMode: DataMappingMode.OpenInterest,
    contractDepthOffset: 0
);
_continuousFutureSymbol = future.Symbol;

The dataNormalizationMode and dataMappingMode arguments makes the transition of the underlying contracts seemless. However, the Future Symbol doesn't map to an underlying Future contract. It works fine to trade within backtests, but could be subjected to friction costs during live trading since the order price could be a normalized price. For more information about this topic, see the Live Trading Considerations section.

The data normalization mode defines how the price series of two contracts are stitched together when the contract rollovers occur. The DataNormalizatoinMode enumeration has the following members available for continuous contracts:

If you use a data normalization mode that's not in the preceding list, LEAN automatically converts it to DataNormalizationMode.BackwardsRatio.

The data mapping mode defines when contract rollovers occur. The DataMappingMode enumeration has the following members:

As the contracts roll over, the Mappedmapped property of the Future object references the next contract in the series and you receive a SymbolChangedEvent. To get the current Symbol change events, index the SymbolChangedEventssymbol_changed_events property of the current Slice with the continuous Futures Symbol. Slice objects deliver unique events to your algorithm as they happen, but the Slice may not contain data for your Future at every time step. To avoid issues, check if the Slice contains the data you want before you index it.

def on_data(self, slice: Slice) -> None:
    changed_event = slice.symbol_changed_events.get(self.continuous_future_symbol)
    if changed_event:
        old_symbol = changed_event.old_symbol
        new_symbol = changed_event.new_symbol
        tag = f"Rollover - Symbol changed at {self.time}: {old_symbol} -> {new_symbol}"
        quantity = self.portfolio[old_symbol].quantity

        # Rolling over: to liquidate any position of the old mapped contract and switch to the newly mapped contract
        self.liquidate(old_symbol, tag = tag)
        if quantity != 0: self.market_order(new_symbol, quantity, tag = tag)
        self.log(tag)

public override void OnData(Slice slice)
{
    if (slice.SymbolChangedEvents.TryGetValue(_continuousFutureSymbol, out var changedEvent))
    {
        var oldSymbol = changedEvent.OldSymbol;
        var newSymbol = changedEvent.NewSymbol;
        var tag = $"Rollover - Symbol changed at {Time}: {oldSymbol} -> {newSymbol}";
        var quantity = Portfolio[oldSymbol].Quantity;
        // Rolling over: to liquidate any position of the old mapped contract and switch to the newly mapped contract
        Liquidate(oldSymbol, tag: tag);
        if (quantity != 0) MarketOrder(newSymbol, quantity, tag: tag);
        Log(tag);
    }
}

SymbolChangedEvent objects have the following attributes:

You can trade continuous Futures, but the continuous Future Symbol doesn't map to a single underlying Future contract. Instead, it represents a set of rolling contracts. Thus, the prices could be frictional during a contract rollover, which could be catastrophic in live trading! For live trading, you should place your orders directly on the underlying contracts. To get the current underlying contract in the continuous Future series, use the Mappedmapped property.

current_contract = self.continuous_contract.mapped
self.buy(current_contract, 1)

var currentContract = _continuousContract.Mapped;
Buy(currentContract, 1);

If you download the files in the US Futures Security Master, you get a factor file and a map file for each of the exchanges with supported continuous Futures. To view the files, see the \data\future\<exchange_name> directory under your LEAN CLI base directory.

For the factor file, it is a .zip collection of REST API styled .csv files for each Future Symbol, including the date, scaling factors for each type of data normalization and the data mapping mode that indicates the Symbol changing event is on that day for that mapping mode. The following line is an example line in the .csv file:

For the map file, it is a .zip collection of .csv files for each Future Symbol, including the date, new underlying contract Symbol, the exchange code, and the data mapping mode that indicates the Symbol changing event is on that day for that mapping mode. The following line is an example line in the .csv file:

The US Futures Security Master enables you to design strategies harnessing continuous Futures contracts. Examples include the following strategies:

• Trading cyclical patterns in commodity Futures.
• Buying gold Futures as an inflation hedge with automatic contract roll overs.
• Detecting arbitrage opportunities between index Futures and Equities.