In This Page

Introduction

Crypto Universes

Historical Data

Alternative Data Universes

Selection Frequency

Live Trading Considerations

Examples

Universes

Crypto

Introduction

A Crypto universe lets you select a basket of Cryptocurrencies based on CryptoUniverse data.

Crypto Universes

To add a universe of Cryptocurrencies, in the Initializeinitialize method, pass a CryptoUniverse to the AddUniverseadd_universe method.

Select Language:

def initialize(self) -> None:
    self.universe_settings.asynchronous = True
    self.universe_settings.resolution = Resolution.DAILY
    self.set_brokerage_model(BrokerageName.COINBASE, AccountType.CASH)
    
    # Add crypto universe selection
    self._universe = self.add_universe(CryptoUniverse.coinbase(lambda universe_day: [c.symbol for c in universe_day]))

private Universe _universe;
public override void Initialize()
{
    UniverseSettings.Asynchronous = true;
    UniverseSettings.Resolution = Resolution.Daily;
    SetBrokerageModel(BrokerageName.Coinbase, AccountType.Cash);
    
    // Add crypto universe selection
    _universe = AddUniverse(CryptoUniverse.Coinbase(universeDay => from x in universeDay select x.Symbol));
}

The following table shows the helper methods to create Crypto universes for the supported exchanges:

Brokerage Name	Helper Method	Example
`BrokerageName.BinanceBINANCE`	`CryptoUniverse.Binancebinance`	Example
`BrokerageName.BinanceUSBINANCE_US`	`CryptoUniverse.BinanceUSbinance_us`	Example
`BrokerageName.BitfinexBITFINEX`	`CryptoUniverse.Bitfinexbitfinex`	Example
`BrokerageName.BybitBYBIT`	`CryptoUniverse.Bybitbybit`	Example
`BrokerageName.CoinbaseCOINBASE`	`CryptoUniverse.Coinbasecoinbase`	Example
`BrokerageName.KrakenKRAKEN`	`CryptoUniverse.Krakenkraken`	Example

The following table describes the CryptoUniverse method arguments:

Argument	Data Type	Description	Default Value
`selector`	`Func<IEnumerable<CryptoUniverse>, IEnumerable<Symbol>>Callable[[list[CryptoUniverse]], list[Symbol]]`	A function to select some of the Cryptocurrencies for the universe.
`universeSettingsuniverse_settings`	`UniverseSettings`	The universe settings.	`nullNone`

The filter function receives CryptoUniverse objects, which represent one of the Cryptocurrencies in the market. The Symbol objects that the filter function returns represent the universe constituents. CryptoUniverse objects have the following attributes:

CryptoUniverse Select Language:

To perform thorough filtering on the CryptoUniverse objects, define an isolated filter method.

Select Language:

def initialize(self) -> None:
    self.universe_settings.asynchronous = True
    self.universe_settings.resolution = Resolution.DAILY
    self.set_brokerage_model(BrokerageName.COINBASE, AccountType.CASH)

    # Add crypto universe selection
    self._universe = self.add_universe(CryptoUniverse.coinbase(self._universe_filter))


def _universe_filter(self, universe_day):
    # Define the universe selection function
    return [cf.symbol for cf in universe_day if cf.volume >= 100 and cf.volume_in_usd > 10000]

private Universe _universe;
public override void Initialize()
{
    UniverseSettings.Asynchronous = true;
    UniverseSettings.Resolution = Resolution.Daily;
    SetBrokerageModel(BrokerageName.Coinbase, AccountType.Cash);

    // Add crypto universe selection
    _universe = AddUniverse(CryptoUniverse.Coinbase(UniverseFilter));
}

private IEnumerable<Symbol> UniverseFilter(IEnumerable< CryptoUniverse> universeDay)
{
    return universeDay.Where(cf => cf.Volume >= 100m && cf.VolumeInUsd > 10000m).Select(x => x.Symbol);
}

Historical Data

To get historical Cryptocurrency universe data, call the Historyhistory method with the Universe object and the lookback period. The return type is a IEnumerable<BaseDataCollection> and you have to cast its items to CryptoUniverse.

To get historical Cryptocurrency universe data, call the Historyhistory method with the Universe object and the lookback period. The return type is a multi-index pandas.Series or pandas.DataFrame containing CryptoUniverse data.

Select Language:

// Get 30 days of history for the Crypto universe.
var history = History(_universe, 30, Resolution.Daily);
foreach (var universeDay in history)
{
    foreach (CryptoUniverse universeItem in universeDay)
    {
        Log($"{universeItem.Symbol} price at {universeItem.EndTime}: {universeItem.Close}");
    }
}

# Get 30 days of history for the Crypto universe.
# DataFrame object:
df_history = self.history(self._universe, 30, Resolution.DAILY, flatten=True)
         
# Series object:
series_history = self.history(self._universe, 30, Resolution.DAILY)
for (univere_symbol, time), universe_day in history.items():
    for universe_item in universe_day:
        self.log(f"{universe_item.symbol} price at {universe_item.end_time}: {universe_item.close}")

For more information about Cryptocurrency data, see Crypto.

Alternative Data Universes

An alternative data universe lets you select a basket of Cryptocurrencies based on an alternative dataset that's linked to them. If you use an alternative data universe, you limit your universe to only the securities in the dataset, which avoids unnecessary subscriptions. Currently, only the Crypto Market Cap alternative dataset supports universe selection for Crypto.

Selection Frequency

Crypto universes run on a daily basis by default. To adjust the selection schedule, see Schedule.

Live Trading Considerations

In live mode, the pipeline has a 16-hour delay. Your algorithm receives the CryptoUniverse objects at around 16:00-16:30 Coordinated Universal Time (UTC) each day, depending on the data processing task.

Examples

The following examples demonstrate some common Crypto universes.

Example 1: Highly Liquid Crypto Universe

To fairly compare the liquidity between Crypto pairs, use the VolumeInUsd volume_in_usd property of the CryptoUniverse objects during universe selection. The following algorithm selects the 10 Crypto pairs with the greatest USD volume on Bitfinex:

Select Language:

public class HighlyLiquidCryptoUniverseAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2021, 1, 1);
        AddUniverse(
            CryptoUniverse.Bitfinex(data => data
                .Where(x => x.VolumeInUsd != null)
                .OrderByDescending(x => x.VolumeInUsd)
                .Take(10)
                .Select(x => x.Symbol)
            )
        );
    }
}

class HighlyLiquidCryptoUniverseAlgorithm(QCAlgorithm):

    def initialize(self):
        self.set_start_date(2021, 1, 1)
        self.add_universe(CryptoUniverse.bitfinex(self._select_assets))

    def _select_assets(self, data):
        selected = sorted(
            [x for x in data if x.volume_in_usd], 
            key=lambda x: x.volume_in_usd
        )[-10:]
        return [x.symbol for x in selected]

Example 2: Highly Volatile Crypto Universe

The following algorithm creates a universe of volatile Crypto pairs on Binance by selecting the pairs with the largest trading range in the previous day:

Select Language:

public class HighlyVolatileCryptoUniverseAlgorithm : QCAlgorithm
{
    public override void Initialize()
    {
        SetStartDate(2021, 1, 1);
        AddUniverse(
            CryptoUniverse.Binance(data => data
                .OrderByDescending(x => (x.High - x.Low) / x.Low)
                .Take(10)
                .Select(x => x.Symbol)
            )
        );
    }
}

class HighlyVolatileCryptoUniverseAlgorithm(QCAlgorithm):

    def initialize(self):
        self.set_start_date(2021, 1, 1)
        self.add_universe(CryptoUniverse.binance(self._select_assets))

    def _select_assets(self, data):
        selected = sorted(data, key=lambda x: (x.high - x.low) / x.low)[-10:]
        return [x.symbol for x in selected]

Example 3: Large Cap Crypto Universe

The following algorithm uses the CoinGecko Crypto Market Cap dataset to create a universe of the largest Crypto pairs on Coinbase. To avoid trading errors, it only selects pairs that have a quote currency that matches your account currency . At noon each day, it rebalances the portfolio to give equal weight to each coin in the universe.

Select Language:

public class LargeCapCryptoUniverseAlgorithm : QCAlgorithm
{
    private Universe _universe;

    public override void Initialize()
    {
        SetStartDate(2020, 1, 1);
        SetEndDate(2021, 1, 1);
        // Set the account currency. USD is already the default value. Change it here if you want.
        SetAccountCurrency("USD");
        // Get the pairs that our brokerage supports and have a quote currency that 
        // matches your account currency. We need this list in the universe selection function.
        var market = Market.Coinbase;
        var marketPairs = SymbolPropertiesDatabase.GetSymbolPropertiesList(market)
            .Where(x => x.Value.QuoteCurrency == AccountCurrency)
            .Select(x => x.Key.Symbol)
            .ToList();
        // Add the Crypto universe and define the selection function.
        _universe = AddUniverse<CoinGeckoUniverse>(
            data => data
                .Select(c => c as CoinGecko)
                // Select the coins that the brokerage supports and have a quote currency that 
                // matches our account currency.
                .Where(c => marketPairs.Contains(c.Coin + AccountCurrency))
                // Select the 10 largest coins.
                .OrderByDescending(c => c.MarketCap)
                .Take(10)
                // Create the Symbol objects of the selected coins.
                .Select(c => c.CreateSymbol(market, AccountCurrency)
            )
        );
        // Add a Sheduled Event to rebalance the portfolio.
        Schedule.On(DateRules.EveryDay(), TimeRules.At(12, 0), Rebalance);
    }

    private void Rebalance()
    {
        if (_universe.Selected == null || _universe.Selected.Count == 0)
        {
            return;
        }
        var symbols = _universe.Selected.Where(symbol => Securities[symbol].Price != 0).ToList();
        // Liquidate coins that are no longer in the universe.
        var targets = Portfolio.Values
            .Where(holding => holding.Invested && !symbols.Contains(holding.Symbol))
            .Select(holding => new PortfolioTarget(holding.Symbol, 0))
            .ToList();
        // Form an equal weighted portfolio of the coins in the universe.
        targets.AddRange(symbols.Select(symbol => new PortfolioTarget(symbol, 0.5m / symbols.Count)));
        // Place orders to rebalance the portfolio.
        SetHoldings(targets);
    }
}

class LargeCapCryptoUniverseAlgorithm(QCAlgorithm):

    def initialize(self):
        self.set_start_date(2020, 1, 1)
        self.set_end_date(2021, 1, 1)
        # Set the account currency. USD is already the default value. Change it here if you want.
        self.set_account_currency("USD") 
        # Get the pairs that our brokerage supports and have a quote currency that 
        # matches your account currency. We need this list in the universe selection function.
        self._market = Market.COINBASE
        self._market_pairs = [
            x.key.symbol 
            for x in self.symbol_properties_database.get_symbol_properties_list(self._market) 
            if x.value.quote_currency == self.account_currency
        ]
        # Add a universe of Cryptocurrencies.
        self._universe = self.add_universe(CoinGeckoUniverse, self._select_assets)
        # Add a Sheduled Event to rebalance the portfolio.
        self.schedule.on(self.date_rules.every_day(), self.time_rules.at(12, 0), self._rebalance)
    
    def _select_assets(self, data: list[CoinGeckoUniverse]) -> list[Symbol]:
        # Select the coins that our brokerage supports and have a quote currency that matches
        # our account currency.
        tradable_coins = [d for d in data if d.coin + self.account_currency in self._market_pairs]
        # Select the largest coins and create their Symbol objects.
        return [
            c.create_symbol(self._market, self.account_currency) 
            for c in sorted(tradable_coins, key=lambda x: x.market_cap)[-10:]
        ]

    def _rebalance(self):
        if not self._universe.selected:
            return
        symbols = [symbol for symbol in self._universe.selected if self.securities[symbol].price]
        # Liquidate coins that are no longer in the universe.
        targets = [PortfolioTarget(symbol, 0) for symbol, holding in self.portfolio.items() if holding.invested and symbol not in symbols]
        # Form an equal weighted portfolio of the coins in the universe.
        targets += [PortfolioTarget(symbol, 0.5/len(symbols)) for symbol in symbols]
        # Place orders to rebalance the portfolio.
        self.set_holdings(targets)

You can also see our Videos. You can also get in touch with us via Discord.

Did you find this page helpful?

Contribute to the documentation:

SIGN IN

Browse

Cloud Platform

Writing Algorithms

▶Key Concepts

Initialization

▶Securities

▶Portfolio

▶Universes

▶Datasets

▶Importing Data

▶Consolidating Data

▶Historical Data

▶Trading and Orders

▶Reality Modeling

Scheduled Events

▶Indicators

Object Store

▶Optimization

▶Machine Learning

▶Algorithm Framework

Charting

Logging

▶Statistics

▶Live Trading

Strategy Library

API Reference

▶Migrations

Research Environment

Local Platform

LEAN CLI

LEAN Engine

Hello

Universes

Crypto

Introduction

Crypto Universes

Historical Data

Alternative Data Universes

Selection Frequency

Live Trading Considerations

Examples

Example 1: Highly Liquid Crypto Universe

Example 2: Highly Volatile Crypto Universe

Example 3: Large Cap Crypto Universe

▶
Key Concepts

▶
Securities

▶
Portfolio

▶
Universes

▶
Datasets

▶
Importing Data

▶
Consolidating Data

▶
Historical Data

▶
Trading and Orders

▶
Reality Modeling

▶
Indicators

▶
Optimization

▶
Machine Learning

▶
Algorithm Framework

▶
Statistics

▶
Live Trading

▶
Migrations