Universes

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]

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]

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)