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

12 files changed, 502 insertions, 98 deletions

diff --git a/main/CMakeLists.txt b/main/CMakeLists.txt
index abbe53b..f21b4e0 100644
--- a/main/CMakeLists.txt
+++ b/main/CMakeLists.txt
@@ -16,6 +16,7 @@ idf_component_register(SRCS "tollgate_main.c"
                             "nip04.c"
                             "mcp_handler.c"
                             "cvm_server.c"
+                            "mint_health.c"
                             "display.c"
                             "font.c"
                             "local_relay.c"
diff --git a/main/captive_portal.c b/main/captive_portal.c
index 1a3d5ce..c9bcf19 100644
--- a/main/captive_portal.c
+++ b/main/captive_portal.c
@@ -2,6 +2,7 @@
 #include "firewall.h"
 #include "session.h"
 #include "config.h"
+#include "mint_health.h"
 #include "esp_log.h"
 #include "esp_wifi.h"
 #include "cJSON.h"
@@ -42,9 +43,14 @@ static const char PORTAL_HTML_TEMPLATE[] = \
 ".btn:disabled{background:#333;color:#666;cursor:not-allowed}"
 ".mints{background:#252525;border-radius:12px;padding:12px;margin-top:16px;text-align:left}"
 ".mints-title{color:#888;font-size:12px;margin-bottom:8px}"
-".mint-url{font-family:monospace;font-size:11px;color:#f7931a;word-break:break-all;"
-"background:#1a1a1a;padding:8px;border-radius:6px;cursor:pointer}"
-".mint-url:active{opacity:0.7}"
+".mint-item{display:flex;align-items:center;padding:6px 8px;margin-bottom:4px;"
+"background:#1a1a1a;border-radius:6px;cursor:pointer}"
+".mint-item:active{opacity:0.7}"
+".mint-dot{width:8px;height:8px;border-radius:50%;margin-right:8px;flex-shrink:0}"
+".mint-dot.green{background:#4caf50}"
+".mint-dot.grey{background:#666}"
+".mint-url{font-family:monospace;font-size:11px;color:#f7931a;word-break:break-all}"
+".mint-url.dim{color:#666}"
 ".mint-hint{color:#666;font-size:10px;margin-top:4px}"
 "#status{margin-top:16px;padding:12px;border-radius:8px;display:none;font-size:14px}"
 "#status.success{display:block;background:#1a472a;color:#4caf50}"
@@ -63,20 +69,21 @@ static const char PORTAL_HTML_TEMPLATE[] = \
 "<button class='btn' id='payBtn' onclick='payToken()'>Pay & Connect</button>"
 "<div class='mints'>"
 "<div class='mints-title'>SUPPORTED MINTS</div>"
-"<div class='mint-url' id='mintUrl' onclick='copyMint()'>__MINT_URL__</div>"
-"<div class='mint-hint'>Tap to copy &bull; Mint tokens at this URL before paying</div>"
+"<div id='mintList'>__MINT_LIST__</div>"
+"<div class='mint-hint'>Tap to copy &bull; Green = reachable</div>"
 "</div>"
 "<div id='status'></div>"
 "</div>"
 "<script>"
-"const mintUrlEl=document.getElementById('mintUrl');"
-"const mintUrl=mintUrlEl.textContent;"
+"const mintListEl=document.getElementById('mintList');"
 "const statusEl=document.getElementById('status');"
 "const payBtn=document.getElementById('payBtn');"
 "const tokenInput=document.getElementById('tokenInput');"
-"function copyMint(){"
-"if(navigator.clipboard){navigator.clipboard.writeText(mintUrl);"
-"mintUrlEl.textContent='Copied!';setTimeout(()=>{mintUrlEl.textContent=mintUrl;},1000);}"
+"function copyMint(url){"
+"if(navigator.clipboard){navigator.clipboard.writeText(url);"
+"const el=event.currentTarget;const u=el.querySelector('.mint-url');"
+"const orig=u.textContent;u.textContent='Copied!';"
+"setTimeout(()=>{u.textContent=orig;},1000);}"
 "}"
 "function showStatus(msg,type){statusEl.textContent=msg;statusEl.className=type;}"
 "function payToken(){"
@@ -93,6 +100,20 @@ static const char PORTAL_HTML_TEMPLATE[] = \
 "else if(d.kind===21023){showStatus('Error: '+(d.content||'Unknown error'),'error');payBtn.disabled=false;}"
 "}).catch(e=>{showStatus(e.message||'Connection error','error');payBtn.disabled=false;});"
 "}"
+"function refreshMints(){"
+"fetch('http://__AP_IP__:2121/mints').then(r=>r.json()).then(data=>{"
+"let html='';"
+"for(const m of data){"
+"const cls=m.reachable?'green':'grey';"
+"const urlCls=m.reachable?'mint-url':'mint-url dim';"
+"html+='<div class=\"mint-item\" onclick=\"copyMint(\\''+m.url+'\\')\">';"
+"html+='<span class=\"mint-dot '+cls+'\"></span>';"
+"html+='<span class=\"'+urlCls+'\">'+m.url+'</span></div>';"
+"}"
+"if(html)mintListEl.innerHTML=html;"
+"}).catch(()=>{});"
+"}"
+"setInterval(refreshMints,30000);"
 "</script>"
 "</body></html>";
 
@@ -122,10 +143,35 @@ static esp_err_t portal_handler(httpd_req_t *req)
     const char *tpl = PORTAL_HTML_TEMPLATE;
     size_t tpl_len = strlen(tpl);
 
+    char mint_list_html[4096];
+    size_t mint_list_cap = sizeof(mint_list_html);
+    size_t mint_list_len = 0;
+    mint_list_html[0] = '\0';
+    int mint_count = 0;
+    const mint_status_t *mints = mint_health_get_all(&mint_count);
+    for (int i = 0; i < mint_count; i++) {
+        const char *cls = mints[i].reachable ? "green" : "grey";
+        const char *url_cls = mints[i].reachable ? "mint-url" : "mint-url dim";
+        int written = snprintf(mint_list_html + mint_list_len, mint_list_cap - mint_list_len,
+                 "<div class='mint-item' onclick='copyMint(\"%s\")'>"
+                 "<span class='mint-dot %s'></span>"
+                 "<span class='%s'>%s</span></div>",
+                 mints[i].url, cls, url_cls, mints[i].url);
+        if (written > 0 && (size_t)written < mint_list_cap - mint_list_len) {
+            mint_list_len += (size_t)written;
+        }
+    }
+    if (mint_count == 0) {
+        const tollgate_config_t *cfg = tollgate_config_get();
+        snprintf(mint_list_html, sizeof(mint_list_html),
+                 "<div class='mint-item'><span class='mint-dot grey'></span>"
+                 "<span class='mint-url dim'>%s</span></div>", cfg->mint_url);
+    }
+
     struct { const char *key; const char *val; } subs[] = {
         { "__AP_IP__", s_ap_ip_str },
         { "__PRICE__", price_str },
-        { "__MINT_URL__", cfg->mint_url },
+        { "__MINT_LIST__", mint_list_html },
     };
     int nsubs = sizeof(subs) / sizeof(subs[0]);
 
diff --git a/main/cashu.c b/main/cashu.c
index ec0566c..da12ff9 100644
--- a/main/cashu.c
+++ b/main/cashu.c
@@ -1,5 +1,6 @@
 #include "cashu.h"
 #include "config.h"
+#include "mint_health.h"
 #include "esp_log.h"
 #include "esp_http_client.h"
 #include "cJSON.h"
@@ -267,6 +268,11 @@ bool cashu_is_mint_accepted(const char *mint_url)
 {
     if (!mint_url || mint_url[0] == '\0') return false;
     const tollgate_config_t *cfg = tollgate_config_get();
-    if (strstr(mint_url, cfg->mint_url) != NULL) return true;
-    return (strcmp(mint_url, cfg->mint_url) == 0);
+    for (int i = 0; i < cfg->accepted_mint_count; i++) {
+        if (strstr(mint_url, cfg->accepted_mints[i]) != NULL ||
+            strcmp(mint_url, cfg->accepted_mints[i]) == 0) {
+            return mint_health_is_reachable(mint_url);
+        }
+    }
+    return false;
 }
diff --git a/main/config.c b/main/config.c
index b991991..5e3b247 100644
--- a/main/config.c
+++ b/main/config.c
@@ -16,7 +16,7 @@ esp_err_t tollgate_config_init(void)
 {
     memset(&g_config, 0, sizeof(g_config));
     g_config.max_retry = 5;
-    g_config.ap_channel = 6;
+    g_config.ap_channel = 1;
     g_config.ap_max_conn = 4;
     g_config.price_per_step = 21;
     g_config.step_size_ms = 60000;
@@ -24,6 +24,8 @@ esp_err_t tollgate_config_init(void)
     strncpy(g_config.metric, "milliseconds", sizeof(g_config.metric) - 1);
     g_config.persist_threshold_sats = 1;
     g_config.nostr_publish_interval_s = 21600;
+    g_config.nostr_sync_interval_s = 1800;
+    g_config.nostr_fallback_sync_interval_s = 21600;
     g_config.client_enabled = false;
     g_config.client_steps_to_buy = 1;
     g_config.client_renewal_threshold_pct = 20;
@@ -35,8 +37,8 @@ esp_err_t tollgate_config_init(void)
     g_config.payout.mint_count = 0;
     g_config.cvm_enabled = true;
     strncpy(g_config.cvm_relays, "wss://relay.primal.net", sizeof(g_config.cvm_relays) - 1);
-    g_config.nostr_sync_interval_s = 1800;
-    g_config.nostr_fallback_sync_interval_s = 21600;
+    strncpy(g_config.wifi_auth_mode, "WPA2", sizeof(g_config.wifi_auth_mode) - 1);
+    g_config.display_enabled = true;
 
     esp_vfs_spiffs_conf_t conf = {
         .base_path = "/spiffs",
@@ -56,17 +58,18 @@ esp_err_t tollgate_config_init(void)
         const char *default_json = "{"
             "\"nsec\":\"a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2\","
             "\"wifi_networks\":["
-              "{\"ssid\":\"EnterSSID-2.4GHz\",\"password\":\"c03rad0r123!\"},"
-              "{\"ssid\":\"c03rad0r\",\"password\":\"c03rad0r123\"},"
-              "{\"ssid\":\"TK-GAESTE\",\"password\":\"\"}"
+              "{\"ssid\":\"c03rad0r\",\"password\":\"c03rad0r123\"}"
             "],"
             "\"ap_password\":\"\","
             "\"mint_url\":\"https://testnut.cashu.space\","
+            "\"accepted_mints\":[\"https://testnut.cashu.space\"],"
             "\"price_per_step\":21,"
             "\"step_size_ms\":60000,"
             "\"nostr_geohash\":\"u281w0dfz\","
             "\"nostr_relays\":[\"wss://relay.damus.io\",\"wss://nos.lol\"],"
             "\"nostr_publish_interval_s\":21600,"
+            "\"nostr_sync_interval_s\":1800,"
+            "\"nostr_fallback_sync_interval_s\":21600,"
             "\"client_enabled\":false,"
             "\"client_steps_to_buy\":1,"
             "\"client_renewal_threshold_pct\":20,"
@@ -129,12 +132,36 @@ esp_err_t tollgate_config_init(void)
         }
     }
 
+    if (g_config.network_count == 0) {
+        cJSON *ssid = cJSON_GetObjectItem(root, "wifi_ssid");
+        cJSON *pass = cJSON_GetObjectItem(root, "wifi_password");
+        if (ssid && cJSON_IsString(ssid) && pass && cJSON_IsString(pass)) {
+            strncpy(g_config.networks[0].ssid, ssid->valuestring, sizeof(g_config.networks[0].ssid) - 1);
+            strncpy(g_config.networks[0].password, pass->valuestring, sizeof(g_config.networks[0].password) - 1);
+            g_config.network_count = 1;
+        }
+    }
+
     cJSON *ap_pass = cJSON_GetObjectItem(root, "ap_password");
     if (ap_pass) strncpy(g_config.ap_password, ap_pass->valuestring, sizeof(g_config.ap_password) - 1);
 
     cJSON *mint = cJSON_GetObjectItem(root, "mint_url");
     if (mint) strncpy(g_config.mint_url, mint->valuestring, sizeof(g_config.mint_url) - 1);
 
+    cJSON *acc_mints = cJSON_GetObjectItem(root, "accepted_mints");
+    if (acc_mints && cJSON_IsArray(acc_mints)) {
+        int mcount = cJSON_GetArraySize(acc_mints);
+        if (mcount > TOLLGATE_MAX_MINT_URLS) mcount = TOLLGATE_MAX_MINT_URLS;
+        for (int i = 0; i < mcount; i++) {
+            cJSON *m = cJSON_GetArrayItem(acc_mints, i);
+            if (m && cJSON_IsString(m)) {
+                strncpy(g_config.accepted_mints[i], m->valuestring,
+                        sizeof(g_config.accepted_mints[i]) - 1);
+                g_config.accepted_mint_count++;
+            }
+        }
+    }
+
     cJSON *lnurl = cJSON_GetObjectItem(root, "lnurl_url");
     if (lnurl) strncpy(g_config.lnurl_url, lnurl->valuestring, sizeof(g_config.lnurl_url) - 1);
 
@@ -175,6 +202,26 @@ esp_err_t tollgate_config_init(void)
     cJSON *pub_interval = cJSON_GetObjectItem(root, "nostr_publish_interval_s");
     if (pub_interval) g_config.nostr_publish_interval_s = pub_interval->valueint;
 
+    cJSON *sync_interval = cJSON_GetObjectItem(root, "nostr_sync_interval_s");
+    if (sync_interval) g_config.nostr_sync_interval_s = sync_interval->valueint;
+
+    cJSON *fallback_interval = cJSON_GetObjectItem(root, "nostr_fallback_sync_interval_s");
+    if (fallback_interval) g_config.nostr_fallback_sync_interval_s = fallback_interval->valueint;
+
+    cJSON *seed_relays = cJSON_GetObjectItem(root, "nostr_seed_relays");
+    if (seed_relays && cJSON_IsArray(seed_relays)) {
+        int srcount = cJSON_GetArraySize(seed_relays);
+        if (srcount > TOLLGATE_MAX_SEED_RELAYS) srcount = TOLLGATE_MAX_SEED_RELAYS;
+        for (int i = 0; i < srcount; i++) {
+            cJSON *r = cJSON_GetArrayItem(seed_relays, i);
+            if (r && cJSON_IsString(r)) {
+                strncpy(g_config.nostr_seed_relays[i], r->valuestring,
+                        sizeof(g_config.nostr_seed_relays[i]) - 1);
+                g_config.nostr_seed_relay_count++;
+            }
+        }
+    }
+
     cJSON *client_enabled = cJSON_GetObjectItem(root, "client_enabled");
     if (client_enabled && cJSON_IsBool(client_enabled)) g_config.client_enabled = cJSON_IsTrue(client_enabled);
 
@@ -251,6 +298,14 @@ esp_err_t tollgate_config_init(void)
         }
     }
 
+    cJSON *auth_mode = cJSON_GetObjectItem(root, "wifi_auth_mode");
+    if (auth_mode && cJSON_IsString(auth_mode)) {
+        strncpy(g_config.wifi_auth_mode, auth_mode->valuestring, sizeof(g_config.wifi_auth_mode) - 1);
+    }
+
+    cJSON *disp_en = cJSON_GetObjectItem(root, "display_enabled");
+    if (disp_en && cJSON_IsBool(disp_en)) g_config.display_enabled = cJSON_IsTrue(disp_en);
+
     if (g_config.payout.mint_count == 0 && g_config.mint_url[0] != '\0') {
         strncpy(g_config.payout.mints[0].url, g_config.mint_url,
                 sizeof(g_config.payout.mints[0].url) - 1);
@@ -259,28 +314,6 @@ esp_err_t tollgate_config_init(void)
         g_config.payout.mint_count = 1;
     }
 
-    cJSON *seed_relays = cJSON_GetObjectItem(root, "nostr_seed_relays");
-    if (seed_relays && cJSON_IsArray(seed_relays)) {
-        int srcount = cJSON_GetArraySize(seed_relays);
-        if (srcount > TOLLGATE_MAX_SEED_RELAYS) srcount = TOLLGATE_MAX_SEED_RELAYS;
-        for (int i = 0; i < srcount; i++) {
-            cJSON *r = cJSON_GetArrayItem(seed_relays, i);
-            if (r && cJSON_IsString(r)) {
-                strncpy(g_config.nostr_seed_relays[i], r->valuestring,
-                        sizeof(g_config.nostr_seed_relays[i]) - 1);
-                g_config.nostr_seed_relay_count++;
-            }
-        }
-    }
-
-    cJSON *sync_interval = cJSON_GetObjectItem(root, "nostr_sync_interval_s");
-    if (sync_interval) g_config.nostr_sync_interval_s = sync_interval->valueint;
-
-    cJSON *fallback_interval = cJSON_GetObjectItem(root, "nostr_fallback_sync_interval_s");
-    if (fallback_interval) g_config.nostr_fallback_sync_interval_s = fallback_interval->valueint;
-
-    cJSON_Delete(root);
-
     if (g_config.payout.recipient_count == 0) {
         strncpy(g_config.payout.recipients[0].lightning_address, "TollGate@coinos.io",
                 sizeof(g_config.payout.recipients[0].lightning_address) - 1);
@@ -288,6 +321,14 @@ esp_err_t tollgate_config_init(void)
         g_config.payout.recipient_count = 1;
     }
 
+    cJSON_Delete(root);
+
+    if (g_config.accepted_mint_count == 0 && g_config.mint_url[0] != '\0') {
+        strncpy(g_config.accepted_mints[0], g_config.mint_url,
+                sizeof(g_config.accepted_mints[0]) - 1);
+        g_config.accepted_mint_count = 1;
+    }
+
     if (g_config.nostr_relay_count == 0) {
         strncpy(g_config.nostr_relays[0], "wss://relay.damus.io", sizeof(g_config.nostr_relays[0]) - 1);
         strncpy(g_config.nostr_relays[1], "wss://nos.lol", sizeof(g_config.nostr_relays[1]) - 1);
@@ -306,9 +347,9 @@ esp_err_t tollgate_config_init(void)
         g_config.nostr_seed_relay_count = 4;
     }
 
-    ESP_LOGI(TAG, "Config loaded: nsec=%s...%s, %d WiFi networks, price=%d sats/%dms",
+    ESP_LOGI(TAG, "Config loaded: nsec=%s...%s, %d WiFi networks, %d accepted mints, price=%d sats/%dms",
              g_config.nsec, g_config.nsec + 60, g_config.network_count,
-             g_config.price_per_step, g_config.step_size_ms);
+             g_config.accepted_mint_count, g_config.price_per_step, g_config.step_size_ms);
     return ESP_OK;
 }
 
@@ -325,14 +366,18 @@ esp_err_t tollgate_config_get_wifi(wifi_config_t *wifi_config)
     strncpy((char *)wifi_config->sta.ssid, g_config.networks[idx].ssid, sizeof(wifi_config->sta.ssid) - 1);
     strncpy((char *)wifi_config->sta.password, g_config.networks[idx].password, sizeof(wifi_config->sta.password) - 1);
     wifi_config->sta.threshold.authmode = WIFI_AUTH_WPA2_PSK;
-    wifi_config->sta.pmf_cfg.capable = true;
-    wifi_config->sta.pmf_cfg.required = false;
-    wifi_config->sta.scan_method = WIFI_ALL_CHANNEL_SCAN;
+    if (strstr(g_config.wifi_auth_mode, "WPA3")) {
+        wifi_config->sta.threshold.authmode = WIFI_AUTH_WPA3_PSK;
+    } else if (strstr(g_config.wifi_auth_mode, "WPA2")) {
+        wifi_config->sta.threshold.authmode = WIFI_AUTH_WPA2_PSK;
+    }
+    ESP_LOGI(TAG, "STA auth threshold: %s -> %d", g_config.wifi_auth_mode, wifi_config->sta.threshold.authmode);
     return ESP_OK;
 }
 
 esp_err_t tollgate_config_get_next_wifi(wifi_config_t *wifi_config)
 {
+    if (g_config.network_count == 0) return ESP_ERR_NOT_FOUND;
     g_config.current_network = (g_config.current_network + 1) % g_config.network_count;
     return tollgate_config_get_wifi(wifi_config);
 }
diff --git a/main/config.h b/main/config.h
index af372af..370e6cc 100644
--- a/main/config.h
+++ b/main/config.h
@@ -9,7 +9,7 @@
 #include "lightning_payout.h"
 
 #define TOLLGATE_MAX_WIFI_NETWORKS 5
-#define TOLLGATE_MAX_MINT_URLS     3
+#define TOLLGATE_MAX_MINT_URLS     8
 #define TOLLGATE_MAX_AP_SSID_LEN   32
 #define TOLLGATE_MAX_AP_PASS_LEN   64
 #define TOLLGATE_MAX_RELAYS        4
@@ -41,6 +41,8 @@ typedef struct {
     char ap_ip_str[16];
 
     char mint_url[256];
+    char accepted_mints[TOLLGATE_MAX_MINT_URLS][256];
+    int accepted_mint_count;
     char lnurl_url[256];
     int price_per_step;
     int step_size_ms;
@@ -52,6 +54,8 @@ typedef struct {
     char nostr_relays[TOLLGATE_MAX_RELAYS][128];
     int nostr_relay_count;
     int nostr_publish_interval_s;
+    int nostr_sync_interval_s;
+    int nostr_fallback_sync_interval_s;
 
     bool identity_initialized;
 
@@ -65,10 +69,11 @@ typedef struct {
     bool cvm_enabled;
     char cvm_relays[256];
 
+    char wifi_auth_mode[16];
+    bool display_enabled;
+
     char nostr_seed_relays[TOLLGATE_MAX_SEED_RELAYS][128];
     int nostr_seed_relay_count;
-    int nostr_sync_interval_s;
-    int nostr_fallback_sync_interval_s;
 
     bool market_enabled;
     int market_scan_interval_s;
diff --git a/main/cvm_server.c b/main/cvm_server.c
index a4804d2..10af956 100644
--- a/main/cvm_server.c
+++ b/main/cvm_server.c
@@ -31,9 +31,6 @@ static void publish_announcements_via_ws(esp_tls_t *tls);
 #define CVM_WS_BUF_SIZE 8192
 #define CVM_MAX_RESPONSE_SIZE 4096
 #define CVM_RECONNECT_DELAY_MS 5000
-#define CVM_WS_READ_TIMEOUT_MS 1000
-#define CVM_WS_PING_INTERVAL_S 30
-#define CVM_WS_MAX_CONSECUTIVE_TIMEOUTS 65
 
 static char *parse_ws_text_frame(const uint8_t *buf, int len)
 {
@@ -557,19 +554,14 @@ static void cvm_relay_task(void *arg)
             return;
         }
 
-        int64_t last_ping_time = (int64_t)esp_timer_get_time() / 1000000;
         int consecutive_timeouts = 0;
-
         while (g_running) {
             int rlen = esp_tls_conn_read(tls, buf, CVM_WS_BUF_SIZE - 1);
             if (rlen < 0) {
-                consecutive_timeouts++;
-                if (consecutive_timeouts >= CVM_WS_MAX_CONSECUTIVE_TIMEOUTS) {
-                    ESP_LOGW(TAG, "Read timeout on %s (%d consecutive)", relay_url, consecutive_timeouts);
-                    break;
-                }
-            } else if (rlen == 0) {
-                ESP_LOGW(TAG, "Connection closed by %s", relay_url);
+                ESP_LOGW(TAG, "Read error on %s (rlen=%d)", relay_url, rlen);
+                break;
+            }
+            if (rlen == 0) {
                 break;
             } else {
                 consecutive_timeouts = 0;
@@ -591,13 +583,6 @@ static void cvm_relay_task(void *arg)
                 }
             }
 
-            int64_t now = (int64_t)esp_timer_get_time() / 1000000;
-            if (now - last_ping_time >= CVM_WS_PING_INTERVAL_S) {
-                uint8_t ping[2] = {0x89, 0x00};
-                esp_tls_conn_write(tls, ping, 2);
-                last_ping_time = now;
-                ESP_LOGD(TAG, "Sent WS keepalive ping");
-            }
         }
 
         free(buf);
diff --git a/main/display.c b/main/display.c
index 72b7686..2b6cc88 100644
--- a/main/display.c
+++ b/main/display.c
@@ -42,7 +42,7 @@ static int qr_pixel_size(int len) {
     return 2;
 }
 
-int escape_wifi_field(const char *src, char *dst, int dst_size) {
+static int escape_wifi_field(const char *src, char *dst, int dst_size) {
     int si = 0, di = 0;
     while (src[si] && di < dst_size - 2) {
         char c = src[si];
diff --git a/main/mint_health.c b/main/mint_health.c
new file mode 100644
index 0000000..5853a39
--- /dev/null
+++ b/main/mint_health.c
@@ -0,0 +1,235 @@
+#include "mint_health.h"
+#include "esp_log.h"
+#include "esp_http_client.h"
+#include "esp_crt_bundle.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/semphr.h"
+#include <string.h>
+#include <stdlib.h>
+
+static const char *TAG = "mint_health";
+
+static mint_status_t s_mints[MINT_HEALTH_MAX];
+static int s_mint_count = 0;
+static bool s_running = false;
+static TaskHandle_t s_task_handle = NULL;
+static SemaphoreHandle_t s_mutex = NULL;
+
+#define MAX_CALLBACKS 4
+static mint_health_changed_cb s_callbacks[MAX_CALLBACKS];
+static int s_callback_count = 0;
+
+static void fire_callbacks(void)
+{
+    for (int i = 0; i < s_callback_count; i++) {
+        if (s_callbacks[i]) s_callbacks[i]();
+    }
+}
+
+esp_err_t mint_health_init(const char urls[][256], int count)
+{
+    if (count > MINT_HEALTH_MAX) count = MINT_HEALTH_MAX;
+    s_mint_count = count;
+    s_callback_count = 0;
+
+    if (!s_mutex) s_mutex = xSemaphoreCreateMutex();
+
+    memset(s_mints, 0, sizeof(s_mints));
+    for (int i = 0; i < count; i++) {
+        strncpy(s_mints[i].url, urls[i], sizeof(s_mints[i].url) - 1);
+        s_mints[i].reachable = false;
+        s_mints[i].consecutive_successes = 0;
+        s_mints[i].last_probe_ms = 0;
+        s_mints[i].last_http_status = 0;
+    }
+
+    ESP_LOGI(TAG, "Initialized with %d mints", count);
+    return ESP_OK;
+}
+
+static bool probe_mint(const char *url)
+{
+    char probe_url[512];
+    snprintf(probe_url, sizeof(probe_url), "%s/v1/info", url);
+
+    esp_http_client_config_t config = {
+        .url = probe_url,
+        .method = HTTP_METHOD_GET,
+        .timeout_ms = MINT_HEALTH_PROBE_TIMEOUT_MS,
+        .crt_bundle_attach = esp_crt_bundle_attach,
+    };
+    esp_http_client_handle_t client = esp_http_client_init(&config);
+    if (!client) return false;
+
+    esp_err_t err = esp_http_client_open(client, 0);
+    if (err != ESP_OK) {
+        esp_http_client_cleanup(client);
+        return false;
+    }
+
+    int content_length = esp_http_client_fetch_headers(client);
+    int status = esp_http_client_get_status_code(client);
+
+    char *resp = NULL;
+    if (content_length > 0 && content_length < 8192) {
+        resp = malloc(content_length + 1);
+        if (resp) {
+            int read = esp_http_client_read(client, resp, content_length);
+            if (read > 0) resp[read] = '\0';
+        }
+    }
+    if (resp) free(resp);
+
+    esp_http_client_cleanup(client);
+    return (status >= 200 && status < 300);
+}
+
+static void run_probes(void)
+{
+    int old_reachable = 0;
+    int new_reachable = 0;
+
+    if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(5000)) != pdTRUE) return;
+
+    for (int i = 0; i < s_mint_count; i++) {
+        if (s_mints[i].reachable) old_reachable++;
+    }
+
+    for (int i = 0; i < s_mint_count; i++) {
+        bool ok = probe_mint(s_mints[i].url);
+        s_mints[i].last_probe_ms = (int64_t)xTaskGetTickCount() * portTICK_PERIOD_MS;
+        s_mints[i].last_http_status = ok ? 200 : 0;
+
+        if (ok) {
+            s_mints[i].consecutive_successes++;
+            if (s_mints[i].consecutive_successes >= MINT_HEALTH_RECOVERY_THRESHOLD) {
+                if (!s_mints[i].reachable) {
+                    ESP_LOGI(TAG, "Mint RECOVERED: %s", s_mints[i].url);
+                }
+                s_mints[i].reachable = true;
+            }
+        } else {
+            if (s_mints[i].reachable) {
+                ESP_LOGW(TAG, "Mint UNREACHABLE: %s", s_mints[i].url);
+            }
+            s_mints[i].reachable = false;
+            s_mints[i].consecutive_successes = 0;
+        }
+
+        if (s_mints[i].reachable) new_reachable++;
+    }
+
+    bool changed = (old_reachable != new_reachable);
+    xSemaphoreGive(s_mutex);
+
+    if (changed) {
+        ESP_LOGI(TAG, "Reachable set changed: %d -> %d", old_reachable, new_reachable);
+        fire_callbacks();
+    }
+}
+
+static void run_initial_probes(void)
+{
+    if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(5000)) != pdTRUE) return;
+
+    for (int i = 0; i < s_mint_count; i++) {
+        bool ok = probe_mint(s_mints[i].url);
+        s_mints[i].last_probe_ms = (int64_t)xTaskGetTickCount() * portTICK_PERIOD_MS;
+        s_mints[i].last_http_status = ok ? 200 : 0;
+
+        if (ok) {
+            s_mints[i].consecutive_successes = MINT_HEALTH_RECOVERY_THRESHOLD;
+            s_mints[i].reachable = true;
+            ESP_LOGI(TAG, "Initial probe OK: %s (reachable)", s_mints[i].url);
+        } else {
+            s_mints[i].consecutive_successes = 0;
+            s_mints[i].reachable = false;
+            ESP_LOGW(TAG, "Initial probe FAIL: %s (unreachable)", s_mints[i].url);
+        }
+    }
+
+    xSemaphoreGive(s_mutex);
+    fire_callbacks();
+}
+
+static void health_task(void *pvParameters)
+{
+    ESP_LOGI(TAG, "Health probe task started, waiting for DNS to stabilize...");
+    vTaskDelay(pdMS_TO_TICKS(5000));
+    run_initial_probes();
+
+    while (s_running) {
+        vTaskDelay(pdMS_TO_TICKS(MINT_HEALTH_PROBE_INTERVAL_S * 1000));
+        if (!s_running) break;
+        run_probes();
+    }
+
+    s_task_handle = NULL;
+    vTaskDelete(NULL);
+}
+
+void mint_health_start(void)
+{
+    if (s_running) return;
+    s_running = true;
+    xTaskCreate(health_task, "mint_health", 16384, NULL, 3, &s_task_handle);
+}
+
+void mint_health_stop(void)
+{
+    s_running = false;
+    if (s_task_handle) {
+        vTaskDelay(pdMS_TO_TICKS(100));
+    }
+}
+
+const mint_status_t *mint_health_get_all(int *out_count)
+{
+    if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(1000)) != pdTRUE) {
+        *out_count = 0;
+        return s_mints;
+    }
+    *out_count = s_mint_count;
+    xSemaphoreGive(s_mutex);
+    return s_mints;
+}
+
+bool mint_health_is_reachable(const char *url)
+{
+    if (!url) return false;
+    if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(1000)) != pdTRUE) return false;
+    bool result = false;
+    for (int i = 0; i < s_mint_count; i++) {
+        if (strcmp(s_mints[i].url, url) == 0 || strstr(url, s_mints[i].url) != NULL) {
+            result = s_mints[i].reachable;
+            break;
+        }
+    }
+    xSemaphoreGive(s_mutex);
+    return result;
+}
+
+void mint_health_mark_unreachable(const char *url)
+{
+    if (!url) return;
+    if (xSemaphoreTake(s_mutex, pdMS_TO_TICKS(1000)) != pdTRUE) return;
+    for (int i = 0; i < s_mint_count; i++) {
+        if (strcmp(s_mints[i].url, url) == 0 || strstr(url, s_mints[i].url) != NULL) {
+            if (s_mints[i].reachable) {
+                s_mints[i].reachable = false;
+                s_mints[i].consecutive_successes = 0;
+                ESP_LOGW(TAG, "Reactively marked unreachable: %s", url);
+            }
+            break;
+        }
+    }
+    xSemaphoreGive(s_mutex);
+}
+
+void mint_health_register_callback(mint_health_changed_cb cb)
+{
+    if (s_callback_count < MAX_CALLBACKS && cb) {
+        s_callbacks[s_callback_count++] = cb;
+    }
+}
diff --git a/main/mint_health.h b/main/mint_health.h
new file mode 100644
index 0000000..f047d6a
--- /dev/null
+++ b/main/mint_health.h
@@ -0,0 +1,31 @@
+#ifndef MINT_HEALTH_H
+#define MINT_HEALTH_H
+
+#include "esp_err.h"
+#include <stdint.h>
+#include <stdbool.h>
+
+#define MINT_HEALTH_MAX             8
+#define MINT_HEALTH_PROBE_INTERVAL_S  300
+#define MINT_HEALTH_PROBE_TIMEOUT_MS  15000
+#define MINT_HEALTH_RECOVERY_THRESHOLD 3
+
+typedef struct {
+    char url[256];
+    bool reachable;
+    uint8_t consecutive_successes;
+    int64_t last_probe_ms;
+    int last_http_status;
+} mint_status_t;
+
+typedef void (*mint_health_changed_cb)(void);
+
+esp_err_t mint_health_init(const char urls[][256], int count);
+void mint_health_start(void);
+void mint_health_stop(void);
+const mint_status_t *mint_health_get_all(int *out_count);
+bool mint_health_is_reachable(const char *url);
+void mint_health_mark_unreachable(const char *url);
+void mint_health_register_callback(mint_health_changed_cb cb);
+
+#endif
diff --git a/main/tollgate_api.c b/main/tollgate_api.c
index 15640c7..21bf9ef 100644
--- a/main/tollgate_api.c
+++ b/main/tollgate_api.c
@@ -1,6 +1,7 @@
 #include "tollgate_api.h"
 #include "cashu.h"
 #include "config.h"
+#include "identity.h"
 #include "session.h"
 #include "firewall.h"
 #include "nucula_wallet.h"
@@ -17,8 +18,6 @@
 static const char *TAG = "tollgate_api";
 static httpd_handle_t s_api_server = NULL;
 
-static const char *TOLLGATE_PUBKEY = "0000000000000000000000000000000000000000000000000000000000000000";
-
 static esp_err_t get_client_ip(httpd_req_t *req, uint32_t *ip_out)
 {
     int sockfd = httpd_req_to_sockfd(req);
@@ -35,7 +34,7 @@ static cJSON *create_notice(const char *level, const char *code, const char *con
 {
     cJSON *root = cJSON_CreateObject();
     cJSON_AddNumberToObject(root, "kind", 21023);
-    cJSON_AddStringToObject(root, "pubkey", TOLLGATE_PUBKEY);
+    cJSON_AddStringToObject(root, "pubkey", identity_get()->npub_hex);
     cJSON *tags = cJSON_CreateArray();
     cJSON *level_tag = cJSON_CreateArray();
     cJSON_AddItemToArray(level_tag, cJSON_CreateString("level"));
@@ -54,7 +53,7 @@ static cJSON *create_session_event(uint32_t client_ip, uint64_t allotment_ms)
 {
     cJSON *root = cJSON_CreateObject();
     cJSON_AddNumberToObject(root, "kind", 1022);
-    cJSON_AddStringToObject(root, "pubkey", TOLLGATE_PUBKEY);
+    cJSON_AddStringToObject(root, "pubkey", identity_get()->npub_hex);
 
     cJSON *tags = cJSON_CreateArray();
 
@@ -96,7 +95,7 @@ static esp_err_t api_get_discovery(httpd_req_t *req)
 
     cJSON *root = cJSON_CreateObject();
     cJSON_AddNumberToObject(root, "kind", 10021);
-    cJSON_AddStringToObject(root, "pubkey", TOLLGATE_PUBKEY);
+    cJSON_AddStringToObject(root, "pubkey", identity_get()->npub_hex);
 
     cJSON *tags = cJSON_CreateArray();
 
@@ -113,16 +112,36 @@ static esp_err_t api_get_discovery(httpd_req_t *req)
     cJSON_AddItemToArray(step_tag, cJSON_CreateString(step_str));
     cJSON_AddItemToArray(tags, step_tag);
 
-    cJSON *price_tag = cJSON_CreateArray();
-    cJSON_AddItemToArray(price_tag, cJSON_CreateString("price_per_step"));
-    cJSON_AddItemToArray(price_tag, cJSON_CreateString("cashu"));
     char price_str[32];
     snprintf(price_str, sizeof(price_str), "%d", cfg->price_per_step);
-    cJSON_AddItemToArray(price_tag, cJSON_CreateString(price_str));
-    cJSON_AddItemToArray(price_tag, cJSON_CreateString("sat"));
-    cJSON_AddItemToArray(price_tag, cJSON_CreateString(cfg->mint_url));
-    cJSON_AddItemToArray(price_tag, cJSON_CreateString("1"));
-    cJSON_AddItemToArray(tags, price_tag);
+
+    int mint_count = 0;
+    const mint_status_t *mints = mint_health_get_all(&mint_count);
+    bool any_reachable = false;
+
+    for (int i = 0; i < mint_count; i++) {
+        if (!mints[i].reachable) continue;
+        any_reachable = true;
+        cJSON *price_tag = cJSON_CreateArray();
+        cJSON_AddItemToArray(price_tag, cJSON_CreateString("price_per_step"));
+        cJSON_AddItemToArray(price_tag, cJSON_CreateString("cashu"));
+        cJSON_AddItemToArray(price_tag, cJSON_CreateString(price_str));
+        cJSON_AddItemToArray(price_tag, cJSON_CreateString("sat"));
+        cJSON_AddItemToArray(price_tag, cJSON_CreateString(mints[i].url));
+        cJSON_AddItemToArray(price_tag, cJSON_CreateString("1"));
+        cJSON_AddItemToArray(tags, price_tag);
+    }
+
+    if (!any_reachable) {
+        cJSON *price_tag = cJSON_CreateArray();
+        cJSON_AddItemToArray(price_tag, cJSON_CreateString("price_per_step"));
+        cJSON_AddItemToArray(price_tag, cJSON_CreateString("cashu"));
+        cJSON_AddItemToArray(price_tag, cJSON_CreateString(price_str));
+        cJSON_AddItemToArray(price_tag, cJSON_CreateString("sat"));
+        cJSON_AddItemToArray(price_tag, cJSON_CreateString(cfg->mint_url));
+        cJSON_AddItemToArray(price_tag, cJSON_CreateString("1"));
+        cJSON_AddItemToArray(tags, price_tag);
+    }
 
     cJSON *tips_tag = cJSON_CreateArray();
     cJSON_AddItemToArray(tips_tag, cJSON_CreateString("tips"));
@@ -466,8 +485,28 @@ static esp_err_t api_post_wallet_send(httpd_req_t *req)
     return ESP_OK;
 }
 
+static esp_err_t api_get_mints(httpd_req_t *req)
+{
+    int mint_count = 0;
+    const mint_status_t *mints = mint_health_get_all(&mint_count);
+    cJSON *arr = cJSON_CreateArray();
+    for (int i = 0; i < mint_count; i++) {
+        cJSON *obj = cJSON_CreateObject();
+        cJSON_AddStringToObject(obj, "url", mints[i].url);
+        cJSON_AddBoolToObject(obj, "reachable", mints[i].reachable);
+        cJSON_AddItemToArray(arr, obj);
+    }
+    char *json = cJSON_PrintUnformatted(arr);
+    httpd_resp_set_type(req, "application/json");
+    httpd_resp_send(req, json, strlen(json));
+    cJSON_free(json);
+    cJSON_Delete(arr);
+    return ESP_OK;
+}
+
 static const httpd_uri_t uri_discovery = { .uri = "/", .method = HTTP_GET, .handler = api_get_discovery };
 static const httpd_uri_t uri_payment = { .uri = "/", .method = HTTP_POST, .handler = api_post_payment };
+static const httpd_uri_t uri_mints = { .uri = "/mints", .method = HTTP_GET, .handler = api_get_mints };
 static const httpd_uri_t uri_usage = { .uri = "/usage", .method = HTTP_GET, .handler = api_get_usage };
 static const httpd_uri_t uri_whoami = { .uri = "/whoami", .method = HTTP_GET, .handler = api_get_whoami };
 static const httpd_uri_t uri_wallet = { .uri = "/wallet", .method = HTTP_GET, .handler = api_get_wallet };
@@ -520,17 +559,19 @@ esp_err_t tollgate_api_start(void)
     httpd_config_t config = HTTPD_DEFAULT_CONFIG();
     config.server_port = 2121;
     config.ctrl_port = 32769;
-    config.max_uri_handlers = 10;
+    config.max_uri_handlers = 12;
     config.stack_size = 16384;
 
     esp_err_t ret = httpd_start(&s_api_server, &config);
     if (ret != ESP_OK) {
-        ESP_LOGE(TAG, "Failed to start API server: %s", esp_err_to_name(ret));
+        ESP_LOGE(TAG, "Failed to start API server: %s (heap: %lu)", esp_err_to_name(ret), (unsigned long)esp_get_free_heap_size());
+        s_api_server = NULL;
         return ret;
     }
 
     httpd_register_uri_handler(s_api_server, &uri_discovery);
     httpd_register_uri_handler(s_api_server, &uri_payment);
+    httpd_register_uri_handler(s_api_server, &uri_mints);
     httpd_register_uri_handler(s_api_server, &uri_usage);
     httpd_register_uri_handler(s_api_server, &uri_whoami);
     httpd_register_uri_handler(s_api_server, &uri_wallet);
diff --git a/main/tollgate_main.c b/main/tollgate_main.c
index f062cb6..33e5b90 100644
--- a/main/tollgate_main.c
+++ b/main/tollgate_main.c
@@ -5,6 +5,7 @@
 #include "esp_wifi.h"
 #include "esp_event.h"
 #include "esp_log.h"
+#include "esp_system.h"
 #include "nvs_flash.h"
 #include "esp_netif.h"
 #include "lwip/netif.h"
@@ -22,6 +23,7 @@
 #include "wifistr.h"
 #include "tollgate_client.h"
 #include "lightning_payout.h"
+#include "mint_health.h"
 #include "cvm_server.h"
 #include "display.h"
 #include "local_relay.h"
@@ -119,6 +121,7 @@ static void wifi_event_handler(void *arg, esp_event_base_t event_base,
 
 static void services_start_task(void *pvParameters)
 {
+    vTaskDelay(pdMS_TO_TICKS(3000));
     start_services();
     vTaskDelete(NULL);
 }
@@ -187,7 +190,15 @@ static void start_services(void)
     session_manager_init();
 
     const tollgate_config_t *cfg = tollgate_config_get();
-    nucula_wallet_init(cfg->mint_url);
+
+    mint_health_init(cfg->accepted_mints, cfg->accepted_mint_count);
+    mint_health_start();
+
+    if (cfg->accepted_mint_count > 1) {
+        nucula_wallet_init_multi(cfg->accepted_mints, cfg->accepted_mint_count);
+    } else {
+        nucula_wallet_init(cfg->mint_url);
+    }
     lightning_payout_init(&cfg->payout);
 
     dns_server_start(ap_ip_info.ip, upstream_dns);
@@ -216,10 +227,12 @@ static void start_services(void)
     if (s_services_mutex) xSemaphoreGive(s_services_mutex);
     ESP_LOGI(TAG, "=== TollGate services started ===");
 
-    display_set_state(DISPLAY_READY);
-    char portal_url[128];
-    snprintf(portal_url, sizeof(portal_url), "http://%s/", cfg->ap_ip_str);
-    display_update(cfg->ap_ssid, 0, 0, portal_url);
+    if (tollgate_config_get()->display_enabled) {
+        display_set_state(DISPLAY_READY);
+        char portal_url[128];
+        snprintf(portal_url, sizeof(portal_url), "http://%s/", cfg->ap_ip_str);
+        display_update(cfg->ap_ssid, 0, 0, portal_url);
+    }
 }
 
 static void stop_services(void)
@@ -306,8 +319,10 @@ void app_main(void)
 {
     ESP_LOGI(TAG, "=== TollGate ESP32 Starting ===");
 
-    display_init();
-    display_set_state(DISPLAY_BOOT);
+    if (tollgate_config_get()->display_enabled) {
+        display_init();
+        display_set_state(DISPLAY_BOOT);
+    }
 
     esp_err_t ret = nvs_flash_init();
     if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
diff --git a/main/wifistr.c b/main/wifistr.c
index 543aaf6..bf03b4d 100644
--- a/main/wifistr.c
+++ b/main/wifistr.c
@@ -2,7 +2,6 @@
 #include "identity.h"
 #include "nostr_event.h"
 #include "config.h"
-#include "local_relay.h"
 #include "esp_log.h"
 #include "esp_tls.h"
 #include "esp_crt_bundle.h"
@@ -217,13 +216,8 @@ esp_err_t wifistr_publish(void)
 
     ESP_LOGI(TAG, "Wifistr event: %s", event_json);
 
-    esp_err_t local_ret = local_relay_publish(event_json, strlen(event_json));
-    if (local_ret == ESP_OK) {
-        ESP_LOGI(TAG, "Published to local relay");
-    }
-
     const tollgate_config_t *cfg = tollgate_config_get();
-    esp_err_t last_err = local_ret;
+    esp_err_t last_err = ESP_FAIL;
 
     for (int i = 0; i < cfg->nostr_relay_count; i++) {
         esp_err_t err = ws_send_to_relay(cfg->nostr_relays[i], event_json);