Update app.py

app.py

@@ -1,23 +1,23 @@
 import gradio as gr
 import requests
 import time
-import hashlib
 import json
+import hashlib
 import random
+from typing import Dict, Any, List
 
 # ======================================================
-# GLOBAL MEMORY
+# GLOBAL LEDGER (in-memory for HF; can persist later)
 # ======================================================
 
-CHAT_MEMORY = []
-LAST_STATE = {}
+LEDGER: List[Dict[str, Any]] = []
+CHAT_MEMORY: List[str] = []
 
 # ======================================================
-# PUBLIC MACRO DATA (WORLD BANK)
+# PUBLIC MACRO DATA (World Bank)
 # ======================================================
 
 WORLD_BANK_BASE = "https://api.worldbank.org/v2"
-
 INDICATORS = {
     "GDP": "NY.GDP.MKTP.CD",
     "INFLATION": "FP.CPI.TOTL.ZG",
@@ -38,160 +38,238 @@ def fetch_indicator(indicator, country="WLD", year="2022"):
 def fetch_macro_anchor(country="WLD"):
     return {
         "country": country,
-        "global_gdp": fetch_indicator(INDICATORS["GDP"], country),
+        "gdp": fetch_indicator(INDICATORS["GDP"], country),
         "inflation": fetch_indicator(INDICATORS["INFLATION"], country),
         "population": fetch_indicator(INDICATORS["POPULATION"], country),
-        "timestamp": time.time(),
     }
 
 # ======================================================
-# ECONOMIC ENGINE
+# BIT + METADATA LAYER
 # ======================================================
 
-def economic_kernel(commodity, anchor, macro):
-    gdp_scale = macro["global_gdp"] / 1e14 if macro["global_gdp"] else 1.0
+def canonical_bytes(obj: Any) -> bytes:
+    return json.dumps(obj, sort_keys=True, separators=(",", ":")).encode()
+
+def bit_stats(payload: Dict[str, Any]) -> Dict[str, Any]:
+    b = canonical_bytes(payload)
+    return {
+        "bytes": len(b),
+        "bits": len(b) * 8,
+        "symbol_diversity": len(set(b)),
+        "entropy_proxy": round(len(set(b)) / max(len(b), 1), 6)
+    }
+
+def hash_payload(payload: Dict[str, Any], prev_hash: str) -> str:
+    b = canonical_bytes({"payload": payload, "prev_hash": prev_hash})
+    return hashlib.sha256(b).hexdigest()
+
+def reliability_score(source: str, latency_s: float) -> float:
+    # simple, explainable scoring model (can be replaced with learned model)
+    base = 0.85 if source == "world_bank" else 0.65
+    penalty = min(0.25, latency_s / 20.0)
+    return round(max(0.1, base - penalty), 3)
+
+# ======================================================
+# SIGNAL GENERATORS (global “bit rails”)
+# ======================================================
+
+def commodity_signal(commodity: str, anchor: float, macro: Dict[str, Any]) -> Dict[str, Any]:
+    gdp_scale = (macro["gdp"] / 1e14) if macro.get("gdp") else 1.0
     supply = anchor * gdp_scale
     demand = supply * 0.95
-    price_index = round((supply / 10) * gdp_scale, 2)
-
+    price_index = round((supply / 10.0) * gdp_scale, 4)
     return {
+        "type": "commodity",
         "commodity": commodity,
-        "supply": round(supply, 2),
-        "demand": round(demand, 2),
+        "supply": round(supply, 4),
+        "demand": round(demand, 4),
         "price_index": price_index,
-        "currency_flow": round(demand * price_index, 2),
+        "currency_flow": round(demand * price_index, 4),
     }
 
-def logistics_engine(econ):
-    friction = abs(econ["supply"] - econ["demand"]) / max(econ["supply"], 1)
+def logistics_signal(econ: Dict[str, Any]) -> Dict[str, Any]:
+    friction = abs(econ["supply"] - econ["demand"]) / max(econ["supply"], 1e-9)
     return {
-        "throughput": round(econ["supply"] * (1 - friction), 2),
-        "friction": round(friction, 4),
+        "type": "logistics",
+        "throughput": round(econ["supply"] * (1 - friction), 4),
+        "friction": round(friction, 6),
     }
 
-def energy_engine(econ):
+def energy_signal(econ: Dict[str, Any]) -> Dict[str, Any]:
     return {
-        "energy_cost_index": round(econ["price_index"] * 0.4, 2),
-        "energy_dependency": (
-            "high" if econ["commodity"].lower() in ["oil", "gas"] else "moderate"
-        ),
+        "type": "energy",
+        "energy_cost_index": round(econ["price_index"] * 0.4, 4),
+        "dependency": "high" if econ["commodity"].lower() in ["oil", "gas"] else "moderate",
     }
 
-def sentiment_engine(commodity):
-    random.seed(sum(ord(c) for c in commodity))
+def sentiment_signal(seed_key: str) -> Dict[str, Any]:
+    random.seed(sum(ord(c) for c in seed_key))
     confidence = random.uniform(0.6, 0.9)
     return {
-        "market_confidence": round(confidence, 3),
+        "type": "sentiment",
+        "market_confidence": round(confidence, 6),
         "risk_bias": "neutral" if confidence > 0.7 else "risk_off",
     }
 
-def analytics_engine(econ, logistics, sentiment, lag):
+def derived_features(econ, logi, energy, sent, lag_days: int) -> Dict[str, Any]:
     projected_price = econ["price_index"] * (
-        1 + (1 - sentiment["market_confidence"]) * 0.08 - logistics["friction"] * 0.1
+        1 + (1 - sent["market_confidence"]) * 0.08 - logi["friction"] * 0.1
     )
     return {
-        "projected_price": round(projected_price, 2),
-        "lag_days": lag,
+        "type": "features",
+        "lag_days": lag_days,
+        "projected_price": round(projected_price, 6),
+        "volatility_proxy": round(0.015 * lag_days, 6),
     }
 
 # ======================================================
-# Ω-PROOF
+# LEDGER APPEND (global bit+metadata record)
 # ======================================================
 
-def omega_proof(state):
-    return hashlib.sha256(json.dumps(state, sort_keys=True).encode()).hexdigest()
+def append_record(payload: Dict[str, Any], meta: Dict[str, Any]) -> Dict[str, Any]:
+    prev = LEDGER[-1]["hash"] if LEDGER else "GENESIS"
+    h = hash_payload(payload, prev)
+    record = {
+        "hash": h,
+        "prev_hash": prev,
+        "payload": payload,
+        "metadata": meta,
+        "bit_stats": bit_stats(payload),
+        "ts": time.time(),
+    }
+    LEDGER.append(record)
+    return record
 
-# ======================================================
-# MASTER RUN
-# ======================================================
+def run_tick(commodity: str, anchor: float, country: str, lag_days: int, use_live: bool):
+    t0 = time.time()
 
-def run_codexflow(commodity, anchor, lag, country, live):
-    macro = fetch_macro_anchor(country) if live else {
-        "country": country,
-        "global_gdp": None,
-        "inflation": None,
-        "population": None,
-        "timestamp": time.time(),
-    }
+    macro = fetch_macro_anchor(country) if use_live else {"country": country, "gdp": None, "inflation": None, "population": None}
+    latency = time.time() - t0
 
-    econ = economic_kernel(commodity, anchor, macro)
-    logistics = logistics_engine(econ)
-    energy = energy_engine(econ)
-    sentiment = sentiment_engine(commodity)
-    projection = analytics_engine(econ, logistics, sentiment, lag)
-
-    state = {
-        "macro": macro,
-        "economy": econ,
-        "logistics": logistics,
-        "energy": energy,
-        "sentiment": sentiment,
-        "projection": projection,
+    # 1) macro record
+    meta_macro = {
+        "source": "world_bank" if use_live else "synthetic",
+        "country": country,
+        "latency_s": round(latency, 4),
+        "reliability": reliability_score("world_bank" if use_live else "synthetic", latency),
+        "schema": "macro.v1",
     }
+    append_record({"type": "macro", **macro}, meta_macro)
+
+    # 2) derived signals
+    econ = commodity_signal(commodity, anchor, macro)
+    logi = logistics_signal(econ)
+    ener = energy_signal(econ)
+    sent = sentiment_signal(commodity + country)
+    feat = derived_features(econ, logi, ener, sent, lag_days)
+
+    for payload, schema in [
+        (econ, "commodity.v1"),
+        (logi, "logistics.v1"),
+        (ener, "energy.v1"),
+        (sent, "sentiment.v1"),
+        (feat, "features.v1"),
+    ]:
+        meta = {
+            "source": "derived",
+            "country": country,
+            "latency_s": 0.0,
+            "reliability": 0.9,
+            "schema": schema,
+        }
+        append_record(payload, meta)
 
-    proof = omega_proof(state)
-
-    global LAST_STATE
-    LAST_STATE = state
+    return {
+        "status": "tick_ok",
+        "ledger_len": len(LEDGER),
+        "tip_hash": LEDGER[-1]["hash"],
+        "latest_macro": macro,
+        "latest_features": feat,
+    }, LEDGER[-1]["hash"]
 
-    return state, proof
+def query_ledger(n: int):
+    n = max(1, min(int(n), 200))
+    return LEDGER[-n:]
 
 # ======================================================
-# JARVIS X CHAT
+# CHAT INTERFACE (queries the ledger)
 # ======================================================
 
-def jarvis_x_chat(message, history):
-    CHAT_MEMORY.append(message)
+def jarvis_chat(msg, history):
+    CHAT_MEMORY.append(msg)
+    m = msg.lower().strip()
+
+    if "latest" in m or "tip" in m:
+        if not LEDGER:
+            return "Ledger is empty. Run a tick first."
+        r = LEDGER[-1]
+        return json.dumps({"tip_hash": r["hash"], "payload": r["payload"], "metadata": r["metadata"]}, indent=2)
+
+    if "ledger" in m or "records" in m:
+        return f"Ledger records: {len(LEDGER)}. Ask 'latest' or 'show last 10'."
+
+    if "show last" in m:
+        try:
+            k = int(m.split("show last")[-1].strip())
+        except Exception:
+            k = 10
+        data = query_ledger(k)
+        return json.dumps(data, indent=2)
+
+    if "proof" in m or "hash" in m:
+        if not LEDGER:
+            return "No proof yet. Run a tick to generate chained hashes."
+        return f"Tip hash: {LEDGER[-1]['hash']} (prev: {LEDGER[-1]['prev_hash']})"
 
-    m = message.lower()
-    if "state" in m:
-        return json.dumps(LAST_STATE, indent=2) if LAST_STATE else "No state yet."
-    if "proof" in m:
-        return "Ω-Proof secures the current economic state deterministically."
     if "what is this" in m:
-        return "CodexFlow ΩΞ is an executable economic world simulation engine."
-    if "memory" in m:
-        return f"I retain {len(CHAT_MEMORY)} interaction steps."
+        return (
+            "This is GVBDMS v1: a Global Virtual Bit + Metadata Ledger. "
+            "It ingests public anchors, derives signals, stores payload+metadata, "
+            "and chains records with hashes for tamper-evident provenance."
+        )
 
-    return "Jarvis X acknowledged. Ask about system state, projections, or design."
+    return "Ask: 'latest', 'proof', 'show last 10', or run a tick to ingest data."
 
 # ======================================================
 # GRADIO UI (HF SAFE)
 # ======================================================
 
 with gr.Blocks() as app:
-    gr.Markdown("# 🌍 CodexFlow ΩΞ")
-    gr.Markdown("**Economic World Engine + Jarvis X Interface**")
+    gr.Markdown("# 🌐 CodexFlow — Global Virtual Bit + Metadata System (GVBDMS v1)")
+    gr.Markdown("A byte-verifiable, provenance-tracked ledger for global economic signals.")
 
     with gr.Row():
         with gr.Column(scale=2):
-            commodity = gr.Dropdown(
-                ["Gold", "Oil", "Gas", "Wheat", "Copper"],
-                value="Gold",
-                label="Commodity"
-            )
+            commodity = gr.Dropdown(["Gold","Oil","Gas","Wheat","Copper"], value="Gold", label="Commodity")
             anchor = gr.Number(value=950, label="Physical Anchor")
+            country = gr.Textbox(value="WLD", label="Country Code (WLD/USA/CHN/ZAF...)")
             lag = gr.Slider(1, 365, value=7, step=1, label="Reporting Lag (days)")
-            country = gr.Textbox(value="WLD", label="Country Code")
-            live = gr.Checkbox(value=True, label="Use Live Public Data")
+            live = gr.Checkbox(value=True, label="Use Live World Bank Anchors")
 
-            run = gr.Button("Execute CodexFlow")
+            run_btn = gr.Button("Run Tick (Ingest + Derive + Ledger Append)")
 
-            state_out = gr.JSON(label="Economic State")
-            proof_out = gr.Textbox(label="Ω-Proof")
+            tick_out = gr.JSON(label="Tick Result")
+            tip_hash = gr.Textbox(label="Tip Hash")
 
-            run.click(
-                run_codexflow,
-                inputs=[commodity, anchor, lag, country, live],
-                outputs=[state_out, proof_out],
+            run_btn.click(
+                fn=run_tick,
+                inputs=[commodity, anchor, country, lag, live],
+                outputs=[tick_out, tip_hash],
             )
 
+            n = gr.Slider(1, 200, value=20, step=1, label="Query last N records")
+            q_btn = gr.Button("Query Ledger")
+            ledger_out = gr.JSON(label="Ledger Records (last N)")
+
+            q_btn.click(fn=query_ledger, inputs=[n], outputs=[ledger_out])
+
         with gr.Column(scale=1):
-            gr.Markdown("## 🧠 Jarvis X")
-            gr.ChatInterface(fn=jarvis_x_chat, height=420)
+            gr.Markdown("## 🧠 Jarvis X — Ledger Interface")
+            gr.ChatInterface(fn=jarvis_chat, height=420)
 
     gr.Markdown(
-        "_Simulation only. No trading, enforcement, or private systems._"
+        "_GVBDMS stores public/derived signals with metadata & hash chaining. "
+        "It is not a trading system, bank interface, or contract enforcer._"
     )
 
 app.launch()