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.

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 NameHelper MethodExample
BrokerageName.BinanceBINANCECryptoUniverse.BinancebinanceExample
BrokerageName.BinanceUSBINANCE_USCryptoUniverse.BinanceUSbinance_usExample
BrokerageName.BitfinexBITFINEXCryptoUniverse.BitfinexbitfinexExample
BrokerageName.BybitBYBITCryptoUniverse.BybitbybitExample
BrokerageName.CoinbaseCOINBASECryptoUniverse.CoinbasecoinbaseExample
BrokerageName.KrakenKRAKENCryptoUniverse.KrakenkrakenExample

The following table describes the CryptoUniverse method arguments:

ArgumentData TypeDescriptionDefault Value
selectorFunc<IEnumerable<CryptoUniverse>, IEnumerable<Symbol>>Callable[[List[CryptoUniverse]], List[Symbol]]A function to select some of the Cryptocurrencies for the universe.
universeSettingsuniverse_settingsUniverseSettingsThe 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:

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

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.

// 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 VolumeInUsdvolume_in_usd property of the CryptoCoarseFundamental objects during universe selection. The following algorithm selects the 10 Crypto pairs with the greatest USD volume on Bitfinex: 

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:

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]

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: