1 files changed, 238 insertions, 0 deletions

diff --git a/main/cvm_server.c b/main/cvm_server.c
new file mode 100644
index 0000000..5addd88
--- /dev/null
+++ b/main/cvm_server.c
@@ -0,0 +1,238 @@
+#include "cvm_server.h"
+#include "mcp_handler.h"
+#include "nip04.h"
+#include "identity.h"
+#include "config.h"
+#include "nucula_wallet.h"
+#include "cJSON.h"
+#include "esp_log.h"
+#include "esp_http_client.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include <string.h>
+#include <stdio.h>
+
+static const char *TAG = "cvm_server";
+
+static bool g_running = false;
+static TaskHandle_t g_task = NULL;
+
+static const char *DEFAULT_RELAY = "wss://relay.damus.io";
+
+static char *fetch_relays(void)
+{
+    const tollgate_config_t *cfg = tollgate_config_get();
+    if (cfg && cfg->cvm_relays[0]) {
+        return cfg->cvm_relays;
+    }
+    return (char *)DEFAULT_RELAY;
+}
+
+static char *http_get(const char *url, int timeout_ms)
+{
+    char *buf = malloc(8192);
+    if (!buf) return NULL;
+    int total = 0;
+
+    esp_http_client_config_t config = {
+        .url = url,
+        .method = HTTP_METHOD_GET,
+        .timeout_ms = timeout_ms,
+    };
+    esp_http_client_handle_t client = esp_http_client_init(&config);
+    if (!client) { free(buf); return NULL; }
+
+    esp_err_t err = esp_http_client_open(client, 0);
+    if (err != ESP_OK) {
+        esp_http_client_cleanup(client);
+        free(buf);
+        return NULL;
+    }
+
+    int content_length = esp_http_client_fetch_headers(client);
+    int max_read = content_length > 0 ? content_length : 8191;
+
+    while (total < max_read) {
+        int n = esp_http_client_read(client, buf + total, max_read - total);
+        if (n <= 0) break;
+        total += n;
+    }
+    buf[total] = '\0';
+    esp_http_client_cleanup(client);
+    return buf;
+}
+
+static cJSON *build_filter(const char *npub)
+{
+    cJSON *filter = cJSON_CreateObject();
+    cJSON *kinds = cJSON_CreateArray();
+    cJSON_AddItemToArray(kinds, cJSON_CreateNumber(4));
+    cJSON_AddItemToObject(filter, "kinds", kinds);
+    cJSON_AddStringToObject(filter, "#p", npub);
+    cJSON_AddNumberToObject(filter, "limit", 10);
+    return filter;
+}
+
+static cJSON *build_subscription(const char *npub)
+{
+    cJSON *sub = cJSON_CreateArray();
+    cJSON_AddItemToArray(sub, cJSON_CreateString("REQ"));
+    cJSON_AddItemToArray(sub, cJSON_CreateString("cvm_sub_01"));
+    cJSON_AddItemToArray(sub, build_filter(npub));
+    return sub;
+}
+
+static void process_dm(const char *sender_pubkey, const char *encrypted_content)
+{
+    const tollgate_identity_t *id = identity_get();
+    if (!id || !id->initialized) {
+        ESP_LOGE(TAG, "Identity not initialized");
+        return;
+    }
+
+    uint8_t sender_pk[64];
+    for (int i = 0; i < 64; i++) {
+        char hex[3] = { sender_pubkey[i*2], sender_pubkey[i*2+1], 0 };
+        sender_pk[i] = (uint8_t)strtol(hex, NULL, 16);
+    }
+
+    char plaintext[2048];
+    int pt_len = nip04_decrypt(id->nsec, sender_pk, encrypted_content, plaintext, sizeof(plaintext));
+    if (pt_len < 0) {
+        ESP_LOGE(TAG, "Failed to decrypt DM from %.8s", sender_pubkey);
+        return;
+    }
+
+    ESP_LOGI(TAG, "Decrypted DM from %.8s: %s", sender_pubkey, plaintext);
+
+    cJSON *msg = cJSON_Parse(plaintext);
+    if (!msg) {
+        ESP_LOGE(TAG, "Invalid JSON in DM");
+        return;
+    }
+
+    cJSON *method = cJSON_GetObjectItem(msg, "method");
+    cJSON *params = cJSON_GetObjectItem(msg, "params");
+    if (!method || !cJSON_IsString(method)) {
+        cJSON_Delete(msg);
+        ESP_LOGE(TAG, "Missing 'method' in CVM request");
+        return;
+    }
+
+    mcp_request_t req = {0};
+    req.tool = mcp_parse_tool(method->valuestring);
+    strncpy(req.method, method->valuestring, sizeof(req.method) - 1);
+    if (params && cJSON_IsString(params)) {
+        strncpy(req.params_json, params->valuestring, sizeof(req.params_json) - 1);
+    } else if (params) {
+        char *pjson = cJSON_PrintUnformatted(params);
+        strncpy(req.params_json, pjson, sizeof(req.params_json) - 1);
+        cJSON_free(pjson);
+    }
+
+    mcp_response_t resp = mcp_dispatch(&req);
+    cJSON_Delete(msg);
+
+    cJSON *response_msg = cJSON_CreateObject();
+    if (resp.success) {
+        cJSON_AddStringToObject(response_msg, "status", "ok");
+        cJSON_AddItemToObject(response_msg, "result", cJSON_Parse(resp.result_json));
+    } else {
+        cJSON_AddStringToObject(response_msg, "status", "error");
+        cJSON_AddStringToObject(response_msg, "error", resp.error);
+    }
+
+    char *response_str = cJSON_PrintUnformatted(response_msg);
+    cJSON_Delete(response_msg);
+
+    uint8_t response_ct[4096];
+    size_t ct_len = 0;
+    nip04_encrypt(id->nsec, sender_pk, response_str, response_ct, &ct_len);
+    free(response_str);
+
+    ESP_LOGI(TAG, "CVM response prepared (%zu bytes encrypted), would send to %.8s", ct_len, sender_pubkey);
+}
+
+static void parse_nostr_events(const char *data)
+{
+    cJSON *arr = cJSON_Parse(data);
+    if (!arr || !cJSON_IsArray(arr)) {
+        if (arr) cJSON_Delete(arr);
+        return;
+    }
+
+    cJSON *item = NULL;
+    cJSON_ArrayForEach(item, arr) {
+        if (!cJSON_IsArray(item)) continue;
+        int arr_size = cJSON_GetArraySize(item);
+        if (arr_size < 3) continue;
+
+        cJSON *cmd = cJSON_GetArrayItem(item, 0);
+        if (!cmd || !cJSON_IsString(cmd) || strcmp(cmd->valuestring, "EVENT") != 0) continue;
+
+        cJSON *event = cJSON_GetArrayItem(item, 2);
+        if (!event) continue;
+
+        cJSON *kind = cJSON_GetObjectItem(event, "kind");
+        if (!kind || kind->valueint != 4) continue;
+
+        cJSON *pubkey = cJSON_GetObjectItem(event, "pubkey");
+        cJSON *content = cJSON_GetObjectItem(event, "content");
+        if (pubkey && content) {
+            process_dm(pubkey->valuestring, content->valuestring);
+        }
+    }
+    cJSON_Delete(arr);
+}
+
+static void cvm_task(void *arg)
+{
+    const tollgate_identity_t *id = identity_get();
+    if (!id || !id->initialized) {
+        ESP_LOGE(TAG, "Cannot start: identity not initialized");
+        vTaskDelete(NULL);
+        return;
+    }
+
+    char *relays = fetch_relays();
+    ESP_LOGI(TAG, "CVM server started, relays: %s", relays);
+
+    while (g_running) {
+        ESP_LOGI(TAG, "Polling for DMs...");
+
+        cJSON *sub = build_subscription(id->npub_hex);
+        char *sub_json = cJSON_PrintUnformatted(sub);
+        cJSON_Delete(sub);
+
+        char url[256];
+        snprintf(url, sizeof(url), "%s/cvm_poll", relays);
+        free(sub_json);
+
+        vTaskDelay(pdMS_TO_TICKS(30000));
+    }
+
+    ESP_LOGI(TAG, "CVM server stopped");
+    vTaskDelete(NULL);
+}
+
+esp_err_t cvm_server_init(void)
+{
+    ESP_LOGI(TAG, "CVM server initialized");
+    return ESP_OK;
+}
+
+void cvm_server_start(void)
+{
+    if (g_running) return;
+    g_running = true;
+    xTaskCreate(cvm_task, "cvm_server", 8192, NULL, 5, &g_task);
+}
+
+void cvm_server_stop(void)
+{
+    g_running = false;
+    if (g_task) {
+        vTaskDelay(pdMS_TO_TICKS(500));
+        g_task = NULL;
+    }
+}