speculos 0.16.1.dev2__tar.gz → 0.16.1.dev6__tar.gz

{speculos-0.16.1.dev2 → speculos-0.16.1.dev6}/CHANGELOG.md

@@ -5,6 +5,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.17.0] 2025-03-14
+
+### Added
+
+- `--save-nvram` and `--load-nvram` parameters that allow NVRAM testing
+- destination boundaries verification for `nvm_write()`
+- Make BAGL-based applications able to call NBGL-based libraries, or NBGL-based applications able to call BAGL-based libraries
+
 ## [0.16.0] 2025-03-05
 
 ### Changed

{speculos-0.16.1.dev2/speculos.egg-info → speculos-0.16.1.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: speculos
-Version: 0.16.1.dev2
+Version: 0.16.1.dev6
 Summary: Ledger Blue, Stax, Flex and Nano S/S+/X application emulator
 Author-email: Ledger <hello@ledger.fr>
 Project-URL: Homepage, https://github.com/LedgerHQ/speculos

{speculos-0.16.1.dev2 → speculos-0.16.1.dev6}/speculos/__version__.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.16.1.dev2'
-__version_tuple__ = version_tuple = (0, 16, 1, 'dev2')
+__version__ = version = '0.16.1.dev6'
+__version_tuple__ = version_tuple = (0, 16, 1, 'dev6')

{speculos-0.16.1.dev2 → speculos-0.16.1.dev6}/speculos/main.py

@@ -14,6 +14,7 @@ import signal
 import socket
 import sys
 import threading
+from dataclasses import dataclass
 from elftools.elf.elffile import ELFFile
 from ledgered.binary import LedgerBinaryApp
 from mnemonic import mnemonic
@@ -34,6 +35,25 @@ from .observer import BroadcastInterface
 from .resources_importer import resources
 
 
+@dataclass
+class ElfInfo:
+    text_offset: int = 0
+    text_size: int = 0
+    stack_addr: int = 0
+    stack_size: int = 0
+    ram_addr: int = 0
+    ram_size: int = 0
+    text_addr: int = 0
+    svc_call_addr: int = 0
+    svc_cx_call_addr: int = 0
+    fonts_addr: int = 0
+    fonts_size: int = 0
+    app_nvram_addr: int = 0
+    app_nvram_size: int = 0
+    cx_ram_addr: int = 0
+    cx_ram_size: int = 0
+
+
 DEFAULT_SEED = ('glory promote mansion idle axis finger extra february uncover one trip resource lawn turtle enact '
                 'monster seven myth punch hobby comfort wild raise skin')
 
@@ -51,26 +71,27 @@ def set_pdeath(sig):
 
 
 def get_elf_infos(app_path, use_bagl):
+    ei = ElfInfo()
     with open(app_path, 'rb') as fp:
         elf = ELFFile(fp)
-        text = elf.get_section_by_name('.text')
+        text_section = elf.get_section_by_name('.text')
         for seg in elf.iter_segments():
             if seg['p_type'] != 'PT_LOAD':
                 continue
-            if seg.section_in_segment(text):
+            if seg.section_in_segment(text_section):
                 text_seg = seg
                 break
         else:
             raise RuntimeError("No program header with text section!")
-        symtab = elf.get_section_by_name('.symtab')
-        bss = elf.get_section_by_name('.bss')
-        sh_offset = text_seg['p_offset']
-        sh_size = text_seg['p_filesz']
-        text_load_addr = text['sh_addr']
-        stack = bss['sh_addr']
-        sym_estack = symtab.get_symbol_by_name('_estack')
+        symtab_section = elf.get_section_by_name('.symtab')
+        bss_section = elf.get_section_by_name('.bss')
+        ei.text_offset = text_seg['p_offset']
+        ei.text_size = text_seg['p_filesz']
+        ei.text_addr = text_section['sh_addr']
+        ei.stack_addr = bss_section['sh_addr']
+        sym_estack = symtab_section.get_symbol_by_name('_estack')
         if sym_estack is None:
-            sym_estack = symtab.get_symbol_by_name('END_STACK')
+            sym_estack = symtab_section.get_symbol_by_name('END_STACK')
         if sym_estack is None:
             logger.error('failed to find _estack/END_STACK symbol')
             sys.exit(1)
@@ -78,48 +99,56 @@ def get_elf_infos(app_path, use_bagl):
 
         # Look for the symbols SVC_Call and SVC_cx_call
         # if they are found, save their addresses to patch them to replace the SYSCALL later
-        svc_call_addr = 0
-        svc_cx_call_addr = 0
-        svc_call_symbol = symtab.get_symbol_by_name("SVC_Call")
+        svc_call_symbol = symtab_section.get_symbol_by_name("SVC_Call")
         if svc_call_symbol is not None:
-            svc_call_addr = svc_call_symbol[0]['st_value'] & (~1)
-        svc_cx_call_symbol = symtab.get_symbol_by_name("SVC_cx_call")
+            ei.svc_call_addr = svc_call_symbol[0]['st_value'] & (~1)
+        svc_cx_call_symbol = symtab_section.get_symbol_by_name("SVC_cx_call")
         if svc_cx_call_symbol is not None:
-            svc_cx_call_addr = svc_cx_call_symbol[0]['st_value'] & (~1)
+            ei.svc_cx_call_addr = svc_cx_call_symbol[0]['st_value'] & (~1)
         # Check where are located fonts in .elf file (LNX/LNS+ with BAGL only)
         # (on apps using NBGL, fonts are loaded from a known location: STAX_FONTS_ARRAY_ADDR,
         #  FLEX_FONTS_ARRAY_ADDR, NANOX_FONTS_ARRAY_ADDR or NANOSP_FONTS_ARRAY_ADDR)
-        fonts_addr = 0
-        fonts_size = 0
-        bagl_fonts_symbol = symtab.get_symbol_by_name('C_bagl_fonts')
+        bagl_fonts_symbol = symtab_section.get_symbol_by_name('C_bagl_fonts')
         if bagl_fonts_symbol is not None:
-            fonts_addr = bagl_fonts_symbol[0]['st_value']
-            fonts_size = bagl_fonts_symbol[0]['st_size']
+            ei.fonts_addr = bagl_fonts_symbol[0]['st_value']
+            ei.fonts_size = bagl_fonts_symbol[0]['st_size']
         elif use_bagl:
             logger.info("Disabling OCR.")
 
-        supp_ram = elf.get_section_by_name('.rfbss')
-        ram_addr, ram_size = (supp_ram['sh_addr'], supp_ram['sh_size']) if supp_ram is not None else (0, 0)
-    stack_size = estack - stack
-    return sh_offset, sh_size, stack, stack_size, ram_addr, ram_size, text_load_addr, \
-        svc_call_addr, svc_cx_call_addr, fonts_addr, fonts_size
+        # App NVRAM handling
+        nvram_data_symbol = symtab_section.get_symbol_by_name('_nvram_data')
+        # _envram for applications built with old SDK version
+        envram_data_symbol = symtab_section.get_symbol_by_name('_envram_data') \
+            or symtab_section.get_symbol_by_name('_envram')
+        if nvram_data_symbol is not None and envram_data_symbol is not None:
+            ei.app_nvram_addr = nvram_data_symbol[0]['st_value']
+            ei.app_nvram_size = envram_data_symbol[0]['st_value'] - nvram_data_symbol[0]['st_value']
+        else:
+            logger.info("The application does not use NVRAM.")
+
+        supp_ram_section = elf.get_section_by_name('.rfbss')
+        ei.ram_addr, ei.ram_size = \
+            (supp_ram_section['sh_addr'], supp_ram_section['sh_size']) if supp_ram_section is not None else (0, 0)
+    ei.stack_size = estack - ei.stack_addr
+    return ei
 
 
 def get_cx_infos(app_path):
+    ei = ElfInfo()
     with open(app_path, 'rb') as fp:
         elf = ELFFile(fp)
-        text = elf.get_section_by_name('.text')
-        cxram = elf.get_section_by_name('.cxram')
-        sh_offset = text['sh_offset']
-        sh_size = text['sh_size']
-        sh_load = text['sh_addr']
-        cx_ram_load = cxram["sh_addr"]
-        cx_ram_size = cxram["sh_size"]
+        text_section = elf.get_section_by_name('.text')
+        cxram_section = elf.get_section_by_name('.cxram')
+        ei.text_offset = text_section['sh_offset']
+        ei.text_size = text_section['sh_size']
+        ei.text_addr = text_section['sh_addr']
+        ei.cx_ram_addr = cxram_section["sh_addr"]
+        ei.cx_ram_size = cxram_section["sh_size"]
 
-    return sh_offset, sh_size, sh_load, cx_ram_size, cx_ram_load
+    return ei
 
 
-def run_qemu(s1: socket.socket, s2: socket.socket, args: argparse.Namespace, use_bagl: bool) -> int:
+def run_qemu(s1: socket.socket, s2: socket.socket, args: argparse.Namespace) -> int:
     argv = ['qemu-arm-static']
 
     if args.debug:
@@ -147,43 +176,55 @@ def run_qemu(s1: socket.socket, s2: socket.socket, args: argparse.Namespace, use
         cxlib_filepath = f"cxlib/{args.model}-cx-{args.sdk}.elf"
     cxlib = str(resources.files(__package__) / cxlib_filepath)
     if os.path.exists(cxlib):
-        sh_offset, sh_size, sh_load, cx_ram_size, cx_ram_load = get_cx_infos(cxlib)
-        cxlib_args = f'{cxlib}:{sh_offset:#x}:{sh_size:#x}:{sh_load:#x}:{cx_ram_size:#x}:{cx_ram_load:#x}'
+        ei = get_cx_infos(cxlib)
+        cxlib_args = f'{cxlib}:{ei.text_offset:#x}:{ei.text_size:#x}:{ei.text_addr:#x}'
+        cxlib_args += f':{ei.cx_ram_size:#x}:{ei.cx_ram_addr:#x}'
         argv += ['-c', cxlib_args]
     else:
         logger.warning(f"Cx lib {cxlib_filepath} not found")
 
-    # for NBGL apps, fonts binary file is mandatory
-    if not use_bagl:
-        fonts_filepath = f"fonts/{args.model}-fonts-{args.apiLevel}.bin"
-        fonts = str(resources.files(__package__) / fonts_filepath)
-        if os.path.exists(fonts):
-            argv += ['-f', fonts]
-        else:
-            logger.error(f"Fonts {fonts_filepath} not found")
-            sys.exit(1)
+    only_bagl = True
+    # 'bagl' is the default value of the binary.sections.sdk_graphics. We need to
+    # manage the cases where it is NOT 'bagl' but the section does not exists yet
+    if args.model in ["stax", "flex"]:
+        only_bagl = False
 
     extra_ram = ''
     app_path = getattr(args, 'app.elf')
     for lib in [f'main:{app_path}'] + args.library:
         name, lib_path = lib.split(':')
-        load_offset, load_size, stack, stack_size, ram_addr, ram_size, \
-            text_load_addr, svc_call_address, svc_cx_call_address, \
-            fonts_addr, fonts_size = get_elf_infos(lib_path, use_bagl)
+        binary = LedgerBinaryApp(lib_path)
+        use_bagl = binary.sections.sdk_graphics == "bagl"
+        if not use_bagl:
+            only_bagl = False
+        ei = get_elf_infos(lib_path, use_bagl)
 
         # Since binaries loaded as libs could also declare extra RAM page(s), collect them all
-        if (ram_addr, ram_size) != (0, 0):
-            arg = f'{ram_addr:#x}:{ram_size:#x}'
+        if (ei.ram_addr, ei.ram_size) != (0, 0):
+            arg = f'{ei.ram_addr:#x}:{ei.ram_size:#x}'
             if extra_ram and arg != extra_ram:
                 logger.error("different extra RAM pages for main app and/or libraries!")
                 sys.exit(1)
             extra_ram = arg
-        lib_arg = f'{name}:{lib_path}:{load_offset:#x}:{load_size:#x}'
-        lib_arg += f':{stack:#x}:{stack_size:#x}:{svc_call_address:#x}'
-        lib_arg += f':{svc_cx_call_address:#x}:{text_load_addr:#x}'
-        lib_arg += f':{fonts_addr:#x}:{fonts_size:#x}'
+        lib_arg = f'{name}:{lib_path}:{ei.text_offset:#x}:{ei.text_size:#x}'
+        lib_arg += f':{ei.stack_addr:#x}:{ei.stack_size:#x}:{ei.svc_call_addr:#x}'
+        lib_arg += f':{ei.svc_cx_call_addr:#x}:{ei.text_addr:#x}'
+        lib_arg += f':{ei.fonts_addr:#x}:{ei.fonts_size:#x}'
+        lib_arg += f':{ei.app_nvram_addr:#x}:{ei.app_nvram_size:#x}'
+        lib_arg += f':{1 if args.load_nvram else 0}'
+        lib_arg += f':{1 if args.save_nvram else 0}'
         argv.append(lib_arg)
 
+    # for NBGL apps, fonts binary file is mandatory
+    if not only_bagl:
+        fonts_filepath = f"fonts/{args.model}-fonts-{args.apiLevel}.bin"
+        fonts = str(resources.files(__package__) / fonts_filepath)
+        if os.path.exists(fonts):
+            argv += ['-f', fonts]
+        else:
+            logger.error(f"Fonts {fonts_filepath} not found")
+            sys.exit(1)
+
     if args.model == 'blue':
         if args.rampage:
             extra_ram = args.rampage
@@ -303,6 +344,8 @@ def main(prog=None) -> int:
                                                         "left button, 'a' right, 's' both). Default: arrow keys")
     group.add_argument('--progressive', action='store_true', help='Enable step-by-step rendering of graphical elements')
     group.add_argument('--zoom', help='Display pixel size.', type=int, choices=range(1, 11))
+    group.add_argument('--load-nvram', action='store_true', help='Preload app NVRAM data from file beforehand')
+    group.add_argument('--save-nvram', action='store_true', help='Save app NVRAM data to file')
 
     if prog:
         parser.prog = prog
@@ -324,13 +367,6 @@ def main(prog=None) -> int:
         args.model = "nanosp" if binary.sections.target == "nanos2" else binary.sections.target
         logger.warning(f"Device model detected from metadata: {args.model}")
 
-    # 'bagl' is the default value of the binary.sections.sdk_graphics. We need to
-    # manage the cases where it is NOT 'bagl' but the section does not exists yet
-    if args.model in ["stax", "flex"]:
-        use_bagl = False
-    else:
-        use_bagl = binary.sections.sdk_graphics == "bagl"
-
     if not args.apiLevel:
         if binary.sections.api_level is not None:
             args.apiLevel = binary.sections.api_level
@@ -475,7 +511,7 @@ def main(prog=None) -> int:
 
     s1, s2 = socket.socketpair()
 
-    qemu_pid = run_qemu(s1, s2, args, use_bagl)
+    qemu_pid = run_qemu(s1, s2, args)
     s1.close()
 
     # The `--transport` argument takes precedence over `--usb`
@@ -488,7 +524,6 @@ def main(prog=None) -> int:
     seph = seproxyhal.SeProxyHal(
         s2,
         args.model,
-        use_bagl,
         automation_path,
         automation_server,
         transport_type,
@@ -530,7 +565,7 @@ def main(prog=None) -> int:
         apirun = ApiRunner(args.api_port)
 
     display_args = DisplayArgs(args.color, args.model, args.ontop, rendering,
-                               args.keymap, zoom, x, y, use_bagl)
+                               args.keymap, zoom, x, y)
     server_args = ServerArgs(apdu, apirun, button, finger, seph, vnc)
     screen_notifier = ScreenNotifier(display_args, server_args)
 

{speculos-0.16.1.dev2 → speculos-0.16.1.dev6}/speculos/mcu/display.py

@@ -259,12 +259,13 @@ class Display(ABC):
         return self._display_args.rendering
 
     @property
-    def use_bagl(self) -> bool:
-        return self._display_args.use_bagl
+    @abstractmethod
+    def nbgl_gl(self) -> GraphicLibrary:
+        pass
 
     @property
     @abstractmethod
-    def gl(self) -> GraphicLibrary:
+    def bagl_gl(self) -> GraphicLibrary:
         pass
 
     @abstractmethod

{speculos-0.16.1.dev2 → speculos-0.16.1.dev6}/speculos/mcu/headless.py

@@ -15,32 +15,32 @@ class Headless(Display):
         super().__init__(display, server)
 
         self.m = HeadlessPaintWidget(self.model, server.vnc)
-        self._gl: GraphicLibrary
-        if display.use_bagl:
-            self._gl = bagl.Bagl(self.m, MODELS[self.model].screen_size, self.model)
-        else:
-            self._gl = nbgl.NBGL(self.m, MODELS[self.model].screen_size, self.model)
+        self._bagl_gl: GraphicLibrary
+        self._nbgl_gl: GraphicLibrary
+        self._bagl_gl = bagl.Bagl(self.m, MODELS[self.model].screen_size, self.model)
+        self._nbgl_gl = nbgl.NBGL(self.m, MODELS[self.model].screen_size, self.model)
 
     @property
-    def gl(self) -> GraphicLibrary:
-        return self._gl
+    def bagl_gl(self):
+        return self._bagl_gl
+
+    @property
+    def nbgl_gl(self):
+        return self._nbgl_gl
 
     def display_status(self, data: bytes) -> List[TextEvent]:
-        assert isinstance(self.gl, bagl.Bagl)
-        ret = self.gl.display_status(data)
+        ret = self.bagl_gl.display_status(data)
         if MODELS[self.model].name == 'blue':
             self.screen_update()    # Actually, this method doesn't work
         return ret
 
     def display_raw_status(self, data: bytes) -> None:
-        assert isinstance(self.gl, bagl.Bagl)
-        self.gl.display_raw_status(data)
+        self.bagl_gl.display_raw_status(data)
         if MODELS[self.model].name == 'blue':
             self.screen_update()    # Actually, this method doesn't work
 
     def screen_update(self) -> bool:
-        assert isinstance(self.gl, bagl.Bagl)
-        return self.gl.refresh()
+        return self.bagl_gl.refresh()
 
 
 class HeadlessPaintWidget(FrameBuffer):

{speculos-0.16.1.dev2 → speculos-0.16.1.dev6}/speculos/mcu/ocr.py

@@ -122,11 +122,10 @@ class OCR:
     MAX_BLANK_SPACE_STAX = 24
     MAX_BLANK_SPACE_FLEX = 26
 
-    def __init__(self, model: str, use_bagl: bool):
+    def __init__(self, model: str):
         self.events: List[TextEvent] = []
         # Store the model of the device
         self.model = model
-        self.use_bagl = use_bagl
         # Maximum space for a letter to be considered part of the same word
         if model == "stax":
             self.max_blank_space = OCR.MAX_BLANK_SPACE_STAX
@@ -212,14 +211,14 @@ class OCR:
         # create a new TextEvent if there are no events yet or if there is a new line
         self.events.append(TextEvent(char, x, y, w, h, False))
 
-    def analyze_bitmap(self, data: bytes) -> None:
+    def analyze_bitmap(self, data: bytes, use_bagl: bool) -> None:
         """
         data contain information about the latest displayed bitmap.
         Since unified SDK, speculos added the displayed character to data.
         For older SKD versions, legacy behaviour is used: parsing internal
         fonts to find a matching bitmap.
         """
-        if not self.use_bagl:
+        if not use_bagl:
             # Can be called via SephTag.NBGL_DRAW_IMAGE or SephTag.NBGL_DRAW_IMAGE_RLE
             # In both cases, data contains:
             # - area (sizeof(nbgl_area_t))

{speculos-0.16.1.dev2 → speculos-0.16.1.dev6}/speculos/mcu/screen.py

@@ -191,24 +191,27 @@ class Screen(Display):
     def __init__(self, display: DisplayArgs, server: ServerArgs) -> None:
         super().__init__(display, server)
         self.app: App
-        self._gl: GraphicLibrary
+        self._bagl_gl: GraphicLibrary
+        self._nbgl_gl: GraphicLibrary
 
     def set_app(self, app: App) -> None:
         self.app = app
         self.app.set_screen(self)
         model = self._display_args.model
-        if self.use_bagl:
-            self._gl = bagl.Bagl(app.widget, MODELS[model].screen_size, model)
-        else:
-            self._gl = nbgl.NBGL(app.widget, MODELS[model].screen_size, model)
+        self._bagl_gl = bagl.Bagl(app.widget, MODELS[model].screen_size, model)
+        self._nbgl_gl = nbgl.NBGL(app.widget, MODELS[model].screen_size, model)
 
     @property
     def m(self) -> QWidget:
         return self.app.widget
 
     @property
-    def gl(self):
-        return self._gl
+    def bagl_gl(self):
+        return self._bagl_gl
+
+    @property
+    def nbgl_gl(self):
+        return self._nbgl_gl
 
     def _key_event(self, event: QKeyEvent, pressed) -> None:
         key = Qt.Key(event.key())
@@ -223,20 +226,18 @@ class Screen(Display):
             self.app.close()
 
     def display_status(self, data: bytes) -> List[TextEvent]:
-        assert isinstance(self.gl, bagl.Bagl)
-        ret = self.gl.display_status(data)
+        ret = self.bagl_gl.display_status(data)
         if MODELS[self.model].name == 'blue':
             self.screen_update()    # Actually, this method doesn't work
         return ret
 
     def display_raw_status(self, data: bytes) -> None:
-        assert isinstance(self.gl, bagl.Bagl)
-        self.gl.display_raw_status(data)
+        self.bagl_gl.display_raw_status(data)
         if MODELS[self.model].name == 'blue':
             self.screen_update()    # Actually, this method doesn't work
 
     def screen_update(self) -> bool:
-        return self.gl.refresh()
+        return self.bagl_gl.refresh()
 
 
 class QtScreenNotifier(DisplayNotifier):

{speculos-0.16.1.dev2 → speculos-0.16.1.dev6}/speculos/mcu/screen_text.py

@@ -105,10 +105,7 @@ class TextScreen(Display):
 
         self.width, self.height = MODELS[display_args.model].screen_size
         self.m = TextWidget(self, display_args.model)
-        if self.use_bagl:
-            self._gl = bagl.Bagl(self.m, MODELS[display_args.model].screen_size, display_args.model)
-        else:
-            raise NotImplementedError("This display can not emulate NBGL OS yet")
+        self._gl = bagl.Bagl(self.m, MODELS[display_args.model].screen_size, display_args.model)
 
         if display_args.keymap is not None:
             self.ARROW_KEYS = list(map(ord, display_args.keymap))

{speculos-0.16.1.dev2 → speculos-0.16.1.dev6}/speculos/mcu/seproxyhal.py

@@ -253,7 +253,6 @@ class SeProxyHal(IODevice):
     def __init__(self,
                  sock: socket,
                  model: str,
-                 use_bagl: bool,
                  automation: Optional[Automation] = None,
                  automation_server: Optional[BroadcastInterface] = None,
                  transport: TransportType = TransportType.HID,
@@ -264,7 +263,8 @@ class SeProxyHal(IODevice):
         self.automation = automation
         self.automation_server = automation_server
         self.events: List[TextEvent] = []
-        self.refreshed = False
+        self.need_nbgl_refresh = False
+        self.is_last_draw_nbgl = False
         self.verbose = verbose
 
         self.status_event = threading.Event()
@@ -277,9 +277,7 @@ class SeProxyHal(IODevice):
 
         self.transport = build_transport(self.socket_helper.queue_packet, transport)
 
-        self.ocr = OCR(model, use_bagl)
-
-        self.use_bagl = use_bagl
+        self.ocr = OCR(model)
 
         # A list of callback methods when an APDU response is received
         self.apdu_callbacks: List[Callable[[bytes], None]] = []
@@ -333,17 +331,17 @@ class SeProxyHal(IODevice):
 
         if tag == SephTag.GENERAL_STATUS:
             if int.from_bytes(data[:2], 'big') == SephTag.GENERAL_STATUS_LAST_COMMAND:
-                if self.refreshed:
-                    self.refreshed = False
+                if self.need_nbgl_refresh:
+                    self.need_nbgl_refresh = False
 
                     # Update the screenshot, we'll upload its associated events shortly
-                    screen.display.gl.update_screenshot()
-                    screen.display.gl.update_public_screenshot()
+                    screen.display.nbgl_gl.update_screenshot()
+                    screen.display.nbgl_gl.update_public_screenshot()
 
-                if self.use_bagl and screen.display.screen_update():
+                if self.is_last_draw_nbgl is False and screen.display.screen_update():
                     if screen.display.model in ["nanox", "nanosp"]:
                         self.events += self.ocr.get_events()
-                elif not self.use_bagl:
+                elif self.is_last_draw_nbgl:
                     self.events += self.ocr.get_events()
 
                 # Apply automation rules after having received a GENERAL_STATUS_LAST_COMMAND tag. It allows the
@@ -362,6 +360,7 @@ class SeProxyHal(IODevice):
                      SephTag.DBG_SCREEN_DISPLAY_STATUS,
                      SephTag.BAGL_DRAW_RECT]:
             self.logger.debug(f"DISPLAY_STATUS {data!r}")
+            self.is_last_draw_nbgl = False
             if screen.display.model not in ["nanox", "nanosp"] or tag == SephTag.BAGL_DRAW_RECT:
                 events = screen.display.display_status(data)
                 self.events += events
@@ -371,8 +370,9 @@ class SeProxyHal(IODevice):
         elif tag in [SephTag.SCREEN_DISPLAY_RAW_STATUS, SephTag.BAGL_DRAW_BITMAP]:
             self.logger.debug("SephTag.SCREEN_DISPLAY_RAW_STATUS")
             screen.display.display_raw_status(data)
+            self.is_last_draw_nbgl = False
             if screen.display.model in ["nanox", "nanosp"]:
-                self.ocr.analyze_bitmap(data)
+                self.ocr.analyze_bitmap(data, True)
             if tag != SephTag.BAGL_DRAW_BITMAP:
                 self.socket_helper.send_packet(SephTag.DISPLAY_PROCESSED_EVENT)
             if screen.display.rendering == RENDER_METHOD.PROGRESSIVE:
@@ -425,34 +425,34 @@ class SeProxyHal(IODevice):
             pass
 
         elif tag == SephTag.NBGL_DRAW_RECT:
-            assert isinstance(screen.display.gl, NBGL)
-            self.events += screen.display.gl.hal_draw_rect(data)
+            assert isinstance(screen.display.nbgl_gl, NBGL)
+            self.events += screen.display.nbgl_gl.hal_draw_rect(data)
 
         elif tag == SephTag.NBGL_REFRESH:
-            assert isinstance(screen.display.gl, NBGL)
-            screen.display.gl.refresh(data)
+            screen.display.nbgl_gl.refresh(data)
             # Stax/Flex only
-            # We have refreshed the screen, remember it for the next time we have SephTag.GENERAL_STATUS
+            # We have need_nbgl_refresh the screen, remember it for the next time we have SephTag.GENERAL_STATUS
             # then we'll perform a screen update and make public the resulting screenshot
-            self.refreshed = True
+            self.need_nbgl_refresh = True
+            self.is_last_draw_nbgl = True
 
         elif tag == SephTag.NBGL_DRAW_LINE:
-            assert isinstance(screen.display.gl, NBGL)
-            screen.display.gl.hal_draw_line(data)
+            assert isinstance(screen.display.nbgl_gl, NBGL)
+            screen.display.nbgl_gl.hal_draw_line(data)
 
         elif tag == SephTag.NBGL_DRAW_IMAGE:
-            assert isinstance(screen.display.gl, NBGL)
-            self.ocr.analyze_bitmap(data)
-            screen.display.gl.hal_draw_image(data)
+            assert isinstance(screen.display.nbgl_gl, NBGL)
+            self.ocr.analyze_bitmap(data, False)
+            screen.display.nbgl_gl.hal_draw_image(data)
 
         elif tag == SephTag.NBGL_DRAW_IMAGE_RLE:
-            assert isinstance(screen.display.gl, NBGL)
-            self.ocr.analyze_bitmap(data)
-            screen.display.gl.hal_draw_image_rle(data)
+            assert isinstance(screen.display.nbgl_gl, NBGL)
+            self.ocr.analyze_bitmap(data, False)
+            screen.display.nbgl_gl.hal_draw_image_rle(data)
 
         elif tag == SephTag.NBGL_DRAW_IMAGE_FILE:
-            assert isinstance(screen.display.gl, NBGL)
-            screen.display.gl.hal_draw_image_file(data)
+            assert isinstance(screen.display.nbgl_gl, NBGL)
+            screen.display.nbgl_gl.hal_draw_image_file(data)
 
         elif tag == SephTag.NFC_RAPDU:
             data = self.transport.handle_rapdu(data)

{speculos-0.16.1.dev2 → speculos-0.16.1.dev6}/speculos/mcu/struct.py

@@ -32,7 +32,6 @@ class DisplayArgs:
     pixel_size: int
     x: Optional[int]
     y: Optional[int]
-    use_bagl: bool
 
 
 class ServerArgs(NamedTuple):

{speculos-0.16.1.dev2 → speculos-0.16.1.dev6/speculos.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: speculos
-Version: 0.16.1.dev2
+Version: 0.16.1.dev6
 Summary: Ledger Blue, Stax, Flex and Nano S/S+/X application emulator
 Author-email: Ledger <hello@ledger.fr>
 Project-URL: Homepage, https://github.com/LedgerHQ/speculos

{speculos-0.16.1.dev2 → speculos-0.16.1.dev6}/speculos.egg-info/SOURCES.txt

@@ -219,6 +219,7 @@ src/environment.c
 src/environment.h
 src/fonts.h
 src/launcher.c
+src/launcher.h
 src/sdk.h
 src/svc.c
 src/svc.h