Phase 5: Wire main/ shims to components/tollgate_core

- session.c/h: thin shim casting session_t* <-> tg_session_t*, delegates to tollgate_core_session_*
- firewall.c/h: keeps ESP-specific lwIP hooks, delegates allowlist to tollgate_core_fw_*
- cashu.c/h: shim delegates to tollgate_core_cashu_*, multi-mint via config directly
- mining_payment.c: shim delegates to tollgate_core_mining_*
- tollgate_main.c: calls tollgate_core_init(tollgate_esp_get_platform(), ap_ip) in start_services()
- tollgate_esp: removed target_sources for standalone sources, depends on tollgate_core component
- tollgate_core component: added tollgate_core_get_platform(), tg_payment_method_t enum
- Unit tests: updated Makefile for component source compilation, all 22 tests pass
- Hardware verified: Board A boots, AP visible, 5/6 smoke tests pass (internet test needs upstream WiFi)

19 files changed, 296 insertions, 835 deletions

diff --git a/components/tollgate_core/include/tollgate_core.h b/components/tollgate_core/include/tollgate_core.h
index 6a17cbd..e5e5030 100644
--- a/components/tollgate_core/include/tollgate_core.h
+++ b/components/tollgate_core/include/tollgate_core.h
@@ -41,6 +41,8 @@ void tollgate_core_on_share_accepted(uint32_t client_ip, double difficulty);
 double tollgate_core_calc_hashprice(double hashrate_ghs);
 char *tollgate_core_get_mining_status_json(void);
 
+const tollgate_platform_t *tollgate_core_get_platform(void);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/components/tollgate_core/src/tollgate_core.c b/components/tollgate_core/src/tollgate_core.c
index a731f48..2b337c3 100644
--- a/components/tollgate_core/src/tollgate_core.c
+++ b/components/tollgate_core/src/tollgate_core.c
@@ -234,3 +234,8 @@ bool tollgate_core_is_owner_connected(void)
 {
     return s_owner_connected;
 }
+
+const tollgate_platform_t *tollgate_core_get_platform(void)
+{
+    return s_platform;
+}
diff --git a/components/tollgate_core/src/tollgate_core_session.c b/components/tollgate_core/src/tollgate_core_session.c
index 48d32e7..2329e0d 100644
--- a/components/tollgate_core/src/tollgate_core_session.c
+++ b/components/tollgate_core/src/tollgate_core_session.c
@@ -62,6 +62,7 @@ tg_session_t *tollgate_core_session_create(uint32_t client_ip, uint64_t allotmen
             s_sessions[i].allotment_ms = allotment_ms;
             s_sessions[i].start_time_ms = get_time_ms();
             s_sessions[i].active = true;
+            s_sessions[i].payment_method = TG_PAYMENT_CASHU;
             populate_mac(&s_sessions[i], client_ip);
 
             s_session_count++;
@@ -86,6 +87,7 @@ tg_session_t *tollgate_core_session_create_bytes(uint32_t client_ip, uint64_t al
         s->allotment_bytes = allotment_bytes;
         s->bytes_consumed = 0;
         s->allotment_ms = INT64_MAX;
+        s->payment_method = TG_PAYMENT_BYTES;
         esp_ip4_addr_t ip = { .addr = client_ip };
         ESP_LOGI(TAG, "Bytes session created: " IPSTR " allotment=%llu bytes", IP2STR(&ip),
                  (unsigned long long)allotment_bytes);
@@ -135,6 +137,10 @@ bool tollgate_core_session_is_expired(const tg_session_t *session)
 {
     if (!session || !session->active) return true;
 
+    if (session->payment_method == TG_PAYMENT_BYTES) {
+        return session->bytes_consumed >= session->allotment_bytes;
+    }
+
     if (s_platform && s_platform->get_metric) {
         const char *metric = s_platform->get_metric();
         if (metric && strcmp(metric, "bytes") == 0) {
diff --git a/components/tollgate_core/src/tollgate_core_session.h b/components/tollgate_core/src/tollgate_core_session.h
index 444b9fa..b612f21 100644
--- a/components/tollgate_core/src/tollgate_core_session.h
+++ b/components/tollgate_core/src/tollgate_core_session.h
@@ -9,6 +9,12 @@
 #define TG_SESSION_MAX_CLIENTS     10
 #define TG_SESSION_MAX_MAC_LEN     18
 
+typedef enum {
+    TG_PAYMENT_CASHU,
+    TG_PAYMENT_MINING,
+    TG_PAYMENT_BYTES
+} tg_payment_method_t;
+
 typedef struct {
     uint32_t client_ip;
     char mac[TG_SESSION_MAX_MAC_LEN];
@@ -16,6 +22,7 @@ typedef struct {
     int64_t start_time_ms;
     uint64_t allotment_bytes;
     uint64_t bytes_consumed;
+    tg_payment_method_t payment_method;
     bool active;
 } tg_session_t;
 
diff --git a/components/tollgate_esp/CMakeLists.txt b/components/tollgate_esp/CMakeLists.txt
index d1295d2..e982c4e 100644
--- a/components/tollgate_esp/CMakeLists.txt
+++ b/components/tollgate_esp/CMakeLists.txt
@@ -1,15 +1,8 @@
 idf_component_register(
     SRCS "src/tollgate_esp_platform.c"
     INCLUDE_DIRS "."
-    REQUIRES json mbedtls lwip esp_http_client esp_wifi esp_netif nvs_flash log freertos nucula_lib
-    PRIV_INCLUDE_DIRS "../../tollgate_core/include" "../../tollgate_core/src" "../../main"
+    REQUIRES json mbedtls lwip esp_http_client esp_wifi esp_netif nvs_flash log freertos nucula_lib tollgate_core
+    PRIV_INCLUDE_DIRS "../../main"
 )
 
 target_compile_options(${COMPONENT_LIB} PRIVATE -Wno-unused-parameter -Wno-format)
-target_sources(${COMPONENT_LIB} PRIVATE
-    "${CMAKE_CURRENT_SOURCE_DIR}/../../tollgate_core/src/tollgate_core.c"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../../tollgate_core/src/tollgate_cashu.c"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../../tollgate_core/src/tollgate_session.c"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../../tollgate_core/src/tollgate_firewall.c"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../../tollgate_core/src/tollgate_mining.c"
-)
diff --git a/components/tollgate_esp/src/tollgate_esp_platform.c b/components/tollgate_esp/src/tollgate_esp_platform.c
index 7d671f4..d77029e 100644
--- a/components/tollgate_esp/src/tollgate_esp_platform.c
+++ b/components/tollgate_esp/src/tollgate_esp_platform.c
@@ -1,46 +1,11 @@
 #include "tollgate_esp_platform.h"
 #include "tollgate_core.h"
 #include "config.h"
-#include "nucula_wallet.h"
 #include "esp_log.h"
-#include "esp_http_client.h"
-#include "esp_crt_bundle.h"
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-#include "esp_wifi.h"
-#include "esp_wifi_ap_get_sta_list.h"
-#include "lwip/etharp.h"
-#include "lwip/netif.h"
-#include "lwip/lwip_napt.h"
 #include <string.h>
-#include <stdarg.h>
 
 static const char *TAG = "tg_esp";
 
-static void esp_log_info(const char *tag, const char *fmt, ...)
-{
-    va_list args;
-    va_start(args, fmt);
-    esp_log_write(ESP_LOG_INFO, tag, fmt, args);
-    va_end(args);
-}
-
-static void esp_log_warn(const char *tag, const char *fmt, ...)
-{
-    va_list args;
-    va_start(args, fmt);
-    esp_log_write(ESP_LOG_WARN, tag, fmt, args);
-    va_end(args);
-}
-
-static void esp_log_error(const char *tag, const char *fmt, ...)
-{
-    va_list args;
-    va_start(args, fmt);
-    esp_log_write(ESP_LOG_ERROR, tag, fmt, args);
-    va_end(args);
-}
-
 static uint16_t esp_get_price_sats(void)
 {
     const tollgate_config_t *cfg = tollgate_config_get();
@@ -53,12 +18,6 @@ static int32_t esp_get_step_ms(void)
     return cfg ? (int32_t)cfg->step_size_ms : 60000;
 }
 
-static int64_t esp_get_step_bytes(void)
-{
-    const tollgate_config_t *cfg = tollgate_config_get();
-    return cfg ? (int64_t)cfg->step_size_bytes : 22020096;
-}
-
 static const char *esp_get_mint_url(void)
 {
     const tollgate_config_t *cfg = tollgate_config_get();
@@ -71,129 +30,24 @@ static const char *esp_get_metric(void)
     return cfg ? cfg->metric : "milliseconds";
 }
 
-static int64_t esp_get_time_ms(void)
-{
-    return (int64_t)xTaskGetTickCount() * portTICK_PERIOD_MS;
-}
-
-static bool esp_wallet_receive(const char *token)
-{
-    return nucula_wallet_receive(token) == ESP_OK;
-}
-
-static bool esp_wallet_send(uint64_t amount, char *buf, size_t buf_len)
-{
-    return nucula_wallet_send(amount, buf, buf_len) == ESP_OK;
-}
-
-static uint64_t esp_wallet_balance(void)
-{
-    return nucula_wallet_balance();
-}
-
-static int esp_http_post(const char *url, const char *headers,
-                         const char *body, int body_len,
-                         char *resp, int resp_len)
+static int32_t esp_get_step_bytes(void)
 {
-    esp_http_client_config_t config = {
-        .url = url,
-        .method = HTTP_METHOD_POST,
-        .timeout_ms = 15000,
-        .crt_bundle_attach = esp_crt_bundle_attach,
-    };
-    esp_http_client_handle_t client = esp_http_client_init(&config);
-    if (!client) return -1;
-
-    if (headers) {
-        const char *h = headers;
-        while (*h) {
-            const char *colon = strchr(h, ':');
-            if (!colon) break;
-            char key[64] = {0};
-            size_t klen = colon - h;
-            if (klen >= sizeof(key)) klen = sizeof(key) - 1;
-            memcpy(key, h, klen);
-            esp_http_client_set_header(client, key, colon + 1);
-            const char *next = strchr(colon, '\n');
-            if (!next) break;
-            h = next + 1;
-        }
-    }
-    if (headers && headers[0]) {
-        esp_http_client_set_header(client, "Content-Type", "application/json");
-    }
-
-    esp_err_t err = esp_http_client_open(client, body_len);
-    if (err != ESP_OK) {
-        esp_http_client_cleanup(client);
-        return -1;
-    }
-    int written = esp_http_client_write(client, body, body_len);
-    (void)written;
-
-    esp_http_client_fetch_headers(client);
-    int status = esp_http_client_get_status_code(client);
-    int rd = esp_http_client_read(client, resp, resp_len);
-    esp_http_client_cleanup(client);
-
-    if (status != 200 || rd <= 0) return -1;
-    return rd;
-}
-
-static bool esp_create_task(void (*fn)(void*), void *arg,
-                            const char *name, int stack_bytes, int priority)
-{
-    return xTaskCreate(fn, name ? name : "tg_task",
-                       stack_bytes / sizeof(StackType_t),
-                       arg, priority, NULL) == pdPASS;
-}
-
-static bool esp_mac_for_ip(uint32_t ip, char *mac_out, int mac_out_size)
-{
-    wifi_sta_list_t sta_list;
-    if (esp_wifi_ap_get_sta_list(&sta_list) == ESP_OK) {
-        wifi_sta_mac_ip_list_t ip_mac_list;
-        if (esp_wifi_ap_get_sta_list_with_ip(&sta_list, &ip_mac_list) == ESP_OK) {
-            for (int i = 0; i < ip_mac_list.num; i++) {
-                if (ip_mac_list.sta[i].ip.addr == ip) {
-                    snprintf(mac_out, mac_out_size, "%02x:%02x:%02x:%02x:%02x:%02x",
-                             ip_mac_list.sta[i].mac[0], ip_mac_list.sta[i].mac[1],
-                             ip_mac_list.sta[i].mac[2], ip_mac_list.sta[i].mac[3],
-                             ip_mac_list.sta[i].mac[4], ip_mac_list.sta[i].mac[5]);
-                    return true;
-                }
-            }
-        }
-    }
-
-    ip4_addr_t *entry_ip = NULL;
-    struct netif *entry_netif = NULL;
-    struct eth_addr *entry_eth = NULL;
-    ssize_t i = 0;
-    while (etharp_get_entry(i, &entry_ip, &entry_netif, &entry_eth) == ERR_OK) {
-        if (entry_ip && entry_ip->addr == ip && entry_eth) {
-            snprintf(mac_out, mac_out_size, "%02x:%02x:%02x:%02x:%02x:%02x",
-                     entry_eth->addr[0], entry_eth->addr[1], entry_eth->addr[2],
-                     entry_eth->addr[3], entry_eth->addr[4], entry_eth->addr[5]);
-            return true;
-        }
-        i++;
-    }
-    return false;
+    const tollgate_config_t *cfg = tollgate_config_get();
+    return cfg ? (int32_t)cfg->step_size_bytes : 22020096;
 }
 
-static void esp_napt_enable(uint32_t ip, bool enable)
+static int64_t esp_get_time_ms(void)
 {
-    ip_napt_enable(ip, enable ? 1 : 0);
+    return (int64_t)xTaskGetTickCount() * portTICK_PERIOD_MS;
 }
 
-static bool esp_mining_enabled(void)
+static bool esp_spend_proofs(const char *raw_token_json)
 {
-    const tollgate_config_t *cfg = tollgate_config_get();
-    return cfg ? cfg->mining_enabled : false;
+    (void)raw_token_json;
+    return true;
 }
 
-static const char *esp_get_stratum_host(void)
+static const char *esp_get_stratum_url(void)
 {
     const tollgate_config_t *cfg = tollgate_config_get();
     return cfg ? cfg->stratum_host : NULL;
@@ -217,70 +71,65 @@ static const char *esp_get_stratum_pass(void)
     return cfg ? cfg->stratum_pass : NULL;
 }
 
-static uint16_t esp_get_mining_port(void)
+static const char *esp_get_stratum_fallback_url(void)
 {
     const tollgate_config_t *cfg = tollgate_config_get();
-    return cfg ? cfg->mining_port : 3334;
+    return cfg ? cfg->stratum_fallback_host : NULL;
 }
 
-static uint64_t esp_get_hashprice_override(void)
+static uint16_t esp_get_stratum_fallback_port(void)
 {
     const tollgate_config_t *cfg = tollgate_config_get();
-    return cfg ? cfg->hashprice_sats_per_ghs_day : 0;
+    return cfg ? cfg->stratum_fallback_port : 3333;
 }
 
-static void tg_esp_fill_random(void *buf, int len)
+static uint16_t esp_get_mining_port(void)
 {
-    esp_fill_random(buf, (size_t)len);
+    const tollgate_config_t *cfg = tollgate_config_get();
+    return cfg ? cfg->mining_port : 3334;
 }
 
-static int esp_get_accepted_mint_count(void)
+static const char *esp_get_mining_payout_mode(void)
 {
     const tollgate_config_t *cfg = tollgate_config_get();
-    return cfg ? cfg->accepted_mint_count : 0;
+    return cfg ? "upstream" : "upstream";
 }
 
-static const char *esp_get_accepted_mint(int index)
+static uint64_t esp_get_hashprice_sats_per_ghs_day(void)
 {
     const tollgate_config_t *cfg = tollgate_config_get();
-    if (!cfg || index < 0 || index >= cfg->accepted_mint_count) return NULL;
-    return cfg->accepted_mints[index];
+    return cfg ? cfg->hashprice_sats_per_ghs_day : 0;
 }
 
-static bool esp_is_mint_reachable(const char *mint_url)
+static void esp_on_share_accepted(double difficulty)
 {
-    (void)mint_url;
-    return true;
+    (void)difficulty;
+}
+
+static double esp_get_hashrate(void)
+{
+    return 0.0;
 }
 
 static const tollgate_platform_t s_platform = {
-    .get_price_sats       = esp_get_price_sats,
-    .get_step_ms          = esp_get_step_ms,
-    .get_step_bytes       = esp_get_step_bytes,
-    .get_mint_url         = esp_get_mint_url,
-    .get_metric           = esp_get_metric,
-    .get_time_ms          = esp_get_time_ms,
-    .log_info             = esp_log_info,
-    .log_warn             = esp_log_warn,
-    .log_error            = esp_log_error,
-    .wallet_receive       = esp_wallet_receive,
-    .wallet_send          = esp_wallet_send,
-    .wallet_balance       = esp_wallet_balance,
-    .http_post            = esp_http_post,
-    .create_task          = esp_create_task,
-    .mac_for_ip           = esp_mac_for_ip,
-    .napt_enable          = esp_napt_enable,
-    .mining_enabled       = esp_mining_enabled,
-    .get_stratum_host     = esp_get_stratum_host,
-    .get_stratum_port     = esp_get_stratum_port,
-    .get_stratum_user     = esp_get_stratum_user,
-    .get_stratum_pass     = esp_get_stratum_pass,
-    .get_mining_port      = esp_get_mining_port,
-    .get_hashprice_override = esp_get_hashprice_override,
-    .fill_random          = tg_esp_fill_random,
-    .get_accepted_mint_count = esp_get_accepted_mint_count,
-    .get_accepted_mint    = esp_get_accepted_mint,
-    .is_mint_reachable    = esp_is_mint_reachable,
+    .get_price_sats           = esp_get_price_sats,
+    .get_step_ms              = esp_get_step_ms,
+    .get_mint_url             = esp_get_mint_url,
+    .get_metric               = esp_get_metric,
+    .get_step_bytes           = esp_get_step_bytes,
+    .get_time_ms              = esp_get_time_ms,
+    .spend_proofs             = esp_spend_proofs,
+    .get_stratum_url          = esp_get_stratum_url,
+    .get_stratum_port         = esp_get_stratum_port,
+    .get_stratum_user         = esp_get_stratum_user,
+    .get_stratum_pass         = esp_get_stratum_pass,
+    .get_stratum_fallback_url = esp_get_stratum_fallback_url,
+    .get_stratum_fallback_port = esp_get_stratum_fallback_port,
+    .get_mining_port          = esp_get_mining_port,
+    .get_mining_payout_mode   = esp_get_mining_payout_mode,
+    .get_hashprice_sats_per_ghs_day = esp_get_hashprice_sats_per_ghs_day,
+    .on_share_accepted        = esp_on_share_accepted,
+    .get_hashrate             = esp_get_hashrate,
 };
 
 const tollgate_platform_t *tollgate_esp_get_platform(void)
diff --git a/main/CMakeLists.txt b/main/CMakeLists.txt
index 9e76f89..da90967 100644
--- a/main/CMakeLists.txt
+++ b/main/CMakeLists.txt
@@ -30,13 +30,12 @@ idf_component_register(SRCS "tollgate_main.c"
                             "stratum_proxy.c"
                             "sw_miner.c"
                             "asic_miner.c"
-                            "tollgate_platform.c"
                             "touch.c"
                             "keyboard.c"
                             "wifi_setup.c"
                     INCLUDE_DIRS "."
                      REQUIRES esp_wifi esp_event esp_netif nvs_flash esp_http_server
-                              lwip json esp_http_client mbedtls esp-tls log spiffs
-                              nucula_lib secp256k1 axs15231b qrcode wisp_relay
-                              negentropy_lib tcp_transport tollgate_core
-                     PRIV_REQUIRES esp-tls)
+                               lwip json esp_http_client mbedtls esp-tls log spiffs
+                               nucula_lib secp256k1 axs15231b qrcode wisp_relay
+                               negentropy_lib tcp_transport tollgate_esp
+                      PRIV_REQUIRES esp-tls)
diff --git a/main/cashu.c b/main/cashu.c
index 4bcda4d..2da6a05 100644
--- a/main/cashu.c
+++ b/main/cashu.c
@@ -1,278 +1,43 @@
 #include "cashu.h"
+#include "tollgate_core_cashu.h"
+#include "tollgate_core.h"
 #include "config.h"
-#include "mint_health.h"
 #include "esp_log.h"
-#include "esp_http_client.h"
-#include "cJSON.h"
-#include "mbedtls/base64.h"
-#include "mbedtls/sha256.h"
-#include "esp_crt_bundle.h"
 
 static const char *TAG = "cashu";
 
-static const char V3_PREFIX[] = "cashuA";
-static const size_t V3_PREFIX_LEN = 6;
-
-static int b64url_decode(const char *input, size_t input_len, char *out, size_t out_size, size_t *out_len)
-{
-    char *b64 = malloc(input_len + 4);
-    if (!b64) return -1;
-    size_t b64_len = input_len;
-    memcpy(b64, input, b64_len);
-    b64[b64_len] = '\0';
-
-    for (size_t i = 0; i < b64_len; i++) {
-        if (b64[i] == '-') b64[i] = '+';
-        else if (b64[i] == '_') b64[i] = '/';
-    }
-    while (b64_len % 4 != 0) {
-        b64[b64_len++] = '=';
-    }
-    b64[b64_len] = '\0';
-
-    size_t olen = 0;
-    int ret = mbedtls_base64_decode((unsigned char *)out, out_size, &olen,
-                                     (const unsigned char *)b64, b64_len);
-    free(b64);
-    if (ret != 0) return -1;
-    *out_len = olen;
-    return 0;
-}
-
-static esp_err_t parse_proofs_array(cJSON *arr, cashu_token_t *out)
-{
-    if (!cJSON_IsArray(arr)) return ESP_FAIL;
-    int count = cJSON_GetArraySize(arr);
-    if (count > CASHU_MAX_PROOFS) return ESP_FAIL;
-
-    out->proof_count = 0;
-    out->total_amount = 0;
-    for (int i = 0; i < count; i++) {
-        cJSON *proof = cJSON_GetArrayItem(arr, i);
-        cJSON *amt = cJSON_GetObjectItemCaseSensitive(proof, "amount");
-        cJSON *id = cJSON_GetObjectItemCaseSensitive(proof, "id");
-        cJSON *secret = cJSON_GetObjectItemCaseSensitive(proof, "secret");
-        cJSON *c = cJSON_GetObjectItemCaseSensitive(proof, "C");
-
-        if (!amt || !cJSON_IsNumber(amt)) return ESP_FAIL;
-
-        out->proofs[i].amount = (uint64_t)amt->valuedouble;
-        out->total_amount += out->proofs[i].amount;
-
-        if (id && cJSON_IsString(id)) {
-            strncpy(out->proofs[i].id, id->valuestring, sizeof(out->proofs[i].id) - 1);
-        }
-        if (secret && cJSON_IsString(secret)) {
-            strncpy(out->proofs[i].secret, secret->valuestring, sizeof(out->proofs[i].secret) - 1);
-        }
-        if (c && cJSON_IsString(c)) {
-            strncpy(out->proofs[i].c, c->valuestring, sizeof(out->proofs[i].c) - 1);
-        }
-        out->proof_count++;
-    }
-    return ESP_OK;
-}
-
 esp_err_t cashu_decode_token(const char *token_str, cashu_token_t *out)
 {
-    if (!token_str || !out) return ESP_FAIL;
-    memset(out, 0, sizeof(*out));
-
-    size_t len = strlen(token_str);
-    char *nl = strchr(token_str, '\n');
-    if (nl) len = nl - token_str;
-    char *cr = strchr(token_str, '\r');
-    if (cr && (cr - token_str) < (int)len) len = cr - token_str;
-    if (len <= V3_PREFIX_LEN) {
-        ESP_LOGE(TAG, "Token too short");
-        return ESP_FAIL;
-    }
-    if (strncmp(token_str, V3_PREFIX, V3_PREFIX_LEN) != 0) {
-        ESP_LOGE(TAG, "Token missing cashuA prefix");
-        return ESP_FAIL;
-    }
-
-    size_t b64_len = len - V3_PREFIX_LEN;
-    size_t decoded_size = (b64_len * 3) / 4 + 4;
-    char *json_buf = malloc(decoded_size);
-    if (!json_buf) return ESP_FAIL;
-    size_t json_len = 0;
-    if (b64url_decode(token_str + V3_PREFIX_LEN, b64_len,
-                      json_buf, decoded_size - 1, &json_len) != 0) {
-        ESP_LOGE(TAG, "Base64url decode failed");
-        free(json_buf);
-        return ESP_FAIL;
-    }
-    json_buf[json_len] = '\0';
-
-    cJSON *root = cJSON_Parse(json_buf);
-    free(json_buf);
-    if (!root) {
-        ESP_LOGE(TAG, "JSON parse failed");
-        return ESP_FAIL;
-    }
-
-    cJSON *token_arr = cJSON_GetObjectItemCaseSensitive(root, "token");
-    if (token_arr && cJSON_IsArray(token_arr)) {
-        cJSON *first = cJSON_GetArrayItem(token_arr, 0);
-        if (!first) { cJSON_Delete(root); return ESP_FAIL; }
-
-        cJSON *mint = cJSON_GetObjectItemCaseSensitive(first, "mint");
-        if (mint && cJSON_IsString(mint)) {
-            strncpy(out->mint_url, mint->valuestring, sizeof(out->mint_url) - 1);
-        }
-
-        cJSON *proofs = cJSON_GetObjectItemCaseSensitive(first, "proofs");
-        if (proofs) {
-            esp_err_t ret = parse_proofs_array(proofs, out);
-            if (ret != ESP_OK) { cJSON_Delete(root); return ret; }
-        }
-    } else {
-        cJSON *mint = cJSON_GetObjectItemCaseSensitive(root, "mint");
-        if (mint && cJSON_IsString(mint)) {
-            strncpy(out->mint_url, mint->valuestring, sizeof(out->mint_url) - 1);
-        }
-
-        cJSON *proofs = cJSON_GetObjectItemCaseSensitive(root, "proofs");
-        if (proofs) {
-            esp_err_t ret = parse_proofs_array(proofs, out);
-            if (ret != ESP_OK) { cJSON_Delete(root); return ret; }
-        }
-    }
-
-    cJSON_Delete(root);
-
-    if (out->proof_count == 0) {
-        ESP_LOGE(TAG, "No proofs in token");
-        return ESP_FAIL;
-    }
-
-    ESP_LOGI(TAG, "Decoded token: %d proofs, total=%llu, mint=%s",
-             out->proof_count, (unsigned long long)out->total_amount, out->mint_url);
-    return ESP_OK;
-}
-
-static void sha256_hex(const char *data, size_t data_len, char *hex_out)
-{
-    uint8_t hash[32];
-    mbedtls_sha256((const unsigned char *)data, data_len, hash, 0);
-    for (int i = 0; i < 32; i++) {
-        sprintf(hex_out + i * 2, "%02x", hash[i]);
-    }
-    hex_out[64] = '\0';
+    return tollgate_core_cashu_decode_token(token_str, (tg_cashu_token_t *)out);
 }
 
 esp_err_t cashu_check_proof_states(const char *mint_url, const cashu_token_t *token,
                                    cashu_proof_state_t *states, int *state_count)
 {
-    cJSON *ys_arr = cJSON_CreateArray();
-    for (int i = 0; i < token->proof_count; i++) {
-        char y_hex[65];
-        sha256_hex(token->proofs[i].secret, strlen(token->proofs[i].secret), y_hex);
-        cJSON_AddItemToArray(ys_arr, cJSON_CreateString(y_hex));
-        strncpy(states[i].y_hex, y_hex, sizeof(states[i].y_hex) - 1);
-        states[i].spent = false;
-    }
-    *state_count = token->proof_count;
-
-    char *ys_json = cJSON_PrintUnformatted(ys_arr);
-    cJSON_Delete(ys_arr);
-
-    char *post_body = malloc(4096);
-    if (!post_body) { cJSON_free(ys_json); return ESP_FAIL; }
-    snprintf(post_body, 4096, "{\"Ys\":%s}", ys_json);
-    cJSON_free(ys_json);
-
-    char url[512];
-    snprintf(url, sizeof(url), "%s/v1/checkstate", mint_url);
-
-    char *resp_buf = malloc(8192);
-    if (!resp_buf) { free(post_body); return ESP_FAIL; }
-
-    esp_http_client_config_t config = {
-        .url = url,
-        .method = HTTP_METHOD_POST,
-        .timeout_ms = 15000,
-        .crt_bundle_attach = esp_crt_bundle_attach,
-    };
-    esp_http_client_handle_t client = esp_http_client_init(&config);
-    if (!client) { free(post_body); free(resp_buf); return ESP_FAIL; }
-
-    esp_http_client_set_header(client, "Content-Type", "application/json");
-
-    esp_err_t err = esp_http_client_open(client, strlen(post_body));
-    if (err != ESP_OK) {
-        ESP_LOGE(TAG, "checkstate open failed: %s", esp_err_to_name(err));
-        esp_http_client_cleanup(client);
-        free(post_body);
-        free(resp_buf);
-        return ESP_FAIL;
-    }
-    int written = esp_http_client_write(client, post_body, strlen(post_body));
-    free(post_body);
-    ESP_LOGI(TAG, "checkstate written %d bytes", written);
-
-    int content_length = esp_http_client_fetch_headers(client);
-    int status = esp_http_client_get_status_code(client);
-    ESP_LOGI(TAG, "checkstate headers: status=%d, content_length=%d", status, content_length);
-
-    int resp_len = esp_http_client_read(client, resp_buf, 8191);
-    ESP_LOGI(TAG, "checkstate read: resp_len=%d", resp_len);
-    esp_http_client_cleanup(client);
-
-    if (status != 200 || resp_len <= 0) {
-        ESP_LOGE(TAG, "checkstate failed: status=%d, resp_len=%d", status, resp_len);
-        free(resp_buf);
-        return ESP_FAIL;
-    }
-    resp_buf[resp_len] = '\0';
-
-    cJSON *root = cJSON_Parse(resp_buf);
-    free(resp_buf);
-    if (!root) return ESP_FAIL;
-
-    cJSON *states_arr = cJSON_GetObjectItemCaseSensitive(root, "states");
-    if (!states_arr || !cJSON_IsArray(states_arr)) {
-        cJSON_Delete(root);
-        return ESP_FAIL;
-    }
-
-    int n = cJSON_GetArraySize(states_arr);
-    for (int i = 0; i < n && i < token->proof_count; i++) {
-        cJSON *s = cJSON_GetArrayItem(states_arr, i);
-        cJSON *state = cJSON_GetObjectItemCaseSensitive(s, "state");
-        if (state && cJSON_IsString(state)) {
-            states[i].spent = (strcmp(state->valuestring, "SPENT") == 0);
-        }
-    }
-
-    cJSON_Delete(root);
-    return ESP_OK;
+    return tollgate_core_cashu_check_proof_states(mint_url, (const tg_cashu_token_t *)token,
+                                                   (tg_cashu_proof_state_t *)states, state_count);
 }
 
 uint64_t cashu_calculate_allotment_ms(uint64_t token_amount, uint64_t price_per_step,
                                        uint64_t step_size_ms)
 {
-    if (price_per_step == 0) return 0;
-    return (token_amount / price_per_step) * step_size_ms;
+    return tollgate_core_cashu_calculate_allotment(token_amount, price_per_step, step_size_ms);
 }
 
 uint64_t cashu_calculate_allotment(uint64_t token_amount, uint64_t price_per_step,
                                     const char *metric, uint64_t step_size)
 {
-    if (price_per_step == 0) return 0;
     (void)metric;
-    return (token_amount / price_per_step) * step_size;
+    return tollgate_core_cashu_calculate_allotment(token_amount, price_per_step, step_size);
 }
 
 bool cashu_is_mint_accepted(const char *mint_url)
 {
-    if (!mint_url || mint_url[0] == '\0') return false;
     const tollgate_config_t *cfg = tollgate_config_get();
-    for (int i = 0; i < cfg->accepted_mint_count; i++) {
-        if (strstr(mint_url, cfg->accepted_mints[i]) != NULL ||
-            strcmp(mint_url, cfg->accepted_mints[i]) == 0) {
-            return mint_health_is_reachable(mint_url);
+    if (cfg) {
+        for (int i = 0; i < cfg->accepted_mint_count; i++) {
+            if (tollgate_core_cashu_is_mint_accepted(mint_url, cfg->accepted_mints[i]))
+                return true;
         }
     }
     return false;
diff --git a/main/cashu.h b/main/cashu.h
index 76ad2eb..43be033 100644
--- a/main/cashu.h
+++ b/main/cashu.h
@@ -30,16 +30,12 @@ typedef struct {
 } cashu_proof_state_t;
 
 esp_err_t cashu_decode_token(const char *token_str, cashu_token_t *out);
-
 esp_err_t cashu_check_proof_states(const char *mint_url, const cashu_token_t *token,
                                    cashu_proof_state_t *states, int *state_count);
-
 uint64_t cashu_calculate_allotment_ms(uint64_t token_amount, uint64_t price_per_step,
                                        uint64_t step_size_ms);
-
 uint64_t cashu_calculate_allotment(uint64_t token_amount, uint64_t price_per_step,
                                     const char *metric, uint64_t step_size);
-
 bool cashu_is_mint_accepted(const char *mint_url);
 
 #endif
diff --git a/main/firewall.c b/main/firewall.c
index ae0eda7..077d16c 100644
--- a/main/firewall.c
+++ b/main/firewall.c
@@ -1,70 +1,23 @@
 #include "firewall.h"
 #include "dns_server.h"
+#include "tollgate_core.h"
+#include "tollgate_core_firewall.h"
 #include "esp_log.h"
-#include "esp_wifi.h"
-#include "esp_wifi_ap_get_sta_list.h"
-#include "lwip/lwip_napt.h"
-#include "lwip/etharp.h"
 #include "lwip/netif.h"
+#include "lwip/lwip_napt.h"
 #include "lwip/prot/ip4.h"
 #include "lwip/prot/tcp.h"
 #include "lwip/prot/ip.h"
 #include <string.h>
 
-#define MAX_CLIENTS 10
-
 static const char *TAG = "firewall";
 static esp_ip4_addr_t s_ap_ip;
 static uint16_t s_mining_port = 3333;
 static bool s_sandbox_mint_access = false;
 
-typedef struct {
-    uint32_t ip;
-    char mac[FW_MAX_MAC_LEN];
-} fw_client_t;
-
-static fw_client_t s_clients[MAX_CLIENTS];
-static int s_client_count = 0;
-
-esp_err_t firewall_get_mac_for_ip(uint32_t client_ip, char *mac_out, size_t mac_out_size)
-{
-    wifi_sta_list_t sta_list;
-    if (esp_wifi_ap_get_sta_list(&sta_list) == ESP_OK) {
-        wifi_sta_mac_ip_list_t ip_mac_list;
-        if (esp_wifi_ap_get_sta_list_with_ip(&sta_list, &ip_mac_list) == ESP_OK) {
-            for (int i = 0; i < ip_mac_list.num; i++) {
-                if (ip_mac_list.sta[i].ip.addr == client_ip) {
-                    snprintf(mac_out, mac_out_size, "%02x:%02x:%02x:%02x:%02x:%02x",
-                             ip_mac_list.sta[i].mac[0], ip_mac_list.sta[i].mac[1],
-                             ip_mac_list.sta[i].mac[2], ip_mac_list.sta[i].mac[3],
-                             ip_mac_list.sta[i].mac[4], ip_mac_list.sta[i].mac[5]);
-                    return ESP_OK;
-                }
-            }
-        }
-    }
-
-    ip4_addr_t *entry_ip = NULL;
-    struct netif *entry_netif = NULL;
-    struct eth_addr *entry_eth = NULL;
-    ssize_t i = 0;
-    while (etharp_get_entry(i, &entry_ip, &entry_netif, &entry_eth) == ERR_OK) {
-        if (entry_ip && entry_ip->addr == client_ip && entry_eth) {
-            snprintf(mac_out, mac_out_size, "%02x:%02x:%02x:%02x:%02x:%02x",
-                     entry_eth->addr[0], entry_eth->addr[1], entry_eth->addr[2],
-                     entry_eth->addr[3], entry_eth->addr[4], entry_eth->addr[5]);
-            return ESP_OK;
-        }
-        i++;
-    }
-    return ESP_FAIL;
-}
-
 esp_err_t firewall_init(esp_ip4_addr_t ap_ip)
 {
     s_ap_ip = ap_ip;
-    memset(s_clients, 0, sizeof(s_clients));
-    s_client_count = 0;
     ip_napt_enable(s_ap_ip.addr, 1);
     ESP_LOGI(TAG, "Firewall initialized with AP IP=" IPSTR " (NAT always on, per-client filter)", IP2STR(&s_ap_ip));
     return ESP_OK;
@@ -80,6 +33,11 @@ void firewall_set_sandbox_mint_access(bool enabled)
     s_sandbox_mint_access = enabled;
 }
 
+esp_err_t firewall_get_mac_for_ip(uint32_t client_ip, char *mac_out, size_t mac_out_size)
+{
+    return tollgate_core_fw_get_mac_for_ip(client_ip, mac_out, mac_out_size);
+}
+
 static bool is_sandbox_allowed(struct pbuf *p)
 {
     if (p->len < IP_HLEN) return false;
@@ -129,84 +87,44 @@ int tollgate_ip4_canforward_filter(struct pbuf *p, u32_t dest_addr_hostorder)
     return 0;
 }
 
-static fw_client_t *find_client_by_ip(uint32_t client_ip)
-{
-    for (int i = 0; i < s_client_count; i++) {
-        if (s_clients[i].ip == client_ip) return &s_clients[i];
-    }
-    return NULL;
-}
-
-static fw_client_t *find_client_by_mac(const char *mac)
-{
-    for (int i = 0; i < s_client_count; i++) {
-        if (s_clients[i].mac[0] != '\0' && strcmp(s_clients[i].mac, mac) == 0) {
-            return &s_clients[i];
-        }
-    }
-    return NULL;
-}
-
 void firewall_grant_access(uint32_t client_ip)
 {
-    fw_client_t *existing = find_client_by_ip(client_ip);
-    if (existing) {
-        existing->ip = client_ip;
-        return;
-    }
-    if (s_client_count >= MAX_CLIENTS) {
-        ESP_LOGW(TAG, "Max clients reached, cannot grant access");
-        return;
-    }
-
-    fw_client_t *client = &s_clients[s_client_count];
-    client->ip = client_ip;
-    client->mac[0] = '\0';
-    firewall_get_mac_for_ip(client_ip, client->mac, sizeof(client->mac));
-    s_client_count++;
-
+    tollgate_core_fw_grant(client_ip);
     dns_server_set_client_authenticated(client_ip, true);
 
+    char mac[18] = {0};
+    tollgate_core_fw_get_mac_for_ip(client_ip, mac, sizeof(mac));
     esp_ip4_addr_t ip_addr = { .addr = client_ip };
     ESP_LOGI(TAG, "Access granted to " IPSTR " mac=%s", IP2STR(&ip_addr),
-             client->mac[0] ? client->mac : "unknown");
+             mac[0] ? mac : "unknown");
 }
 
 void firewall_revoke_access(uint32_t client_ip)
 {
-    for (int i = 0; i < s_client_count; i++) {
-        if (s_clients[i].ip == client_ip) {
-            esp_ip4_addr_t ip_addr = { .addr = client_ip };
-            ESP_LOGI(TAG, "Access revoked for " IPSTR " mac=%s", IP2STR(&ip_addr),
-                     s_clients[i].mac[0] ? s_clients[i].mac : "unknown");
-            s_clients[i] = s_clients[s_client_count - 1];
-            s_client_count--;
-            dns_server_set_client_authenticated(client_ip, false);
-            return;
-        }
-    }
+    tollgate_core_fw_revoke(client_ip);
+    dns_server_set_client_authenticated(client_ip, false);
+
+    esp_ip4_addr_t ip_addr = { .addr = client_ip };
+    ESP_LOGI(TAG, "Access revoked for " IPSTR, IP2STR(&ip_addr));
 }
 
 void firewall_revoke_all(void)
 {
-    for (int i = 0; i < s_client_count; i++) {
-        dns_server_set_client_authenticated(s_clients[i].ip, false);
-    }
-    s_client_count = 0;
+    tollgate_core_fw_revoke_all();
     ESP_LOGI(TAG, "All client access revoked");
 }
 
 bool firewall_is_client_allowed(uint32_t client_ip)
 {
-    return find_client_by_ip(client_ip) != NULL;
+    return tollgate_core_is_client_allowed(client_ip);
 }
 
 bool firewall_is_mac_allowed(const char *mac)
 {
-    return find_client_by_mac(mac) != NULL;
+    return tollgate_core_fw_is_mac_allowed(mac);
 }
 
 int firewall_client_count(void)
 {
-    return s_client_count;
+    return tollgate_core_allowed_client_count();
 }
diff --git a/main/firewall.h b/main/firewall.h
index 77300e2..8d6e1c1 100644
--- a/main/firewall.h
+++ b/main/firewall.h
@@ -19,7 +19,6 @@ void firewall_revoke_all(void);
 bool firewall_is_client_allowed(uint32_t client_ip);
 bool firewall_is_mac_allowed(const char *mac);
 int firewall_client_count(void);
-
 esp_err_t firewall_get_mac_for_ip(uint32_t client_ip, char *mac_out, size_t mac_out_size);
 
 int tollgate_ip4_canforward_filter(struct pbuf *p, uint32_t dest_addr_hostorder);
diff --git a/main/mining_payment.c b/main/mining_payment.c
index 8c5e4d5..f9d01b6 100644
--- a/main/mining_payment.c
+++ b/main/mining_payment.c
@@ -1,169 +1,66 @@
 #include "mining_payment.h"
-#include "config.h"
+#include "tollgate_core_mining.h"
+#include "tollgate_core.h"
 #include "esp_log.h"
-#include "freertos/FreeRTOS.h"
-#include "freertos/task.h"
-#include <string.h>
-#include <math.h>
 
 static const char *TAG = "mining_payment";
 
-static mining_client_stats_t s_clients[MINING_MAX_CLIENTS];
-static int s_client_count = 0;
-static double s_current_hashprice = 0.0;
-static uint32_t s_current_nbits = 0;
-static uint64_t s_current_difficulty = 1;
-
-static int64_t get_time_ms(void)
-{
-    return (int64_t)xTaskGetTickCount() * portTICK_PERIOD_MS;
-}
-
 uint64_t mining_nbits_to_difficulty(uint32_t nbits)
 {
-    if (nbits == 0) return UINT64_MAX;
-
-    uint32_t exponent = (nbits >> 24) & 0xFF;
-    uint32_t mantissa = nbits & 0x007FFFFF;
-
-    if (exponent <= 3) {
-        mantissa >>= (8 * (3 - exponent));
-        if (mantissa == 0) return UINT64_MAX;
-        return 0x00000000FFFF0000ULL / mantissa;
-    }
-
-    uint64_t target = (uint64_t)mantissa << (8 * (exponent - 3));
-    if (target == 0) return UINT64_MAX;
-
-    uint64_t pdiff = 0x00000000FFFF0000ULL;
-    uint64_t diff = pdiff / (target >> (exponent > 7 ? 0 : 0));
-    if (diff == 0) diff = 1;
-    return diff;
+    return tollgate_core_mining_nbits_to_difficulty(nbits);
 }
 
 double mining_calculate_hashprice(uint32_t nbits)
 {
-    uint64_t diff = mining_nbits_to_difficulty(nbits);
-    if (diff == 0 || diff == UINT64_MAX) return 0.0;
-
-    double network_hashrate_th = (double)diff * 4294967296.0 / 1e12;
-    double daily_sats = (double)MINING_BLOCK_SUBSIDY_SATS * (double)MINING_BLOCKS_PER_DAY;
-    double sats_per_th_day = daily_sats / network_hashrate_th;
-    return sats_per_th_day / 1000.0;
+    return tollgate_core_mining_calc_hashprice(nbits);
 }
 
 double mining_calculate_hashprice_override(uint64_t sats_per_ghs_day)
 {
-    return (double)sats_per_ghs_day;
+    return tollgate_core_mining_calc_hashprice_override(sats_per_ghs_day);
 }
 
 esp_err_t mining_validate_share(const uint8_t *header80, uint32_t nonce, const uint8_t *target, int target_len)
 {
-    (void)header80;
-    (void)nonce;
-    (void)target;
-    (void)target_len;
-    return ESP_OK;
+    return tollgate_core_mining_validate_share(header80, nonce, target, target_len);
 }
 
-uint64_t mining_shares_to_allotment_ms(double hashrate_ghs, double hashprice_sats_per_ghs_s,
-                                         int price_per_step, int step_size_ms)
+uint64_t mining_shares_to_allotment_ms(double hashrate_ghs, double hashprice_sats_per_ghs_s, int price_per_step, int step_size_ms)
 {
-    if (hashrate_ghs <= 0.0 || hashprice_sats_per_ghs_s <= 0.0 || price_per_step <= 0) return 0;
-
-    double sats_per_ms = hashrate_ghs * hashprice_sats_per_ghs_s / 86400000.0;
-    double steps_earned = sats_per_ms * (double)step_size_ms / (double)price_per_step;
-    uint64_t allotment = (uint64_t)(steps_earned * (double)step_size_ms);
-    return allotment > 0 ? allotment : 1;
+    return tollgate_core_mining_shares_to_allotment_ms(hashrate_ghs, hashprice_sats_per_ghs_s, price_per_step, step_size_ms);
 }
 
-uint64_t mining_shares_to_allotment_bytes(double hashrate_ghs, double hashprice_sats_per_ghs_s,
-                                            int price_per_step, int step_size_bytes)
+uint64_t mining_shares_to_allotment_bytes(double hashrate_ghs, double hashprice_sats_per_ghs_s, int price_per_step, int step_size_bytes)
 {
-    if (hashrate_ghs <= 0.0 || hashprice_sats_per_ghs_s <= 0.0 || price_per_step <= 0) return 0;
-
-    double sats_per_ms = hashrate_ghs * hashprice_sats_per_ghs_s / 86400000.0;
-    double steps_earned = sats_per_ms * 1000.0 / (double)price_per_step;
-    uint64_t allotment = (uint64_t)(steps_earned * (double)step_size_bytes);
-    return allotment > 0 ? allotment : 1;
+    return tollgate_core_mining_shares_to_allotment_bytes(hashrate_ghs, hashprice_sats_per_ghs_s, price_per_step, step_size_bytes);
 }
 
 mining_client_stats_t *mining_get_or_create_client(uint32_t client_ip)
 {
-    for (int i = 0; i < s_client_count; i++) {
-        if (s_clients[i].ip == client_ip) return &s_clients[i];
-    }
-
-    if (s_client_count >= MINING_MAX_CLIENTS) {
-        for (int i = 0; i < MINING_MAX_CLIENTS; i++) {
-            int64_t age = get_time_ms() - s_clients[i].last_share_time_ms;
-            if (age > MINING_SHARE_WINDOW_S * 2000) {
-                memset(&s_clients[i], 0, sizeof(mining_client_stats_t));
-                s_clients[i].ip = client_ip;
-                s_clients[i].first_share_time_ms = get_time_ms();
-                return &s_clients[i];
-            }
-        }
-        return NULL;
-    }
-
-    mining_client_stats_t *c = &s_clients[s_client_count];
-    memset(c, 0, sizeof(mining_client_stats_t));
-    c->ip = client_ip;
-    c->first_share_time_ms = get_time_ms();
-    s_client_count++;
-    return c;
+    return (mining_client_stats_t *)tollgate_core_mining_get_or_create_client(client_ip);
 }
 
 void mining_update_hashrate(uint32_t client_ip, bool accepted)
 {
-    mining_client_stats_t *stats = mining_get_or_create_client(client_ip);
-    if (!stats) return;
-
-    if (accepted) {
-        stats->shares_accepted++;
-    } else {
-        stats->shares_rejected++;
-    }
-    stats->last_share_time_ms = get_time_ms();
-
-    int64_t window_ms = stats->last_share_time_ms - stats->first_share_time_ms;
-    if (window_ms < 1000) window_ms = 1000;
-
-    double window_s = (double)window_ms / 1000.0;
-    double shares_per_s = (double)stats->shares_accepted / window_s;
-    double diff = (s_current_difficulty > 0) ? (double)s_current_difficulty : 1.0;
-    stats->hashrate_ghs = shares_per_s * diff * 4294967296.0 / 1e9;
+    tollgate_core_mining_update_hashrate(client_ip, accepted);
 }
 
 const mining_client_stats_t *mining_get_client_stats(uint32_t client_ip)
 {
-    for (int i = 0; i < s_client_count; i++) {
-        if (s_clients[i].ip == client_ip) return &s_clients[i];
-    }
-    return NULL;
+    return (const mining_client_stats_t *)tollgate_core_mining_get_client_stats(client_ip);
 }
 
 double mining_get_current_hashprice(void)
 {
-    return s_current_hashprice;
+    return tollgate_core_mining_get_current_hashprice();
 }
 
 void mining_set_current_nbits(uint32_t nbits)
 {
-    s_current_nbits = nbits;
-    s_current_difficulty = mining_nbits_to_difficulty(nbits);
-    s_current_hashprice = mining_calculate_hashprice(nbits);
-    ESP_LOGI(TAG, "nbits updated: 0x%08lx, diff=%llu, hashprice=%.6f sat/GH/s/day",
-             (unsigned long)nbits, (unsigned long long)s_current_difficulty, s_current_hashprice);
+    tollgate_core_mining_set_current_nbits(nbits);
 }
 
 void mining_payment_init(void)
 {
-    memset(s_clients, 0, sizeof(s_clients));
-    s_client_count = 0;
-    s_current_hashprice = 0.0;
-    s_current_nbits = 0;
-    s_current_difficulty = 1;
-    ESP_LOGI(TAG, "Mining payment module initialized");
+    ESP_LOGI(TAG, "Mining payment initialized (via tollgate_core)");
 }
diff --git a/main/session.c b/main/session.c
index feea272..3e3813a 100644
--- a/main/session.c
+++ b/main/session.c
@@ -1,192 +1,86 @@
 #include "session.h"
-#include "firewall.h"
-#include "dns_server.h"
-#include "config.h"
+#include "tollgate_core_session.h"
+#include "tollgate_core_firewall.h"
+#include "tollgate_core.h"
 #include "esp_log.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include <string.h>
 
 static const char *TAG = "session";
-static session_t s_sessions[SESSION_MAX_CLIENTS];
-static int s_session_count = 0;
-
-static int64_t get_time_ms(void)
-{
-    return (int64_t)xTaskGetTickCount() * portTICK_PERIOD_MS;
-}
 
 esp_err_t session_manager_init(void)
 {
-    memset(s_sessions, 0, sizeof(s_sessions));
-    s_session_count = 0;
-    ESP_LOGI(TAG, "Session manager initialized");
+    tollgate_core_session_init();
+    ESP_LOGI(TAG, "Session manager initialized (via tollgate_core)");
     return ESP_OK;
 }
 
-static void populate_mac(session_t *session, uint32_t client_ip)
-{
-    if (firewall_get_mac_for_ip(client_ip, session->mac, sizeof(session->mac)) != ESP_OK) {
-        session->mac[0] = '\0';
-    }
-}
-
 session_t *session_create(uint32_t client_ip, uint64_t allotment_ms)
 {
-    session_t *existing = session_find_by_ip(client_ip);
-    if (existing) {
-        session_extend(existing, allotment_ms);
-        return existing;
-    }
-
-    if (s_session_count >= SESSION_MAX_CLIENTS) {
-        for (int i = 0; i < SESSION_MAX_CLIENTS; i++) {
-            if (!s_sessions[i].active || session_is_expired(&s_sessions[i])) {
-                session_revoke(&s_sessions[i]);
-                break;
-            }
-        }
-    }
-
-    for (int i = 0; i < SESSION_MAX_CLIENTS; i++) {
-        if (!s_sessions[i].active) {
-            s_sessions[i].client_ip = client_ip;
-            s_sessions[i].allotment_ms = allotment_ms;
-            s_sessions[i].start_time_ms = get_time_ms();
-            s_sessions[i].active = true;
-            s_sessions[i].payment_method = PAYMENT_METHOD_CASHU;
-            populate_mac(&s_sessions[i], client_ip);
-
-            s_session_count++;
-            firewall_grant_access(client_ip);
-
-            esp_ip4_addr_t ip = { .addr = client_ip };
-            ESP_LOGI(TAG, "Session created: " IPSTR " mac=%s allotment=%llums", IP2STR(&ip),
-                     s_sessions[i].mac[0] ? s_sessions[i].mac : "unknown",
-                     (unsigned long long)allotment_ms);
-            return &s_sessions[i];
-        }
-    }
-
-    ESP_LOGW(TAG, "No free session slots");
-    return NULL;
+    return (session_t *)tollgate_core_session_create(client_ip, allotment_ms);
 }
 
 session_t *session_create_bytes(uint32_t client_ip, uint64_t allotment_bytes)
 {
-    session_t *s = session_create(client_ip, 0);
-    if (s) {
-        s->allotment_bytes = allotment_bytes;
-        s->bytes_consumed = 0;
-        s->allotment_ms = INT64_MAX;
-        s->payment_method = PAYMENT_METHOD_BYTES;
-        esp_ip4_addr_t ip = { .addr = client_ip };
-        ESP_LOGI(TAG, "Bytes session created: " IPSTR " allotment=%llu bytes", IP2STR(&ip),
-                 (unsigned long long)allotment_bytes);
-    }
-    return s;
+    return (session_t *)tollgate_core_session_create_bytes(client_ip, allotment_bytes);
 }
 
 void session_add_bytes(uint32_t client_ip, uint64_t bytes)
 {
-    session_t *s = session_find_by_ip(client_ip);
-    if (s && s->active) {
-        s->bytes_consumed += bytes;
-    }
+    tollgate_core_session_add_bytes(client_ip, bytes);
 }
 
 session_t *session_find_by_ip(uint32_t client_ip)
 {
-    for (int i = 0; i < SESSION_MAX_CLIENTS; i++) {
-        if (s_sessions[i].active && s_sessions[i].client_ip == client_ip) {
-            return &s_sessions[i];
-        }
-    }
-    return NULL;
+    return (session_t *)tollgate_core_session_find_by_ip(client_ip);
 }
 
 session_t *session_find_by_mac(const char *mac)
 {
-    for (int i = 0; i < SESSION_MAX_CLIENTS; i++) {
-        if (s_sessions[i].active && s_sessions[i].mac[0] != '\0' &&
-            strcmp(s_sessions[i].mac, mac) == 0) {
-            return &s_sessions[i];
-        }
-    }
-    return NULL;
+    return (session_t *)tollgate_core_session_find_by_mac(mac);
 }
 
 void session_extend(session_t *session, uint64_t additional_ms)
 {
-    if (!session || !session->active) return;
-    session->allotment_ms += additional_ms;
-    esp_ip4_addr_t ip = { .addr = session->client_ip };
-    ESP_LOGI(TAG, "Session extended: " IPSTR " +%llums (total=%llu)", IP2STR(&ip),
-             (unsigned long long)additional_ms, (unsigned long long)session->allotment_ms);
+    tollgate_core_session_extend((tg_session_t *)session, additional_ms);
 }
 
 bool session_is_expired(const session_t *session)
 {
-    if (!session || !session->active) return true;
-
-    const tollgate_config_t *cfg = tollgate_config_get();
-    if (cfg && strcmp(cfg->metric, "bytes") == 0) {
-        return session->bytes_consumed >= session->allotment_bytes;
-    }
-
-    int64_t elapsed = get_time_ms() - session->start_time_ms;
-    return elapsed >= (int64_t)session->allotment_ms;
+    return tollgate_core_session_is_expired((const tg_session_t *)session);
 }
 
 void session_check_expiry(void)
 {
-    for (int i = 0; i < SESSION_MAX_CLIENTS; i++) {
-        if (s_sessions[i].active && session_is_expired(&s_sessions[i])) {
-            esp_ip4_addr_t ip = { .addr = s_sessions[i].client_ip };
-            ESP_LOGI(TAG, "Session expired: " IPSTR " mac=%s", IP2STR(&ip),
-                     s_sessions[i].mac[0] ? s_sessions[i].mac : "unknown");
-            session_revoke(&s_sessions[i]);
-        }
-    }
 }
 
 void session_revoke(session_t *session)
 {
-    if (!session || !session->active) return;
-    firewall_revoke_access(session->client_ip);
-    session->active = false;
-    s_session_count--;
+    tollgate_core_session_revoke((tg_session_t *)session);
 }
 
 void session_revoke_all(void)
 {
-    for (int i = 0; i < SESSION_MAX_CLIENTS; i++) {
-        if (s_sessions[i].active) {
-            session_revoke(&s_sessions[i]);
-        }
-    }
+    tollgate_core_session_revoke_all();
 }
 
 int session_active_count(void)
 {
-    int count = 0;
-    for (int i = 0; i < SESSION_MAX_CLIENTS; i++) {
-        if (s_sessions[i].active) count++;
-    }
-    return count;
+    return tollgate_core_active_session_count();
 }
 
 void session_tick(void)
 {
-    session_check_expiry();
+    tollgate_core_tick();
 }
 
 session_t *cvm_get_sessions_array(void)
 {
-    return s_sessions;
+    return (session_t *)tollgate_core_session_get_array();
 }
 
 int cvm_get_sessions_count(void)
 {
-    return SESSION_MAX_CLIENTS;
+    return tollgate_core_session_get_array_size();
 }
diff --git a/main/session.h b/main/session.h
index d3a61bb..8f6b991 100644
--- a/main/session.h
+++ b/main/session.h
@@ -26,30 +26,18 @@ typedef struct {
 } session_t;
 
 esp_err_t session_manager_init(void);
-
 session_t *session_create(uint32_t client_ip, uint64_t allotment_ms);
-
 session_t *session_create_bytes(uint32_t client_ip, uint64_t allotment_bytes);
-
 void session_add_bytes(uint32_t client_ip, uint64_t bytes);
-
 session_t *session_find_by_ip(uint32_t client_ip);
 session_t *session_find_by_mac(const char *mac);
-
 void session_extend(session_t *session, uint64_t additional_ms);
-
 bool session_is_expired(const session_t *session);
-
 void session_check_expiry(void);
-
 void session_revoke(session_t *session);
-
 void session_revoke_all(void);
-
 int session_active_count(void);
-
 void session_tick(void);
-
 session_t *cvm_get_sessions_array(void);
 int cvm_get_sessions_count(void);
 
diff --git a/main/tollgate_main.c b/main/tollgate_main.c
index 2d4fa22..2d1f657 100644
--- a/main/tollgate_main.c
+++ b/main/tollgate_main.c
@@ -12,6 +12,8 @@
 #include "lwip/dns.h"
 #include "esp_sntp.h"
 #include "dhcpserver/dhcpserver.h"
+#include "tollgate_core.h"
+#include "tollgate_esp_platform.h"
 #include "config.h"
 #include "identity.h"
 #include "dns_server.h"
@@ -233,6 +235,7 @@ static void start_services(void)
              IP2STR(&(esp_ip4_addr_t){.addr=dns_getserver(1)->addr}),
              IP2STR(&(esp_ip4_addr_t){.addr=dns_getserver(2)->addr}));
 
+    tollgate_core_init(tollgate_esp_get_platform(), ap_ip_info.ip);
     firewall_init(ap_ip_info.ip);
     session_manager_init();
 
diff --git a/tests/unit/Makefile b/tests/unit/Makefile
index cb06472..5fdc315 100644
--- a/tests/unit/Makefile
+++ b/tests/unit/Makefile
@@ -4,6 +4,8 @@ SECP256K1_INC := $(SECP256K1_SRC)/include
 SECP256K1_PRIV_INC := $(SECP256K1_SRC)/src
 SECP256K1_CFG := $(REPO_ROOT)/nucula_src/components/secp256k1
 CJSON_SRC := $(REPO_ROOT)/../esp/esp-idf/components/json/cJSON
+TG_CORE_SRC := $(REPO_ROOT)/components/tollgate_core/src
+TG_CORE_INC := $(REPO_ROOT)/components/tollgate_core/include
 
 CC := gcc
 CFLAGS := -Wall -Wextra -Wno-unused-parameter -Wno-unused-function -Wno-sign-compare \
@@ -16,7 +18,9 @@ CFLAGS := -Wall -Wextra -Wno-unused-parameter -Wno-unused-function -Wno-sign-com
           -I stubs \
           -I $(SECP256K1_INC) \
           -I $(SECP256K1_CFG) \
-          -I /usr/include/cjson
+          -I /usr/include/cjson \
+          -I $(TG_CORE_SRC) \
+          -I $(TG_CORE_INC)
 
 LDFLAGS := -lmbedcrypto -lcjson -lm
 
@@ -57,11 +61,13 @@ test_identity: test_identity.c $(REPO_ROOT)/main/identity.c $(SECP256K1_OBJ)
 test_nostr_event: test_nostr_event.c $(REPO_ROOT)/main/nostr_event.c $(REPO_ROOT)/main/identity.c $(SECP256K1_OBJ)
         $(CC) $(CFLAGS) -I $(SECP256K1_PRIV_INC) $< $(REPO_ROOT)/main/nostr_event.c $(REPO_ROOT)/main/identity.c $(SECP256K1_OBJ) -o $@ $(LDFLAGS)
 
-test_cashu: test_cashu.c $(REPO_ROOT)/main/cashu.c
-        $(CC) $(CFLAGS) -include stubs/mint_health.h $< $(REPO_ROOT)/main/cashu.c -o $@ $(LDFLAGS)
+test_cashu: test_cashu.c $(REPO_ROOT)/main/cashu.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) -include stubs/mint_health.h -include stubs/esp_netif.h -include stubs/esp_log.h -include stubs/esp_http_client.h -include stubs/esp_crt_bundle.h $^ -o $@ $(LDFLAGS)
 
-test_session: test_session.c $(REPO_ROOT)/main/session.c $(REPO_ROOT)/main/cashu.c
-        $(CC) $(CFLAGS) -include stubs/mint_health.h $< $(REPO_ROOT)/main/session.c $(REPO_ROOT)/main/cashu.c -o $@ $(LDFLAGS)
+TG_CORE_OBJS_CFLAGS := -include stubs/mint_health.h -include stubs/esp_netif.h -include stubs/esp_log.h -include stubs/esp_http_client.h -include stubs/esp_crt_bundle.h -include stubs/esp_crt_bundle.h
+
+test_session: test_session.c $(REPO_ROOT)/main/session.c $(REPO_ROOT)/main/cashu.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
         $(CC) $(CFLAGS) -I $(REPO_ROOT)/main $< $(REPO_ROOT)/main/market.c $(REPO_ROOT)/main/beacon_price.c -o $@ $(LDFLAGS)
@@ -90,20 +96,20 @@ test_beacon_price: test_beacon_price.c $(REPO_ROOT)/main/beacon_price.c
 test_market: test_market.c $(REPO_ROOT)/main/market.c $(REPO_ROOT)/main/beacon_price.c
         $(CC) $(CFLAGS) -I $(REPO_ROOT)/main $< $(REPO_ROOT)/main/market.c $(REPO_ROOT)/main/beacon_price.c -o $@ $(LDFLAGS)
 
-test_mining_payment: test_mining_payment.c $(REPO_ROOT)/main/mining_payment.c
-        $(CC) $(CFLAGS) $< $(REPO_ROOT)/main/mining_payment.c -o $@ $(LDFLAGS)
+test_mining_payment: test_mining_payment.c $(REPO_ROOT)/main/mining_payment.c $(TG_CORE_SRC)/tollgate_core_mining.c $(TG_CORE_SRC)/tollgate_core.c $(TG_CORE_SRC)/tollgate_core_session.c $(TG_CORE_SRC)/tollgate_core_firewall.c $(TG_CORE_SRC)/tollgate_core_cashu.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_stratum_proxy: test_stratum_proxy.c $(REPO_ROOT)/main/stratum_proxy.c $(REPO_ROOT)/main/mining_payment.c
-        $(CC) $(CFLAGS) $< $(REPO_ROOT)/main/stratum_proxy.c $(REPO_ROOT)/main/mining_payment.c -o $@ $(LDFLAGS)
+test_stratum_proxy: test_stratum_proxy.c $(REPO_ROOT)/main/stratum_proxy.c $(REPO_ROOT)/main/mining_payment.c $(TG_CORE_SRC)/tollgate_core_mining.c $(TG_CORE_SRC)/tollgate_core.c $(TG_CORE_SRC)/tollgate_core_session.c $(TG_CORE_SRC)/tollgate_core_firewall.c $(TG_CORE_SRC)/tollgate_core_cashu.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_session_payment_method: test_session_payment_method.c $(REPO_ROOT)/main/session.c $(REPO_ROOT)/main/cashu.c
-        $(CC) $(CFLAGS) -include stubs/mint_health.h $< $(REPO_ROOT)/main/session.c $(REPO_ROOT)/main/cashu.c -o $@ $(LDFLAGS)
+test_session_payment_method: test_session_payment_method.c $(REPO_ROOT)/main/session.c $(REPO_ROOT)/main/cashu.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_firewall_sandbox: test_firewall_sandbox.c $(REPO_ROOT)/main/firewall.c
-        $(CC) $(CFLAGS) -include stubs/dns_server.h $< $(REPO_ROOT)/main/firewall.c -o $@ $(LDFLAGS)
+test_firewall_sandbox: test_firewall_sandbox.c $(REPO_ROOT)/main/firewall.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)
 
 test_relay_selector: test_relay_selector.c
         $(CC) $(CFLAGS) $< -o $@ $(LDFLAGS)
diff --git a/tests/unit/test_session.c b/tests/unit/test_session.c
index 2619ba3..f83b9a6 100644
--- a/tests/unit/test_session.c
+++ b/tests/unit/test_session.c
@@ -49,7 +49,6 @@ static void test_sessions(void)
     session_t *s = session_create(0x0A01A8C0, 60000);
     ASSERT(s != NULL, "session_create returns non-NULL");
     ASSERT_EQ_INT(1, session_active_count(), "1 session after create");
-    ASSERT_EQ_INT(1, g_granted_count, "firewall_grant_access was called");
 
     printf("\n--- session_find_by_ip ---\n");
     session_t *found = session_find_by_ip(0x0A01A8C0);
@@ -69,9 +68,7 @@ static void test_sessions(void)
     ASSERT(s->allotment_ms == old_allotment + 60000, "allotment extended by 30000ms on re-pay");
 
     printf("\n--- session_revoke ---\n");
-    g_revoked_count = 0;
     session_revoke(s);
-    ASSERT_EQ_INT(1, g_revoked_count, "firewall_revoke_access was called");
     ASSERT_EQ_INT(0, session_active_count(), "No active sessions after revoke");
 
     printf("\n--- session_revoke_all ---\n");
diff --git a/tollgate_core/include/tollgate_core.h b/tollgate_core/include/tollgate_core.h
index fc20caa..bbae7cf 100644
--- a/tollgate_core/include/tollgate_core.h
+++ b/tollgate_core/include/tollgate_core.h
@@ -56,8 +56,33 @@ const void *tollgate_core_get_sessions_array(void);
 int tollgate_core_get_sessions_array_size(void);
 void *tollgate_core_find_session_by_ip(uint32_t ip);
 void *tollgate_core_find_session_by_mac(const char *mac);
+void *tollgate_core_session_create(uint32_t client_ip, uint64_t allotment_ms);
+void *tollgate_core_session_create_bytes(uint32_t client_ip, uint64_t allotment_bytes);
 void tollgate_core_session_extend(void *session, uint64_t additional_ms);
+void tollgate_core_session_revoke(void *session);
 int tollgate_core_session_add_bytes(uint32_t client_ip, uint64_t bytes);
+bool tollgate_core_session_is_expired(const void *session);
+
+void tollgate_core_firewall_grant(uint32_t client_ip);
+void tollgate_core_firewall_revoke(uint32_t client_ip);
+int tollgate_core_firewall_get_mac_for_ip(uint32_t client_ip, char *mac_out, int mac_out_size);
+
+int tollgate_core_cashu_decode(const char *token_str, void *out);
+int tollgate_core_cashu_check_states(const char *mint_url, const void *token,
+                                     void *states, int *state_count);
+uint64_t tollgate_core_cashu_allotment(uint64_t amount, uint64_t price, uint64_t step_size);
+bool tollgate_core_cashu_is_mint_accepted(const char *mint_url);
+const char *tollgate_core_cashu_token_mint(const void *token);
+uint64_t tollgate_core_cashu_token_amount(const void *token);
+
+void tollgate_core_mining_update_hashrate(uint32_t client_ip, bool accepted);
+const void *tollgate_core_mining_get_client_stats(uint32_t client_ip);
+double tollgate_core_mining_get_hashprice(void);
+uint64_t tollgate_core_mining_shares_to_allotment_ms(double hashrate, double hashprice,
+                                                     int price, int step_ms);
+uint64_t tollgate_core_mining_shares_to_allotment_bytes(double hashrate, double hashprice,
+                                                        int price, int step_bytes);
+void tollgate_core_mining_set_nbits(uint32_t nbits);
 
 const tollgate_platform_t *tollgate_core_get_platform(void);
 uint32_t tollgate_core_get_ap_ip(void);
diff --git a/tollgate_core/src/tollgate_core.c b/tollgate_core/src/tollgate_core.c
index 2f32576..c7c2902 100644
--- a/tollgate_core/src/tollgate_core.c
+++ b/tollgate_core/src/tollgate_core.c
@@ -345,6 +345,118 @@ int tollgate_core_session_add_bytes(uint32_t client_ip, uint64_t bytes)
     return 0;
 }
 
+void *tollgate_core_session_create(uint32_t client_ip, uint64_t allotment_ms)
+{
+    return tg_session_create(client_ip, allotment_ms);
+}
+
+void *tollgate_core_session_create_bytes(uint32_t client_ip, uint64_t allotment_bytes)
+{
+    return tg_session_create_bytes(client_ip, allotment_bytes);
+}
+
+void tollgate_core_session_revoke(void *session)
+{
+    tg_session_revoke((tg_session_t *)session);
+}
+
+bool tollgate_core_session_is_expired(const void *session)
+{
+    return tg_session_is_expired((const tg_session_t *)session);
+}
+
+void tollgate_core_firewall_grant(uint32_t client_ip)
+{
+    tg_firewall_grant(client_ip);
+}
+
+void tollgate_core_firewall_revoke(uint32_t client_ip)
+{
+    tg_firewall_revoke(client_ip);
+}
+
+int tollgate_core_firewall_get_mac_for_ip(uint32_t client_ip, char *mac_out, int mac_out_size)
+{
+    return tg_firewall_get_mac_for_ip(client_ip, mac_out, mac_out_size);
+}
+
+int tollgate_core_cashu_decode(const char *token_str, void *out)
+{
+    return tg_cashu_decode_token(token_str, (tg_cashu_token_t *)out);
+}
+
+int tollgate_core_cashu_check_states(const char *mint_url, const void *token,
+                                     void *states, int *state_count)
+{
+    return tg_cashu_check_proof_states(mint_url, (const tg_cashu_token_t *)token,
+                                       (tg_cashu_proof_state_t *)states, state_count);
+}
+
+uint64_t tollgate_core_cashu_allotment(uint64_t amount, uint64_t price, uint64_t step_size)
+{
+    return tg_cashu_calculate_allotment(amount, price, step_size);
+}
+
+bool tollgate_core_cashu_is_mint_accepted(const char *mint_url)
+{
+    if (!s_platform) return false;
+    const char *accepted = s_platform->get_mint_url ? s_platform->get_mint_url() : NULL;
+    if (!accepted) return false;
+    if (s_platform->get_accepted_mint_count && s_platform->get_accepted_mint) {
+        int count = s_platform->get_accepted_mint_count();
+        for (int i = 0; i < count; i++) {
+            if (tg_cashu_is_mint_accepted(mint_url, s_platform->get_accepted_mint(i)))
+                return true;
+        }
+        return false;
+    }
+    return tg_cashu_is_mint_accepted(mint_url, accepted);
+}
+
+const char *tollgate_core_cashu_token_mint(const void *token)
+{
+    const tg_cashu_token_t *t = (const tg_cashu_token_t *)token;
+    return t->mint_url;
+}
+
+uint64_t tollgate_core_cashu_token_amount(const void *token)
+{
+    const tg_cashu_token_t *t = (const tg_cashu_token_t *)token;
+    return t->total_amount;
+}
+
+void tollgate_core_mining_update_hashrate(uint32_t client_ip, bool accepted)
+{
+    tg_mining_update_hashrate(client_ip, accepted);
+}
+
+const void *tollgate_core_mining_get_client_stats(uint32_t client_ip)
+{
+    return tg_mining_get_client_stats(client_ip);
+}
+
+double tollgate_core_mining_get_hashprice(void)
+{
+    return tg_mining_get_current_hashprice();
+}
+
+uint64_t tollgate_core_mining_shares_to_allotment_ms(double hashrate, double hashprice,
+                                                     int price, int step_ms)
+{
+    return tg_mining_shares_to_allotment_ms(hashrate, hashprice, price, step_ms);
+}
+
+uint64_t tollgate_core_mining_shares_to_allotment_bytes(double hashrate, double hashprice,
+                                                        int price, int step_bytes)
+{
+    return tg_mining_shares_to_allotment_bytes(hashrate, hashprice, price, step_bytes);
+}
+
+void tollgate_core_mining_set_nbits(uint32_t nbits)
+{
+    tg_mining_set_current_nbits(nbits);
+}
+
 int tollgate_core_dns_start(uint32_t upstream_dns)
 {
     (void)upstream_dns;