book
Checkout our new book! Hands on AI Trading with Python, QuantConnect, and AWS Learn More arrow

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 initialize method, pass a CryptoUniverse to the add_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]))

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

Brokerage NameHelper MethodExample
BrokerageName.BINANCECryptoUniverse.binanceExample
BrokerageName.BINANCE_USCryptoUniverse.binance_usExample
BrokerageName.BITFINEXCryptoUniverse.bitfinexExample
BrokerageName.BYBITCryptoUniverse.bybitExample
BrokerageName.COINBASECryptoUniverse.coinbaseExample
BrokerageName.KRAKENCryptoUniverse.krakenExample

The following table describes the CryptoUniverse method arguments:

ArgumentData TypeDescriptionDefault Value
selectorCallable[[List[CryptoUniverse]], List[Symbol]]A function to select some of the Cryptocurrencies for the universe.
universe_settingsUniverseSettingsThe universe settings.None

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.

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]

Historical Data

To get historical Cryptocurrency universe data, call the history 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.
# 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 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:
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:
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:
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: