Phase 8c-8f: Extract portal, stratum_client, mint_health, client into tollgate_core

New component modules:
- tollgate_core_portal.c/h: template rendering, usage calc, captive URI detection
- tollgate_core_stratum_client.c/h: Stratum V1 JSON protocol parsing, message building
- tollgate_core_mint_health.c/h: mint health state tracking, recovery threshold logic
- tollgate_core_client.c/h: discovery/session/usage JSON parsing, renewal check, price calc

Main shims updated to delegate pure logic to component:
- captive_portal.c: uses tollgate_core_portal_render(), format_usage(), is_captive_uri()
- stratum_client.c: uses tollgate_core_stratum_parse_notify/build_*()
- mint_health.c: uses tollgate_core_mint_health_update/is_reachable/mark_unreachable()
- tollgate_client.c: uses tollgate_core_client_parse_*/should_renew/calc_price_per_min()

4 new unit tests (test_portal, test_stratum_client, test_mint_health_core, test_client_core)
All 25 unit tests pass. ESP-IDF build passes (68% partition free).

19 files changed, 1393 insertions, 391 deletions

diff --git a/components/tollgate_core/CMakeLists.txt b/components/tollgate_core/CMakeLists.txt
index 3cd5e85..502a276 100644
--- a/components/tollgate_core/CMakeLists.txt
+++ b/components/tollgate_core/CMakeLists.txt
@@ -8,6 +8,10 @@ idf_component_register(
          "src/tollgate_core_stratum_proxy.c"
          "src/tollgate_core_beacon.c"
          "src/tollgate_core_market.c"
+         "src/tollgate_core_portal.c"
+         "src/tollgate_core_stratum_client.c"
+         "src/tollgate_core_mint_health.c"
+         "src/tollgate_core_client.c"
     INCLUDE_DIRS "include" "src"
     REQUIRES lwip json esp_http_client mbedtls log esp_netif
     PRIV_REQUIRES esp_wifi)
diff --git a/components/tollgate_core/src/tollgate_core_client.c b/components/tollgate_core/src/tollgate_core_client.c
new file mode 100644
index 0000000..9e8508a
--- /dev/null
+++ b/components/tollgate_core/src/tollgate_core_client.c
@@ -0,0 +1,146 @@
+#include "tollgate_core_client.h"
+#include "cJSON.h"
+#include <string.h>
+#include <stdlib.h>
+
+bool tollgate_core_client_parse_discovery(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;
+}
+
+bool tollgate_core_client_parse_session(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;
+}
+
+bool tollgate_core_client_parse_usage(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;
+}
+
+bool tollgate_core_client_should_renew(int64_t remaining_ms, int64_t allotment_ms, int threshold_pct)
+{
+    if (threshold_pct <= 0) threshold_pct = 20;
+    if (allotment_ms <= 0 || remaining_ms < 0) return false;
+
+    int remaining_pct = (int)((remaining_ms * 100) / allotment_ms);
+    return remaining_pct <= threshold_pct;
+}
+
+int tollgate_core_client_calc_price_per_min(int price_per_step, int step_size_ms)
+{
+    if (step_size_ms <= 0) step_size_ms = 1;
+    return price_per_step * 60000 / step_size_ms;
+}
+
+int tollgate_core_client_calc_steps(int steps_to_buy, int price_per_step, int discovery_price)
+{
+    if (steps_to_buy <= 0) steps_to_buy = 1;
+    return steps_to_buy * discovery_price;
+}
diff --git a/components/tollgate_core/src/tollgate_core_client.h b/components/tollgate_core/src/tollgate_core_client.h
new file mode 100644
index 0000000..32b90e6
--- /dev/null
+++ b/components/tollgate_core/src/tollgate_core_client.h
@@ -0,0 +1,51 @@
+#ifndef TOLLGATE_CORE_CLIENT_H
+#define TOLLGATE_CORE_CLIENT_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#define TG_CLIENT_MAX_MINT_URL        256
+#define TG_CLIENT_MAX_METRIC          32
+#define TG_CLIENT_MAX_GW_IP_LEN      16
+
+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;
+
+typedef struct {
+    const char *ssid;
+    int price_per_step;
+    uint32_t step_size;
+} tollgate_client_market_entry_t;
+
+bool tollgate_core_client_parse_discovery(const char *json_str, tollgate_discovery_t *out);
+
+bool tollgate_core_client_parse_session(const char *json_str, int64_t *allotment_ms_out);
+
+bool tollgate_core_client_parse_usage(const char *resp, int64_t *remaining_out, int64_t *total_out);
+
+bool tollgate_core_client_should_renew(int64_t remaining_ms, int64_t allotment_ms, int threshold_pct);
+
+int tollgate_core_client_calc_price_per_min(int price_per_step, int step_size_ms);
+
+int tollgate_core_client_calc_steps(int steps_to_buy, int price_per_step, int discovery_price);
+
+#endif
diff --git a/components/tollgate_core/src/tollgate_core_mint_health.c b/components/tollgate_core/src/tollgate_core_mint_health.c
new file mode 100644
index 0000000..c810003
--- /dev/null
+++ b/components/tollgate_core/src/tollgate_core_mint_health.c
@@ -0,0 +1,91 @@
+#include "tollgate_core_mint_health.h"
+#include <string.h>
+
+void tollgate_core_mint_health_init(const char urls[][256], int count)
+{
+}
+
+void tollgate_core_mint_health_update(tollgate_mint_health_t *state,
+                                       int mint_index,
+                                       bool probe_ok,
+                                       int http_status,
+                                       int err_code,
+                                       int64_t probe_time_ms)
+{
+    if (!state || mint_index < 0 || mint_index >= state->count) return;
+
+    tollgate_mint_status_t *m = &state->mints[mint_index];
+    m->last_probe_ms = probe_time_ms;
+    m->last_http_status = probe_ok ? http_status : 0;
+    m->last_err = probe_ok ? 0 : err_code;
+
+    if (probe_ok) {
+        m->consecutive_successes++;
+        if (m->consecutive_successes >= TG_MINT_HEALTH_RECOVERY_THRESHOLD) {
+            m->reachable = true;
+        }
+    } else {
+        m->reachable = false;
+        m->consecutive_successes = 0;
+    }
+}
+
+void tollgate_core_mint_health_update_initial(tollgate_mint_health_t *state,
+                                               int mint_index,
+                                               bool probe_ok,
+                                               int http_status,
+                                               int err_code,
+                                               int64_t probe_time_ms)
+{
+    if (!state || mint_index < 0 || mint_index >= state->count) return;
+
+    tollgate_mint_status_t *m = &state->mints[mint_index];
+    m->last_probe_ms = probe_time_ms;
+    m->last_http_status = probe_ok ? http_status : 0;
+    m->last_err = probe_ok ? 0 : err_code;
+
+    if (probe_ok) {
+        m->consecutive_successes = TG_MINT_HEALTH_RECOVERY_THRESHOLD;
+        m->reachable = true;
+    } else {
+        m->consecutive_successes = 0;
+        m->reachable = false;
+    }
+}
+
+bool tollgate_core_mint_health_is_reachable(const tollgate_mint_health_t *state,
+                                              const char *url)
+{
+    if (!state || !url) return false;
+    for (int i = 0; i < state->count; i++) {
+        if (strcmp(state->mints[i].url, url) == 0 || strstr(url, state->mints[i].url) != NULL) {
+            return state->mints[i].reachable;
+        }
+    }
+    return false;
+}
+
+void tollgate_core_mint_health_mark_unreachable(tollgate_mint_health_t *state,
+                                                  const char *url)
+{
+    if (!state || !url) return;
+    for (int i = 0; i < state->count; i++) {
+        if (strcmp(state->mints[i].url, url) == 0 || strstr(url, state->mints[i].url) != NULL) {
+            if (state->mints[i].reachable) {
+                state->mints[i].reachable = false;
+                state->mints[i].consecutive_successes = 0;
+            }
+            break;
+        }
+    }
+}
+
+int tollgate_core_mint_health_count_reachable(const tollgate_mint_health_t *state)
+{
+    if (!state) return 0;
+    int count = 0;
+    for (int i = 0; i < state->count; i++) {
+        if (state->mints[i].reachable) count++;
+    }
+    return count;
+}
diff --git a/components/tollgate_core/src/tollgate_core_mint_health.h b/components/tollgate_core/src/tollgate_core_mint_health.h
new file mode 100644
index 0000000..4435a14
--- /dev/null
+++ b/components/tollgate_core/src/tollgate_core_mint_health.h
@@ -0,0 +1,50 @@
+#ifndef TOLLGATE_CORE_MINT_HEALTH_H
+#define TOLLGATE_CORE_MINT_HEALTH_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#define TG_MINT_HEALTH_MAX             8
+#define TG_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;
+    int last_err;
+} tollgate_mint_status_t;
+
+typedef struct {
+    tollgate_mint_status_t mints[TG_MINT_HEALTH_MAX];
+    int count;
+} tollgate_mint_health_t;
+
+typedef void (*tollgate_mint_health_changed_fn)(int old_reachable, int new_reachable);
+
+void tollgate_core_mint_health_init(const char urls[][256], int count);
+
+void tollgate_core_mint_health_update(tollgate_mint_health_t *state,
+                                       int mint_index,
+                                       bool probe_ok,
+                                       int http_status,
+                                       int err_code,
+                                       int64_t probe_time_ms);
+
+void tollgate_core_mint_health_update_initial(tollgate_mint_health_t *state,
+                                               int mint_index,
+                                               bool probe_ok,
+                                               int http_status,
+                                               int err_code,
+                                               int64_t probe_time_ms);
+
+bool tollgate_core_mint_health_is_reachable(const tollgate_mint_health_t *state,
+                                              const char *url);
+
+void tollgate_core_mint_health_mark_unreachable(tollgate_mint_health_t *state,
+                                                  const char *url);
+
+int tollgate_core_mint_health_count_reachable(const tollgate_mint_health_t *state);
+
+#endif
diff --git a/components/tollgate_core/src/tollgate_core_portal.c b/components/tollgate_core/src/tollgate_core_portal.c
new file mode 100644
index 0000000..ef2ae1e
--- /dev/null
+++ b/components/tollgate_core/src/tollgate_core_portal.c
@@ -0,0 +1,149 @@
+#include "tollgate_core_portal.h"
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+static const char *CAPTIVE_URIS[] = {
+    "/generate_204",
+    "/hotspot-detect.html",
+    "/canonical.html",
+    "/success.txt",
+    "/ncsi.txt",
+    "/connecttest.txt",
+    "/wpad.dat",
+    NULL
+};
+
+char *tollgate_core_portal_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;
+}
+
+char *tollgate_core_portal_render(const char *tpl,
+                                   const tollgate_portal_sub_t *subs,
+                                   int nsubs)
+{
+    size_t tpl_len = strlen(tpl);
+
+    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);
+    if (!html) return NULL;
+
+    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';
+    return html;
+}
+
+bool tollgate_core_portal_calc_usage(const tg_session_t *session,
+                                      const char *metric,
+                                      int64_t now_ms,
+                                      int64_t *remaining_out,
+                                      int64_t *total_out)
+{
+    if (!session || !session->active) return false;
+
+    bool is_bytes = (strcmp(metric, "bytes") == 0);
+
+    if (is_bytes) {
+        int64_t remaining = (int64_t)session->allotment_bytes - (int64_t)session->bytes_consumed;
+        if (remaining < 0) remaining = 0;
+        *remaining_out = remaining;
+        *total_out = (int64_t)session->allotment_bytes;
+    } else {
+        int64_t elapsed = now_ms - session->start_time_ms;
+        int64_t remaining = (int64_t)session->allotment_ms - elapsed;
+        if (remaining < 0) remaining = 0;
+        *remaining_out = remaining;
+        *total_out = (int64_t)session->allotment_ms;
+    }
+    return true;
+}
+
+int tollgate_core_portal_format_usage(const tg_session_t *session,
+                                       const char *metric,
+                                       int64_t now_ms,
+                                       char *buf,
+                                       size_t buf_size)
+{
+    int64_t remaining = 0, total = 0;
+    if (!tollgate_core_portal_calc_usage(session, metric, now_ms, &remaining, &total)) {
+        return snprintf(buf, buf_size, "-1/-1");
+    }
+    return snprintf(buf, buf_size, "%lld/%llu", (long long)remaining, (unsigned long long)total);
+}
+
+bool tollgate_core_portal_is_captive_uri(const char *uri)
+{
+    if (!uri) return false;
+    for (int i = 0; CAPTIVE_URIS[i] != NULL; i++) {
+        if (strcmp(uri, CAPTIVE_URIS[i]) == 0) return true;
+    }
+    return false;
+}
diff --git a/components/tollgate_core/src/tollgate_core_portal.h b/components/tollgate_core/src/tollgate_core_portal.h
new file mode 100644
index 0000000..20c0552
--- /dev/null
+++ b/components/tollgate_core/src/tollgate_core_portal.h
@@ -0,0 +1,34 @@
+#ifndef TOLLGATE_CORE_PORTAL_H
+#define TOLLGATE_CORE_PORTAL_H
+
+#include "tollgate_core_session.h"
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+
+typedef struct {
+    const char *key;
+    const char *val;
+} tollgate_portal_sub_t;
+
+char *tollgate_core_portal_template_replace(const char *tpl, const char *key, const char *val);
+
+char *tollgate_core_portal_render(const char *tpl,
+                                   const tollgate_portal_sub_t *subs,
+                                   int nsubs);
+
+bool tollgate_core_portal_calc_usage(const tg_session_t *session,
+                                      const char *metric,
+                                      int64_t now_ms,
+                                      int64_t *remaining_out,
+                                      int64_t *total_out);
+
+int tollgate_core_portal_format_usage(const tg_session_t *session,
+                                       const char *metric,
+                                       int64_t now_ms,
+                                       char *buf,
+                                       size_t buf_size);
+
+bool tollgate_core_portal_is_captive_uri(const char *uri);
+
+#endif
diff --git a/components/tollgate_core/src/tollgate_core_stratum_client.c b/components/tollgate_core/src/tollgate_core_stratum_client.c
new file mode 100644
index 0000000..8cf22da
--- /dev/null
+++ b/components/tollgate_core/src/tollgate_core_stratum_client.c
@@ -0,0 +1,91 @@
+#include "tollgate_core_stratum_client.h"
+#include "cJSON.h"
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+void tollgate_core_stratum_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);
+    }
+}
+
+bool tollgate_core_stratum_parse_notify(const void *params_json,
+                                         tollgate_stratum_job_t *job,
+                                         uint32_t *out_nbits)
+{
+    const cJSON *params = (const cJSON *)params_json;
+    if (!params || !cJSON_IsArray(params) || cJSON_GetArraySize(params) < 6) return false;
+
+    const cJSON *p_job_id = cJSON_GetArrayItem(params, 0);
+    const cJSON *p_prevhash = cJSON_GetArrayItem(params, 1);
+    const cJSON *p_version = cJSON_GetArrayItem(params, 5);
+    const cJSON *p_nbits = cJSON_GetArrayItem(params, 6);
+    const cJSON *p_ntime = cJSON_GetArrayItem(params, 7);
+
+    if (!p_job_id || !p_prevhash || !p_nbits) return false;
+
+    memset(job, 0, sizeof(*job));
+    job->job_id = (uint32_t)atoi(p_job_id->valuestring);
+    job->valid = true;
+
+    tollgate_core_stratum_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);
+        if (out_nbits) *out_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;
+
+    return true;
+}
+
+bool tollgate_core_stratum_parse_difficulty(const void *params_json,
+                                             uint64_t *difficulty_out)
+{
+    const cJSON *params = (const cJSON *)params_json;
+    if (!params || !cJSON_IsArray(params) || cJSON_GetArraySize(params) < 1) return false;
+
+    const cJSON *diff = cJSON_GetArrayItem(params, 0);
+    if (diff && cJSON_IsNumber(diff)) {
+        *difficulty_out = (uint64_t)diff->valuedouble;
+        return true;
+    }
+    return false;
+}
+
+int tollgate_core_stratum_build_subscribe(char *buf, size_t buf_size, uint32_t req_id)
+{
+    return snprintf(buf, buf_size,
+                    "{\"id\":%lu,\"method\":\"mining.subscribe\",\"params\":[\"TollGate/1.0\"]}\n",
+                    (unsigned long)req_id);
+}
+
+int tollgate_core_stratum_build_authorize(char *buf, size_t buf_size, uint32_t req_id,
+                                            const char *user, const char *pass)
+{
+    return snprintf(buf, buf_size,
+                    "{\"id\":%lu,\"method\":\"mining.authorize\",\"params\":[\"%s\",\"%s\"]}\n",
+                    (unsigned long)req_id, user, pass);
+}
+
+int tollgate_core_stratum_build_submit(char *buf, size_t buf_size, uint32_t req_id,
+                                        const char *user, uint32_t job_id,
+                                        uint32_t ntime, uint32_t nonce, uint32_t version)
+{
+    return snprintf(buf, buf_size,
+                    "{\"id\":%lu,\"method\":\"mining.submit\",\"params\":[\"%s\",\"%lu\",\"%08lx\",\"%08lx\",\"%08lx\"]}\n",
+                    (unsigned long)req_id, user,
+                    (unsigned long)job_id, (unsigned long)ntime,
+                    (unsigned long)nonce, (unsigned long)version);
+}
diff --git a/components/tollgate_core/src/tollgate_core_stratum_client.h b/components/tollgate_core/src/tollgate_core_stratum_client.h
new file mode 100644
index 0000000..fdcce1c
--- /dev/null
+++ b/components/tollgate_core/src/tollgate_core_stratum_client.h
@@ -0,0 +1,50 @@
+#ifndef TOLLGATE_CORE_STRATUM_CLIENT_H
+#define TOLLGATE_CORE_STRATUM_CLIENT_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+
+#define TG_STRATUM_MAX_JOB_ID_LEN 32
+
+typedef struct {
+    uint32_t job_id;
+    uint8_t prevhash[32];
+    uint8_t merkle_root[32];
+    uint32_t ntime;
+    uint32_t nbits;
+    uint32_t version;
+    uint8_t target[32];
+    int target_len;
+    bool valid;
+} tollgate_stratum_job_t;
+
+typedef struct {
+    bool connected;
+    char pool_host[128];
+    uint16_t pool_port;
+    uint32_t nbits;
+    uint64_t difficulty;
+    uint64_t shares_accepted;
+    uint64_t shares_rejected;
+} tollgate_stratum_client_state_t;
+
+void tollgate_core_stratum_hex_to_bytes(const char *hex, uint8_t *out, int len);
+
+bool tollgate_core_stratum_parse_notify(const void *params_json,
+                                         tollgate_stratum_job_t *job,
+                                         uint32_t *out_nbits);
+
+bool tollgate_core_stratum_parse_difficulty(const void *params_json,
+                                             uint64_t *difficulty_out);
+
+int tollgate_core_stratum_build_subscribe(char *buf, size_t buf_size, uint32_t req_id);
+
+int tollgate_core_stratum_build_authorize(char *buf, size_t buf_size, uint32_t req_id,
+                                            const char *user, const char *pass);
+
+int tollgate_core_stratum_build_submit(char *buf, size_t buf_size, uint32_t req_id,
+                                        const char *user, uint32_t job_id,
+                                        uint32_t ntime, uint32_t nonce, uint32_t version);
+
+#endif
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);
diff --git a/tests/unit/Makefile b/tests/unit/Makefile
index 9347516..591ec0f 100644
--- a/tests/unit/Makefile
+++ b/tests/unit/Makefile
@@ -26,7 +26,7 @@ LDFLAGS := -lmbedcrypto -lcjson -lm
 
 SECP256K1_OBJ := secp256k1.o precomputed_ecmult.o precomputed_ecmult_gen.o
 
-TESTS := test_geohash test_identity test_nostr_event test_cashu test_session test_tollgate_client test_lnurl_pay test_lightning_payout test_mcp_handler test_nip04 test_cvm_server test_beacon_price test_market test_mint_health test_mining_payment test_stratum_proxy test_session_payment_method test_tollgate_client_mining test_firewall_sandbox test_relay_selector test_relay_validator
+TESTS := test_geohash test_identity test_nostr_event test_cashu test_session test_tollgate_client test_lnurl_pay test_lightning_payout test_mcp_handler test_nip04 test_cvm_server test_beacon_price test_market test_mint_health test_mining_payment test_stratum_proxy test_session_payment_method test_tollgate_client_mining test_firewall_sandbox test_relay_selector test_relay_validator test_portal test_stratum_client test_mint_health_core test_client_core
 
 .PHONY: all test clean $(TESTS)
 
@@ -69,8 +69,8 @@ TG_CORE_OBJS_CFLAGS := -include stubs/mint_health.h -include stubs/esp_netif.h -
 test_session: test_session.c $(TG_CORE_SRC)/tollgate_core_cashu.c $(TG_CORE_SRC)/tollgate_core_session.c $(TG_CORE_SRC)/tollgate_core_firewall.c $(TG_CORE_SRC)/tollgate_core.c $(TG_CORE_SRC)/tollgate_core_mining.c $(TG_CORE_SRC)/tollgate_core_dns.c $(TG_CORE_SRC)/tollgate_core_stratum_proxy.c
         $(CC) $(CFLAGS) $(TG_CORE_OBJS_CFLAGS) $^ -o $@ $(LDFLAGS)
 
-test_tollgate_client: test_tollgate_client.c $(REPO_ROOT)/main/market.c $(REPO_ROOT)/main/beacon_price.c $(TG_CORE_SRC)/tollgate_core_beacon.c $(TG_CORE_SRC)/tollgate_core_market.c
-        $(CC) $(CFLAGS) -I $(REPO_ROOT)/main $< $(REPO_ROOT)/main/market.c $(REPO_ROOT)/main/beacon_price.c $(TG_CORE_SRC)/tollgate_core_beacon.c $(TG_CORE_SRC)/tollgate_core_market.c -o $@ $(LDFLAGS)
+test_tollgate_client: test_tollgate_client.c $(REPO_ROOT)/main/market.c $(REPO_ROOT)/main/beacon_price.c $(TG_CORE_SRC)/tollgate_core_beacon.c $(TG_CORE_SRC)/tollgate_core_market.c $(TG_CORE_SRC)/tollgate_core_client.c
+        $(CC) $(CFLAGS) -I $(REPO_ROOT)/main $< $(REPO_ROOT)/main/market.c $(REPO_ROOT)/main/beacon_price.c $(TG_CORE_SRC)/tollgate_core_beacon.c $(TG_CORE_SRC)/tollgate_core_market.c $(TG_CORE_SRC)/tollgate_core_client.c -o $@ $(LDFLAGS)
 
 test_lnurl_pay: test_lnurl_pay.c
         $(CC) $(CFLAGS) $< -o $@ $(LDFLAGS)
@@ -87,8 +87,8 @@ test_nip04: test_nip04.c $(REPO_ROOT)/main/nip04.c $(SECP256K1_OBJ)
 test_cvm_server: test_cvm_server.c
         $(CC) $(CFLAGS) $< -o $@ $(LDFLAGS)
 
-test_mint_health: test_mint_health.c $(REPO_ROOT)/main/mint_health.c
-        $(CC) -Wall -Wextra -Wno-unused-parameter -Wno-unused-function -Wno-sign-compare -std=gnu17 -g -O0 -DTEST_HOST -include stubs/esp_err.h -I $(REPO_ROOT)/main -I stubs -I $(SECP256K1_INC) -I $(SECP256K1_CFG) -I /usr/include/cjson $< $(REPO_ROOT)/main/mint_health.c -o $@ $(LDFLAGS)
+test_mint_health: test_mint_health.c $(REPO_ROOT)/main/mint_health.c $(TG_CORE_SRC)/tollgate_core_mint_health.c
+        $(CC) -Wall -Wextra -Wno-unused-parameter -Wno-unused-function -Wno-sign-compare -std=gnu17 -g -O0 -DTEST_HOST -include stubs/esp_err.h -I $(REPO_ROOT)/main -I stubs -I $(SECP256K1_INC) -I $(SECP256K1_CFG) -I /usr/include/cjson -I $(TG_CORE_SRC) -I $(TG_CORE_INC) $^ -o $@ $(LDFLAGS)
 
 test_beacon_price: test_beacon_price.c $(REPO_ROOT)/main/beacon_price.c $(TG_CORE_SRC)/tollgate_core_beacon.c
         $(CC) $(CFLAGS) -I $(REPO_ROOT)/main $< $(REPO_ROOT)/main/beacon_price.c $(TG_CORE_SRC)/tollgate_core_beacon.c -o $@ $(LDFLAGS)
@@ -105,8 +105,8 @@ test_stratum_proxy: test_stratum_proxy.c $(REPO_ROOT)/main/stratum_proxy.c $(TG_
 test_session_payment_method: test_session_payment_method.c $(TG_CORE_SRC)/tollgate_core_cashu.c $(TG_CORE_SRC)/tollgate_core_session.c $(TG_CORE_SRC)/tollgate_core_firewall.c $(TG_CORE_SRC)/tollgate_core.c $(TG_CORE_SRC)/tollgate_core_mining.c $(TG_CORE_SRC)/tollgate_core_dns.c $(TG_CORE_SRC)/tollgate_core_stratum_proxy.c
         $(CC) $(CFLAGS) $(TG_CORE_OBJS_CFLAGS) $^ -o $@ $(LDFLAGS)
 
-test_tollgate_client_mining: test_tollgate_client_mining.c
-        $(CC) $(CFLAGS) $< -o $@ $(LDFLAGS)
+test_tollgate_client_mining: test_tollgate_client_mining.c $(TG_CORE_SRC)/tollgate_core_client.c
+        $(CC) $(CFLAGS) -I $(REPO_ROOT)/main $< $(TG_CORE_SRC)/tollgate_core_client.c -o $@ $(LDFLAGS)
 
 test_firewall_sandbox: test_firewall_sandbox.c $(TG_CORE_SRC)/tollgate_core_firewall.c $(TG_CORE_SRC)/tollgate_core.c $(TG_CORE_SRC)/tollgate_core_session.c $(TG_CORE_SRC)/tollgate_core_cashu.c $(TG_CORE_SRC)/tollgate_core_mining.c $(TG_CORE_SRC)/tollgate_core_dns.c $(TG_CORE_SRC)/tollgate_core_stratum_proxy.c
         $(CC) $(CFLAGS) -include stubs/dns_server.h $(TG_CORE_OBJS_CFLAGS) $^ -o $@ $(LDFLAGS)
@@ -117,5 +117,17 @@ test_relay_selector: test_relay_selector.c
 test_relay_validator: test_relay_validator.c $(REPO_ROOT)/main/nostr_event.c $(REPO_ROOT)/main/identity.c $(REPO_ROOT)/components/wisp_relay/relay_validator.c $(SECP256K1_OBJ)
         $(CC) $(CFLAGS) -I $(SECP256K1_PRIV_INC) -I $(REPO_ROOT)/main -I $(REPO_ROOT)/components/wisp_relay $< $(REPO_ROOT)/main/nostr_event.c $(REPO_ROOT)/main/identity.c $(REPO_ROOT)/components/wisp_relay/relay_validator.c $(SECP256K1_OBJ) -o $@ $(LDFLAGS)
 
+test_portal: test_portal.c $(TG_CORE_SRC)/tollgate_core_portal.c
+        $(CC) $(CFLAGS) $(TG_CORE_OBJS_CFLAGS) $^ -o $@ $(LDFLAGS)
+
+test_stratum_client: test_stratum_client.c $(TG_CORE_SRC)/tollgate_core_stratum_client.c
+        $(CC) $(CFLAGS) $^ -o $@ $(LDFLAGS)
+
+test_mint_health_core: test_mint_health_core.c $(TG_CORE_SRC)/tollgate_core_mint_health.c
+        $(CC) $(CFLAGS) $^ -o $@ $(LDFLAGS)
+
+test_client_core: test_client_core.c $(TG_CORE_SRC)/tollgate_core_client.c
+        $(CC) $(CFLAGS) $^ -o $@ $(LDFLAGS)
+
 clean:
         rm -f $(TESTS) $(SECP256K1_OBJ)
diff --git a/tests/unit/test_client_core.c b/tests/unit/test_client_core.c
new file mode 100644
index 0000000..7cc6cc7
--- /dev/null
+++ b/tests/unit/test_client_core.c
@@ -0,0 +1,189 @@
+#include "test_framework.h"
+#include "../../components/tollgate_core/src/tollgate_core_client.h"
+#include <cjson/cJSON.h>
+#include <string.h>
+#include <stdio.h>
+
+int main(void)
+{
+    printf("=== test_client_core ===\n");
+
+    printf("\n--- parse_discovery valid ---\n");
+    {
+        const char *json = "{\"kind\":10021,\"content\":\"discovery\","
+                           "\"tags\":["
+                           "[\"metric\",\"milliseconds\"],"
+                           "[\"step_size\",\"60000\"],"
+                           "[\"price_per_step\",\"21\",\"21\",\"sha256\",\"https://test.mint\"]"
+                           "]}";
+        tollgate_discovery_t disc = {0};
+        bool ok = tollgate_core_client_parse_discovery(json, &disc);
+        ASSERT(ok, "parse_discovery returns true");
+        ASSERT(disc.is_tollgate, "is_tollgate set");
+        ASSERT_EQ_INT(21, disc.price_per_step, "price_per_step");
+        ASSERT_EQ_INT(60000, disc.step_size_ms, "step_size_ms");
+        ASSERT(strcmp(disc.metric, "milliseconds") == 0, "metric");
+        ASSERT(strcmp(disc.mint_url, "https://test.mint") == 0, "mint_url");
+    }
+
+    printf("\n--- parse_discovery wrong kind ---\n");
+    {
+        const char *json = "{\"kind\":9999}";
+        tollgate_discovery_t disc = {0};
+        bool ok = tollgate_core_client_parse_discovery(json, &disc);
+        ASSERT(!ok, "wrong kind returns false");
+    }
+
+    printf("\n--- parse_discovery mining payment ---\n");
+    {
+        const char *json = "{\"kind\":10021,\"content\":\"\","
+                           "\"tags\":["
+                           "[\"metric\",\"milliseconds\"],"
+                           "[\"step_size\",\"60000\"],"
+                           "[\"price_per_step\",\"0\",\"mining\",\"3333\",\"extra\"]"
+                           "]}";
+        tollgate_discovery_t disc = {0};
+        bool ok = tollgate_core_client_parse_discovery(json, &disc);
+        ASSERT(ok, "parse_discovery mining returns true");
+        ASSERT(disc.mining_available, "mining_available set");
+        ASSERT_EQ_INT(3333, (int)disc.mining_port, "mining_port");
+    }
+
+    printf("\n--- parse_discovery empty tags ---\n");
+    {
+        const char *json = "{\"kind\":10021,\"tags\":[]}";
+        tollgate_discovery_t disc = {0};
+        bool ok = tollgate_core_client_parse_discovery(json, &disc);
+        ASSERT(ok, "empty tags returns true");
+        ASSERT(disc.is_tollgate, "is_tollgate set");
+    }
+
+    printf("\n--- parse_discovery no tags ---\n");
+    {
+        const char *json = "{\"kind\":10021}";
+        tollgate_discovery_t disc = {0};
+        bool ok = tollgate_core_client_parse_discovery(json, &disc);
+        ASSERT(ok, "no tags returns true");
+    }
+
+    printf("\n--- parse_discovery invalid JSON ---\n");
+    {
+        tollgate_discovery_t disc = {0};
+        bool ok = tollgate_core_client_parse_discovery("not json", &disc);
+        ASSERT(!ok, "invalid JSON returns false");
+    }
+
+    printf("\n--- parse_session valid ---\n");
+    {
+        const char *json = "{\"kind\":1022,\"content\":\"session\","
+                           "\"tags\":[[\"allotment\",\"120000\"]]}";
+        int64_t allotment = 0;
+        bool ok = tollgate_core_client_parse_session(json, &allotment);
+        ASSERT(ok, "parse_session returns true");
+        ASSERT_EQ_UINT64(120000, (unsigned long long)allotment, "allotment_ms");
+    }
+
+    printf("\n--- parse_session wrong kind ---\n");
+    {
+        const char *json = "{\"kind\":10021}";
+        int64_t allotment = 0;
+        bool ok = tollgate_core_client_parse_session(json, &allotment);
+        ASSERT(!ok, "wrong kind returns false");
+    }
+
+    printf("\n--- parse_session no allotment tag ---\n");
+    {
+        const char *json = "{\"kind\":1022,\"tags\":[]}";
+        int64_t allotment = 999;
+        bool ok = tollgate_core_client_parse_session(json, &allotment);
+        ASSERT(ok, "returns true");
+        ASSERT_EQ_UINT64(999, (unsigned long long)allotment, "allotment unchanged when no tag");
+    }
+
+    printf("\n--- parse_usage valid ---\n");
+    {
+        int64_t remaining = 0, total = 0;
+        bool ok = tollgate_core_client_parse_usage("45000/60000", &remaining, &total);
+        ASSERT(ok, "parse_usage returns true");
+        ASSERT_EQ_UINT64(45000, (unsigned long long)remaining, "remaining");
+        ASSERT_EQ_UINT64(60000, (unsigned long long)total, "total");
+    }
+
+    printf("\n--- parse_usage no slash ---\n");
+    {
+        int64_t remaining = 0, total = 0;
+        bool ok = tollgate_core_client_parse_usage("45000", &remaining, &total);
+        ASSERT(!ok, "no slash returns false");
+    }
+
+    printf("\n--- parse_usage zero values ---\n");
+    {
+        int64_t remaining = 0, total = 0;
+        bool ok = tollgate_core_client_parse_usage("0/0", &remaining, &total);
+        ASSERT(ok, "parse_usage zero values");
+        ASSERT_EQ_UINT64(0, (unsigned long long)remaining, "remaining is 0");
+        ASSERT_EQ_UINT64(0, (unsigned long long)total, "total is 0");
+    }
+
+    printf("\n--- should_renew ---\n");
+    {
+        ASSERT(tollgate_core_client_should_renew(1000, 60000, 20),
+               "1.6% remaining → should renew");
+        ASSERT(tollgate_core_client_should_renew(0, 60000, 20),
+               "0% remaining → should renew");
+        ASSERT(!tollgate_core_client_should_renew(30000, 60000, 20),
+               "50% remaining → should not renew");
+        ASSERT(!tollgate_core_client_should_renew(60000, 60000, 20),
+               "100% remaining → should not renew");
+        ASSERT(tollgate_core_client_should_renew(11999, 60000, 20),
+               "19.99% → should renew");
+        ASSERT(tollgate_core_client_should_renew(12000, 60000, 20),
+               "20% exactly at threshold → should renew");
+    }
+
+    printf("\n--- should_renew default threshold ---\n");
+    {
+        ASSERT(tollgate_core_client_should_renew(1000, 60000, 0),
+               "threshold=0 defaults to 20%");
+        ASSERT(tollgate_core_client_should_renew(1000, 60000, -1),
+               "negative threshold defaults to 20%");
+    }
+
+    printf("\n--- should_renew edge cases ---\n");
+    {
+        ASSERT(!tollgate_core_client_should_renew(-1, 60000, 20),
+               "negative remaining → false");
+        ASSERT(!tollgate_core_client_should_renew(1000, 0, 20),
+               "zero allotment → false");
+    }
+
+    printf("\n--- calc_price_per_min ---\n");
+    {
+        ASSERT_EQ_INT(21, tollgate_core_client_calc_price_per_min(21, 60000),
+                      "21 sats/60s = 21 sats/min");
+        ASSERT_EQ_INT(42, tollgate_core_client_calc_price_per_min(21, 30000),
+                      "21 sats/30s = 42 sats/min");
+        ASSERT_EQ_INT(21000, tollgate_core_client_calc_price_per_min(21, 60),
+                      "21 sats/60ms effective");
+    }
+
+    printf("\n--- calc_price_per_min zero step ---\n");
+    {
+        int result = tollgate_core_client_calc_price_per_min(21, 0);
+        ASSERT(result > 0, "zero step_size_ms doesn't crash");
+    }
+
+    printf("\n--- calc_steps ---\n");
+    {
+        ASSERT_EQ_INT(21, tollgate_core_client_calc_steps(1, 21, 21),
+                      "1 step * 21 = 21");
+        ASSERT_EQ_INT(42, tollgate_core_client_calc_steps(2, 21, 21),
+                      "2 steps * 21 = 42");
+        ASSERT_EQ_INT(21, tollgate_core_client_calc_steps(0, 21, 21),
+                      "0 steps defaults to 1");
+        ASSERT_EQ_INT(21, tollgate_core_client_calc_steps(-1, 21, 21),
+                      "negative steps defaults to 1");
+    }
+
+    TEST_SUMMARY();
+}
diff --git a/tests/unit/test_mint_health_core.c b/tests/unit/test_mint_health_core.c
new file mode 100644
index 0000000..9727edb
--- /dev/null
+++ b/tests/unit/test_mint_health_core.c
@@ -0,0 +1,130 @@
+#include "test_framework.h"
+#include "../../components/tollgate_core/src/tollgate_core_mint_health.h"
+#include <string.h>
+#include <stdio.h>
+
+int main(void)
+{
+    printf("=== test_mint_health_core ===\n");
+
+    printf("\n--- update: probe success ---\n");
+    {
+        tollgate_mint_health_t state = {0};
+        strncpy(state.mints[0].url, "https://test.mint", sizeof(state.mints[0].url) - 1);
+        state.count = 1;
+
+        tollgate_core_mint_health_update(&state, 0, true, 200, 0, 1000);
+        ASSERT_EQ_INT(1, state.mints[0].consecutive_successes, "1st success");
+        ASSERT(!state.mints[0].reachable, "not yet reachable (threshold=3)");
+
+        tollgate_core_mint_health_update(&state, 0, true, 200, 0, 2000);
+        ASSERT_EQ_INT(2, state.mints[0].consecutive_successes, "2nd success");
+        ASSERT(!state.mints[0].reachable, "still not reachable");
+
+        tollgate_core_mint_health_update(&state, 0, true, 200, 0, 3000);
+        ASSERT_EQ_INT(3, state.mints[0].consecutive_successes, "3rd success");
+        ASSERT(state.mints[0].reachable, "now reachable after threshold");
+    }
+
+    printf("\n--- update: failure resets ---\n");
+    {
+        tollgate_mint_health_t state = {0};
+        strncpy(state.mints[0].url, "https://test.mint", sizeof(state.mints[0].url) - 1);
+        state.count = 1;
+        state.mints[0].reachable = true;
+        state.mints[0].consecutive_successes = 5;
+
+        tollgate_core_mint_health_update(&state, 0, false, 0, -1, 1000);
+        ASSERT(!state.mints[0].reachable, "failure marks unreachable");
+        ASSERT_EQ_INT(0, state.mints[0].consecutive_successes, "successes reset to 0");
+        ASSERT_EQ_INT(-1, state.mints[0].last_err, "error code recorded");
+    }
+
+    printf("\n--- update_initial: success ---\n");
+    {
+        tollgate_mint_health_t state = {0};
+        strncpy(state.mints[0].url, "https://test.mint", sizeof(state.mints[0].url) - 1);
+        state.count = 1;
+
+        tollgate_core_mint_health_update_initial(&state, 0, true, 200, 0, 1000);
+        ASSERT(state.mints[0].reachable, "immediately reachable on initial success");
+        ASSERT_EQ_INT(TG_MINT_HEALTH_RECOVERY_THRESHOLD,
+                      state.mints[0].consecutive_successes, "successes set to threshold");
+    }
+
+    printf("\n--- update_initial: failure ---\n");
+    {
+        tollgate_mint_health_t state = {0};
+        strncpy(state.mints[0].url, "https://test.mint", sizeof(state.mints[0].url) - 1);
+        state.count = 1;
+
+        tollgate_core_mint_health_update_initial(&state, 0, false, 0, -2, 1000);
+        ASSERT(!state.mints[0].reachable, "not reachable on initial failure");
+        ASSERT_EQ_INT(0, state.mints[0].consecutive_successes, "successes is 0");
+    }
+
+    printf("\n--- is_reachable ---\n");
+    {
+        tollgate_mint_health_t state = {0};
+        strncpy(state.mints[0].url, "https://test.mint", sizeof(state.mints[0].url) - 1);
+        state.count = 1;
+        state.mints[0].reachable = true;
+
+        ASSERT(tollgate_core_mint_health_is_reachable(&state, "https://test.mint"),
+               "exact URL match");
+        ASSERT(tollgate_core_mint_health_is_reachable(&state, "https://test.mint/v1/info"),
+               "substring match");
+        ASSERT(!tollgate_core_mint_health_is_reachable(&state, "https://other.mint"),
+               "no match for other URL");
+        ASSERT(!tollgate_core_mint_health_is_reachable(NULL, "https://test.mint"),
+               "NULL state");
+        ASSERT(!tollgate_core_mint_health_is_reachable(&state, NULL),
+               "NULL url");
+    }
+
+    printf("\n--- mark_unreachable ---\n");
+    {
+        tollgate_mint_health_t state = {0};
+        strncpy(state.mints[0].url, "https://test.mint", sizeof(state.mints[0].url) - 1);
+        state.count = 1;
+        state.mints[0].reachable = true;
+        state.mints[0].consecutive_successes = 5;
+
+        tollgate_core_mint_health_mark_unreachable(&state, "https://test.mint");
+        ASSERT(!state.mints[0].reachable, "marked unreachable");
+        ASSERT_EQ_INT(0, state.mints[0].consecutive_successes, "successes cleared");
+
+        tollgate_core_mint_health_mark_unreachable(&state, "https://test.mint");
+        ASSERT(!state.mints[0].reachable, "idempotent");
+    }
+
+    printf("\n--- count_reachable ---\n");
+    {
+        tollgate_mint_health_t state = {0};
+        state.count = 3;
+        strncpy(state.mints[0].url, "https://a.mint", sizeof(state.mints[0].url) - 1);
+        strncpy(state.mints[1].url, "https://b.mint", sizeof(state.mints[1].url) - 1);
+        strncpy(state.mints[2].url, "https://c.mint", sizeof(state.mints[2].url) - 1);
+        state.mints[0].reachable = true;
+        state.mints[1].reachable = false;
+        state.mints[2].reachable = true;
+
+        ASSERT_EQ_INT(2, tollgate_core_mint_health_count_reachable(&state),
+                      "2 out of 3 reachable");
+        ASSERT_EQ_INT(0, tollgate_core_mint_health_count_reachable(NULL),
+                      "NULL returns 0");
+    }
+
+    printf("\n--- update with invalid index ---\n");
+    {
+        tollgate_mint_health_t state = {0};
+        state.count = 1;
+
+        tollgate_core_mint_health_update(&state, -1, true, 200, 0, 1000);
+        tollgate_core_mint_health_update(&state, 5, true, 200, 0, 1000);
+        tollgate_core_mint_health_update(NULL, 0, true, 200, 0, 1000);
+        ASSERT(true, "no crash on invalid inputs");
+    }
+
+    TEST_SUMMARY();
+}
diff --git a/tests/unit/test_portal.c b/tests/unit/test_portal.c
new file mode 100644
index 0000000..575921e
--- /dev/null
+++ b/tests/unit/test_portal.c
@@ -0,0 +1,153 @@
+#include "test_framework.h"
+#include "../../components/tollgate_core/src/tollgate_core_portal.h"
+#include "../../components/tollgate_core/src/tollgate_core_session.h"
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void)
+{
+    printf("=== test_portal ===\n");
+
+    printf("\n--- template_replace single key ---\n");
+    {
+        char *result = tollgate_core_portal_template_replace(
+            "Hello __NAME__!", "__NAME__", "World");
+        ASSERT(result != NULL, "result not NULL");
+        ASSERT(strcmp(result, "Hello World!") == 0, "single substitution works");
+        free(result);
+    }
+
+    printf("\n--- template_replace no match ---\n");
+    {
+        char *result = tollgate_core_portal_template_replace(
+            "Hello World!", "__NAME__", "Test");
+        ASSERT(result != NULL, "result not NULL");
+        ASSERT(strcmp(result, "Hello World!") == 0, "no match returns original");
+        free(result);
+    }
+
+    printf("\n--- template_replace multiple occurrences ---\n");
+    {
+        char *result = tollgate_core_portal_template_replace(
+            "__IP__:2121 and __IP__:80", "__IP__", "10.0.0.1");
+        ASSERT(result != NULL, "result not NULL");
+        ASSERT(strcmp(result, "10.0.0.1:2121 and 10.0.0.1:80") == 0,
+               "multiple occurrences replaced");
+        free(result);
+    }
+
+    printf("\n--- template_replace key longer than value ---\n");
+    {
+        char *result = tollgate_core_portal_template_replace(
+            "A __LONGKEY__ B", "__LONGKEY__", "X");
+        ASSERT(result != NULL, "result not NULL");
+        ASSERT(strcmp(result, "A X B") == 0, "shrinks correctly");
+        free(result);
+    }
+
+    printf("\n--- render multi-key substitution ---\n");
+    {
+        tollgate_portal_sub_t subs[] = {
+            { "__AP_IP__", "10.0.0.1" },
+            { "__PRICE__", "21" },
+            { "__MINT_URL__", "https://test.mint" },
+        };
+        char *result = tollgate_core_portal_render(
+            "IP=__AP_IP__ price=__PRICE__ mint=__MINT_URL__", subs, 3);
+        ASSERT(result != NULL, "result not NULL");
+        ASSERT(strcmp(result, "IP=10.0.0.1 price=21 mint=https://test.mint") == 0,
+               "multi-key render works");
+        free(result);
+    }
+
+    printf("\n--- render with no matches ---\n");
+    {
+        tollgate_portal_sub_t subs[] = {
+            { "__AP_IP__", "10.0.0.1" },
+        };
+        char *result = tollgate_core_portal_render("no placeholders", subs, 1);
+        ASSERT(result != NULL, "result not NULL");
+        ASSERT(strcmp(result, "no placeholders") == 0, "no matches returns original");
+        free(result);
+    }
+
+    printf("\n--- calc_usage time metric ---\n");
+    {
+        tg_session_t session = {0};
+        session.active = true;
+        session.allotment_ms = 60000;
+        session.start_time_ms = 10000;
+
+        int64_t remaining = 0, total = 0;
+        bool ok = tollgate_core_portal_calc_usage(&session, "milliseconds", 30000, &remaining, &total);
+        ASSERT(ok, "calc_usage returns true for active session");
+        ASSERT_EQ_UINT64(40000, (unsigned long long)remaining, "remaining = 60000 - 20000");
+        ASSERT_EQ_UINT64(60000, (unsigned long long)total, "total = allotment_ms");
+    }
+
+    printf("\n--- calc_usage bytes metric ---\n");
+    {
+        tg_session_t session = {0};
+        session.active = true;
+        session.allotment_bytes = 1000000;
+        session.bytes_consumed = 300000;
+
+        int64_t remaining = 0, total = 0;
+        bool ok = tollgate_core_portal_calc_usage(&session, "bytes", 0, &remaining, &total);
+        ASSERT(ok, "calc_usage returns true for bytes");
+        ASSERT_EQ_UINT64(700000, (unsigned long long)remaining, "remaining = 1000000 - 300000");
+        ASSERT_EQ_UINT64(1000000, (unsigned long long)total, "total = allotment_bytes");
+    }
+
+    printf("\n--- calc_usage expired time ---\n");
+    {
+        tg_session_t session = {0};
+        session.active = true;
+        session.allotment_ms = 60000;
+        session.start_time_ms = 0;
+
+        int64_t remaining = 0, total = 0;
+        tollgate_core_portal_calc_usage(&session, "milliseconds", 120000, &remaining, &total);
+        ASSERT_EQ_UINT64(0, (unsigned long long)remaining, "remaining clamped to 0 when expired");
+    }
+
+    printf("\n--- calc_usage inactive session ---\n");
+    {
+        tg_session_t session = {0};
+        session.active = false;
+
+        int64_t remaining = 0, total = 0;
+        bool ok = tollgate_core_portal_calc_usage(&session, "milliseconds", 0, &remaining, &total);
+        ASSERT(!ok, "inactive session returns false");
+    }
+
+    printf("\n--- format_usage ---\n");
+    {
+        tg_session_t session = {0};
+        session.active = true;
+        session.allotment_ms = 60000;
+        session.start_time_ms = 10000;
+
+        char buf[64];
+        int len = tollgate_core_portal_format_usage(&session, "milliseconds", 30000, buf, sizeof(buf));
+        ASSERT(len > 0, "format_usage returns positive length");
+        ASSERT(strstr(buf, "/") != NULL, "contains separator");
+        ASSERT(strstr(buf, "60000") != NULL, "contains total");
+    }
+
+    printf("\n--- is_captive_uri ---\n");
+    {
+        ASSERT(tollgate_core_portal_is_captive_uri("/generate_204"), "generate_204 is captive");
+        ASSERT(tollgate_core_portal_is_captive_uri("/hotspot-detect.html"), "hotspot-detect is captive");
+        ASSERT(tollgate_core_portal_is_captive_uri("/success.txt"), "success.txt is captive");
+        ASSERT(tollgate_core_portal_is_captive_uri("/ncsi.txt"), "ncsi.txt is captive");
+        ASSERT(tollgate_core_portal_is_captive_uri("/connecttest.txt"), "connecttest is captive");
+        ASSERT(tollgate_core_portal_is_captive_uri("/wpad.dat"), "wpad.dat is captive");
+        ASSERT(!tollgate_core_portal_is_captive_uri("/"), "root is not captive");
+        ASSERT(!tollgate_core_portal_is_captive_uri("/setup"), "setup is not captive");
+        ASSERT(!tollgate_core_portal_is_captive_uri(NULL), "NULL is not captive");
+    }
+
+    TEST_SUMMARY();
+}
diff --git a/tests/unit/test_stratum_client.c b/tests/unit/test_stratum_client.c
new file mode 100644
index 0000000..302fcba
--- /dev/null
+++ b/tests/unit/test_stratum_client.c
@@ -0,0 +1,125 @@
+#include "test_framework.h"
+#include "../../components/tollgate_core/src/tollgate_core_stratum_client.h"
+#include <cjson/cJSON.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void)
+{
+    printf("=== test_stratum_client ===\n");
+
+    printf("\n--- hex_to_bytes ---\n");
+    {
+        const char *hex = "0a1b2c3d";
+        uint8_t out[4] = {0};
+        tollgate_core_stratum_hex_to_bytes(hex, out, 4);
+        ASSERT_EQ_INT(0x0a, (int)out[0], "byte 0");
+        ASSERT_EQ_INT(0x1b, (int)out[1], "byte 1");
+        ASSERT_EQ_INT(0x2c, (int)out[2], "byte 2");
+        ASSERT_EQ_INT(0x3d, (int)out[3], "byte 3");
+    }
+
+    printf("\n--- hex_to_bytes zeros ---\n");
+    {
+        const char *hex = "00000000";
+        uint8_t out[4] = {0xff, 0xff, 0xff, 0xff};
+        tollgate_core_stratum_hex_to_bytes(hex, out, 4);
+        ASSERT_EQ_INT(0, (int)out[0], "zero byte 0");
+        ASSERT_EQ_INT(0, (int)out[1], "zero byte 1");
+    }
+
+    printf("\n--- parse_notify valid ---\n");
+    {
+        cJSON *params = cJSON_Parse("[\"123\",\"0000000000000000000000000000000000000000000000000000000000000000\","
+                                     "\"\""
+                                     ",\"\""
+                                     ",\"\""
+                                     ",\"20000000\""
+                                     ",\"1705e3c4\""
+                                     ",\"65a3b2c1\"]");
+        tollgate_stratum_job_t job = {0};
+        uint32_t nbits = 0;
+        bool ok = tollgate_core_stratum_parse_notify(params, &job, &nbits);
+        ASSERT(ok, "parse_notify returns true");
+        ASSERT_EQ_INT(123, (int)job.job_id, "job_id parsed");
+        ASSERT(job.valid, "job is valid");
+        ASSERT_EQ_INT(0x20000000, (int)job.version, "version parsed");
+        ASSERT_EQ_INT(0x1705e3c4, (int)job.nbits, "nbits parsed");
+        ASSERT_EQ_INT(0x65a3b2c1, (int)job.ntime, "ntime parsed");
+        ASSERT_EQ_INT(0x1705e3c4, (int)nbits, "out_nbits set");
+        ASSERT_EQ_INT(32, job.target_len, "target_len is 32");
+        cJSON_Delete(params);
+    }
+
+    printf("\n--- parse_notify too few params ---\n");
+    {
+        cJSON *params = cJSON_Parse("[\"123\",\"abcd\"]");
+        tollgate_stratum_job_t job = {0};
+        bool ok = tollgate_core_stratum_parse_notify(params, &job, NULL);
+        ASSERT(!ok, "parse_notify returns false for insufficient params");
+        cJSON_Delete(params);
+    }
+
+    printf("\n--- parse_notify NULL ---\n");
+    {
+        tollgate_stratum_job_t job = {0};
+        bool ok = tollgate_core_stratum_parse_notify(NULL, &job, NULL);
+        ASSERT(!ok, "parse_notify returns false for NULL");
+    }
+
+    printf("\n--- parse_difficulty valid ---\n");
+    {
+        cJSON *params = cJSON_Parse("[512]");
+        uint64_t diff = 0;
+        bool ok = tollgate_core_stratum_parse_difficulty(params, &diff);
+        ASSERT(ok, "parse_difficulty returns true");
+        ASSERT_EQ_UINT64(512, (unsigned long long)diff, "difficulty parsed");
+        cJSON_Delete(params);
+    }
+
+    printf("\n--- parse_difficulty invalid ---\n");
+    {
+        cJSON *params = cJSON_Parse("[]");
+        uint64_t diff = 0;
+        bool ok = tollgate_core_stratum_parse_difficulty(params, &diff);
+        ASSERT(!ok, "parse_difficulty returns false for empty array");
+        cJSON_Delete(params);
+    }
+
+    printf("\n--- build_subscribe ---\n");
+    {
+        char buf[256];
+        int len = tollgate_core_stratum_build_subscribe(buf, sizeof(buf), 1);
+        ASSERT(len > 0, "build_subscribe returns positive length");
+        ASSERT(strstr(buf, "mining.subscribe") != NULL, "contains method");
+        ASSERT(strstr(buf, "\"id\":1") != NULL, "contains id");
+        ASSERT(strstr(buf, "TollGate/1.0") != NULL, "contains user agent");
+        ASSERT(buf[len - 1] == '\n', "ends with newline");
+    }
+
+    printf("\n--- build_authorize ---\n");
+    {
+        char buf[512];
+        int len = tollgate_core_stratum_build_authorize(buf, sizeof(buf), 2, "user1", "pass1");
+        ASSERT(len > 0, "build_authorize returns positive length");
+        ASSERT(strstr(buf, "mining.authorize") != NULL, "contains method");
+        ASSERT(strstr(buf, "user1") != NULL, "contains user");
+        ASSERT(strstr(buf, "pass1") != NULL, "contains pass");
+    }
+
+    printf("\n--- build_submit ---\n");
+    {
+        char buf[512];
+        int len = tollgate_core_stratum_build_submit(buf, sizeof(buf), 3, "worker1",
+                                                       100, 0x65a3b2c1, 0x12345678, 0x20000000);
+        ASSERT(len > 0, "build_submit returns positive length");
+        ASSERT(strstr(buf, "mining.submit") != NULL, "contains method");
+        ASSERT(strstr(buf, "worker1") != NULL, "contains worker");
+        ASSERT(strstr(buf, "100") != NULL, "contains job_id");
+        ASSERT(strstr(buf, "65a3b2c1") != NULL, "contains ntime");
+        ASSERT(strstr(buf, "12345678") != NULL, "contains nonce");
+    }
+
+    TEST_SUMMARY();
+}