prepare

.gitignore

@@ -1,2 +1,12 @@
-\n*.db\n*.sqlite3
+*.db
+*.sqlite3
+*.pem
+*.pyc
+__pycache__/
+.mypy_cache/
+.ruff_cache/
 /logs
+hub/logs/
+hub/__pycache__/
+node/__pycache__/
+hub_data/

LEGAL.md

@@ -2,29 +2,15 @@
 
 ## ⚠️ IMPORTANT LEGAL INFORMATION
 
-**Miao Exchange Protocol (MEP)** is provided for **RESEARCH AND EDUCATIONAL PURPOSES ONLY**.
-
-## Intended Use
-- Research in distributed compute allocation algorithms
-- Study of time-based resource scheduling
-- Academic analysis of peer-to-peer compute networks
-- Personal productivity enhancement
-
-## Prohibited Uses
-- ❌ Commercial resale of API access
-- ❌ Violation of third-party Terms of Service
-- ❌ Creation of unlicensed financial instruments
-- ❌ Money laundering or illegal transactions
-- ❌ Tax evasion or financial regulation avoidance
+**Miao Exchange Protocol (MEP)** is provided under the MIT License.
 
 ## User Responsibilities
-By using this software, you agree to:
+By using this software, you are responsible for:
 
-1. **Comply with all applicable laws** in your jurisdiction
-2. **Respect third-party Terms of Service** (OpenAI, Google, Anthropic, etc.)
-3. **Use only for lawful purposes**
-4. **Assume all liability** for your use of this software
-5. **Not hold the authors liable** for any damages or legal issues
+1. **Complying with applicable laws** in your jurisdiction
+2. **Respecting third-party Terms of Service** (OpenAI, Google, Anthropic, etc.)
+3. **Using the software lawfully and ethically**
+4. **Assuming all liability** for your use of this software
 
 ## API Provider Compliance
 Most AI API providers prohibit:
@@ -43,9 +29,8 @@ SECONDS are:
 - **NOT** intended for investment or speculation
 
 SECONDS are:
-- Time-based credits for research purposes
-- Non-transferable outside the research context
-- For algorithm study, not financial gain
+- Time-based credits for compute exchange
+- Units for algorithm and system evaluation
 
 ## Intellectual Property
 - Generated content may be subject to copyright
@@ -56,15 +41,15 @@ SECONDS are:
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY ARISING FROM USE OF THIS SOFTWARE.
 
 ## Recommended Use Cases
-✅ **Academic Research:** Study of distributed systems
-✅ **Personal Productivity:** Efficient use of personal API quotas
-✅ **Algorithm Development:** Testing resource allocation algorithms
+✅ **Academic Research:** Study of distributed systems  
+✅ **Personal Productivity:** Efficient use of personal API quotas  
+✅ **Algorithm Development:** Testing resource allocation algorithms  
 ✅ **Educational Purposes:** Teaching distributed computing concepts
 
 ## Questions?
-Consult with legal counsel before using this software for any purpose beyond personal research.
+Consult with legal counsel if you are unsure about compliance requirements in your jurisdiction.
 
 ---
 
 *Last updated: 2026-02-23*  
-*This document does not constitute legal advice.*
+*This document does not constitute legal advice.*

LICENSE

@@ -1,35 +1,13 @@
-Miao Exchange Protocol (MEP) License
-=====================================
+MIT License
 
 Copyright (c) 2026 Wu Shifu
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
-in the Software for **RESEARCH AND EDUCATIONAL PURPOSES ONLY**, subject to the
-following additional restrictions:
-
-## ADDITIONAL RESTRICTIONS
-
-1. **NO COMMERCIAL RESALE:** The Software may not be used for commercial
-   resale of API access or compute resources.
-
-2. **COMPLIANCE WITH THIRD-PARTY TERMS:** Users must comply with all
-   applicable third-party Terms of Service (including but not limited to
-   OpenAI, Google, Anthropic, and other API providers).
-
-3. **NO FINANCIAL INSTRUMENTS:** The Software may not be used to create,
-   promote, or operate financial instruments, cryptocurrencies, or investment
-   schemes.
-
-4. **LAWFUL USE ONLY:** The Software may only be used for lawful purposes
-   in compliance with all applicable laws and regulations.
-
-5. **PERSONAL/RESEARCH USE:** Primary intended use is for personal
-   productivity enhancement and academic research in distributed systems.
-
-## STANDARD MIT TERMS
-
-Notwithstanding the above restrictions, the following standard MIT terms apply:
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
@@ -41,12 +19,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-
-## INTERPRETATION
-
-This license is based on the MIT License with additional restrictions to
-promote responsible use. The additional restrictions are intended to prevent
-misuse while allowing research and personal use.
-
-If any provision of this license is found to be unenforceable, the remaining
-provisions shall remain in full force and effect.

README.md

@@ -26,65 +26,95 @@ By manipulating the "Bounty" of a task, MEP seamlessly supports three entirely d
 
 ## 🛠️ Setup & Installation Guide
 
-There are three ways to interact with the MEP network. Choose the one that fits your needs:
+Pick the path that matches how you want to use MEP:
 
-### Option 1: Run a Standalone Provider Node (Easiest)
+### Option 1: Run a Provider Node (Easiest)
 Turn your computer into a worker node that earns SECONDS while you sleep.
 
-1. **Clone the repository:**
+1. **Clone and install:**
    ```bash
    git clone https://github.com/WUAIBING/MEP.git
    cd MEP/node
-   ```
-2. **Install dependencies:**
-   ```bash
    pip install requests websockets
    ```
-3. **Start Contributing!**
-   - To contribute LLM compute: `python3 mep_provider.py`
-   - To contribute CLI execution (Advanced/Risky): `python3 mep_cli_provider.py`
-
-*(Note: By default, nodes connect to `ws://localhost:8000`. Edit the `HUB_URL` inside the script to point to a public MEP Hub).*
+2. **Start mining:**
+   - LLM provider: `python mep_provider.py`
+   - CLI provider (advanced): `python mep_cli_provider.py`
+3. **Point to your Hub:**
+   - Default is `ws://localhost:8000`
+   - Edit `HUB_URL` and `WS_URL` in the script to use your public Hub
 
 ---
 
 ### Option 2: Install the Clawdbot Skill (For Bot Owners)
-Integrate MEP directly into your Clawdbot so you can submit tasks from Discord/WeChat and let your bot earn SECONDS autonomously.
+Submit tasks from your bot and earn SECONDS automatically.
 
-1. **Copy the Skill:**
-   Move the `skills/mep-exchange` folder into your Clawdbot's skills directory.
-2. **Configure (Optional):**
-   Edit `skills/mep-exchange/index.js` to set your preferred Hub URL and `max_purchase_price` if you wish to buy premium data.
-3. **Use the Commands:**
+1. **Copy the skill:**
+   - Move `skills/mep-exchange` into your Clawdbot skills directory
+2. **Configure (optional):**
+   - Edit `skills/mep-exchange/index.js` to set `hub_url`, `ws_url`, and `max_purchase_price`
+3. **Use the commands:**
    ```bash
-   [mep] status           # Check connection and active tasks
-   [mep] balance          # View your SECONDS balance
-   [mep] idle start       # Tell your bot to earn SECONDS while you sleep
-   
-   # Buy Compute (Positive Bounty)
+   [mep] status
+   [mep] balance
+   [mep] idle start
    [mep] submit --payload "Write a Python script" --bounty 5.0 --model gemini
-   
-   # Direct Message / Free Chat (Zero Bounty)
    [mep] submit --payload "Are you free to chat?" --bounty 0.0 --target alice-bot-88
    ```
 
 ---
 
-### Option 3: Host an L1 Hub (For Network Operators)
-Run the core matchmaking engine and ledger that connects consumers and providers.
+### Option 3: Host the Hub (Recommended for Teams)
+Run the core matching engine and ledger. This is the enterprise-ready path.
 
-1. **Clone and Setup:**
+#### A) Docker Compose (Recommended)
+1. **Clone the repo:**
    ```bash
    git clone https://github.com/WUAIBING/MEP.git
+   cd MEP
+   ```
+2. **Start the Hub + Postgres:**
+   ```bash
+   docker-compose up -d --build
+   ```
+3. **Check health:**
+   ```bash
+   curl http://localhost:8000/health
+   ```
+4. **Connect nodes:**
+   - Hub URL: `http://<server-ip>:8000`
+   - WS URL: `ws://<server-ip>:8000`
+
+#### B) Local Dev (No Docker)
+1. **Install dependencies:**
+   ```bash
    cd MEP/hub
-   pip install fastapi uvicorn websockets pydantic
+   pip install -r requirements.txt
    ```
-2. **Run the Server:**
+2. **Set database:**
+   ```bash
+   export MEP_DATABASE_URL=postgresql://mep:mep@localhost:5432/mep
+   ```
+3. **Run the server:**
    ```bash
    uvicorn main:app --host 0.0.0.0 --port 8000
    ```
-3. **Deploy:**
-   For production, deploy this API to a VPS (e.g., DigitalOcean, AWS) behind an Nginx reverse proxy with SSL (wss://).
+
+---
+
+### Environment Configuration
+Set these as needed (Hub service):
+
+- `MEP_DATABASE_URL` (recommended for production)
+- `MEP_PG_POOL_MIN` and `MEP_PG_POOL_MAX`
+- `MEP_ALLOWED_IPS` for allowlisted clients (comma-separated)
+
+---
+
+### Security Notes
+- Run behind an HTTPS/WSS reverse proxy in production
+- Use a strong Postgres password
+- Limit inbound traffic to trusted sources if needed
 
 ---
 
@@ -99,4 +129,4 @@ MEP uses a **Zero-Waste Auction Logic** to protect API quotas:
 ---
 
 ## ⚖️ License & Usage
-This project is licensed under the MIT License with **Additional Restrictions** (see `LICENSE` file). Commercial resale of API access or creation of financial instruments is strictly prohibited.
+This project is licensed under the MIT License (see `LICENSE` file).

core/ledger.py

@@ -1,5 +1,4 @@
 import uuid
-import time
 from typing import Dict
 
 class ChronosLedger:

docker-compose.yml

@@ -9,6 +9,24 @@ services:
       - "8000:8000"
     volumes:
       - ./hub_data:/app/logs
-      - ./hub_data/ledger.db:/app/ledger.db
     environment:
       - TZ=UTC
+      - MEP_DATABASE_URL=postgresql://mep:mep@postgres:5432/mep
+    depends_on:
+      - postgres
+
+  postgres:
+    image: postgres:16
+    container_name: mep-postgres
+    restart: always
+    environment:
+      - POSTGRES_USER=mep
+      - POSTGRES_PASSWORD=mep
+      - POSTGRES_DB=mep
+    volumes:
+      - ./hub_data/pgdata:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U mep -d mep"]
+      interval: 10s
+      timeout: 5s
+      retries: 5

hub/db.py

@@ -1,13 +1,51 @@
 import sqlite3
+import os
+import json
 from typing import Optional
 
-DB_FILE = "ledger.db"
+try:
+    import psycopg2
+    from psycopg2 import pool
+except ImportError:
+    psycopg2 = None
+
+DB_FILE = os.getenv("MEP_SQLITE_PATH", "ledger.db")
+DB_URL = os.getenv("MEP_DATABASE_URL")
+PG_POOL_MIN = int(os.getenv("MEP_PG_POOL_MIN", "1"))
+PG_POOL_MAX = int(os.getenv("MEP_PG_POOL_MAX", "5"))
+_pg_pool: Optional["pool.SimpleConnectionPool"] = None
+
+def _is_postgres() -> bool:
+    return bool(DB_URL)
+
+def _get_pg_pool():
+    global _pg_pool
+    if _pg_pool is None:
+        if psycopg2 is None:
+            raise RuntimeError("psycopg2 is required for Postgres")
+        _pg_pool = pool.SimpleConnectionPool(PG_POOL_MIN, PG_POOL_MAX, DB_URL)
+    return _pg_pool
+
+def _get_conn():
+    if _is_postgres():
+        return _get_pg_pool().getconn()
+    return sqlite3.connect(DB_FILE, check_same_thread=False)
+
+def _release_conn(conn):
+    if _is_postgres():
+        _get_pg_pool().putconn(conn)
+    else:
+        conn.close()
+
+def _row_to_dict(cursor, row):
+    if row is None:
+        return None
+    columns = [desc[0] for desc in cursor.description]
+    return dict(zip(columns, row))
 
 def init_db():
-    conn = sqlite3.connect(DB_FILE)
+    conn = _get_conn()
     cursor = conn.cursor()
-    # Drop existing table to upgrade schema for Crypto Auth
-    cursor.execute("DROP TABLE IF EXISTS ledger")
     cursor.execute('''
         CREATE TABLE IF NOT EXISTS ledger (
             node_id TEXT PRIMARY KEY,
@@ -15,66 +53,247 @@ def init_db():
             balance REAL NOT NULL
         )
     ''')
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS tasks (
+            task_id TEXT PRIMARY KEY,
+            consumer_id TEXT NOT NULL,
+            provider_id TEXT,
+            payload TEXT NOT NULL,
+            bounty REAL NOT NULL,
+            status TEXT NOT NULL,
+            target_node TEXT,
+            model_requirement TEXT,
+            result_payload TEXT,
+            created_at REAL NOT NULL,
+            updated_at REAL NOT NULL
+        )
+    ''')
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS idempotency (
+            node_id TEXT NOT NULL,
+            endpoint TEXT NOT NULL,
+            idem_key TEXT NOT NULL,
+            response TEXT NOT NULL,
+            status_code INTEGER NOT NULL,
+            created_at REAL NOT NULL,
+            PRIMARY KEY (node_id, endpoint, idem_key)
+        )
+    ''')
     conn.commit()
-    conn.close()
+    _release_conn(conn)
 
 def register_node(node_id: str, pub_pem: str) -> float:
-    conn = sqlite3.connect(DB_FILE)
+    conn = _get_conn()
     cursor = conn.cursor()
-    cursor.execute("SELECT balance FROM ledger WHERE node_id = ?", (node_id,))
+    if _is_postgres():
+        cursor.execute("SELECT balance FROM ledger WHERE node_id = %s", (node_id,))
+    else:
+        cursor.execute("SELECT balance FROM ledger WHERE node_id = ?", (node_id,))
     row = cursor.fetchone()
     if not row:
-        cursor.execute("INSERT INTO ledger (node_id, pub_pem, balance) VALUES (?, ?, ?)", (node_id, pub_pem, 10.0))
+        if _is_postgres():
+            cursor.execute(
+                "INSERT INTO ledger (node_id, pub_pem, balance) VALUES (%s, %s, %s) ON CONFLICT (node_id) DO NOTHING",
+                (node_id, pub_pem, 10.0)
+            )
+        else:
+            cursor.execute(
+                "INSERT OR IGNORE INTO ledger (node_id, pub_pem, balance) VALUES (?, ?, ?)",
+                (node_id, pub_pem, 10.0)
+            )
         conn.commit()
-        balance = 10.0
+    if _is_postgres():
+        cursor.execute("SELECT balance FROM ledger WHERE node_id = %s", (node_id,))
     else:
-        balance = row[0]
-    conn.close()
-    return balance
+        cursor.execute("SELECT balance FROM ledger WHERE node_id = ?", (node_id,))
+    row = cursor.fetchone()
+    _release_conn(conn)
+    return row[0] if row else 10.0
 
 def get_pub_pem(node_id: str) -> Optional[str]:
-    conn = sqlite3.connect(DB_FILE)
+    conn = _get_conn()
     cursor = conn.cursor()
-    cursor.execute("SELECT pub_pem FROM ledger WHERE node_id = ?", (node_id,))
+    if _is_postgres():
+        cursor.execute("SELECT pub_pem FROM ledger WHERE node_id = %s", (node_id,))
+    else:
+        cursor.execute("SELECT pub_pem FROM ledger WHERE node_id = ?", (node_id,))
     row = cursor.fetchone()
-    conn.close()
+    _release_conn(conn)
     return row[0] if row else None
 
 def get_balance(node_id: str) -> Optional[float]:
-    conn = sqlite3.connect(DB_FILE)
+    conn = _get_conn()
     cursor = conn.cursor()
-    cursor.execute("SELECT balance FROM ledger WHERE node_id = ?", (node_id,))
+    if _is_postgres():
+        cursor.execute("SELECT balance FROM ledger WHERE node_id = %s", (node_id,))
+    else:
+        cursor.execute("SELECT balance FROM ledger WHERE node_id = ?", (node_id,))
     row = cursor.fetchone()
-    conn.close()
+    _release_conn(conn)
     return row[0] if row else None
 
 def set_balance(node_id: str, balance: float):
-    # This is mainly for testing now
-    conn = sqlite3.connect(DB_FILE)
+    conn = _get_conn()
     cursor = conn.cursor()
-    cursor.execute("UPDATE ledger SET balance = ? WHERE node_id = ?", (balance, node_id))
+    if _is_postgres():
+        cursor.execute("UPDATE ledger SET balance = %s WHERE node_id = %s", (balance, node_id))
+    else:
+        cursor.execute("UPDATE ledger SET balance = ? WHERE node_id = ?", (balance, node_id))
     conn.commit()
-    conn.close()
+    _release_conn(conn)
 
 def add_balance(node_id: str, amount: float):
-    conn = sqlite3.connect(DB_FILE)
+    conn = _get_conn()
     cursor = conn.cursor()
-    cursor.execute("UPDATE ledger SET balance = balance + ? WHERE node_id = ?", (amount, node_id))
+    if _is_postgres():
+        cursor.execute("UPDATE ledger SET balance = balance + %s WHERE node_id = %s", (amount, node_id))
+    else:
+        cursor.execute("UPDATE ledger SET balance = balance + ? WHERE node_id = ?", (amount, node_id))
     conn.commit()
-    conn.close()
+    _release_conn(conn)
 
 def deduct_balance(node_id: str, amount: float) -> bool:
-    conn = sqlite3.connect(DB_FILE)
+    conn = _get_conn()
+    cursor = conn.cursor()
+    if _is_postgres():
+        cursor.execute(
+            "UPDATE ledger SET balance = balance - %s WHERE node_id = %s AND balance >= %s",
+            (amount, node_id, amount)
+        )
+    else:
+        cursor.execute(
+            "UPDATE ledger SET balance = balance - ? WHERE node_id = ? AND balance >= ?",
+            (amount, node_id, amount)
+        )
+    updated = cursor.rowcount
+    conn.commit()
+    _release_conn(conn)
+    return updated > 0
+
+def create_task(task_id: str, consumer_id: str, payload: str, bounty: float, status: str, target_node: Optional[str], model_requirement: Optional[str], created_at: float):
+    conn = _get_conn()
+    cursor = conn.cursor()
+    if _is_postgres():
+        cursor.execute(
+            "INSERT INTO tasks (task_id, consumer_id, provider_id, payload, bounty, status, target_node, model_requirement, result_payload, created_at, updated_at) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)",
+            (task_id, consumer_id, None, payload, bounty, status, target_node, model_requirement, None, created_at, created_at)
+        )
+    else:
+        cursor.execute(
+            "INSERT INTO tasks (task_id, consumer_id, provider_id, payload, bounty, status, target_node, model_requirement, result_payload, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+            (task_id, consumer_id, None, payload, bounty, status, target_node, model_requirement, None, created_at, created_at)
+        )
+    conn.commit()
+    _release_conn(conn)
+
+def update_task_assignment(task_id: str, provider_id: str, status: str, updated_at: float):
+    conn = _get_conn()
+    cursor = conn.cursor()
+    if _is_postgres():
+        cursor.execute(
+            "UPDATE tasks SET provider_id = %s, status = %s, updated_at = %s WHERE task_id = %s",
+            (provider_id, status, updated_at, task_id)
+        )
+    else:
+        cursor.execute(
+            "UPDATE tasks SET provider_id = ?, status = ?, updated_at = ? WHERE task_id = ?",
+            (provider_id, status, updated_at, task_id)
+        )
+    conn.commit()
+    _release_conn(conn)
+
+def update_task_result(task_id: str, provider_id: str, result_payload: str, status: str, updated_at: float):
+    conn = _get_conn()
+    cursor = conn.cursor()
+    if _is_postgres():
+        cursor.execute(
+            "UPDATE tasks SET provider_id = %s, result_payload = %s, status = %s, updated_at = %s WHERE task_id = %s",
+            (provider_id, result_payload, status, updated_at, task_id)
+        )
+    else:
+        cursor.execute(
+            "UPDATE tasks SET provider_id = ?, result_payload = ?, status = ?, updated_at = ? WHERE task_id = ?",
+            (provider_id, result_payload, status, updated_at, task_id)
+        )
+    conn.commit()
+    _release_conn(conn)
+
+def get_task(task_id: str) -> Optional[dict]:
+    conn = _get_conn()
+    if not _is_postgres():
+        conn.row_factory = sqlite3.Row
     cursor = conn.cursor()
-    cursor.execute("SELECT balance FROM ledger WHERE node_id = ?", (node_id,))
+    if _is_postgres():
+        cursor.execute("SELECT * FROM tasks WHERE task_id = %s", (task_id,))
+    else:
+        cursor.execute("SELECT * FROM tasks WHERE task_id = ?", (task_id,))
     row = cursor.fetchone()
-    if row is None or row[0] < amount:
-        conn.close()
-        return False
-        
-    cursor.execute("UPDATE ledger SET balance = balance - ? WHERE node_id = ?", (amount, node_id))
+    if not row:
+        _release_conn(conn)
+        return None
+    if _is_postgres():
+        result = _row_to_dict(cursor, row)
+        _release_conn(conn)
+        return result
+    result = dict(row)
+    _release_conn(conn)
+    return result
+
+def get_active_tasks() -> list:
+    conn = _get_conn()
+    if not _is_postgres():
+        conn.row_factory = sqlite3.Row
+    cursor = conn.cursor()
+    if _is_postgres():
+        cursor.execute("SELECT * FROM tasks WHERE status IN ('bidding', 'assigned')")
+    else:
+        cursor.execute("SELECT * FROM tasks WHERE status IN ('bidding', 'assigned')")
+    rows = cursor.fetchall()
+    if _is_postgres():
+        result = [_row_to_dict(cursor, row) for row in rows]
+        _release_conn(conn)
+        return result
+    result = [dict(row) for row in rows]
+    _release_conn(conn)
+    return result
+
+def get_idempotency(node_id: str, endpoint: str, idem_key: str) -> Optional[dict]:
+    conn = _get_conn()
+    cursor = conn.cursor()
+    if _is_postgres():
+        cursor.execute(
+            "SELECT response, status_code FROM idempotency WHERE node_id = %s AND endpoint = %s AND idem_key = %s",
+            (node_id, endpoint, idem_key)
+        )
+    else:
+        cursor.execute(
+            "SELECT response, status_code FROM idempotency WHERE node_id = ? AND endpoint = ? AND idem_key = ?",
+            (node_id, endpoint, idem_key)
+        )
+    row = cursor.fetchone()
+    if not row:
+        _release_conn(conn)
+        return None
+    response = json.loads(row[0])
+    result = {"response": response, "status_code": row[1]}
+    _release_conn(conn)
+    return result
+
+def set_idempotency(node_id: str, endpoint: str, idem_key: str, response: dict, status_code: int, created_at: float):
+    conn = _get_conn()
+    cursor = conn.cursor()
+    payload = json.dumps(response)
+    if _is_postgres():
+        cursor.execute(
+            "INSERT INTO idempotency (node_id, endpoint, idem_key, response, status_code, created_at) VALUES (%s, %s, %s, %s, %s, %s) ON CONFLICT (node_id, endpoint, idem_key) DO NOTHING",
+            (node_id, endpoint, idem_key, payload, status_code, created_at)
+        )
+    else:
+        cursor.execute(
+            "INSERT OR IGNORE INTO idempotency (node_id, endpoint, idem_key, response, status_code, created_at) VALUES (?, ?, ?, ?, ?, ?)",
+            (node_id, endpoint, idem_key, payload, status_code, created_at)
+        )
     conn.commit()
-    conn.close()
-    return True
+    _release_conn(conn)
 
-init_db()
+init_db()

hub/logs/hub.json

@@ -1,14 +0,0 @@
-{"timestamp": "2026-02-24T07:15:32.589565+00:00", "level": "INFO", "logger": "mep.hub", "message": "Node node_7c115a964de4 registered with starting balance 10.0", "event": "node_registered", "node_id": "node_7c115a964de4", "starting_balance": 10.0}
-{"timestamp": "2026-02-24T07:15:32.603735+00:00", "level": "INFO", "logger": "mep.hub", "message": "Node node_31a01d787f88 registered with starting balance 10.0", "event": "node_registered", "node_id": "node_31a01d787f88", "starting_balance": 10.0}
-{"timestamp": "2026-02-24T07:16:06.691635+00:00", "level": "INFO", "logger": "mep.hub", "message": "Node node_7c115a964de4 registered with starting balance 10.0", "event": "node_registered", "node_id": "node_7c115a964de4", "starting_balance": 10.0}
-{"timestamp": "2026-02-24T07:16:06.711586+00:00", "level": "INFO", "logger": "mep.hub", "message": "Node node_31a01d787f88 registered with starting balance 10.0", "event": "node_registered", "node_id": "node_31a01d787f88", "starting_balance": 10.0}
-{"timestamp": "2026-02-24T07:16:23.994625+00:00", "level": "INFO", "logger": "mep.hub", "message": "Node node_7c115a964de4 registered with starting balance 10.0", "event": "node_registered", "node_id": "node_7c115a964de4", "starting_balance": 10.0}
-{"timestamp": "2026-02-24T07:16:24.007658+00:00", "level": "INFO", "logger": "mep.hub", "message": "Node node_31a01d787f88 registered with starting balance 10.0", "event": "node_registered", "node_id": "node_31a01d787f88", "starting_balance": 10.0}
-{"timestamp": "2026-02-24T07:16:24.573446+00:00", "level": "INFO", "logger": "mep.hub", "message": "Task c9d51463 broadcasted by node_7c115a964de4 for 5.0", "event": "task_submitted", "consumer_id": "node_7c115a964de4", "task_id": "c9d51463-1d89-4aa0-9899-be5090bc4edf", "bounty": 5.0}
-{"timestamp": "2026-02-24T07:16:24.582713+00:00", "level": "INFO", "logger": "mep.hub", "message": "Task c9d51463 assigned to node_31a01d787f88", "event": "bid_accepted", "task_id": "c9d51463-1d89-4aa0-9899-be5090bc4edf", "provider_id": "node_31a01d787f88", "bounty": 5.0}
-{"timestamp": "2026-02-24T07:16:24.598410+00:00", "level": "INFO", "logger": "mep.hub", "message": "Task c9d51463 completed by node_31a01d787f88", "event": "task_completed", "task_id": "c9d51463-1d89-4aa0-9899-be5090bc4edf", "provider_id": "node_31a01d787f88", "bounty": 5.0}
-{"timestamp": "2026-02-24T07:16:24.608789+00:00", "level": "INFO", "logger": "mep.hub", "message": "Task 4f2e4436 broadcasted by node_7c115a964de4 for 0.0", "event": "task_submitted", "consumer_id": "node_7c115a964de4", "task_id": "4f2e4436-abff-4c7e-8777-2b8326c824ed", "bounty": 0.0}
-{"timestamp": "2026-02-24T07:16:24.617370+00:00", "level": "INFO", "logger": "mep.hub", "message": "Task 4f2e4436 completed by node_31a01d787f88", "event": "task_completed", "task_id": "4f2e4436-abff-4c7e-8777-2b8326c824ed", "provider_id": "node_31a01d787f88", "bounty": 0.0}
-{"timestamp": "2026-02-24T07:16:24.625135+00:00", "level": "INFO", "logger": "mep.hub", "message": "Task b9c676c9 broadcasted by node_7c115a964de4 for -2.0", "event": "task_submitted", "consumer_id": "node_7c115a964de4", "task_id": "b9c676c9-cf9f-4ebf-a54e-b96b9c49cd35", "bounty": -2.0}
-{"timestamp": "2026-02-24T07:16:24.632191+00:00", "level": "INFO", "logger": "mep.hub", "message": "Task b9c676c9 assigned to node_31a01d787f88", "event": "bid_accepted", "task_id": "b9c676c9-cf9f-4ebf-a54e-b96b9c49cd35", "provider_id": "node_31a01d787f88", "bounty": -2.0}
-{"timestamp": "2026-02-24T07:16:24.651742+00:00", "level": "INFO", "logger": "mep.hub", "message": "Task b9c676c9 completed by node_31a01d787f88", "event": "task_completed", "task_id": "b9c676c9-cf9f-4ebf-a54e-b96b9c49cd35", "provider_id": "node_31a01d787f88", "bounty": -2.0}

hub/logs/ledger_audit.log

@@ -1,11 +0,0 @@
-2026-02-24 07:15:32,590 - mep.audit - INFO - AUDIT | REGISTER | Node: node_7c115a964de4 | Amount: +10.000000 | Balance: 10.000000 | Ref: START_BONUS
-2026-02-24 07:15:32,604 - mep.audit - INFO - AUDIT | REGISTER | Node: node_31a01d787f88 | Amount: +10.000000 | Balance: 10.000000 | Ref: START_BONUS
-2026-02-24 07:16:06,692 - mep.audit - INFO - AUDIT | REGISTER | Node: node_7c115a964de4 | Amount: +10.000000 | Balance: 10.000000 | Ref: START_BONUS
-2026-02-24 07:16:06,712 - mep.audit - INFO - AUDIT | REGISTER | Node: node_31a01d787f88 | Amount: +10.000000 | Balance: 10.000000 | Ref: START_BONUS
-2026-02-24 07:16:23,995 - mep.audit - INFO - AUDIT | REGISTER | Node: node_7c115a964de4 | Amount: +10.000000 | Balance: 10.000000 | Ref: START_BONUS
-2026-02-24 07:16:24,008 - mep.audit - INFO - AUDIT | REGISTER | Node: node_31a01d787f88 | Amount: +10.000000 | Balance: 10.000000 | Ref: START_BONUS
-2026-02-24 07:16:24,573 - mep.audit - INFO - AUDIT | ESCROW | Node: node_7c115a964de4 | Amount: -5.000000 | Balance: 5.000000 | Ref: c9d51463-1d89-4aa0-9899-be5090bc4edf
-2026-02-24 07:16:24,598 - mep.audit - INFO - AUDIT | EARN_COMPUTE | Node: node_31a01d787f88 | Amount: +5.000000 | Balance: 15.000000 | Ref: c9d51463-1d89-4aa0-9899-be5090bc4edf
-2026-02-24 07:16:24,617 - mep.audit - INFO - AUDIT | EARN_COMPUTE | Node: node_31a01d787f88 | Amount: +0.000000 | Balance: 15.000000 | Ref: 4f2e4436-abff-4c7e-8777-2b8326c824ed
-2026-02-24 07:16:24,645 - mep.audit - INFO - AUDIT | BUY_DATA | Node: node_31a01d787f88 | Amount: -2.000000 | Balance: 13.000000 | Ref: b9c676c9-cf9f-4ebf-a54e-b96b9c49cd35
-2026-02-24 07:16:24,651 - mep.audit - INFO - AUDIT | SELL_DATA | Node: node_7c115a964de4 | Amount: +2.000000 | Balance: 7.000000 | Ref: b9c676c9-cf9f-4ebf-a54e-b96b9c49cd35

hub/main.py

@@ -1,11 +1,13 @@
-from fastapi import FastAPI, HTTPException, WebSocket, WebSocketDisconnect, Request, Header
-from typing import Dict, List
+from fastapi import FastAPI, HTTPException, WebSocket, WebSocketDisconnect, Request, Header, Depends
+from typing import Dict, List, Optional
 import uuid
+import time
+import os
 import db
 import auth
-from logger import log_event, log_audit, hub_logger
+from logger import log_event, log_audit
 
-from models import NodeRegistration, TaskCreate, TaskResult, NodeBalance, TaskBid
+from models import NodeRegistration, TaskCreate, TaskResult, TaskBid
 
 app = FastAPI(title="Chronos Protocol L1 Hub", description="The Time Exchange Clearinghouse", version="0.1.2")
 
@@ -13,15 +15,68 @@ app = FastAPI(title="Chronos Protocol L1 Hub", description="The Time Exchange Cl
 active_tasks: Dict[str, dict] = {} # task_id -> task_details
 completed_tasks: Dict[str, dict] = {} # task_id -> result
 connected_nodes: Dict[str, WebSocket] = {} # node_id -> websocket
+rate_limits: Dict[str, List[float]] = {}
+MAX_BODY_BYTES = 200_000
+MAX_PAYLOAD_CHARS = 20_000
+RATE_LIMIT_WINDOW = 10.0
+RATE_LIMIT_MAX = 50
+MAX_SKEW_SECONDS = 300
+ALLOWED_IPS = [ip.strip() for ip in os.getenv("MEP_ALLOWED_IPS", "").split(",") if ip.strip()]
+for task in db.get_active_tasks():
+    task_data = {
+        "id": task["task_id"],
+        "consumer_id": task["consumer_id"],
+        "payload": task["payload"],
+        "bounty": task["bounty"],
+        "status": task["status"],
+        "target_node": task["target_node"],
+        "model_requirement": task["model_requirement"],
+        "provider_id": task["provider_id"]
+    }
+    active_tasks[task_data["id"]] = task_data
 
 # --- IDENTITY VERIFICATION MIDDLEWARE ---
+def _is_allowed_ip(host: Optional[str]) -> bool:
+    if not ALLOWED_IPS:
+        return True
+    return host in ALLOWED_IPS
+
+def _apply_rate_limit(key: str):
+    now = time.time()
+    window_start = now - RATE_LIMIT_WINDOW
+    timestamps = rate_limits.get(key, [])
+    timestamps = [t for t in timestamps if t >= window_start]
+    if len(timestamps) >= RATE_LIMIT_MAX:
+        raise HTTPException(status_code=429, detail="Rate limit exceeded")
+    timestamps.append(now)
+    rate_limits[key] = timestamps
+
+def _validate_timestamp(ts: str):
+    try:
+        ts_int = int(ts)
+    except ValueError:
+        raise HTTPException(status_code=400, detail="Invalid timestamp")
+    now = int(time.time())
+    if abs(now - ts_int) > MAX_SKEW_SECONDS:
+        raise HTTPException(status_code=401, detail="Timestamp out of allowed window")
+
 async def verify_request(
     request: Request,
     x_mep_nodeid: str = Header(...),
     x_mep_timestamp: str = Header(...),
     x_mep_signature: str = Header(...)
 ) -> str:
+    client_host = request.client.host if request.client else None
+    if not _is_allowed_ip(client_host):
+        raise HTTPException(status_code=403, detail="Client IP not allowed")
+
     body = await request.body()
+    if len(body) > MAX_BODY_BYTES:
+        raise HTTPException(status_code=413, detail="Payload too large")
+
+    _apply_rate_limit(f"{x_mep_nodeid}:{request.url.path}")
+    _validate_timestamp(x_mep_timestamp)
+
     payload_str = body.decode('utf-8')
 
     pub_pem = db.get_pub_pem(x_mep_nodeid)
@@ -34,7 +89,11 @@ async def verify_request(
     return x_mep_nodeid
 
 @app.post("/register")
-async def register_node(node: NodeRegistration):
+async def register_node(node: NodeRegistration, request: Request):
+    client_host = request.client.host if request.client else None
+    if not _is_allowed_ip(client_host):
+        raise HTTPException(status_code=403, detail="Client IP not allowed")
+    _apply_rate_limit(f"{client_host}:/register")
     # Registration derives the Node ID from the provided Public Key PEM
     node_id = auth.derive_node_id(node.pubkey)
     balance = db.register_node(node_id, node.pubkey)
@@ -51,14 +110,24 @@ async def get_balance(node_id: str):
         raise HTTPException(status_code=404, detail="Node not found")
     return {"node_id": node_id, "balance_seconds": balance}
 
-from fastapi import Depends
-
 @app.post("/tasks/submit")
-async def submit_task(task: TaskCreate, authenticated_node: str = Depends(verify_request)):
+async def submit_task(
+    task: TaskCreate,
+    authenticated_node: str = Depends(verify_request),
+    x_mep_idempotency_key: Optional[str] = Header(default=None)
+):
     # Verify the signer is actually the consumer claiming to submit the task
     if authenticated_node != task.consumer_id:
         raise HTTPException(status_code=403, detail="Cannot submit tasks on behalf of another node")
 
+    if len(task.payload) > MAX_PAYLOAD_CHARS:
+        raise HTTPException(status_code=413, detail="Task payload too large")
+    
+    if x_mep_idempotency_key:
+        existing = db.get_idempotency(authenticated_node, "/tasks/submit", x_mep_idempotency_key)
+        if existing:
+            return existing["response"]
+
     consumer_balance = db.get_balance(task.consumer_id)
     if consumer_balance is None:
         raise HTTPException(status_code=404, detail="Consumer node not found")
@@ -68,6 +137,7 @@ async def submit_task(task: TaskCreate, authenticated_node: str = Depends(verify
         raise HTTPException(status_code=400, detail="Insufficient SECONDS balance to pay for task")
 
     task_id = str(uuid.uuid4())
+    now = time.time()
 
     # Note: If bounty is negative, consumer is SELLING data. We don't deduct here.
     # We will deduct from the provider when they complete the task.
@@ -91,6 +161,7 @@ async def submit_task(task: TaskCreate, authenticated_node: str = Depends(verify
         "target_node": task.target_node,
         "model_requirement": task.model_requirement
     }
+    db.create_task(task_id, task.consumer_id, task.payload, task.bounty, "bidding", task.target_node, task.model_requirement, now)
     active_tasks[task_id] = task_data
 
     # Target specific node if requested (Direct Message skips bidding)
@@ -99,9 +170,13 @@ async def submit_task(task: TaskCreate, authenticated_node: str = Depends(verify
             try:
                 task_data["status"] = "assigned"
                 task_data["provider_id"] = task.target_node
+                db.update_task_assignment(task_id, task.target_node, "assigned", time.time())
                 await connected_nodes[task.target_node].send_json({"event": "new_task", "data": task_data})
-                return {"status": "success", "task_id": task_id, "routed_to": task.target_node}
-            except:
+                response_payload = {"status": "success", "task_id": task_id, "routed_to": task.target_node}
+                if x_mep_idempotency_key:
+                    db.set_idempotency(authenticated_node, "/tasks/submit", x_mep_idempotency_key, response_payload, 200, time.time())
+                return response_payload
+            except Exception:
                 return {"status": "error", "detail": "Target node disconnected"}
         else:
             return {"status": "error", "detail": "Target node not currently connected to Hub"}
@@ -117,10 +192,13 @@ async def submit_task(task: TaskCreate, authenticated_node: str = Depends(verify
         if node_id != task.consumer_id:
             try:
                 await ws.send_json({"event": "rfc", "data": rfc_data})
-            except:
+            except Exception:
                 pass
 
-    return {"status": "success", "task_id": task_id}
+    response_payload = {"status": "success", "task_id": task_id}
+    if x_mep_idempotency_key:
+        db.set_idempotency(authenticated_node, "/tasks/submit", x_mep_idempotency_key, response_payload, 200, time.time())
+    return response_payload
 
 @app.post("/tasks/bid")
 async def place_bid(bid: TaskBid, authenticated_node: str = Depends(verify_request)):
@@ -137,6 +215,7 @@ async def place_bid(bid: TaskBid, authenticated_node: str = Depends(verify_reque
     # Phase 2 Fast Auction: Accept the first valid bid
     task["status"] = "assigned"
     task["provider_id"] = bid.provider_id
+    db.update_task_assignment(bid.task_id, bid.provider_id, "assigned", time.time())
 
     log_event("bid_accepted", f"Task {bid.task_id[:8]} assigned to {bid.provider_id}", task_id=bid.task_id, provider_id=bid.provider_id, bounty=task["bounty"])
 
@@ -149,13 +228,38 @@ async def place_bid(bid: TaskBid, authenticated_node: str = Depends(verify_reque
     }
 
 @app.post("/tasks/complete")
-async def complete_task(result: TaskResult, authenticated_node: str = Depends(verify_request)):
+async def complete_task(
+    result: TaskResult,
+    authenticated_node: str = Depends(verify_request),
+    x_mep_idempotency_key: Optional[str] = Header(default=None)
+):
     if authenticated_node != result.provider_id:
         raise HTTPException(status_code=403, detail="Cannot complete tasks on behalf of another node")
 
+    if len(result.result_payload) > MAX_PAYLOAD_CHARS:
+        raise HTTPException(status_code=413, detail="Result payload too large")
+    
+    if x_mep_idempotency_key:
+        existing = db.get_idempotency(authenticated_node, "/tasks/complete", x_mep_idempotency_key)
+        if existing:
+            return existing["response"]
+
     task = active_tasks.get(result.task_id)
     if not task:
-        raise HTTPException(status_code=404, detail="Task not found or already claimed")
+        db_task = db.get_task(result.task_id)
+        if not db_task or db_task["status"] not in ("bidding", "assigned"):
+            raise HTTPException(status_code=404, detail="Task not found or already claimed")
+        task = {
+            "id": db_task["task_id"],
+            "consumer_id": db_task["consumer_id"],
+            "payload": db_task["payload"],
+            "bounty": db_task["bounty"],
+            "status": db_task["status"],
+            "target_node": db_task["target_node"],
+            "model_requirement": db_task["model_requirement"],
+            "provider_id": db_task["provider_id"]
+        }
+        active_tasks[result.task_id] = task
 
     provider_balance = db.get_balance(result.provider_id)
     if provider_balance is None:
@@ -191,6 +295,7 @@ async def complete_task(result: TaskResult, authenticated_node: str = Depends(ve
     task["result"] = result.result_payload
     completed_tasks[result.task_id] = task
     del active_tasks[result.task_id]
+    db.update_task_result(result.task_id, result.provider_id, result.result_payload, "completed", time.time())
 
     # ROUTE RESULT BACK TO CONSUMER VIA WEBSOCKET
     consumer_id = task["consumer_id"]
@@ -205,13 +310,47 @@ async def complete_task(result: TaskResult, authenticated_node: str = Depends(ve
                     "bounty_spent": task["bounty"]
                 }
             })
-        except:
+        except Exception:
             pass # Consumer disconnected, they can fetch it via REST later (TODO)
 
-    return {"status": "success", "earned": task["bounty"], "new_balance": db.get_balance(result.provider_id)}
+    response_payload = {"status": "success", "earned": task["bounty"], "new_balance": db.get_balance(result.provider_id)}
+    if x_mep_idempotency_key:
+        db.set_idempotency(authenticated_node, "/tasks/complete", x_mep_idempotency_key, response_payload, 200, time.time())
+    return response_payload
+
+@app.get("/tasks/result/{task_id}")
+async def get_task_result(task_id: str, authenticated_node: str = Depends(verify_request)):
+    task = db.get_task(task_id)
+    if not task or task["status"] != "completed":
+        raise HTTPException(status_code=404, detail="Task not found or not completed")
+    if authenticated_node not in (task["consumer_id"], task["provider_id"]):
+        raise HTTPException(status_code=403, detail="Not authorized to view this result")
+    return {
+        "task_id": task["task_id"],
+        "consumer_id": task["consumer_id"],
+        "provider_id": task["provider_id"],
+        "bounty": task["bounty"],
+        "result_payload": task["result_payload"]
+    }
+
+@app.get("/health")
+async def health_check():
+    return {"status": "ok"}
 
 @app.websocket("/ws/{node_id}")
 async def websocket_endpoint(websocket: WebSocket, node_id: str, timestamp: str, signature: str):
+    client_host = websocket.client.host if websocket.client else None
+    if not _is_allowed_ip(client_host):
+        await websocket.close(code=4003, reason="Client IP not allowed")
+        return
+
+    try:
+        _apply_rate_limit(f"{node_id}:/ws")
+        _validate_timestamp(timestamp)
+    except HTTPException as exc:
+        await websocket.close(code=4004, reason=exc.detail)
+        return
+
     pub_pem = db.get_pub_pem(node_id)
     if not pub_pem:
         await websocket.close(code=4001, reason="Unknown Node ID")
@@ -225,7 +364,7 @@ async def websocket_endpoint(websocket: WebSocket, node_id: str, timestamp: str,
     connected_nodes[node_id] = websocket
     try:
         while True:
-            data = await websocket.receive_text()
+            await websocket.receive_text()
     except WebSocketDisconnect:
         if node_id in connected_nodes:
             del connected_nodes[node_id]

hub/models.py

@@ -1,6 +1,5 @@
 from pydantic import BaseModel, Field
-from typing import Optional, Dict
-from datetime import datetime
+from typing import Optional
 
 class NodeRegistration(BaseModel):
     pubkey: str = Field(..., description="Node's public key or UUID")

hub/requirements.txt

@@ -2,4 +2,5 @@ fastapi
 uvicorn
 pydantic
 websockets
-cryptography
+cryptography
+psycopg2-binary

node/client.py

@@ -3,27 +3,30 @@ import json
 import websockets
 import requests
 import uuid
-import sys
+import time
+import urllib.parse
 from reputation import ReputationManager
+from identity import MEPIdentity
 
 class ChronosNode:
     """
     Simulated Clawdbot Client (Both Consumer & Provider)
     """
-    def __init__(self, node_id: str, hub_url: str = "http://localhost:8000", ws_url: str = "ws://localhost:8000"):
-        self.node_id = node_id
+    def __init__(self, key_path: str, hub_url: str = "http://localhost:8000", ws_url: str = "ws://localhost:8000"):
+        self.identity = MEPIdentity(key_path)
+        self.node_id = self.identity.node_id
         self.hub_url = hub_url
         self.ws_url = ws_url
-        self.reputation = ReputationManager(storage_path=f"reputation_{node_id}.json")
+        self.reputation = ReputationManager(storage_path=f"reputation_{self.node_id}.json")
         self.is_sleeping = False
         
         # Track pending tasks we created (Consumer)
-        self.my_pending_tasks = {}
+        self.my_pending_tasks: dict[str, dict] = {}
 
     def register(self):
         """Register to get 10 SECONDS."""
         print(f"[Node {self.node_id}] Registering with Hub...")
-        resp = requests.post(f"{self.hub_url}/register", json={"pubkey": self.node_id, "alias": "test"})
+        resp = requests.post(f"{self.hub_url}/register", json={"pubkey": self.identity.pub_pem, "alias": "test"})
         data = resp.json()
         print(f"[Node {self.node_id}] Balance: {data['balance']}s")
 
@@ -35,8 +38,6 @@ class ChronosNode:
         task_id = task_data["id"]
         payload = task_data["payload"]
         bounty = task_data["bounty"]
-        consumer_id = task_data["consumer_id"]
-
         print(f"[Node {self.node_id}] Broadcast received: Task {task_id[:6]} for {bounty}s")
         
         # 1. Check L2 Reputation of Consumer (Don't work for bad nodes)
@@ -47,11 +48,14 @@ class ChronosNode:
         result = f"Hello from {self.node_id}. I processed your payload: {payload[:20]}..."
         
         # 3. Submit proof of work
-        resp = requests.post(f"{self.hub_url}/tasks/complete", json={
+        payload_str = json.dumps({
             "task_id": task_id,
             "provider_id": self.node_id,
             "result_payload": result
         })
+        headers = self.identity.get_auth_headers(payload_str)
+        headers["Content-Type"] = "application/json"
+        resp = requests.post(f"{self.hub_url}/tasks/complete", data=payload_str, headers=headers)
         if resp.status_code == 200:
             print(f"[Node {self.node_id}] Mined {bounty}s! New Balance: {resp.json()['new_balance']}s")
 
@@ -71,7 +75,10 @@ class ChronosNode:
 
     async def listen(self):
         """Persistent WebSocket connection."""
-        uri = f"{self.ws_url}/ws/{self.node_id}"
+        ts = str(int(time.time()))
+        sig = self.identity.sign(self.node_id, ts)
+        sig_safe = urllib.parse.quote(sig)
+        uri = f"{self.ws_url}/ws/{self.node_id}?timestamp={ts}&signature={sig_safe}"
         async with websockets.connect(uri) as ws:
             print(f"[Node {self.node_id}] Connected to Hub via WebSocket.")
             while True:
@@ -85,11 +92,14 @@ class ChronosNode:
 
     async def submit_task(self, payload: str, bounty: float):
         """As a Consumer, create a task and lock SECONDS."""
-        resp = requests.post(f"{self.hub_url}/tasks/submit", json={
+        payload_str = json.dumps({
             "consumer_id": self.node_id,
             "payload": payload,
             "bounty": bounty
         })
+        headers = self.identity.get_auth_headers(payload_str)
+        headers["Content-Type"] = "application/json"
+        resp = requests.post(f"{self.hub_url}/tasks/submit", data=payload_str, headers=headers)
         if resp.status_code == 200:
             task_id = resp.json()["task_id"]
             print(f"[Node {self.node_id} (Consumer)] Submitted Task {task_id[:6]} for {bounty}s")
@@ -98,11 +108,11 @@ class ChronosNode:
 
 async def run_demo():
     # Setup two nodes
-    usa_node = ChronosNode("usa_node")
+    usa_node = ChronosNode(f"usa_node_{uuid.uuid4().hex[:6]}.pem")
     usa_node.is_sleeping = False
     usa_node.register()
     
-    asia_node = ChronosNode("asia_node")
+    asia_node = ChronosNode(f"asia_node_{uuid.uuid4().hex[:6]}.pem")
     asia_node.is_sleeping = True # Asia goes to sleep and mines
     asia_node.register()
 

node/mep_cli_provider.py

@@ -9,22 +9,25 @@ import websockets
 import json
 import requests
 import uuid
-import sys
 import os
 import shlex
+import time
+import urllib.parse
+import tempfile
+from identity import MEPIdentity
 
 HUB_URL = "http://localhost:8000"
 WS_URL = "ws://localhost:8000"
 
 class MEPCLIProvider:
-    def __init__(self, node_id: str):
-        self.node_id = node_id
+    def __init__(self, key_path: str):
+        self.identity = MEPIdentity(key_path)
+        self.node_id = self.identity.node_id
         self.balance = 0.0
         self.is_contributing = True
         self.capabilities = ["cli-agent", "bash", "python"]
         
-        # Security: In production, run this inside a Docker container!
-        self.workspace_dir = "/tmp/mep_workspaces"
+        self.workspace_dir = os.path.join(tempfile.gettempdir(), "mep_workspaces")
         os.makedirs(self.workspace_dir, exist_ok=True)
         
     async def connect(self):
@@ -33,17 +36,20 @@ class MEPCLIProvider:
         
         # Register with hub
         try:
-            resp = # Registration happens automatically now via Identity module, json={"pubkey": self.node_id})
+            resp = requests.post(f"{HUB_URL}/register", json={"pubkey": self.identity.pub_pem})
             self.balance = resp.json().get("balance", 0.0)
             print(f"[CLI Provider] Registered. Balance: {self.balance:.6f} SECONDS")
         except Exception as e:
             print(f"[CLI Provider] Registration failed: {e}")
             return
             
-        uri = f"{WS_URL}/ws/{self.node_id}"
+        ts = str(int(time.time()))
+        sig = self.identity.sign(self.node_id, ts)
+        sig_safe = urllib.parse.quote(sig)
+        uri = f"{WS_URL}/ws/{self.node_id}?timestamp={ts}&signature={sig_safe}"
         try:
             async with websockets.connect(uri) as ws:
-                print(f"[CLI Provider] Connected to MEP Hub. Awaiting CLI tasks...")
+                print("[CLI Provider] Connected to MEP Hub. Awaiting CLI tasks...")
                 while self.is_contributing:
                     try:
                         msg = await asyncio.wait_for(ws.recv(), timeout=1.0)
@@ -75,10 +81,13 @@ class MEPCLIProvider:
         print(f"[CLI Provider] Received matching RFC {task_id[:8]} for {bounty:.6f} SECONDS. Bidding...")
         
         try:
-            resp = requests.post(f"{HUB_URL}/tasks/bid", json={
+            payload_str = json.dumps({
                 "task_id": task_id,
                 "provider_id": self.node_id
             })
+            headers = self.identity.get_auth_headers(payload_str)
+            headers["Content-Type"] = "application/json"
+            resp = requests.post(f"{HUB_URL}/tasks/bid", data=payload_str, headers=headers)
             
             if resp.status_code == 200:
                 data = resp.json()
@@ -136,11 +145,14 @@ class MEPCLIProvider:
         result_payload = f"```bash\n{output}\n```\n*Workspace: {task_dir}*"
         
         # Submit result back to Hub
-        requests.post(f"{HUB_URL}/tasks/complete", json={
+        payload_str = json.dumps({
             "task_id": task_id,
             "provider_id": self.node_id,
             "result_payload": result_payload
         })
+        headers = self.identity.get_auth_headers(payload_str)
+        headers["Content-Type"] = "application/json"
+        requests.post(f"{HUB_URL}/tasks/complete", data=payload_str, headers=headers)
         print(f"[CLI Provider] Result submitted! Earned {bounty:.6f} SECONDS.\n")
 
 if __name__ == "__main__":
@@ -149,8 +161,8 @@ if __name__ == "__main__":
     print("WARNING: This node executes shell commands. Use sandboxing!")
     print("=" * 60)
     
-    provider_id = f"cli-agent-{uuid.uuid4().hex[:6]}"
-    provider = MEPCLIProvider(provider_id)
+    key_path = f"cli_provider_{uuid.uuid4().hex[:6]}.pem"
+    provider = MEPCLIProvider(key_path)
     
     try:
         asyncio.run(provider.connect())

node/mep_provider.py

@@ -10,16 +10,20 @@ import requests
 import uuid
 import sys
 import os
+import time
+import urllib.parse
 
 # Add parent directory to path for imports
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from identity import MEPIdentity
 
 HUB_URL = "http://localhost:8000"
 WS_URL = "ws://localhost:8000"
 
 class MEPProvider:
-    def __init__(self, node_id: str):
-        self.node_id = node_id
+    def __init__(self, key_path: str):
+        self.identity = MEPIdentity(key_path)
+        self.node_id = self.identity.node_id
         self.balance = 0.0
         self.is_mining = True
         
@@ -29,7 +33,7 @@ class MEPProvider:
         
         # Register with hub
         try:
-            resp = # Registration happens automatically now via Identity module, json={"pubkey": self.node_id})
+            resp = requests.post(f"{HUB_URL}/register", json={"pubkey": self.identity.pub_pem})
             data = resp.json()
             self.balance = data.get("balance", 0.0)
             print(f"[MEP Provider {self.node_id}] Registered. Balance: {self.balance:.6f} SECONDS")
@@ -38,7 +42,10 @@ class MEPProvider:
             return
         
         # Connect to WebSocket
-        uri = f"{WS_URL}/ws/{self.node_id}"
+        ts = str(int(time.time()))
+        sig = self.identity.sign(self.node_id, ts)
+        sig_safe = urllib.parse.quote(sig)
+        uri = f"{WS_URL}/ws/{self.node_id}?timestamp={ts}&signature={sig_safe}"
         try:
             async with websockets.connect(uri) as ws:
                 print(f"[MEP Provider {self.node_id}] Connected to MEP Hub")
@@ -67,8 +74,6 @@ class MEPProvider:
         """Phase 2: Evaluate Request For Compute and submit Bid."""
         task_id = rfc_data["id"]
         bounty = rfc_data["bounty"]
-        model = rfc_data.get("model_requirement")
-        
         # SAFETY SWITCH: Prevent purchasing data unless explicitly allowed
         max_purchase_price = 0.0 # Set to e.g., -5.0 to buy premium data
         if bounty < max_purchase_price:
@@ -79,10 +84,13 @@ class MEPProvider:
         
         # Place bid
         try:
-            resp = requests.post(f"{HUB_URL}/tasks/bid", json={
+            payload_str = json.dumps({
                 "task_id": task_id,
                 "provider_id": self.node_id
             })
+            headers = self.identity.get_auth_headers(payload_str)
+            headers["Content-Type"] = "application/json"
+            resp = requests.post(f"{HUB_URL}/tasks/bid", data=payload_str, headers=headers)
             
             if resp.status_code == 200:
                 data = resp.json()
@@ -107,8 +115,6 @@ class MEPProvider:
         task_id = task_data["id"]
         payload = task_data["payload"]
         bounty = task_data["bounty"]
-        consumer_id = task_data["consumer_id"]
-        
         print(f"[MEP Provider {self.node_id}] Received task {task_id[:8]} for {bounty:.6f} SECONDS")
         print(f"  Payload: {payload[:50]}...")
         
@@ -131,11 +137,14 @@ Would you like me to elaborate on any specific aspect?"""
         
         # Submit result
         try:
-            resp = requests.post(f"{HUB_URL}/tasks/complete", json={
+            payload_str = json.dumps({
                 "task_id": task_id,
                 "provider_id": self.node_id,
                 "result_payload": result
             })
+            headers = self.identity.get_auth_headers(payload_str)
+            headers["Content-Type"] = "application/json"
+            resp = requests.post(f"{HUB_URL}/tasks/complete", data=payload_str, headers=headers)
             
             if resp.status_code == 200:
                 data = resp.json()
@@ -154,9 +163,8 @@ Would you like me to elaborate on any specific aspect?"""
         print(f"[MEP Provider {self.node_id}] Stopping...")
 
 async def main():
-    # Create a miner with unique ID
-    provider_id = f"mep-provider-{uuid.uuid4().hex[:8]}"
-    miner = MEPProvider(provider_id)
+    key_path = f"mep_provider_{uuid.uuid4().hex[:8]}.pem"
+    miner = MEPProvider(key_path)
     
     try:
         await miner.connect()

node/race_test.py

@@ -9,6 +9,8 @@ import json
 import requests
 import uuid
 import time
+import urllib.parse
+from identity import MEPIdentity
 
 HUB_URL = "http://localhost:8000"
 WS_URL = "ws://localhost:8000"
@@ -17,7 +19,8 @@ class RacingProvider:
     def __init__(self, name, location):
         self.name = name
         self.location = location
-        self.node_id = f"{name}-{uuid.uuid4().hex[:6]}"
+        self.identity = MEPIdentity(f"{name.replace(' ', '_')}_{uuid.uuid4().hex[:6]}.pem")
+        self.node_id = self.identity.node_id
         self.balance = 0
         self.won_race = False
         self.response_time = None
@@ -27,11 +30,14 @@ class RacingProvider:
         print(f"[{self.name} in {self.location}] Connecting to MEP Hub...")
         
         # Register
-        requests.post(f"{HUB_URL}/register", json={"pubkey": self.node_id})
+        requests.post(f"{HUB_URL}/register", json={"pubkey": self.identity.pub_pem})
         
         # Connect via WebSocket
         start_time = time.time()
-        async with websockets.connect(f"{WS_URL}/ws/{self.node_id}") as ws:
+        ts = str(int(time.time()))
+        sig = self.identity.sign(self.node_id, ts)
+        sig_safe = urllib.parse.quote(sig)
+        async with websockets.connect(f"{WS_URL}/ws/{self.node_id}?timestamp={ts}&signature={sig_safe}") as ws:
             print(f"[{self.name}] Connected. Waiting for task {task_id[:8]}...")
             
             try:
@@ -49,11 +55,14 @@ class RacingProvider:
                     
                     # Submit result
                     result = f"Processed by {self.name} from {self.location}. Task: {task_payload[:30]}..."
-                    resp = requests.post(f"{HUB_URL}/tasks/complete", json={
+                    payload_str = json.dumps({
                         "task_id": task_id,
                         "provider_id": self.node_id,
                         "result_payload": result
                     })
+                    headers = self.identity.get_auth_headers(payload_str)
+                    headers["Content-Type"] = "application/json"
+                    resp = requests.post(f"{HUB_URL}/tasks/complete", data=payload_str, headers=headers)
                     
                     if resp.status_code == 200:
                         self.won_race = True
@@ -73,8 +82,8 @@ async def run_race():
     print("=" * 60)
     
     # Register consumer
-    consumer_id = "race-test-consumer"
-    requests.post(f"{HUB_URL}/register", json={"pubkey": consumer_id})
+    consumer = MEPIdentity(f"race_consumer_{uuid.uuid4().hex[:6]}.pem")
+    requests.post(f"{HUB_URL}/register", json={"pubkey": consumer.pub_pem})
     
     # Create 4 providers in different "locations"
     providers = [
@@ -91,11 +100,14 @@ async def run_race():
     print(f"\n📤 Submitting task: {task_payload[:50]}...")
     print(f"   Bounty: {bounty} SECONDS")
     
-    resp = requests.post(f"{HUB_URL}/tasks/submit", json={
-        "consumer_id": consumer_id,
+    payload_str = json.dumps({
+        "consumer_id": consumer.node_id,
         "payload": task_payload,
         "bounty": bounty
     })
+    headers = consumer.get_auth_headers(payload_str)
+    headers["Content-Type"] = "application/json"
+    resp = requests.post(f"{HUB_URL}/tasks/submit", data=payload_str, headers=headers)
     
     task_data = resp.json()
     task_id = task_data["task_id"]
@@ -128,7 +140,7 @@ async def run_race():
         print("\n⚠️ No winner - task may have failed")
     
     # Check consumer balance
-    balance_resp = requests.get(f"{HUB_URL}/balance/{consumer_id}")
+    balance_resp = requests.get(f"{HUB_URL}/balance/{consumer.node_id}")
     consumer_balance = balance_resp.json()["balance_seconds"]
     print(f"\n💰 Consumer spent {bounty} SECONDS, new balance: {consumer_balance}")
     

node/race_test_fixed.py

@@ -8,6 +8,8 @@ import json
 import requests
 import uuid
 import time
+import urllib.parse
+from identity import MEPIdentity
 
 HUB_URL = "http://localhost:8000"
 WS_URL = "ws://localhost:8000"
@@ -16,7 +18,8 @@ class RacingProvider:
     def __init__(self, name, location):
         self.name = name
         self.location = location
-        self.node_id = f"{name}-{uuid.uuid4().hex[:6]}"
+        self.identity = MEPIdentity(f"{name.replace(' ', '_')}_{uuid.uuid4().hex[:6]}.pem")
+        self.node_id = self.identity.node_id
         self.balance = 0
         self.won_race = False
         self.response_time = None
@@ -24,8 +27,11 @@ class RacingProvider:
         
     async def connect(self):
         """Connect to hub and wait for tasks."""
-        requests.post(f"{HUB_URL}/register", json={"pubkey": self.node_id})
-        self.ws = await websockets.connect(f"{WS_URL}/ws/{self.node_id}")
+        requests.post(f"{HUB_URL}/register", json={"pubkey": self.identity.pub_pem})
+        ts = str(int(time.time()))
+        sig = self.identity.sign(self.node_id, ts)
+        sig_safe = urllib.parse.quote(sig)
+        self.ws = await websockets.connect(f"{WS_URL}/ws/{self.node_id}?timestamp={ts}&signature={sig_safe}")
         print(f"[{self.name}] Connected to hub")
         return self.ws
         
@@ -44,11 +50,14 @@ class RacingProvider:
                 await asyncio.sleep(0.05)  # Very fast!
                 
                 result = f"WON by {self.name} from {self.location}. Response time: {self.response_time:.3f}s"
-                resp = requests.post(f"{HUB_URL}/tasks/complete", json={
+                payload_str = json.dumps({
                     "task_id": task_id,
                     "provider_id": self.node_id,
                     "result_payload": result
                 })
+                headers = self.identity.get_auth_headers(payload_str)
+                headers["Content-Type"] = "application/json"
+                resp = requests.post(f"{HUB_URL}/tasks/complete", data=payload_str, headers=headers)
                 
                 if resp.status_code == 200:
                     self.won_race = True
@@ -87,8 +96,8 @@ async def run_race():
     await asyncio.sleep(0.5)  # Ensure all connected
     
     # Register consumer and submit task
-    consumer_id = "race-consumer-v2"
-    requests.post(f"{HUB_URL}/register", json={"pubkey": consumer_id})
+    consumer = MEPIdentity(f"race_consumer_{uuid.uuid4().hex[:6]}.pem")
+    requests.post(f"{HUB_URL}/register", json={"pubkey": consumer.pub_pem})
     
     task_payload = "Which provider is fastest in the MEP race?"
     bounty = 7.5
@@ -97,18 +106,21 @@ async def run_race():
     print(f"   Task: {task_payload}")
     print(f"   Bounty: {bounty} SECONDS")
     
-    resp = requests.post(f"{HUB_URL}/tasks/submit", json={
-        "consumer_id": consumer_id,
+    payload_str = json.dumps({
+        "consumer_id": consumer.node_id,
         "payload": task_payload,
         "bounty": bounty
     })
+    headers = consumer.get_auth_headers(payload_str)
+    headers["Content-Type"] = "application/json"
+    resp = requests.post(f"{HUB_URL}/tasks/submit", data=payload_str, headers=headers)
     
     task_id = resp.json()["task_id"]
     print(f"   Task ID: {task_id[:8]}...")
     
     # All providers listen simultaneously
     print("\n🏁 ALL PROVIDERS LISTENING... RACE STARTS!")
-    results = await asyncio.gather(*[provider.listen_for_task(task_id, bounty) for provider in providers])
+    await asyncio.gather(*[provider.listen_for_task(task_id, bounty) for provider in providers])
     
     # Close connections
     for provider in providers:
@@ -129,7 +141,7 @@ async def run_race():
         print(f"   New balance: {winner.balance} SECONDS")
         
         # Show all times
-        print(f"\n📊 All response times:")
+        print("\n📊 All response times:")
         for provider in providers:
             if provider.response_time:
                 status = "✅ WON" if provider.won_race else "❌ Lost"
@@ -138,7 +150,7 @@ async def run_race():
         print("❌ No winner - check hub logs")
     
     # Consumer balance
-    balance_resp = requests.get(f"{HUB_URL}/balance/{consumer_id}")
+    balance_resp = requests.get(f"{HUB_URL}/balance/{consumer.node_id}")
     consumer_balance = balance_resp.json()["balance_seconds"]
     print(f"\n💰 Consumer balance: {consumer_balance} SECONDS")
     

node/test_auction.py

@@ -3,16 +3,25 @@ import websockets
 import json
 import requests
 import uuid
+import time
+import urllib.parse
+from identity import MEPIdentity
 
 HUB_URL = "http://localhost:8000"
 
 async def test():
-    provider = f'mep-provider-{uuid.uuid4().hex[:6]}'
-    requests.post(f'{HUB_URL}/register', json={'pubkey': provider})
-    async with websockets.connect(f'ws://localhost:8000/ws/{provider}') as ws:
-        consumer = 'test-consumer'
-        requests.post(f'{HUB_URL}/register', json={'pubkey': consumer})
-        requests.post(f'{HUB_URL}/tasks/submit', json={'consumer_id': consumer, 'payload': 'Test payload', 'bounty': 1.0})
+    provider = MEPIdentity(f"test_provider_{uuid.uuid4().hex[:6]}.pem")
+    consumer = MEPIdentity(f"test_consumer_{uuid.uuid4().hex[:6]}.pem")
+    requests.post(f'{HUB_URL}/register', json={'pubkey': provider.pub_pem})
+    requests.post(f'{HUB_URL}/register', json={'pubkey': consumer.pub_pem})
+    ts = str(int(time.time()))
+    sig = provider.sign(provider.node_id, ts)
+    sig_safe = urllib.parse.quote(sig)
+    async with websockets.connect(f'ws://localhost:8000/ws/{provider.node_id}?timestamp={ts}&signature={sig_safe}') as ws:
+        submit_payload = json.dumps({'consumer_id': consumer.node_id, 'payload': 'Test payload', 'bounty': 1.0})
+        submit_headers = consumer.get_auth_headers(submit_payload)
+        submit_headers["Content-Type"] = "application/json"
+        requests.post(f'{HUB_URL}/tasks/submit', data=submit_payload, headers=submit_headers)
         
         msg = await asyncio.wait_for(ws.recv(), timeout=2.0)
         data = json.loads(msg)
@@ -20,14 +29,20 @@ async def test():
         
         if data['event'] == 'rfc':
             task_id = data['data']['id']
-            resp = requests.post(f'{HUB_URL}/tasks/bid', json={'task_id': task_id, 'provider_id': provider})
+            bid_payload = json.dumps({'task_id': task_id, 'provider_id': provider.node_id})
+            bid_headers = provider.get_auth_headers(bid_payload)
+            bid_headers["Content-Type"] = "application/json"
+            resp = requests.post(f'{HUB_URL}/tasks/bid', data=bid_payload, headers=bid_headers)
             print('Bid response:', resp.json())
             
-            complete_resp = requests.post(f'{HUB_URL}/tasks/complete', json={
-                'task_id': task_id, 
-                'provider_id': provider, 
+            complete_payload = json.dumps({
+                'task_id': task_id,
+                'provider_id': provider.node_id,
                 'result_payload': 'Done!'
             })
+            complete_headers = provider.get_auth_headers(complete_payload)
+            complete_headers["Content-Type"] = "application/json"
+            complete_resp = requests.post(f'{HUB_URL}/tasks/complete', data=complete_payload, headers=complete_headers)
             print('Complete response:', complete_resp.json())
 
 if __name__ == '__main__':

node/test_crypto.py

@@ -26,7 +26,7 @@ async def test():
     
     ws_url = f"ws://localhost:8000/ws/{bot.node_id}?timestamp={ts}&signature={sig_safe}"
     try:
-        async with websockets.connect(ws_url) as ws:
+        async with websockets.connect(ws_url):
             print("✅ WebSocket Authenticated!")
             
             # 4. Submit Task

node/test_dm.py

@@ -3,6 +3,9 @@ import websockets
 import json
 import requests
 import uuid
+import time
+import urllib.parse
+from identity import MEPIdentity
 
 HUB_URL = "http://localhost:8000"
 WS_URL = "ws://localhost:8000"
@@ -11,44 +14,57 @@ async def test_direct_message():
     print("=== Testing MEP Direct Messaging (Zero Bounty) ===")
     
     # 1. Start Alice (Provider)
-    alice_id = "alice-specialist-88"
-    # Registration happens automatically now via Identity module, json={"pubkey": alice_id})
+    alice = MEPIdentity(f"alice_{uuid.uuid4().hex[:6]}.pem")
     
     # 2. Start Bob (Consumer)
-    bob_id = "bob-general-12"
-    # Registration happens automatically now via Identity module, json={"pubkey": bob_id})
+    bob = MEPIdentity(f"bob_{uuid.uuid4().hex[:6]}.pem")
     
-    print(f"✅ Registered Alice ({alice_id}) and Bob ({bob_id})")
+    requests.post(f"{HUB_URL}/register", json={"pubkey": alice.pub_pem})
+    requests.post(f"{HUB_URL}/register", json={"pubkey": bob.pub_pem})
+    
+    print(f"✅ Registered Alice ({alice.node_id}) and Bob ({bob.node_id})")
     
     async def alice_listen():
-        async with websockets.connect(f"{WS_URL}/ws/{alice_id}") as ws:
+        ts = str(int(time.time()))
+        sig = alice.sign(alice.node_id, ts)
+        sig_safe = urllib.parse.quote(sig)
+        async with websockets.connect(f"{WS_URL}/ws/{alice.node_id}?timestamp={ts}&signature={sig_safe}") as ws:
             print("👧 Alice: Online and listening...")
             msg = await asyncio.wait_for(ws.recv(), timeout=5)
             data = json.loads(msg)
             
-            print(f"👧 Alice: Received DIRECT MESSAGE!")
+            print("👧 Alice: Received DIRECT MESSAGE!")
             print(f"👧 Alice: Payload: {data['data']['payload']}")
             print(f"👧 Alice: Bounty: {data['data']['bounty']} SECONDS")
             
             # Alice replies for free
-            requests.post(f"{HUB_URL}/tasks/complete", json={
+            payload_str = json.dumps({
                 "task_id": data['data']['id'],
-                "provider_id": alice_id,
+                "provider_id": alice.node_id,
                 "result_payload": "Yes Bob, I am available for a meeting tomorrow at 2 PM. Free of charge! 🐱"
             })
+            headers = alice.get_auth_headers(payload_str)
+            headers["Content-Type"] = "application/json"
+            requests.post(f"{HUB_URL}/tasks/complete", data=payload_str, headers=headers)
             print("👧 Alice: Sent reply!")
 
     async def bob_listen():
-        async with websockets.connect(f"{WS_URL}/ws/{bob_id}") as ws:
+        ts = str(int(time.time()))
+        sig = bob.sign(bob.node_id, ts)
+        sig_safe = urllib.parse.quote(sig)
+        async with websockets.connect(f"{WS_URL}/ws/{bob.node_id}?timestamp={ts}&signature={sig_safe}") as ws:
             # Bob submits a direct task to Alice with 0 bounty
             await asyncio.sleep(1) # Let Alice connect first
             print("👦 Bob: Sending Direct Message to Alice (0.0 SECONDS)...")
-            requests.post(f"{HUB_URL}/tasks/submit", json={
-                "consumer_id": bob_id,
+            payload_str = json.dumps({
+                "consumer_id": bob.node_id,
                 "payload": "Hey Alice, are you free for a meeting tomorrow at 2 PM?",
                 "bounty": 0.0,
-                "target_node": alice_id
+                "target_node": alice.node_id
             })
+            headers = bob.get_auth_headers(payload_str)
+            headers["Content-Type"] = "application/json"
+            requests.post(f"{HUB_URL}/tasks/submit", data=payload_str, headers=headers)
             
             # Bob waits for Alice's reply
             msg = await asyncio.wait_for(ws.recv(), timeout=5)
@@ -60,4 +76,4 @@ async def test_direct_message():
     print("=== Direct Messaging Test Complete! ===")
 
 if __name__ == "__main__":
-    asyncio.run(test_direct_message())
+    asyncio.run(test_direct_message())

node/test_three_markets.py

@@ -5,6 +5,8 @@ import websockets
 import time
 import urllib.parse
 from identity import MEPIdentity
+import uuid
+from typing import Optional
 
 HUB_URL = "http://localhost:8000"
 WS_URL = "ws://localhost:8000/ws"
@@ -15,7 +17,7 @@ def get_auth_url(identity: MEPIdentity):
     sig_safe = urllib.parse.quote(sig)
     return f"{WS_URL}/{identity.node_id}?timestamp={ts}&signature={sig_safe}"
 
-def submit_task(identity: MEPIdentity, payload: str, bounty: float, target: str = None):
+def submit_task(identity: MEPIdentity, payload: str, bounty: float, target: Optional[str] = None):
     data = {
         "consumer_id": identity.node_id,
         "payload": payload,
@@ -62,8 +64,8 @@ async def test_three_markets():
     print("Testing the 3 MEP Markets (+, 0, -)")
     print("=" * 60)
     
-    alice = MEPIdentity("alice.pem")
-    bob = MEPIdentity("bob.pem")
+    alice = MEPIdentity(f"alice_{uuid.uuid4().hex[:6]}.pem")
+    bob = MEPIdentity(f"bob_{uuid.uuid4().hex[:6]}.pem")
     
     requests.post(f"{HUB_URL}/register", json={"pubkey": alice.pub_pem})
     requests.post(f"{HUB_URL}/register", json={"pubkey": bob.pub_pem})
@@ -81,9 +83,9 @@ async def test_three_markets():
                 print(f"👦 Bob: Received Compute RFC {task_id[:8]} for +{data['data']['bounty']} SECONDS")
                 bid_res = place_bid(bob, task_id)
                 if bid_res["status"] == "accepted":
-                    print(f"👦 Bob: Won Compute Bid! Completing task...")
+                    print("👦 Bob: Won Compute Bid! Completing task...")
                     complete_task(bob, task_id, "Here is the code you requested.")
-                    print(f"👦 Bob: Compute task done.\n")
+                    print("👦 Bob: Compute task done.\n")
 
             # 2. Wait for Cyberspace Direct Message (0.0)
             msg = await ws.recv()
@@ -93,7 +95,7 @@ async def test_three_markets():
                 print(f"👦 Bob: Received Cyberspace DM {task_id[:8]} from Alice (0.0 SECONDS)")
                 print(f"👦 Bob: Message = '{data['data']['payload']}'")
                 complete_task(bob, task_id, "Yes Alice, I am free.")
-                print(f"👦 Bob: Sent free reply.\n")
+                print("👦 Bob: Sent free reply.\n")
 
             # 3. Wait for Data Market RFC (-2.0)
             msg = await ws.recv()
@@ -106,14 +108,14 @@ async def test_three_markets():
                 # Bob's local configuration allows him to spend up to 5.0 SECONDS
                 max_purchase_price = -5.0
                 if cost >= max_purchase_price:
-                    print(f"👦 Bob: Budget allows it! Bidding on premium data...")
+                    print("👦 Bob: Budget allows it! Bidding on premium data...")
                     bid_res = place_bid(bob, task_id)
                     if bid_res["status"] == "accepted":
                         print(f"👦 Bob: Paid {abs(cost)} SECONDS to download premium data: '{bid_res['payload']}'")
                         complete_task(bob, task_id, "Data received successfully.")
-                        print(f"👦 Bob: Premium data acquisition complete.\n")
+                        print("👦 Bob: Premium data acquisition complete.\n")
                 else:
-                    print(f"👦 Bob: Too expensive. Ignored.")
+                    print("👦 Bob: Too expensive. Ignored.")
                     
             await asyncio.sleep(0.5)
 
@@ -123,19 +125,19 @@ async def test_three_markets():
         
         async with websockets.connect(get_auth_url(alice)) as ws:
             # Market 1: Compute Market (+5.0)
-            print(f"👩 Alice: Submitting Compute Task (+5.0 SECONDS)...")
+            print("👩 Alice: Submitting Compute Task (+5.0 SECONDS)...")
             submit_task(alice, "Write me a python script", 5.0)
-            await asyncio.wait_for(ws.recv(), timeout=2.0) # wait for result
+            await asyncio.wait_for(ws.recv(), timeout=6.0)
             
             # Market 2: Cyberspace Market (0.0)
-            print(f"👩 Alice: Sending Cyberspace DM to Bob (0.0 SECONDS)...")
+            print("👩 Alice: Sending Cyberspace DM to Bob (0.0 SECONDS)...")
             submit_task(alice, "Are you free to chat?", 0.0, target=bob.node_id)
-            await asyncio.wait_for(ws.recv(), timeout=2.0) # wait for result
+            await asyncio.wait_for(ws.recv(), timeout=6.0)
             
             # Market 3: Data Market (-2.0)
-            print(f"👩 Alice: Broadcasting Premium Dataset (-2.0 SECONDS)...")
+            print("👩 Alice: Broadcasting Premium Dataset (-2.0 SECONDS)...")
             submit_task(alice, "SECRET_TRADING_ALGO_V9", -2.0)
-            await asyncio.wait_for(ws.recv(), timeout=2.0) # wait for result
+            await asyncio.wait_for(ws.recv(), timeout=6.0)
             
             await asyncio.sleep(0.5)
 

pyproject.toml

@@ -0,0 +1,19 @@
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+extend-exclude = ["**/__pycache__/*", "**/logs/*", "**/hub_data/*"]
+
+[tool.ruff.lint]
+select = ["E", "F"]
+ignore = ["E501"]
+
+[tool.mypy]
+python_version = "3.10"
+ignore_missing_imports = true
+warn_unused_ignores = true
+warn_redundant_casts = true
+warn_unused_configs = true
+show_error_codes = true
+explicit_package_bases = true
+disable_error_code = ["import-untyped"]
+files = ["hub", "node", "core", "skills", "tests"]

skills/sleeping_api.py

@@ -1,5 +1,3 @@
-import os
-import json
 from typing import Dict, Any
 
 class SleepingAPI: