Above 5%

Here is a QuantConnect algorithm implementing the exact logic you described for Digitall:

from AlgorithmImports import *

class GapAndMomentumTrader(QCAlgorithm):

    def initialize(self) -> None:
        self.set_start_date(2021, 1, 1)
        self.set_end_date(2022, 1, 1)
        self.set_cash(100000)

        self._watchlist = set()
        self._traded_today = set()
        self._entry_prices = {}
        self._open_prices = {}
        self._prev_closes = {}
        self._equity_symbols = set()
        self._can_trade = False

        self.universe_settings.resolution = Resolution.SECOND
        self.add_universe(self.coarse_selection_function, self.fine_selection_function)
        # Schedule gap scan 10 seconds after market open
        self.schedule.on(self.date_rules.every_day(), self.time_rules.after_market_open('SPY', 0.1667), self.scan_gap_opens)
        # Schedule close positions 3 seconds before market close
        self.schedule.on(self.date_rules.every_day(), self.time_rules.before_market_close('SPY', 0.05), self.close_all_positions)
        self.schedule.on(self.date_rules.every_day(), self.time_rules.after_market_close('SPY', 1), self.clear_daily_state)

    def coarse_selection_function(self, coarse):
        # Only liquid, US primary equities, no ETFs/ADRs/OTC
        filtered = [x for x in coarse if x.has_fundamental_data and x.volume > 500000 and x.price > 5]
        symbols = [x.symbol for x in filtered]
        return symbols[:2000]

    def fine_selection_function(self, fine):
        # US Equities only, no ETFs or ADRs
        out = []
        for f in fine:
            if (f.security_reference.security_type == "ST00000001"
                and f.security_reference.is_primary_share
                and f.company_reference.country_id == "USA"
                and not f.security_reference.is_adr_certificate
                and not f.security_reference.is_depositary_receipt):
                out.append(f.symbol)
        return out

    def on_securities_changed(self, changes):
        for security in changes.added_securities:
            self._equity_symbols.add(security.symbol)
        for security in changes.removed_securities:
            self._equity_symbols.discard(security.symbol)
            self._open_prices.pop(security.symbol, None)
            self._prev_closes.pop(security.symbol, None)

    def on_data(self, slice):
        if not self._can_trade:
            return

        remove_from_watchlist = set()
        for symbol in list(self._watchlist):
            if symbol not in slice.bars or symbol in self._traded_today:
                continue
            o_price = self._open_prices.get(symbol, 0)
            if o_price == 0:
                continue
            bar = slice.bars[symbol]
            if bar.close >= 1.3 * o_price and not self.portfolio[symbol].invested:
                size = self.calculate_order_quantity(symbol, 0.05)
                if size != 0:
                    self.market_order(symbol, size)
                    self._traded_today.add(symbol)
                    self._entry_prices[symbol] = bar.close
                    self.log(f"{self.time.date()} Buy {symbol} at {bar.close}")

        # Sell logic (take profit/stop loss)
        for symbol in list(self._entry_prices):
            if symbol not in slice.bars or not self.portfolio[symbol].invested:
                continue
            entry = self._entry_prices[symbol]
            price = slice.bars[symbol].close
            if entry == 0:
                continue
            if price >= 1.35 * entry or price <= 0.65 * entry:
                self.liquidate(symbol, "TP/SL Exit")
                self._watchlist.discard(symbol)
                self._traded_today.add(symbol)
                remove_from_watchlist.add(symbol)
                self.log(f"{self.time.date()} Sell {symbol} at {price}")

        for symbol in remove_from_watchlist:
            self._watchlist.discard(symbol)

    def scan_gap_opens(self):
        self._can_trade = False
        self._watchlist.clear()
        self._traded_today.clear()
        self._entry_prices.clear()
        self._open_prices.clear()
        self._prev_closes.clear()
        for symbol in self._equity_symbols:
            sec = self.securities[symbol]
            if not sec.has_data or not sec.is_tradable:
                continue
            open_price = sec.open
            hist = self.history(symbol, 2, Resolution.DAILY)
            prev_close = None
            if not hist.empty and 'close' in hist.columns:
                prev_close = hist.iloc[-2]['close']
            if prev_close is None or prev_close == 0:
                continue
            if open_price >= 1.05 * prev_close:
                self._watchlist.add(symbol)
                self._open_prices[symbol] = open_price
                self._prev_closes[symbol] = prev_close
                self.log(f"{self.time.date()} Watchlist Add {symbol}. Open={open_price}, PrevClose={prev_close}")
        self._can_trade = True

    def close_all_positions(self):
        for symbol in list(self.portfolio.keys):
            if self.portfolio[symbol].invested:
                self.liquidate(symbol, "End of day close")
                self.log(f"{self.time.date()} Liquidate {symbol}")

    def clear_daily_state(self):
        for symbol in self._watchlist:
            self.log(f"{self.time.date()} Watchlist Remove {symbol}")
        self._watchlist.clear()
        self._traded_today.clear()
        self._entry_prices.clear()
        self._open_prices.clear()
        self._prev_closes.clear()
        self._can_trade = False

Key features:

• Daily watchlist is built 10 seconds after the open based on a 5% or greater gap up.
• The algorithm logs all symbols added or removed from the watchlist.
• Every second, it scans the watchlist and buys any symbol reaching 30% above its open.
• Exits are triggered at 35% profit or loss.
• Symbols are removed after trading for that day.
• All positions are closed and watchlist cleared before market close.

You can check the logs to verify specific dates for symbols like SBET (5/27) and KNW (6/6).

Sources: Head & Shoulders TA Pattern Detection, Momentum And State Of Market Filters, Opening Range Breakout for Stocks in Play, WallStreetBets - QuantConnect.com, Momentum Effect In Commodities Futures

Thanks!