feat: multi-mint wallet with health tracking, WPA auto-detect, display gating

Squash merge of feature/multi-mint-support (21 commits):

Multi-mint wallet:
- Accept payments from 4 mints: minibits, coinos, 21mint, lnvoltz
- Periodic health probing (300s interval, 3 recovery threshold)
- Multi-wallet init with nucula_wallet_init_multi()
- /mints and /wallet API endpoints

WPA auto-detect:
- wifi_auth_mode config field (default WPA2, supports WPA3)
- Runtime mapping to wifi_auth_mode_t in STA config

Display gating:
- display_enabled config field (default true)
- Guards display_init/display_update per-board

Bug fixes:
- 3s delay before service start prevents lwip mem_free assertion
- Real npub in discovery (identity_get()->npub_hex)
- Health probe interval 300s (production value)
- Duplicate services_start_task call removed
- UTF-8 arrow replaced with ASCII in log message

Tests: 61+14 unit tests passing, firmware builds clean

1 files changed, 194 insertions, 0 deletions

diff --git a/tests/unit/test_mint_health.c b/tests/unit/test_mint_health.c
new file mode 100644
index 0000000..d170d55
--- /dev/null
+++ b/tests/unit/test_mint_health.c
@@ -0,0 +1,194 @@
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include "mint_health.h"
+
+static int test_count = 0;
+static int pass_count = 0;
+
+#define TEST(name) do { \
+    test_count++; \
+    printf("  TEST: %s ... ", name); \
+} while(0)
+
+#define PASS() do { \
+    pass_count++; \
+    printf("PASS\n"); \
+} while(0)
+
+#define FAIL(msg) do { \
+    printf("FAIL: %s\n", msg); \
+} while(0)
+
+#define ASSERT_EQ(a, b, msg) do { \
+    if ((a) != (b)) { FAIL(msg); return; } \
+} while(0)
+
+#define ASSERT_TRUE(a, msg) do { \
+    if (!(a)) { FAIL(msg); return; } \
+} while(0)
+
+#define ASSERT_FALSE(a, msg) do { \
+    if ((a)) { FAIL(msg); return; } \
+} while(0)
+
+static void test_init_basic(void) {
+    TEST("init with 4 mints");
+    const char urls[4][256] = {
+        "https://mint.minibits.cash/Bitcoin",
+        "https://mint.coinos.io",
+        "https://21mint.me",
+        "https://mint.lnvoltz.com"
+    };
+    esp_err_t err = mint_health_init(urls, 4);
+    ASSERT_EQ(err, 0, "init should return ESP_OK");
+    PASS();
+}
+
+static void test_get_all(void) {
+    TEST("get_all returns correct count");
+    int count = 0;
+    const mint_status_t *mints = mint_health_get_all(&count);
+    ASSERT_EQ(count, 4, "should have 4 mints");
+    ASSERT_TRUE(mints != NULL, "mints should not be NULL");
+    PASS();
+}
+
+static void test_initial_state_unreachable(void) {
+    TEST("initial state: all mints unreachable (no probes run)");
+    const char *expected_urls[] = {
+        "https://mint.minibits.cash/Bitcoin",
+        "https://mint.coinos.io",
+        "https://21mint.me",
+        "https://mint.lnvoltz.com"
+    };
+    int count = 0;
+    const mint_status_t *mints = mint_health_get_all(&count);
+    ASSERT_EQ(count, 4, "should have 4 mints");
+    for (int i = 0; i < count; i++) {
+        ASSERT_FALSE(mints[i].reachable, "initial mint should be unreachable");
+        ASSERT_EQ(mints[i].consecutive_successes, 0, "initial successes should be 0");
+        ASSERT_TRUE(strcmp(mints[i].url, expected_urls[i]) == 0, "URL mismatch");
+    }
+    PASS();
+}
+
+static void test_is_reachable_before_probes(void) {
+    TEST("is_reachable returns false before probes");
+    bool r = mint_health_is_reachable("https://mint.minibits.cash/Bitcoin");
+    ASSERT_FALSE(r, "should be unreachable before probes");
+    PASS();
+}
+
+static void test_is_reachable_null(void) {
+    TEST("is_reachable returns false for NULL");
+    bool r = mint_health_is_reachable(NULL);
+    ASSERT_FALSE(r, "NULL should return false");
+    PASS();
+}
+
+static void test_is_reachable_unknown_url(void) {
+    TEST("is_reachable returns false for unknown URL");
+    bool r = mint_health_is_reachable("https://unknown.mint.example.com");
+    ASSERT_FALSE(r, "unknown URL should return false");
+    PASS();
+}
+
+static void test_mark_unreachable(void) {
+    TEST("mark_unreachable on already-unreachable mint");
+    mint_health_mark_unreachable("https://mint.coinos.io");
+    bool r = mint_health_is_reachable("https://mint.coinos.io");
+    ASSERT_FALSE(r, "should still be unreachable");
+    PASS();
+}
+
+static void test_mark_unreachable_null(void) {
+    TEST("mark_unreachable with NULL does not crash");
+    mint_health_mark_unreachable(NULL);
+    PASS();
+}
+
+static void test_init_overflow(void) {
+    TEST("init with more than MAX mints truncates");
+    const char urls[MINT_HEALTH_MAX + 2][256];
+    for (int i = 0; i < MINT_HEALTH_MAX + 2; i++) {
+        snprintf((char *)urls[i], 256, "https://mint%d.example.com", i);
+    }
+    esp_err_t err = mint_health_init(urls, MINT_HEALTH_MAX + 2);
+    ASSERT_EQ(err, 0, "init should succeed");
+
+    int count = 0;
+    mint_health_get_all(&count);
+    ASSERT_EQ(count, MINT_HEALTH_MAX, "should be truncated to MAX");
+    PASS();
+}
+
+static void test_init_empty(void) {
+    TEST("init with 0 mints");
+    esp_err_t err = mint_health_init(NULL, 0);
+    ASSERT_EQ(err, 0, "init with 0 should succeed");
+
+    int count = -1;
+    mint_health_get_all(&count);
+    ASSERT_EQ(count, 0, "should have 0 mints");
+    PASS();
+}
+
+static void dummy_cb(void) { }
+
+static void test_register_callback(void) {
+    TEST("register_callback does not crash");
+    mint_health_register_callback(dummy_cb);
+    PASS();
+}
+
+static void test_register_callback_null(void) {
+    TEST("register_callback NULL does not crash");
+    mint_health_register_callback(NULL);
+    PASS();
+}
+
+static void test_reinit_resets_state(void) {
+    TEST("re-init resets state");
+    const char urls[2][256] = {
+        "https://mint-a.example.com",
+        "https://mint-b.example.com"
+    };
+    mint_health_init(urls, 2);
+
+    int count = 0;
+    const mint_status_t *mints = mint_health_get_all(&count);
+    ASSERT_EQ(count, 2, "should have 2 mints");
+    ASSERT_TRUE(strcmp(mints[0].url, "https://mint-a.example.com") == 0, "first URL");
+    ASSERT_TRUE(strcmp(mints[1].url, "https://mint-b.example.com") == 0, "second URL");
+    PASS();
+}
+
+static void test_start_stop(void) {
+    TEST("start/stop do not crash (task stubbed)");
+    mint_health_start();
+    mint_health_stop();
+    PASS();
+}
+
+int main(void) {
+    printf("\n=== Mint Health Unit Tests ===\n\n");
+
+    test_init_basic();
+    test_get_all();
+    test_initial_state_unreachable();
+    test_is_reachable_before_probes();
+    test_is_reachable_null();
+    test_is_reachable_unknown_url();
+    test_mark_unreachable();
+    test_mark_unreachable_null();
+    test_init_overflow();
+    test_init_empty();
+    test_register_callback();
+    test_register_callback_null();
+    test_reinit_resets_state();
+    test_start_stop();
+
+    printf("\n=== Results: %d passed, %d failed ===\n\n", pass_count, test_count - pass_count);
+    return (pass_count == test_count) ? 0 : 1;
+}