Add Jared read-only token OHLCV ingestion and manual contract lookup

core/data.py

@@ -81,6 +81,127 @@ def fetch_ompfinex_data(ticker, start_date, end_date, interval):
         print_log(f"OMPFINEX fetch failed for {ticker}: {str(e)}", 'ERROR')
         return pd.DataFrame()
 
+JARED_TRPC_BASE = os.getenv("JARED_TRPC_BASE", "https://jaredfromsubway.manus.space/api/trpc")
+GECKO_BASE = os.getenv("GECKO_TERMINAL_BASE", "https://api.geckoterminal.com/api/v2")
+
+
+def _trpc_get(procedure, payload=None, timeout=20):
+    """Read-only request to the public Jared evidence console tRPC API."""
+    query = {"json": payload}
+    response = requests.get(
+        f"{JARED_TRPC_BASE.rstrip('/')}/{procedure}",
+        params={"input": json.dumps(query, separators=(",", ":"))},
+        headers={"accept": "application/json"},
+        timeout=timeout,
+    )
+    response.raise_for_status()
+    body = response.json()
+    return body.get("result", {}).get("data", {}).get("json")
+
+
+def fetch_jared_observed_tokens(limit=100):
+    """Return source-labeled, read-only wallet observations from Jared's public console."""
+    try:
+        result = _trpc_get("ml.getObservedTokenTable", {"limit": int(limit)})
+        return result if isinstance(result, list) else []
+    except Exception as exc:
+        print_log(f"Jared observed-token feed unavailable: {exc}", "WARNING")
+        return []
+
+
+def resolve_jared_token(token_query=None):
+    """Resolve a symbol/name/address against the public observed-token table.
+
+    If no query is provided, choose the first observation with a verified OHLCV price.
+    The returned metadata is retained by callers for provenance display.
+    """
+    observations = fetch_jared_observed_tokens()
+    query = (token_query or "").strip().lower()
+    candidates = observations
+    if query:
+        candidates = [
+            row for row in observations
+            if query in str(row.get("tokenAddress", "")).lower()
+            or query == str(row.get("symbol", "")).lower()
+            or query == str(row.get("name", "")).lower()
+        ]
+    for row in candidates:
+        address = str(row.get("tokenAddress", "")).strip()
+        if address.startswith("0x") and len(address) == 42 and (
+            row.get("pricePathStatus") == "verified_ohlcv" or row.get("priceUsd") is not None
+        ):
+            return row
+    return None
+
+
+def _gecko_interval(interval):
+    if interval in {"1m", "2m", "5m", "15m", "30m", "60m", "90m", "1h"}:
+        return "hour", 1
+    if interval in {"1wk"}:
+        return "day", 7
+    return "day", 1
+
+
+def fetch_token_ohlcv(address, start_date, end_date, interval="1d", network="eth"):
+    """Fetch public DEX OHLCV candles for an ERC-20 address via GeckoTerminal."""
+    if not (isinstance(address, str) and address.lower().startswith("0x") and len(address) == 42):
+        raise ValueError("A valid EVM token contract address is required")
+    headers = {"accept": "application/json"}
+    pools_url = f"{GECKO_BASE}/networks/{network}/tokens/{address}/pools"
+    pools_resp = requests.get(pools_url, params={"page": 1}, headers=headers, timeout=25)
+    pools_resp.raise_for_status()
+    pools = pools_resp.json().get("data", [])
+    if not pools:
+        raise ValueError(f"No public DEX pool found for {address}")
+    # Prefer the pool with the greatest 24h USD volume; otherwise use the first pool.
+    def volume(pool):
+        try:
+            return float((pool.get("attributes") or {}).get("volume_usd", {}).get("h24") or 0)
+        except Exception:
+            return 0.0
+    pool = max(pools, key=volume)
+    attrs = pool.get("attributes") or {}
+    pool_address = attrs.get("address") or str(pool.get("id", "")).split("_", 1)[-1]
+    timeframe, aggregate = _gecko_interval(interval)
+    ohlcv_url = f"{GECKO_BASE}/networks/{network}/pools/{pool_address}/ohlcv/{timeframe}"
+    ohlcv_resp = requests.get(
+        ohlcv_url,
+        params={"aggregate": aggregate, "limit": 1000},
+        headers=headers,
+        timeout=25,
+    )
+    ohlcv_resp.raise_for_status()
+    values = (((ohlcv_resp.json().get("data") or {}).get("attributes") or {}).get("ohlcv_list") or [])
+    if not values:
+        raise ValueError(f"No OHLCV history returned for {address}")
+    rows = []
+    for candle in values:
+        if len(candle) < 6:
+            continue
+        rows.append({"Date": pd.to_datetime(candle[0], unit="s"), "Open": candle[1], "High": candle[2], "Low": candle[3], "value": candle[4], "Volume": candle[5]})
+    df = pd.DataFrame(rows).dropna(subset=["Date", "value"])
+    if df.empty:
+        raise ValueError(f"OHLCV history contained no usable rows for {address}")
+    df = df.set_index("Date").sort_index()
+    start_ts, end_ts = pd.to_datetime(start_date), pd.to_datetime(end_date)
+    filtered = df[(df.index >= start_ts) & (df.index <= end_ts)]
+    # New meme tokens may have only a short history; never fabricate older candles.
+    return filtered if not filtered.empty else df
+
+
+def fetch_jared_token_data(token_query, start_date, end_date, interval="1d"):
+    """Resolve a Jared-observed token and load its public DEX OHLCV history."""
+    row = resolve_jared_token(token_query)
+    if not row:
+        raise ValueError("No Jared observation with verified public OHLCV was found; enter a contract address or symbol.")
+    df = fetch_token_ohlcv(row["tokenAddress"], start_date, end_date, interval)
+    df.attrs["source"] = "Jared public observed-token table + GeckoTerminal public DEX OHLCV"
+    df.attrs["token_address"] = row.get("tokenAddress")
+    df.attrs["token_symbol"] = row.get("symbol") or row.get("name") or token_query
+    df.attrs["jared_observation"] = row
+    return df
+
+
 def load_data(data_src='yahoo', ticker='AAPL', start='2020-01-01', end='2023-01-01', interval='1d', file_upload=None, alpha_api_key=None):
     try:
         print_log(f"Loading data: source={data_src}, ticker={ticker}, start={start}, end={end}, interval={interval}, file_upload={'set' if file_upload else 'unset'}, alpha_api_key={'set' if alpha_api_key else 'unset'}")
@@ -115,6 +236,17 @@ def load_data(data_src='yahoo', ticker='AAPL', start='2020-01-01', end='2023-01-
             except Exception as e:
                 print_log(f"Failed to load CSV {file_path}: {str(e)}", 'ERROR')
                 raise ValueError(f"Failed to load CSV: {str(e)}")
+        elif data_src == 'jared' or ticker == 'JARED-LATEST' or (isinstance(ticker, str) and ticker.lower().startswith('0x')):
+            print_log(f"Fetching Jared-observed token OHLCV for {ticker}")
+            if isinstance(ticker, str) and ticker.lower().startswith('0x'):
+                df = fetch_token_ohlcv(ticker, start_date, end_date, interval)
+                df.attrs['source'] = 'Manual EVM contract address + GeckoTerminal public DEX OHLCV'
+                df.attrs['token_address'] = ticker
+                df.attrs['token_symbol'] = ticker
+            else:
+                df = fetch_jared_token_data(None if ticker == 'JARED-LATEST' else ticker, start_date, end_date, interval)
+            if df.empty:
+                raise ValueError(f"No public OHLCV history found for {ticker}")
         elif ticker in ["USDT-IRT", "BTC-IRT", "ETH-IRT"]:
             print_log(f"Fetching {ticker} from OMPFINEX")
             df = fetch_ompfinex_data(ticker, start_date, end_date, interval)