1 files changed, 270 insertions, 0 deletions

diff --git a/main/relay_selector.c b/main/relay_selector.c
new file mode 100644
index 0000000..7c443fe
--- /dev/null
+++ b/main/relay_selector.c
@@ -0,0 +1,270 @@
+#include "relay_selector.h"
+#include "config.h"
+#include "esp_log.h"
+#include "esp_http_client.h"
+#include "esp_tls.h"
+#include "esp_crt_bundle.h"
+#include "esp_timer.h"
+#include "cJSON.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/semphr.h"
+#include <string.h>
+#include <stdlib.h>
+
+static const char *TAG = "relay_sel";
+static const int MAX_REDIRECTS = 3;
+static const int PROBE_TIMEOUT_MS = 5000;
+static const int MAX_FAILURES = 3;
+
+static int compare_relays(const void *a, const void *b)
+{
+    const relay_info_t *ra = (const relay_info_t *)a;
+    const relay_info_t *rb = (const relay_info_t *)b;
+
+    if (ra->alive && !rb->alive) return -1;
+    if (!ra->alive && rb->alive) return 1;
+
+    int score_a = (ra->supports_nip77 ? 1000 : 0) - ra->consecutive_failures * 100;
+    int score_b = (rb->supports_nip77 ? 1000 : 0) - rb->consecutive_failures * 100;
+    if (score_a != score_b) return score_b - score_a;
+
+    return (int)ra->latency_ms - (int)rb->latency_ms;
+}
+
+esp_err_t relay_selector_init(relay_selector_t *sel)
+{
+    memset(sel, 0, sizeof(relay_selector_t));
+    sel->primary_idx = -1;
+    sel->fallback_idx = -1;
+    sel->lock = xSemaphoreCreateMutex();
+    if (!sel->lock) return ESP_ERR_NO_MEM;
+    return ESP_OK;
+}
+
+void relay_selector_destroy(relay_selector_t *sel)
+{
+    if (sel->lock) { vSemaphoreDelete(sel->lock); sel->lock = NULL; }
+}
+
+static esp_err_t probe_nip11(const char *wss_url, relay_info_t *info)
+{
+    char http_url[192];
+    const char *host_start = wss_url;
+    if (strncmp(wss_url, "wss://", 6) == 0) host_start = wss_url + 6;
+    else if (strncmp(wss_url, "ws://", 5) == 0) host_start = wss_url + 5;
+
+    snprintf(http_url, sizeof(http_url), "https://%s/", host_start);
+
+    char response[4096];
+    int total_len = 0;
+
+    esp_http_client_config_t http_cfg = {
+        .url = http_url,
+        .method = HTTP_METHOD_GET,
+        .timeout_ms = PROBE_TIMEOUT_MS,
+        .crt_bundle_attach = esp_crt_bundle_attach,
+        .max_redirection_count = MAX_REDIRECTS,
+        .disable_auto_redirect = false,
+    };
+
+    esp_http_client_handle_t client = esp_http_client_init(&http_cfg);
+    if (!client) return ESP_FAIL;
+
+    esp_http_client_set_header(client, "Accept", "application/nostr+json");
+
+    int64_t start_time = esp_timer_get_time();
+    esp_err_t err = esp_http_client_open(client, 0);
+    if (err != ESP_OK) {
+        esp_http_client_cleanup(client);
+        info->alive = false;
+        return err;
+    }
+
+    int content_length = esp_http_client_fetch_headers(client);
+    int status = esp_http_client_get_status_code(client);
+
+    if (status != 200) {
+        esp_http_client_close(client);
+        esp_http_client_cleanup(client);
+        info->alive = (status > 0);
+        return ESP_FAIL;
+    }
+
+    int max_read = content_length > 0 ? content_length : (int)sizeof(response) - 1;
+    if (max_read > (int)sizeof(response) - 1) max_read = (int)sizeof(response) - 1;
+
+    while (total_len < max_read) {
+        int read_len = esp_http_client_read(client, response + total_len,
+                                            max_read - total_len);
+        if (read_len <= 0) break;
+        total_len += read_len;
+    }
+    response[total_len] = '\0';
+
+    int64_t end_time = esp_timer_get_time();
+    info->latency_ms = (uint32_t)((end_time - start_time) / 1000);
+
+    esp_http_client_close(client);
+    esp_http_client_cleanup(client);
+
+    info->alive = true;
+    info->consecutive_failures = 0;
+
+    cJSON *root = cJSON_Parse(response);
+    if (!root) return ESP_OK;
+
+    cJSON *name = cJSON_GetObjectItem(root, "name");
+    if (name && cJSON_IsString(name))
+        strncpy(info->name, name->valuestring, sizeof(info->name) - 1);
+
+    cJSON *nips = cJSON_GetObjectItem(root, "supported_nips");
+    if (nips && cJSON_IsArray(nips)) {
+        info->nips_count = cJSON_GetArraySize(nips);
+        if (info->nips_count > 32) info->nips_count = 32;
+        info->supports_nip77 = false;
+        for (size_t i = 0; i < info->nips_count; i++) {
+            cJSON *nip = cJSON_GetArrayItem(nips, i);
+            if (nip) {
+                info->supported_nips[i] = (uint8_t)nip->valueint;
+                if (nip->valueint == 77) info->supports_nip77 = true;
+            }
+        }
+    }
+
+    cJSON_Delete(root);
+    return ESP_OK;
+}
+
+static void select_primary_fallback(relay_selector_t *sel)
+{
+    relay_info_t sorted[RELAY_SELECTOR_MAX_RELAYS];
+    size_t sorted_count = 0;
+
+    for (size_t i = 0; i < sel->count; i++) {
+        if (sel->relays[i].alive) {
+            sorted[sorted_count++] = sel->relays[i];
+        }
+    }
+
+    if (sorted_count == 0) {
+        sel->primary_idx = -1;
+        sel->fallback_idx = -1;
+        return;
+    }
+
+    qsort(sorted, sorted_count, sizeof(relay_info_t), compare_relays);
+
+    for (size_t i = 0; i < sel->count; i++) {
+        if (strcmp(sel->relays[i].url, sorted[0].url) == 0) {
+            sel->primary_idx = (int)i;
+            break;
+        }
+    }
+
+    if (sorted_count > 1) {
+        for (size_t i = 0; i < sel->count; i++) {
+            if (strcmp(sel->relays[i].url, sorted[1].url) == 0) {
+                sel->fallback_idx = (int)i;
+                break;
+            }
+        }
+    } else {
+        sel->fallback_idx = -1;
+    }
+
+    ESP_LOGI(TAG, "Primary: %s (latency=%lums, NIP-77=%s)",
+             sel->primary_idx >= 0 ? sel->relays[sel->primary_idx].url : "none",
+             sel->primary_idx >= 0 ? (unsigned long)sel->relays[sel->primary_idx].latency_ms : 0,
+             sel->primary_idx >= 0 && sel->relays[sel->primary_idx].supports_nip77 ? "yes" : "no");
+}
+
+esp_err_t relay_selector_probe_all(relay_selector_t *sel)
+{
+    xSemaphoreTake(sel->lock, portMAX_DELAY);
+
+    ESP_LOGI(TAG, "Probing %zu relays via NIP-11...", sel->count);
+
+    for (size_t i = 0; i < sel->count; i++) {
+        ESP_LOGI(TAG, "Probing %s...", sel->relays[i].url);
+        esp_err_t err = probe_nip11(sel->relays[i].url, &sel->relays[i]);
+        if (err != ESP_OK) {
+            sel->relays[i].consecutive_failures++;
+            ESP_LOGW(TAG, "Probe failed for %s (failures=%d)",
+                     sel->relays[i].url, sel->relays[i].consecutive_failures);
+            if (sel->relays[i].consecutive_failures >= MAX_FAILURES) {
+                sel->relays[i].alive = false;
+            }
+        }
+        vTaskDelay(pdMS_TO_TICKS(100));
+    }
+
+    select_primary_fallback(sel);
+
+    int64_t now = (int64_t)(xTaskGetTickCount() / configTICK_RATE_HZ);
+    sel->last_full_probe = (uint32_t)now;
+
+    xSemaphoreGive(sel->lock);
+    return ESP_OK;
+}
+
+const relay_info_t *relay_selector_get_primary(relay_selector_t *sel)
+{
+    if (sel->primary_idx < 0 || sel->primary_idx >= (int)sel->count) return NULL;
+    return &sel->relays[sel->primary_idx];
+}
+
+const relay_info_t *relay_selector_get_fallback(relay_selector_t *sel, int idx)
+{
+    if (idx == 0) {
+        if (sel->fallback_idx < 0) return NULL;
+        return &sel->relays[sel->fallback_idx];
+    }
+    for (size_t i = 0; i < sel->count; i++) {
+        if ((int)i != sel->primary_idx && (int)i != sel->fallback_idx) {
+            if (sel->relays[i].alive) {
+                if (idx <= 0) return &sel->relays[i];
+                idx--;
+            }
+        }
+    }
+    return NULL;
+}
+
+void relay_selector_report_disconnect(relay_selector_t *sel, const char *url)
+{
+    xSemaphoreTake(sel->lock, portMAX_DELAY);
+    for (size_t i = 0; i < sel->count; i++) {
+        if (strcmp(sel->relays[i].url, url) == 0) {
+            sel->relays[i].consecutive_failures++;
+            ESP_LOGW(TAG, "Disconnect reported for %s (failures=%d)",
+                     url, sel->relays[i].consecutive_failures);
+            if (sel->relays[i].consecutive_failures >= MAX_FAILURES) {
+                sel->relays[i].alive = false;
+                ESP_LOGW(TAG, "Relay %s marked dead, triggering re-probe", url);
+                select_primary_fallback(sel);
+            }
+            break;
+        }
+    }
+    xSemaphoreGive(sel->lock);
+}
+
+esp_err_t relay_selector_seed_from_config(relay_selector_t *sel)
+{
+    const tollgate_config_t *cfg = tollgate_config_get();
+    xSemaphoreTake(sel->lock, portMAX_DELAY);
+
+    sel->count = 0;
+    for (int i = 0; i < cfg->nostr_seed_relay_count && sel->count < RELAY_SELECTOR_MAX_RELAYS; i++) {
+        if (cfg->nostr_seed_relays[i][0] != '\0') {
+            strncpy(sel->relays[sel->count].url, cfg->nostr_seed_relays[i],
+                    RELAY_SELECTOR_URL_LEN - 1);
+            sel->relays[sel->count].alive = true;
+            sel->count++;
+        }
+    }
+
+    xSemaphoreGive(sel->lock);
+    ESP_LOGI(TAG, "Seeded %zu relays from config", sel->count);
+    return ESP_OK;
+}