5 files changed, 111 insertions, 384 deletions

diff --git a/main/captive_portal.c b/main/captive_portal.c
index f95a791..8113856 100644
--- a/main/captive_portal.c
+++ b/main/captive_portal.c
@@ -2,6 +2,7 @@
 #include "tollgate_core.h"
 #include "tollgate_core_firewall.h"
 #include "tollgate_core_session.h"
+#include "tollgate_core_portal.h"
 #include "config.h"
 #include "stratum_proxy.h"
 #include "esp_log.h"
@@ -176,10 +177,12 @@ static esp_err_t portal_handler(httpd_req_t *req)
     char price_str[16];
     snprintf(price_str, sizeof(price_str), "%d", cfg->price_per_step);
 
-    const char *tpl = PORTAL_HTML_TEMPLATE;
-    size_t tpl_len = strlen(tpl);
+    char mining_port_buf[8] = "3333";
+    if (cfg->mining_enabled) {
+        snprintf(mining_port_buf, sizeof(mining_port_buf), "%d", cfg->mining_port);
+    }
 
-    struct { const char *key; const char *val; } subs[] = {
+    tollgate_portal_sub_t subs[] = {
         { "__AP_IP__", s_ap_ip_str },
         { "__PRICE__", price_str },
         { "__MINT_URL__", cfg->mint_url },
@@ -188,63 +191,19 @@ static esp_err_t portal_handler(httpd_req_t *req)
             "<button class='tab active' onclick=\"switchTab('cashu')\">Cashu</button>"
             "<button class='tab' onclick=\"switchTab('mining')\">Mine</button>"
             "</div>" : "" },
-        { "__MINING_PORT__", cfg->mining_enabled ?
-            (char[]){ [0 ... 7] = 0 } : "3333" },
+        { "__MINING_PORT__", mining_port_buf },
         { "__CASHU_ACTIVE__", "active" },
         { "__MINING_ACTIVE__", "" },
     };
-    char mining_port_buf[8] = "3333";
-    if (cfg->mining_enabled) {
-        snprintf(mining_port_buf, sizeof(mining_port_buf), "%d", cfg->mining_port);
-        subs[4].val = mining_port_buf;
-    }
     int nsubs = sizeof(subs) / sizeof(subs[0]);
 
-    size_t extra = 0;
-    for (int i = 0; i < nsubs; i++) {
-        const char *p = tpl;
-        size_t klen = strlen(subs[i].key);
-        while ((p = strstr(p, subs[i].key)) != NULL) {
-            extra += strlen(subs[i].val) - klen;
-            p += klen;
-        }
-    }
-
-    size_t out_size = tpl_len + extra + 1;
-    char *html = malloc(out_size);
+    char *html = tollgate_core_portal_render(PORTAL_HTML_TEMPLATE, subs, nsubs);
     if (!html) {
         httpd_resp_send_500(req);
         return ESP_OK;
     }
 
-    char *out = html;
-    const char *src = tpl;
-    while (*src) {
-        const char *earliest = NULL;
-        int ei = -1;
-        for (int i = 0; i < nsubs; i++) {
-            const char *found = strstr(src, subs[i].key);
-            if (found && (earliest == NULL || found < earliest)) {
-                earliest = found;
-                ei = i;
-            }
-        }
-        if (earliest) {
-            size_t vlen = strlen(subs[ei].val);
-            memcpy(out, src, earliest - src);
-            out += earliest - src;
-            memcpy(out, subs[ei].val, vlen);
-            out += vlen;
-            src = earliest + strlen(subs[ei].key);
-        } else {
-            strcpy(out, src);
-            out += strlen(src);
-            break;
-        }
-    }
-    *out = '\0';
-
-    httpd_resp_send(req, html, out - html);
+    httpd_resp_send(req, html, strlen(html));
     free(html);
     return ESP_OK;
 }
@@ -312,19 +271,10 @@ static esp_err_t usage_handler(httpd_req_t *req)
     }
 
     const tollgate_config_t *cfg = tollgate_config_get();
-    bool is_bytes = (strcmp(cfg->metric, "bytes") == 0);
+    int64_t now_ms = (int64_t)xTaskGetTickCount() * portTICK_PERIOD_MS;
 
     char resp[64];
-    if (is_bytes) {
-        int64_t remaining = (int64_t)session->allotment_bytes - (int64_t)session->bytes_consumed;
-        if (remaining < 0) remaining = 0;
-        snprintf(resp, sizeof(resp), "%lld/%llu", (long long)remaining, (unsigned long long)session->allotment_bytes);
-    } else {
-        int64_t elapsed = (int64_t)xTaskGetTickCount() * portTICK_PERIOD_MS - session->start_time_ms;
-        int64_t remaining = session->allotment_ms - elapsed;
-        if (remaining < 0) remaining = 0;
-        snprintf(resp, sizeof(resp), "%lld/%llu", (long long)remaining, (unsigned long long)session->allotment_ms);
-    }
+    tollgate_core_portal_format_usage(session, cfg->metric, now_ms, resp, sizeof(resp));
     httpd_resp_set_type(req, "text/plain");
     httpd_resp_send(req, resp, strlen(resp));
     return ESP_OK;
@@ -342,7 +292,9 @@ static esp_err_t reset_auth_handler(httpd_req_t *req)
 
 static esp_err_t redirect_to_portal_handler(httpd_req_t *req)
 {
-    ESP_LOGI(TAG, "Captive detect: GET %s → 200 portal HTML", req->uri);
+    if (tollgate_core_portal_is_captive_uri(req->uri)) {
+        ESP_LOGI(TAG, "Captive detect: GET %s → 200 portal HTML", req->uri);
+    }
     return portal_handler(req);
 }
 
@@ -493,37 +445,7 @@ static const char SETUP_HTML_TEMPLATE[] = \
 "</body></html>";
 
 static char *template_replace(const char *tpl, const char *key, const char *val) {
-    const char *p;
-    size_t klen = strlen(key);
-    size_t vlen = strlen(val);
-    size_t tlen = strlen(tpl);
-    size_t extra = 0;
-    p = tpl;
-    while ((p = strstr(p, key)) != NULL) {
-        extra += vlen - klen;
-        p += klen;
-    }
-    size_t out_size = tlen + extra + 1;
-    char *out = malloc(out_size);
-    if (!out) return NULL;
-    char *dst = out;
-    p = tpl;
-    while (*p) {
-        const char *found = strstr(p, key);
-        if (found) {
-            memcpy(dst, p, found - p);
-            dst += found - p;
-            memcpy(dst, val, vlen);
-            dst += vlen;
-            p = found + klen;
-        } else {
-            strcpy(dst, p);
-            dst += strlen(p);
-            break;
-        }
-    }
-    *dst = '\0';
-    return out;
+    return tollgate_core_portal_template_replace(tpl, key, val);
 }
 
 static bool is_setup_available(void) {
diff --git a/main/mint_health.c b/main/mint_health.c
index d309731..48a4333 100644
--- a/main/mint_health.c
+++ b/main/mint_health.c
@@ -1,5 +1,6 @@
 #include "mint_health.h"
 #include "tls_worker.h"
+#include "tollgate_core_mint_health.h"
 #include "esp_log.h"
 #include "esp_http_client.h"
 #include "esp_crt_bundle.h"
@@ -18,8 +19,7 @@ static QueueHandle_t s_wallet_queue = NULL;
 
 static int s_last_probe_err = 0;
 
-static mint_status_t s_mints[MINT_HEALTH_MAX];
-static int s_mint_count = 0;
+static tollgate_mint_health_t s_health_state;
 static bool s_running = false;
 static TaskHandle_t s_task_handle = NULL;
 static SemaphoreHandle_t s_mutex = NULL;
@@ -38,18 +38,18 @@ static void fire_callbacks(void)
 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_health_state.count = count;
     s_callback_count = 0;
 
     if (!s_mutex) s_mutex = xSemaphoreCreateMutex();
 
-    memset(s_mints, 0, sizeof(s_mints));
+    memset(s_health_state.mints, 0, sizeof(s_health_state.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;
+        strncpy(s_health_state.mints[i].url, urls[i], sizeof(s_health_state.mints[i].url) - 1);
+        s_health_state.mints[i].reachable = false;
+        s_health_state.mints[i].consecutive_successes = 0;
+        s_health_state.mints[i].last_probe_ms = 0;
+        s_health_state.mints[i].last_http_status = 0;
     }
 
     ESP_LOGI(TAG, "Initialized with %d mints", count);
@@ -106,35 +106,17 @@ static void run_probes(void)
 
     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;
-        s_mints[i].last_err = ok ? 0 : s_last_probe_err;
+    old_reachable = tollgate_core_mint_health_count_reachable(&s_health_state);
 
-        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 err=0x%x", s_mints[i].url, s_last_probe_err);
-            }
-            s_mints[i].reachable = false;
-            s_mints[i].consecutive_successes = 0;
-        }
+    for (int i = 0; i < s_health_state.count; i++) {
+        bool ok = probe_mint(s_health_state.mints[i].url);
+        int64_t probe_time = (int64_t)xTaskGetTickCount() * portTICK_PERIOD_MS;
 
-        if (s_mints[i].reachable) new_reachable++;
+        tollgate_core_mint_health_update(&s_health_state, i, ok, ok ? 200 : 0,
+                                          ok ? 0 : s_last_probe_err, probe_time);
     }
 
+    new_reachable = tollgate_core_mint_health_count_reachable(&s_health_state);
     bool changed = (old_reachable != new_reachable);
     xSemaphoreGive(s_mutex);
 
@@ -148,20 +130,17 @@ 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;
-        s_mints[i].last_err = ok ? 0 : s_last_probe_err;
+    for (int i = 0; i < s_health_state.count; i++) {
+        bool ok = probe_mint(s_health_state.mints[i].url);
+        int64_t probe_time = (int64_t)xTaskGetTickCount() * portTICK_PERIOD_MS;
+
+        tollgate_core_mint_health_update_initial(&s_health_state, i, ok, ok ? 200 : 0,
+                                                   ok ? 0 : s_last_probe_err, probe_time);
 
         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);
+            ESP_LOGI(TAG, "Initial probe OK: %s (reachable)", s_health_state.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);
+            ESP_LOGW(TAG, "Initial probe FAIL: %s (unreachable)", s_health_state.mints[i].url);
         }
     }
 
@@ -246,24 +225,18 @@ 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;
+        return (const mint_status_t *)s_health_state.mints;
     }
-    *out_count = s_mint_count;
+    *out_count = s_health_state.count;
     xSemaphoreGive(s_mutex);
-    return s_mints;
+    return (const mint_status_t *)s_health_state.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;
-        }
-    }
+    bool result = tollgate_core_mint_health_is_reachable(&s_health_state, url);
     xSemaphoreGive(s_mutex);
     return result;
 }
@@ -272,16 +245,7 @@ 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;
-        }
-    }
+    tollgate_core_mint_health_mark_unreachable(&s_health_state, url);
     xSemaphoreGive(s_mutex);
 }
 
diff --git a/main/stratum_client.c b/main/stratum_client.c
index a308a5b..14f0880 100644
--- a/main/stratum_client.c
+++ b/main/stratum_client.c
@@ -1,6 +1,7 @@
 #include "stratum_client.h"
 #include "stratum_proxy.h"
 #include "tollgate_core_mining.h"
+#include "tollgate_core_stratum_client.h"
 #include "config.h"
 #include "esp_log.h"
 #include "esp_transport.h"
@@ -66,76 +67,53 @@ static esp_err_t stratum_connect(const char *host, uint16_t port)
 static void send_subscribe(void)
 {
     char subscribe[256];
-    snprintf(subscribe, sizeof(subscribe),
-             "{\"id\":%lu,\"method\":\"mining.subscribe\",\"params\":[\"TollGate/1.0\"]}\n",
-             (unsigned long)s_req_id++);
-    esp_transport_write(s_transport, subscribe, strlen(subscribe), 5000);
-    ESP_LOGI(TAG, "Sent mining.subscribe");
+    int len = tollgate_core_stratum_build_subscribe(subscribe, sizeof(subscribe), s_req_id++);
+    if (len > 0) {
+        esp_transport_write(s_transport, subscribe, len, 5000);
+        ESP_LOGI(TAG, "Sent mining.subscribe");
+    }
 }
 
 static void send_authorize(void)
 {
     const tollgate_config_t *cfg = tollgate_config_get();
     char authorize[512];
-    snprintf(authorize, sizeof(authorize),
-             "{\"id\":%lu,\"method\":\"mining.authorize\",\"params\":[\"%s\",\"%s\"]}\n",
-             (unsigned long)s_req_id++, cfg->stratum_user, cfg->stratum_pass);
-    esp_transport_write(s_transport, authorize, strlen(authorize), 5000);
-    ESP_LOGI(TAG, "Sent mining.authorize for user=%s", cfg->stratum_user);
-}
-
-static void hex_to_bytes(const char *hex, uint8_t *out, int len)
-{
-    for (int i = 0; i < len && hex[i * 2] && hex[i * 2 + 1]; i++) {
-        char byte[3] = {hex[i * 2], hex[i * 2 + 1], 0};
-        out[i] = (uint8_t)strtoul(byte, NULL, 16);
+    int len = tollgate_core_stratum_build_authorize(authorize, sizeof(authorize),
+                                                      s_req_id++, cfg->stratum_user, cfg->stratum_pass);
+    if (len > 0) {
+        esp_transport_write(s_transport, authorize, len, 5000);
+        ESP_LOGI(TAG, "Sent mining.authorize for user=%s", cfg->stratum_user);
     }
 }
 
 static void handle_mining_notify(cJSON *params)
 {
-    if (!params || !cJSON_IsArray(params) || cJSON_GetArraySize(params) < 6) return;
-
-    cJSON *p_job_id = cJSON_GetArrayItem(params, 0);
-    cJSON *p_prevhash = cJSON_GetArrayItem(params, 1);
-    cJSON *p_version = cJSON_GetArrayItem(params, 5);
-    cJSON *p_nbits = cJSON_GetArrayItem(params, 6);
-    cJSON *p_ntime = cJSON_GetArrayItem(params, 7);
-
-    if (!p_job_id || !p_prevhash || !p_nbits) return;
-
-    stratum_job_t job = {0};
-    job.job_id = (uint32_t)atoi(p_job_id->valuestring);
-    job.valid = true;
-
-    hex_to_bytes(p_prevhash->valuestring, job.prevhash, 32);
-
-    if (p_version && cJSON_IsString(p_version)) {
-        job.version = (uint32_t)strtoul(p_version->valuestring, NULL, 16);
-    }
-    if (p_nbits && cJSON_IsString(p_nbits)) {
-        job.nbits = (uint32_t)strtoul(p_nbits->valuestring, NULL, 16);
-        s_state.nbits = job.nbits;
-    }
-    if (p_ntime && cJSON_IsString(p_ntime)) {
-        job.ntime = (uint32_t)strtoul(p_ntime->valuestring, NULL, 16);
-    }
-
-    memset(job.target, 0xFF, 32);
-    job.target_len = 32;
-
-    tollgate_core_mining_set_current_nbits(job.nbits);
-    stratum_proxy_set_job(&job);
-
+    tollgate_stratum_job_t job = {0};
+    uint32_t nbits = 0;
+    if (!tollgate_core_stratum_parse_notify(params, &job, &nbits)) return;
+
+    stratum_job_t proxy_job = {0};
+    proxy_job.job_id = job.job_id;
+    memcpy(proxy_job.prevhash, job.prevhash, 32);
+    proxy_job.version = job.version;
+    proxy_job.nbits = job.nbits;
+    proxy_job.ntime = job.ntime;
+    memcpy(proxy_job.target, job.target, 32);
+    proxy_job.target_len = job.target_len;
+    proxy_job.valid = job.valid;
+
+    tollgate_core_mining_set_current_nbits(proxy_job.nbits);
+    stratum_proxy_set_job(&proxy_job);
+
+    if (nbits) s_state.nbits = nbits;
     ESP_LOGI(TAG, "New mining job: id=%lu, nbits=0x%08lx", (unsigned long)job.job_id, (unsigned long)job.nbits);
 }
 
 static void handle_mining_set_difficulty(cJSON *params)
 {
-    if (!params || !cJSON_IsArray(params) || cJSON_GetArraySize(params) < 1) return;
-    cJSON *diff = cJSON_GetArrayItem(params, 0);
-    if (diff && cJSON_IsNumber(diff)) {
-        s_state.difficulty = (uint64_t)diff->valuedouble;
+    uint64_t diff = 0;
+    if (tollgate_core_stratum_parse_difficulty(params, &diff)) {
+        s_state.difficulty = diff;
         ESP_LOGI(TAG, "Pool set difficulty: %llu", (unsigned long long)s_state.difficulty);
     }
 }
@@ -243,12 +221,11 @@ esp_err_t stratum_client_submit_share(uint32_t job_id, uint32_t nonce, uint32_t
     const tollgate_config_t *cfg = tollgate_config_get();
 
     char submit[512];
-    snprintf(submit, sizeof(submit),
-             "{\"id\":%lu,\"method\":\"mining.submit\",\"params\":[\"%s\",\"%lu\",\"%08lx\",\"%08lx\",\"%08lx\"]}\n",
-             (unsigned long)s_req_id++, cfg->stratum_user,
-             (unsigned long)job_id, (unsigned long)ntime, (unsigned long)nonce, (unsigned long)version);
+    int len = tollgate_core_stratum_build_submit(submit, sizeof(submit), s_req_id++,
+                                                   cfg->stratum_user, job_id, ntime, nonce, version);
+    if (len <= 0) return ESP_FAIL;
 
-    int written = esp_transport_write(s_transport, submit, strlen(submit), 5000);
+    int written = esp_transport_write(s_transport, submit, len, 5000);
     if (written < 0) {
         ESP_LOGW(TAG, "Failed to submit share");
         s_state.shares_rejected++;
diff --git a/main/tollgate_client.c b/main/tollgate_client.c
index 73c8370..70a25c2 100644
--- a/main/tollgate_client.c
+++ b/main/tollgate_client.c
@@ -88,123 +88,17 @@ static esp_err_t http_post_text(const char *url, const char *body, char *resp_bu
 
 static bool parse_discovery_response(const char *json_str, tollgate_discovery_t *out)
 {
-    cJSON *root = cJSON_Parse(json_str);
-    if (!root) return false;
-
-    cJSON *kind = cJSON_GetObjectItemCaseSensitive(root, "kind");
-    if (!kind || !cJSON_IsNumber(kind) || kind->valueint != 10021) {
-        cJSON_Delete(root);
-        return false;
-    }
-
-    memset(out, 0, sizeof(tollgate_discovery_t));
-    out->is_tollgate = true;
-
-    cJSON *tags = cJSON_GetObjectItemCaseSensitive(root, "tags");
-    if (!tags || !cJSON_IsArray(tags)) {
-        cJSON_Delete(root);
-        return true;
-    }
-
-    int tag_count = cJSON_GetArraySize(tags);
-    for (int i = 0; i < tag_count; i++) {
-        cJSON *tag = cJSON_GetArrayItem(tags, i);
-        if (!tag || !cJSON_IsArray(tag)) continue;
-
-        int tag_len = cJSON_GetArraySize(tag);
-        if (tag_len < 2) continue;
-
-        cJSON *tag_name = cJSON_GetArrayItem(tag, 0);
-        if (!tag_name || !cJSON_IsString(tag_name)) continue;
-
-        if (strcmp(tag_name->valuestring, "metric") == 0) {
-            cJSON *val = cJSON_GetArrayItem(tag, 1);
-            if (val && cJSON_IsString(val)) {
-                strncpy(out->metric, val->valuestring, sizeof(out->metric) - 1);
-            }
-        } else if (strcmp(tag_name->valuestring, "step_size") == 0) {
-            cJSON *val = cJSON_GetArrayItem(tag, 1);
-            if (val && cJSON_IsString(val)) {
-                out->step_size_ms = atoi(val->valuestring);
-            }
-        } else if (strcmp(tag_name->valuestring, "price_per_step") == 0 && tag_len >= 4) {
-            cJSON *payment_type = cJSON_GetArrayItem(tag, 2);
-
-            if (cJSON_IsString(payment_type) && strcmp(payment_type->valuestring, "mining") == 0 && tag_len >= 5) {
-                out->mining_available = true;
-                cJSON *port_val = cJSON_GetArrayItem(tag, 3);
-                if (port_val && cJSON_IsString(port_val)) {
-                    out->mining_port = (uint16_t)atoi(port_val->valuestring);
-                }
-            } else {
-                cJSON *amount = cJSON_GetArrayItem(tag, 2);
-                cJSON *mint = cJSON_GetArrayItem(tag, 4);
-
-                if (amount && cJSON_IsString(amount)) {
-                    out->price_per_step = atoi(amount->valuestring);
-                }
-                if (mint && cJSON_IsString(mint)) {
-                    strncpy(out->mint_url, mint->valuestring, sizeof(out->mint_url) - 1);
-                }
-            }
-        }
-    }
-
-    cJSON_Delete(root);
-    return true;
+    return tollgate_core_client_parse_discovery(json_str, out);
 }
 
 static bool parse_session_response(const char *json_str, int64_t *allotment_ms_out)
 {
-    cJSON *root = cJSON_Parse(json_str);
-    if (!root) return false;
-
-    cJSON *kind = cJSON_GetObjectItemCaseSensitive(root, "kind");
-    if (!kind || !cJSON_IsNumber(kind)) {
-        cJSON_Delete(root);
-        return false;
-    }
-
-    if (kind->valueint != 1022) {
-        cJSON_Delete(root);
-        return false;
-    }
-
-    cJSON *tags = cJSON_GetObjectItemCaseSensitive(root, "tags");
-    if (tags && cJSON_IsArray(tags)) {
-        int tag_count = cJSON_GetArraySize(tags);
-        for (int i = 0; i < tag_count; i++) {
-            cJSON *tag = cJSON_GetArrayItem(tags, i);
-            if (!tag || !cJSON_IsArray(tag)) continue;
-            cJSON *tag_name = cJSON_GetArrayItem(tag, 0);
-            if (tag_name && cJSON_IsString(tag_name) && strcmp(tag_name->valuestring, "allotment") == 0) {
-                cJSON *val = cJSON_GetArrayItem(tag, 1);
-                if (val && cJSON_IsString(val)) {
-                    *allotment_ms_out = atoll(val->valuestring);
-                }
-            }
-        }
-    }
-
-    cJSON_Delete(root);
-    return true;
+    return tollgate_core_client_parse_session(json_str, allotment_ms_out);
 }
 
 static bool parse_usage_response(const char *resp, int64_t *remaining_out, int64_t *total_out)
 {
-    char remaining_str[32] = {0};
-    char total_str[32] = {0};
-    const char *slash = strchr(resp, '/');
-    if (!slash) return false;
-
-    size_t rlen = slash - resp;
-    if (rlen >= sizeof(remaining_str)) return false;
-    memcpy(remaining_str, resp, rlen);
-    strncpy(total_str, slash + 1, sizeof(total_str) - 1);
-
-    *remaining_out = atoll(remaining_str);
-    *total_out = atoll(total_str);
-    return true;
+    return tollgate_core_client_parse_usage(resp, remaining_out, total_out);
 }
 
 esp_err_t tollgate_client_detect(const char *gw_ip, tollgate_discovery_t *discovery)
@@ -358,13 +252,11 @@ esp_err_t tollgate_client_on_sta_connected(const char *gw_ip_str)
     const market_t *mkt = market_get();
     int cheapest = market_find_cheapest();
     if (cheapest >= 0 && mkt->entries[cheapest].valid && mkt->entries[cheapest].ssid[0] != '\0') {
-        uint32_t upstream_step = s_discovery.step_size_ms > 0 ? s_discovery.step_size_ms : 1;
-        uint32_t upstream_eff = (uint32_t)s_discovery.price_per_step * 60000 / upstream_step;
-        uint32_t cheap_step = mkt->entries[cheapest].step_size > 0 ? mkt->entries[cheapest].step_size : 1;
-        uint32_t cheap_eff = (uint32_t)mkt->entries[cheapest].price_per_step * 60000 / cheap_step;
+        int upstream_eff = tollgate_core_client_calc_price_per_min(s_discovery.price_per_step, s_discovery.step_size_ms);
+        int cheap_eff = tollgate_core_client_calc_price_per_min(mkt->entries[cheapest].price_per_step, mkt->entries[cheapest].step_size);
         if (cheap_eff < upstream_eff) {
-            ESP_LOGW(TAG, "CHEAPER TOLLGATE AVAILABLE: %s at %lu sats/min vs upstream %lu sats/min",
-                     mkt->entries[cheapest].ssid, (unsigned long)cheap_eff, (unsigned long)upstream_eff);
+            ESP_LOGW(TAG, "CHEAPER TOLLGATE AVAILABLE: %s at %d sats/min vs upstream %d sats/min",
+                     mkt->entries[cheapest].ssid, cheap_eff, upstream_eff);
         }
     }
     return ESP_OK;
@@ -430,32 +322,29 @@ void tollgate_client_tick(void)
 
     const tollgate_config_t *cfg = tollgate_config_get();
     int threshold_pct = cfg->client_renewal_threshold_pct;
-    if (threshold_pct <= 0) threshold_pct = 20;
-
-    if (s_allotment_ms > 0 && s_remaining_ms >= 0) {
-        int remaining_pct = (int)((s_remaining_ms * 100) / s_allotment_ms);
-        if (remaining_pct <= threshold_pct) {
-            ESP_LOGI(TAG, "session nearing expiry (%lld/%lldms, %d%%), renewing",
-                     (long long)s_remaining_ms, (long long)s_allotment_ms, remaining_pct);
-
-            s_state = TG_CLIENT_RENEWING;
-            int steps = cfg->client_steps_to_buy;
-            if (steps <= 0) steps = 1;
-            int amount_sats = steps * s_discovery.price_per_step;
-
-            int64_t allotment = 0;
-            err = tollgate_client_pay(s_gw_ip, amount_sats, &allotment);
-            if (err == ESP_OK) {
-                s_allotment_ms = allotment;
-                s_remaining_ms = allotment;
-                s_last_pay_time_ms = get_time_ms();
-                s_state = TG_CLIENT_PAID;
-                ESP_LOGI(TAG, "renewal succeeded: %lldms", (long long)allotment);
-            } else {
-                s_state = TG_CLIENT_ERROR;
-                s_last_pay_time_ms = get_time_ms();
-                ESP_LOGE(TAG, "renewal payment failed");
-            }
+
+    if (tollgate_core_client_should_renew(s_remaining_ms, s_allotment_ms, threshold_pct)) {
+        ESP_LOGI(TAG, "session nearing expiry (%lld/%lldms, %d%%), renewing",
+                 (long long)s_remaining_ms, (long long)s_allotment_ms,
+                 (int)((s_remaining_ms * 100) / s_allotment_ms));
+
+        s_state = TG_CLIENT_RENEWING;
+        int steps = cfg->client_steps_to_buy;
+        if (steps <= 0) steps = 1;
+        int amount_sats = steps * s_discovery.price_per_step;
+
+        int64_t allotment = 0;
+        err = tollgate_client_pay(s_gw_ip, amount_sats, &allotment);
+        if (err == ESP_OK) {
+            s_allotment_ms = allotment;
+            s_remaining_ms = allotment;
+            s_last_pay_time_ms = get_time_ms();
+            s_state = TG_CLIENT_PAID;
+            ESP_LOGI(TAG, "renewal succeeded: %lldms", (long long)allotment);
+        } else {
+            s_state = TG_CLIENT_ERROR;
+            s_last_pay_time_ms = get_time_ms();
+            ESP_LOGE(TAG, "renewal payment failed");
         }
     }
 }
diff --git a/main/tollgate_client.h b/main/tollgate_client.h
index ccee624..463cf63 100644
--- a/main/tollgate_client.h
+++ b/main/tollgate_client.h
@@ -1,36 +1,11 @@
 #ifndef TOLLGATE_CLIENT_H
 #define TOLLGATE_CLIENT_H
 
+#include "tollgate_core_client.h"
 #include "esp_err.h"
 #include <stdint.h>
 #include <stdbool.h>
 
-#define TG_CLIENT_MAX_GW_IP_LEN       16
-#define TG_CLIENT_MAX_MINT_URL        256
-#define TG_CLIENT_MAX_METRIC          32
-
-typedef enum {
-    TG_CLIENT_IDLE,
-    TG_CLIENT_DETECTING,
-    TG_CLIENT_NO_TOLLGATE,
-    TG_CLIENT_NEEDS_PAY,
-    TG_CLIENT_PAYING,
-    TG_CLIENT_PAID,
-    TG_CLIENT_RENEWING,
-    TG_CLIENT_MINING,
-    TG_CLIENT_ERROR
-} tollgate_client_state_t;
-
-typedef struct {
-    bool is_tollgate;
-    int price_per_step;
-    int step_size_ms;
-    char mint_url[TG_CLIENT_MAX_MINT_URL];
-    char metric[TG_CLIENT_MAX_METRIC];
-    bool mining_available;
-    uint16_t mining_port;
-} tollgate_discovery_t;
-
 esp_err_t tollgate_client_init(void);
 
 esp_err_t tollgate_client_on_sta_connected(const char *gw_ip_str);