Merge pull request #20 from sandman21vs/address-blocks

Group an address in fours, and say when a row was cut

Author: oroderico

host/origo_sdl.c

@@ -126,6 +126,13 @@ void seedtool_display_nav_text(
     present();
 }
 
+void seedtool_display_nav_grouped(const seedtool_nav_t* nav, const char* title, const char* const* lines,
+    const size_t* first_group, const size_t count)
+{
+    seedtool_render_nav_grouped(nav, title, lines, first_group, count);
+    present();
+}
+
 void seedtool_display_nav_rows(const seedtool_nav_t* nav, const char* title, const char* const* rows, const size_t count)
 {
     seedtool_render_nav_rows(nav, title, rows, count);

host/origo_simulator.c

@@ -1610,6 +1610,139 @@ static bool nav_left_slot_is_drawn(void)
     return false;
 }
 
+/* Grouping an address is a drawing decision, so the one thing it must never
+ * do is change the address. Walking a value with seedtool_render_fit_grouped
+ * the way page_text_impl does has to reproduce it character for character -
+ * a group dropped, doubled or reordered at a line break would hand the reader
+ * an address that is not theirs, and they would have no way to tell.
+ *
+ * Also checks the cut lands on a group boundary. That is what keeps the
+ * alternating ink meaningful across a break: a line ending mid-group would
+ * put two same-coloured groups against each other with only the gap between
+ * them, and the gap is the signal the colour is there to back up. */
+/* A truncated row has to say so, and has to pay for saying it out of the same
+ * width. Two things are checked, because either alone passes while the other
+ * is broken: that the dots stay inside the row's own column rather than
+ * running under the scrollbar, and that they are drawn at all.
+ *
+ * The second is the one worth explaining. A row drawn without the ellipsis
+ * would be exactly its own fit_row prefix, so rendering that prefix as a row
+ * in its own right and comparing the two framebuffers says whether anything
+ * extra reached the screen. Without it this test would pass on a draw_row
+ * that silently cut, which is the bug it exists for. */
+static bool truncated_rows_show_an_ellipsis(void)
+{
+    static uint16_t truncated[SEEDTOOL_DISPLAY_WIDTH * SEEDTOOL_DISPLAY_HEIGHT];
+    /* Longer than any row can hold, which is what every address row is: an
+     * index, two spaces and a full address. */
+    static const char* const row = "  0  bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4";
+    const seedtool_nav_t nav = { .selected = 0, .back = true };
+    const char* const items[] = { row };
+    seedtool_render_nav_list(&nav, "m/84'/0'/0'/0", items, 1, 0);
+    memcpy(truncated, seedtool_render_pixels(), sizeof(truncated));
+
+    int rightmost = -1;
+    for (int y = 21; y < 55; ++y) {
+        for (int x = 0; x < SEEDTOOL_DISPLAY_WIDTH; ++x) {
+            if (truncated[y * SEEDTOOL_DISPLAY_WIDTH + x] != 0x0000 && x > rightmost) {
+                rightmost = x;
+            }
+        }
+    }
+    if (rightmost < 0) {
+        return false; /* the row never reached the screen */
+    }
+    /* LIST_TEXT_X + LIST_TEXT_WIDTH in seedtool_render.c, kept in sync with
+     * the 6 + 222 below: the row's own column, which the ellipsis has to stay
+     * inside rather than run past into the scrollbar's strip. */
+    if (rightmost > 6 + 222) {
+        return false;
+    }
+
+    /* What a silent cut would have drawn. */
+    char prefix[64] = { 0 };
+    const size_t fit = seedtool_render_fit_row(row);
+    if (fit >= sizeof(prefix) || fit >= strlen(row)) {
+        return false; /* the row was meant to be too long for one */
+    }
+    memcpy(prefix, row, fit);
+    const char* const cut[] = { prefix };
+    seedtool_render_nav_list(&nav, "m/84'/0'/0'/0", cut, 1, 0);
+    return memcmp(truncated, seedtool_render_pixels(), sizeof(truncated)) != 0;
+}
+
+static bool grouped_paging_preserves_the_value(void)
+{
+    static const char* const values[] = {
+        /* Both address shapes this firmware derives, plus lengths that land
+         * exactly on a group boundary and one past it. */
+        "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4",
+        "bc1p5cyxnuxmeuwuvkwfem96lqzszd02n6xdcjrs20cac6yqjjwudpxqkedrcr",
+        "1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2",
+        "3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy",
+        "abcd",
+        "abcde",
+        "abcdefgh",
+    };
+    for (size_t v = 0; v < sizeof(values) / sizeof(values[0]); ++v) {
+        const char* const value = values[v];
+        const size_t total = strlen(value);
+        char rebuilt[128] = { 0 };
+        size_t used = 0, offset = 0, lines = 0;
+        while (offset < total && lines < 32) {
+            const size_t fit = seedtool_render_fit_grouped(value + offset, 48);
+            if (!fit) {
+                return false; /* no progress: the walk would never end */
+            }
+            /* A whole number of groups unless this is the value's own tail. */
+            if (offset + fit < total && fit % SEEDTOOL_GROUP_LEN) {
+                return false;
+            }
+            if (used + fit >= sizeof(rebuilt)) {
+                return false;
+            }
+            memcpy(rebuilt + used, value + offset, fit);
+            used += fit;
+            offset += fit;
+            ++lines;
+        }
+        rebuilt[used] = '\0';
+        if (offset != total || strcmp(rebuilt, value) != 0) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/* The grouped line is centred with its gaps counted in, so it can run off an
+ * edge in a way the plain centred line cannot. Measured, not assumed. */
+static bool grouped_lines_clear_the_edges(void)
+{
+    static const char* const lines[] = { "bc1qw508d6qejxtdg4y5r3zarvary0", "bc1p5cyxnuxmeuwuvkwfem96lqzs" };
+    static const size_t first_group[] = { 0, 7, 14 };
+    for (size_t i = 0; i < sizeof(lines) / sizeof(lines[0]); ++i) {
+        /* The widest a line can be: fit_grouped's own answer for this value. */
+        char line[64] = { 0 };
+        const size_t fit = seedtool_render_fit_grouped(lines[i], 48);
+        memcpy(line, lines[i], fit);
+        const char* const shown[] = { line, line, line };
+        const seedtool_nav_t nav = { .selected = SEEDTOOL_NAV_BODY,
+            .confirm = "Continue",
+            .confirm_enabled = true,
+            .back = true,
+            .counter = "1/2" };
+        seedtool_render_nav_grouped(&nav, "m/84'/0'/0'/0/0", shown, first_group, 3);
+        const uint16_t* const pixels = seedtool_render_pixels();
+        for (int y = 30; y < 100; ++y) {
+            if (pixels[y * SEEDTOOL_DISPLAY_WIDTH] != 0x0000
+                || pixels[y * SEEDTOOL_DISPLAY_WIDTH + SEEDTOOL_DISPLAY_WIDTH - 1] != 0x0000) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
 static bool nav_chrome_bands_do_not_collide(void)
 {
     /* Twelve rows of the widest label review_and_confirm can build: two
@@ -2202,6 +2335,18 @@ static int self_test(void)
         fputs("Origo backup confirmation screen self-test failed\n", stderr);
         return 1;
     }
+    if (!truncated_rows_show_an_ellipsis()) {
+        fputs("Origo truncated row self-test failed\n", stderr);
+        return 1;
+    }
+    if (!grouped_paging_preserves_the_value()) {
+        fputs("Origo grouped address paging self-test failed\n", stderr);
+        return 1;
+    }
+    if (!grouped_lines_clear_the_edges()) {
+        fputs("Origo grouped address geometry self-test failed\n", stderr);
+        return 1;
+    }
     if (!nav_chrome_bands_do_not_collide()) {
         fputs("Origo nav chrome geometry self-test failed\n", stderr);
         return 1;

main/seedtool_app.c

@@ -731,13 +731,14 @@ static void hexstr(const uint8_t* bytes, const size_t len, char* output)
  * the tighter line pitch the renderer uses for a third line: a third fewer
  * pages to review the same value. Returns true when the reader advanced past
  * the last page or accepted, false when they backed out. */
-static bool page_text_impl(const char* title, const char* text, const bool confirmable)
+static bool page_text_impl(const char* title, const char* text, const bool confirmable, const bool grouped)
 {
     size_t start[MAX_PAGE_LINES], length[MAX_PAGE_LINES];
     const size_t total = strlen(text);
     size_t lines = 0, offset = 0;
     while (lines < MAX_PAGE_LINES && (offset < total || !lines)) {
-        const size_t fit = seedtool_render_fit(text + offset, MAX_LINE_CHARS);
+        const size_t fit = grouped ? seedtool_render_fit_grouped(text + offset, MAX_LINE_CHARS)
+                                   : seedtool_render_fit(text + offset, MAX_LINE_CHARS);
         start[lines] = offset;
         length[lines] = fit;
         /* A glyph wider than the display would otherwise loop forever. */
@@ -773,7 +774,19 @@ static bool page_text_impl(const char* title, const char* text, const bool confi
         }
         (void)snprintf(footer, sizeof(footer), "%u/%u", (unsigned)(page + 1), (unsigned)pages);
         const seedtool_nav_t nav = page_nav(position, pages, footer, confirmable);
-        seedtool_display_nav_text(&nav, title, line1, line2, line3);
+        if (grouped) {
+            /* Where each line sits in the whole value, in groups, so the
+             * alternating ink carries across the line break rather than
+             * restarting three times a page. Every line but a final short one
+             * is a whole number of groups, which is what makes this exact. */
+            const char* const shown[] = { line1, line2, line3 };
+            const size_t first_group[] = { start[first] / SEEDTOOL_GROUP_LEN,
+                (first + 1 < lines ? start[first + 1] : 0) / SEEDTOOL_GROUP_LEN,
+                (first + 2 < lines ? start[first + 2] : 0) / SEEDTOOL_GROUP_LEN };
+            seedtool_display_nav_grouped(&nav, title, shown, first_group, 3);
+        } else {
+            seedtool_display_nav_text(&nav, title, line1, line2, line3);
+        }
         switch (wait_key()) {
         case KEY_SELECT:
             if (!position) {
@@ -814,15 +827,23 @@ static bool page_text_impl(const char* title, const char* text, const bool confi
  * caller acts on the answer, so the tick is there to give one. */
 static bool page_text(const char* title, const char* text)
 {
-    return page_text_impl(title, text, true);
+    return page_text_impl(title, text, true, false);
+}
+
+/* page_text for a value with no word shapes to read by - an address. Drawn in
+ * groups of four so the reader transcribing it has somewhere to keep their
+ * place; the string itself is untouched. */
+static bool page_grouped(const char* title, const char* text)
+{
+    return page_text_impl(title, text, true, true);
 }
 
 /* Paged text there is nothing to take. Returns nothing because there is
  * nothing to return: the reader pages down and leaves by the arrow, and a
  * caller that cannot ask for an answer cannot forget to use it. */
 static void page_read(const char* title, const char* text)
 {
-    (void)page_text_impl(title, text, false);
+    (void)page_text_impl(title, text, false, false);
 }
 
 /* The account key carries its key origin, so a scan does not have to be told
@@ -2214,7 +2235,7 @@ static void show_addresses(
          * make. */
         char path[sizeof(prefix) + 12];
         (void)snprintf(path, sizeof(path), "%s/%u", prefix, (unsigned)index);
-        if (page_text(path, address)) {
+        if (page_grouped(path, address)) {
             show_address_qr(path, address);
         }
         seedtool_zero(address, sizeof(address));

main/seedtool_display.c

@@ -222,6 +222,13 @@ void seedtool_display_nav_text(
     flush();
 }
 
+void seedtool_display_nav_grouped(const seedtool_nav_t* nav, const char* title, const char* const* lines,
+    const size_t* first_group, const size_t count)
+{
+    seedtool_render_nav_grouped(nav, title, lines, first_group, count);
+    flush();
+}
+
 void seedtool_display_nav_rows(const seedtool_nav_t* nav, const char* title, const char* const* rows, const size_t count)
 {
     seedtool_render_nav_rows(nav, title, rows, count);

main/seedtool_display.h

@@ -33,6 +33,8 @@ void seedtool_display_splash(void);
  * chrome itself is already carried by seedtool_nav_t. */
 void seedtool_display_nav_text(
     const seedtool_nav_t* nav, const char* title, const char* line1, const char* line2, const char* line3);
+void seedtool_display_nav_grouped(const seedtool_nav_t* nav, const char* title, const char* const* lines,
+    const size_t* first_group, size_t count);
 void seedtool_display_nav_rows(const seedtool_nav_t* nav, const char* title, const char* const* rows, size_t count);
 void seedtool_display_nav_list(
     const seedtool_nav_t* nav, const char* title, const char* const* items, size_t count, size_t top);