probable-trader 1.0.0

package/scripts/lib/client_wrapper.py

@@ -0,0 +1,241 @@
+"""ProbableClient: wraps opinion_clob_sdk.Client with normalization, audit logging, and safety."""
+
+import json
+import traceback
+from dataclasses import asdict
+from typing import Any, Optional
+
+from .config import ProbableConfig, create_client, load_config
+from .db import ProbableDB
+from .safety import ActionResult
+
+
+def _normalize(obj: Any) -> Any:
+    """Convert SDK response objects to plain dicts/lists."""
+    if obj is None:
+        return None
+    if isinstance(obj, (str, int, float, bool)):
+        return obj
+    if isinstance(obj, (bytes, bytearray)):
+        return "0x" + obj.hex()
+    if isinstance(obj, dict):
+        return {k: _normalize(v) for k, v in obj.items()}
+    if isinstance(obj, (list, tuple)):
+        return [_normalize(v) for v in obj]
+    # Handle dataclasses
+    if hasattr(obj, "__dataclass_fields__"):
+        return {k: _normalize(v) for k, v in asdict(obj).items()}
+    # Handle OpenAPI generated models (have to_dict or attribute_map)
+    if hasattr(obj, "to_dict"):
+        return _normalize(obj.to_dict())
+    if hasattr(obj, "__dict__"):
+        return {k: _normalize(v) for k, v in obj.__dict__.items() if not k.startswith("_")}
+    return str(obj)
+
+
+class ProbableClient:
+    """High-level wrapper around opinion_clob_sdk.Client."""
+
+    def __init__(self, cfg: Optional[ProbableConfig] = None, db: Optional[ProbableDB] = None):
+        self.cfg = cfg or load_config()
+        self.db = db
+        self._sdk = None
+
+    @property
+    def sdk(self):
+        if self._sdk is None:
+            self._sdk = create_client(self.cfg)
+        return self._sdk
+
+    def _log(self, action: str, request: Any, response: Any, success: bool):
+        if self.db:
+            self.db.log_action(action, request, response, success)
+
+    def _call(self, action: str, request_data: Any, fn, *args, **kwargs) -> ActionResult:
+        """Execute an SDK call with error handling and audit logging."""
+        try:
+            raw = fn(*args, **kwargs)
+            data = _normalize(raw)
+            self._log(action, request_data, data, True)
+            return ActionResult(success=True, action=action, data=data)
+        except Exception as e:
+            err = f"{type(e).__name__}: {e}"
+            self._log(action, request_data, {"error": err}, False)
+            return ActionResult(success=False, action=action, error=err)
+
+    # --- Health / Info ---
+
+    def doctor(self) -> ActionResult:
+        """Health check: verify API connectivity and config."""
+        checks = {}
+        # Config check
+        missing = self.cfg.validate()
+        checks["config"] = {"ok": len(missing) == 0, "missing": missing}
+        checks["host"] = self.cfg.host
+        checks["chain_id"] = self.cfg.chain_id
+        checks["authenticated"] = self.cfg.is_authenticated()
+
+        # API connectivity
+        try:
+            qt = self.sdk.get_quote_tokens(use_cache=False)
+            checks["api_reachable"] = True
+            checks["quote_tokens"] = _normalize(qt)
+        except Exception as e:
+            checks["api_reachable"] = False
+            checks["api_error"] = str(e)
+
+        ok = checks.get("api_reachable", False)
+        self._log("doctor", None, checks, ok)
+        return ActionResult(success=ok, action="doctor", data=checks)
+
+    # --- Market Data (Read-Only) ---
+
+    def get_markets(self, topic_type=None, page: int = 1, limit: int = 20,
+                    status=None, sort_by=None) -> ActionResult:
+        from opinion_clob_sdk.sdk import TopicType, TopicStatusFilter, TopicSortType
+
+        tt = TopicType.ALL
+        if topic_type == "binary":
+            tt = TopicType.BINARY
+        elif topic_type == "categorical":
+            tt = TopicType.CATEGORICAL
+
+        sf = None
+        if status == "activated":
+            sf = TopicStatusFilter.ACTIVATED
+        elif status == "resolved":
+            sf = TopicStatusFilter.RESOLVED
+
+        sb = None
+        if sort_by:
+            sort_map = {
+                "time": TopicSortType.BY_TIME_DESC,
+                "volume": TopicSortType.BY_VOLUME_DESC,
+                "volume_24h": TopicSortType.BY_VOLUME_24H_DESC,
+                "volume_7d": TopicSortType.BY_VOLUME_7D_DESC,
+                "cutoff": TopicSortType.BY_CUTOFF_TIME_ASC,
+            }
+            sb = sort_map.get(sort_by)
+
+        req = {"topic_type": topic_type, "page": page, "limit": limit, "status": status, "sort_by": sort_by}
+        return self._call("get_markets", req, self.sdk.get_markets, tt, page, limit, sf, sb)
+
+    def get_market(self, market_id: int) -> ActionResult:
+        # Check cache first
+        if self.db:
+            cached = self.db.get_cached_market(market_id)
+            if cached:
+                self._log("get_market", {"market_id": market_id}, cached, True)
+                return ActionResult(success=True, action="get_market", data=cached)
+
+        result = self._call("get_market", {"market_id": market_id}, self.sdk.get_market, market_id)
+        if result.success and result.data and self.db:
+            self.db.cache_market(market_id, result.data)
+        return result
+
+    def get_orderbook(self, token_id: str) -> ActionResult:
+        return self._call("get_orderbook", {"token_id": token_id}, self.sdk.get_orderbook, token_id)
+
+    def get_latest_price(self, token_id: str) -> ActionResult:
+        return self._call("get_latest_price", {"token_id": token_id}, self.sdk.get_latest_price, token_id)
+
+    def get_price_history(self, token_id: str, interval: str = "1h",
+                          start_at=None, end_at=None) -> ActionResult:
+        req = {"token_id": token_id, "interval": interval, "start_at": start_at, "end_at": end_at}
+        kwargs = {"token_id": token_id, "interval": interval}
+        if start_at:
+            kwargs["start_at"] = start_at
+        if end_at:
+            kwargs["end_at"] = end_at
+        return self._call("get_price_history", req, self.sdk.get_price_history, **kwargs)
+
+    def get_fee_rates(self, token_id: str) -> ActionResult:
+        return self._call("get_fee_rates", {"token_id": token_id}, self.sdk.get_fee_rates, token_id)
+
+    def get_quote_tokens(self) -> ActionResult:
+        return self._call("get_quote_tokens", {}, self.sdk.get_quote_tokens)
+
+    # --- Authenticated: Trading ---
+
+    def enable_trading(self) -> ActionResult:
+        return self._call("enable_trading", {}, self.sdk.enable_trading)
+
+    def get_user_auth(self) -> ActionResult:
+        return self._call("get_user_auth", {}, self.sdk.get_user_auth)
+
+    def place_order(self, market_id: int, token_id: str, side: str, price: str,
+                    amount: str, order_type: str = "limit") -> ActionResult:
+        from opinion_clob_sdk.chain.py_order_utils.model.order import PlaceOrderDataInput
+
+        side_int = 0 if side.upper() == "BUY" else 1
+        otype_int = 2 if order_type.lower() == "limit" else 1
+
+        data = PlaceOrderDataInput()
+        data.marketId = market_id
+        data.tokenId = token_id
+        data.side = side_int
+        data.price = price
+        data.orderType = otype_int
+
+        # Set amount based on side
+        if side_int == 0:  # BUY
+            data.makerAmountInQuoteToken = amount
+        else:  # SELL
+            data.makerAmountInBaseToken = amount
+
+        req = {"market_id": market_id, "token_id": token_id, "side": side, "price": price,
+               "amount": amount, "order_type": order_type}
+        result = self._call("place_order", req, self.sdk.place_order, data)
+
+        if result.success and result.data and self.db:
+            oid = result.data.get("id", result.data.get("order_id", ""))
+            if oid:
+                self.db.log_order(str(oid), market_id, token_id, side, price, amount, "pending", result.data)
+        return result
+
+    def cancel_order(self, order_id: str) -> ActionResult:
+        result = self._call("cancel_order", {"order_id": order_id}, self.sdk.cancel_order, order_id)
+        if result.success and self.db:
+            self.db.log_order(order_id, 0, "", "", "", "", "cancelled", result.data or {})
+        return result
+
+    def cancel_all_orders(self, market_id: Optional[int] = None) -> ActionResult:
+        req = {"market_id": market_id}
+        kwargs = {}
+        if market_id:
+            kwargs["market_id"] = market_id
+        return self._call("cancel_all_orders", req, self.sdk.cancel_all_orders, **kwargs)
+
+    def get_my_orders(self, market_id: int = 0, status: str = "", limit: int = 10,
+                      page: int = 1) -> ActionResult:
+        req = {"market_id": market_id, "status": status, "limit": limit, "page": page}
+        return self._call("get_my_orders", req, self.sdk.get_my_orders, market_id, status, limit, page)
+
+    def get_order_by_id(self, order_id: str) -> ActionResult:
+        return self._call("get_order_by_id", {"order_id": order_id}, self.sdk.get_order_by_id, order_id)
+
+    def get_my_positions(self, market_id: int = 0, page: int = 1, limit: int = 10) -> ActionResult:
+        req = {"market_id": market_id, "page": page, "limit": limit}
+        return self._call("get_my_positions", req, self.sdk.get_my_positions, market_id, page, limit)
+
+    def get_my_trades(self, market_id: Optional[int] = None, page: int = 1,
+                      limit: int = 10) -> ActionResult:
+        req = {"market_id": market_id, "page": page, "limit": limit}
+        return self._call("get_my_trades", req, self.sdk.get_my_trades, market_id, page, limit)
+
+    def get_my_balances(self) -> ActionResult:
+        return self._call("get_my_balances", {}, self.sdk.get_my_balances)
+
+    # --- On-chain: Split / Merge / Redeem ---
+
+    def split(self, market_id: int, amount: int) -> ActionResult:
+        req = {"market_id": market_id, "amount": amount}
+        return self._call("split", req, self.sdk.split, market_id, amount)
+
+    def merge(self, market_id: int, amount: int) -> ActionResult:
+        req = {"market_id": market_id, "amount": amount}
+        return self._call("merge", req, self.sdk.merge, market_id, amount)
+
+    def redeem(self, market_id: int) -> ActionResult:
+        req = {"market_id": market_id}
+        return self._call("redeem", req, self.sdk.redeem, market_id)

package/scripts/lib/config.py

@@ -0,0 +1,150 @@
+"""Configuration loading for Probable Markets Skill.
+
+Loads from environment variables and optional .probable/config.json.
+Provides create_client() factory for opinion_clob_sdk.Client.
+"""
+
+import json
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+DEFAULTS = {
+    "host": "https://api.probable.markets",
+    "chain_id": 56,
+    "rpc_url": "",
+    "api_key": "",
+    "private_key": "",
+    "multi_sig_addr": "",
+}
+
+CONFIG_DIR = ".probable"
+CONFIG_FILE = "config.json"
+DB_FILE = "probable.db"
+
+
+@dataclass
+class ProbableConfig:
+    host: str = DEFAULTS["host"]
+    api_key: str = ""
+    api_secret: str = ""
+    api_passphrase: str = ""
+    chain_id: int = DEFAULTS["chain_id"]
+    rpc_url: str = ""
+    private_key: str = ""
+    multi_sig_addr: str = ""
+
+    @property
+    def config_dir(self) -> Path:
+        return Path(CONFIG_DIR)
+
+    @property
+    def db_path(self) -> Path:
+        return self.config_dir / DB_FILE
+
+    def is_authenticated(self) -> bool:
+        return bool(self.api_key and self.private_key and self.multi_sig_addr)
+
+    def validate(self) -> list[str]:
+        """Return list of missing required fields for trading."""
+        missing = []
+        if not self.api_key:
+            missing.append("PROB_API_KEY")
+        if not self.rpc_url:
+            missing.append("PROB_RPC_URL")
+        if not self.private_key:
+            missing.append("PROB_PRIVATE_KEY")
+        if not self.multi_sig_addr:
+            missing.append("PROB_MULTI_SIG_ADDR")
+        return missing
+
+    def to_dict(self, mask_secrets: bool = True) -> dict:
+        d = {
+            "host": self.host,
+            "chain_id": self.chain_id,
+            "rpc_url": self.rpc_url,
+            "api_key": _mask(self.api_key) if mask_secrets else self.api_key,
+            "api_secret": _mask(self.api_secret) if mask_secrets else self.api_secret,
+            "api_passphrase": _mask(self.api_passphrase) if mask_secrets else self.api_passphrase,
+            "private_key": _mask(self.private_key) if mask_secrets else self.private_key,
+            "multi_sig_addr": self.multi_sig_addr,
+        }
+        return d
+
+
+def _mask(val: str) -> str:
+    if not val:
+        return ""
+    if len(val) <= 8:
+        return "***"
+    return val[:4] + "..." + val[-4:]
+
+
+def load_config() -> ProbableConfig:
+    """Load config from env vars, then overlay .probable/config.json if present."""
+    cfg = ProbableConfig(
+        host=os.environ.get("PROB_HOST", DEFAULTS["host"]),
+        api_key=os.environ.get("PROB_API_KEY", ""),
+        api_secret=os.environ.get("PROB_API_SECRET", ""),
+        api_passphrase=os.environ.get("PROB_API_PASSPHRASE", ""),
+        chain_id=int(os.environ.get("PROB_CHAIN_ID", str(DEFAULTS["chain_id"]))),
+        rpc_url=os.environ.get("PROB_RPC_URL", ""),
+        private_key=os.environ.get("PROB_PRIVATE_KEY", ""),
+        multi_sig_addr=os.environ.get("PROB_MULTI_SIG_ADDR", ""),
+    )
+
+    config_path = Path(CONFIG_DIR) / CONFIG_FILE
+    if config_path.exists():
+        try:
+            with open(config_path) as f:
+                overrides = json.load(f)
+            for key in ("host", "api_key", "api_secret", "api_passphrase",
+                        "chain_id", "rpc_url", "private_key", "multi_sig_addr"):
+                if key in overrides and overrides[key]:
+                    setattr(cfg, key, overrides[key])
+        except (json.JSONDecodeError, OSError):
+            pass  # Ignore malformed config file
+
+    return cfg
+
+
+def init_config_dir() -> Path:
+    """Create .probable/ directory and empty config.json if not exists."""
+    config_dir = Path(CONFIG_DIR)
+    config_dir.mkdir(exist_ok=True)
+    config_path = config_dir / CONFIG_FILE
+    if not config_path.exists():
+        config_path.write_text(json.dumps({
+            "host": DEFAULTS["host"],
+            "chain_id": DEFAULTS["chain_id"],
+            "rpc_url": "",
+            "api_key": "",
+            "private_key": "",
+            "multi_sig_addr": "",
+        }, indent=2))
+    return config_dir
+
+
+def create_client(cfg: Optional[ProbableConfig] = None):
+    """Factory: instantiate opinion_clob_sdk.Client from config."""
+    from opinion_clob_sdk import Client
+    from hexbytes import HexBytes
+
+    if cfg is None:
+        cfg = load_config()
+
+    kwargs = {
+        "host": cfg.host,
+        "chain_id": cfg.chain_id,
+    }
+    if cfg.api_key:
+        kwargs["apikey"] = cfg.api_key
+    if cfg.rpc_url:
+        kwargs["rpc_url"] = cfg.rpc_url
+    if cfg.private_key:
+        kwargs["private_key"] = cfg.private_key
+    if cfg.multi_sig_addr:
+        kwargs["multi_sig_addr"] = cfg.multi_sig_addr
+
+    return Client(**kwargs)

package/scripts/lib/db.py

@@ -0,0 +1,176 @@
+"""SQLite audit log and local cache for Probable Markets Skill."""
+
+import hashlib
+import json
+import sqlite3
+import time
+from contextlib import contextmanager
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Optional
+
+
+def _json_hash(obj: Any) -> str:
+    """Deterministic JSON hash for audit logging."""
+    raw = json.dumps(obj, sort_keys=True, default=str)
+    return hashlib.sha256(raw.encode()).hexdigest()[:16]
+
+
+class ProbableDB:
+    def __init__(self, db_path: Path):
+        self.db_path = db_path
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._init_tables()
+
+    @contextmanager
+    def _conn(self):
+        conn = sqlite3.connect(str(self.db_path))
+        conn.row_factory = sqlite3.Row
+        try:
+            yield conn
+            conn.commit()
+        finally:
+            conn.close()
+
+    def _init_tables(self):
+        with self._conn() as conn:
+            conn.executescript("""
+                CREATE TABLE IF NOT EXISTS audit_log (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    timestamp TEXT NOT NULL,
+                    action TEXT NOT NULL,
+                    request_hash TEXT,
+                    response_hash TEXT,
+                    success INTEGER NOT NULL,
+                    details TEXT
+                );
+
+                CREATE TABLE IF NOT EXISTS markets_cache (
+                    market_id INTEGER PRIMARY KEY,
+                    data TEXT NOT NULL,
+                    updated_at TEXT NOT NULL
+                );
+
+                CREATE TABLE IF NOT EXISTS orders_log (
+                    order_id TEXT PRIMARY KEY,
+                    market_id INTEGER,
+                    token_id TEXT,
+                    side TEXT,
+                    price TEXT,
+                    amount TEXT,
+                    status TEXT,
+                    created_at TEXT,
+                    updated_at TEXT,
+                    data TEXT
+                );
+
+                CREATE TABLE IF NOT EXISTS trades_log (
+                    trade_id TEXT PRIMARY KEY,
+                    order_id TEXT,
+                    market_id INTEGER,
+                    side TEXT,
+                    price TEXT,
+                    amount TEXT,
+                    timestamp TEXT,
+                    data TEXT
+                );
+
+                CREATE INDEX IF NOT EXISTS idx_audit_timestamp ON audit_log(timestamp);
+                CREATE INDEX IF NOT EXISTS idx_audit_action ON audit_log(action);
+                CREATE INDEX IF NOT EXISTS idx_orders_market ON orders_log(market_id);
+                CREATE INDEX IF NOT EXISTS idx_trades_market ON trades_log(market_id);
+            """)
+
+    def log_action(self, action: str, request: Any, response: Any, success: bool, details: str = ""):
+        """Write an audit log row."""
+        now = datetime.now(timezone.utc).isoformat()
+        req_hash = _json_hash(request) if request else None
+        resp_hash = _json_hash(response) if response else None
+        with self._conn() as conn:
+            conn.execute(
+                "INSERT INTO audit_log (timestamp, action, request_hash, response_hash, success, details) "
+                "VALUES (?, ?, ?, ?, ?, ?)",
+                (now, action, req_hash, resp_hash, int(success), details),
+            )
+
+    def cache_market(self, market_id: int, data: dict):
+        """Upsert market cache."""
+        now = datetime.now(timezone.utc).isoformat()
+        with self._conn() as conn:
+            conn.execute(
+                "INSERT OR REPLACE INTO markets_cache (market_id, data, updated_at) VALUES (?, ?, ?)",
+                (market_id, json.dumps(data, default=str), now),
+            )
+
+    def get_cached_market(self, market_id: int, max_age_seconds: int = 300) -> Optional[dict]:
+        """Get cached market data if fresh enough."""
+        with self._conn() as conn:
+            row = conn.execute(
+                "SELECT data, updated_at FROM markets_cache WHERE market_id = ?",
+                (market_id,),
+            ).fetchone()
+        if not row:
+            return None
+        updated = datetime.fromisoformat(row["updated_at"])
+        age = (datetime.now(timezone.utc) - updated).total_seconds()
+        if age > max_age_seconds:
+            return None
+        return json.loads(row["data"])
+
+    def log_order(self, order_id: str, market_id: int, token_id: str, side: str,
+                  price: str, amount: str, status: str, data: dict):
+        """Upsert order record."""
+        now = datetime.now(timezone.utc).isoformat()
+        with self._conn() as conn:
+            conn.execute(
+                "INSERT OR REPLACE INTO orders_log "
+                "(order_id, market_id, token_id, side, price, amount, status, created_at, updated_at, data) "
+                "VALUES (?, ?, ?, ?, ?, ?, ?, COALESCE((SELECT created_at FROM orders_log WHERE order_id = ?), ?), ?, ?)",
+                (order_id, market_id, token_id, side, price, amount, status, order_id, now, now,
+                 json.dumps(data, default=str)),
+            )
+
+    def log_trade(self, trade_id: str, order_id: str, market_id: int, side: str,
+                  price: str, amount: str, timestamp: str, data: dict):
+        """Insert trade record."""
+        with self._conn() as conn:
+            conn.execute(
+                "INSERT OR IGNORE INTO trades_log "
+                "(trade_id, order_id, market_id, side, price, amount, timestamp, data) "
+                "VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+                (trade_id, order_id, market_id, side, price, amount, timestamp,
+                 json.dumps(data, default=str)),
+            )
+
+    def get_recent_trades(self, hours: int = 24) -> list[dict]:
+        """Get trades from the past N hours."""
+        cutoff = datetime.now(timezone.utc).isoformat()
+        with self._conn() as conn:
+            rows = conn.execute(
+                "SELECT * FROM trades_log WHERE timestamp >= datetime(?, '-' || ? || ' hours') ORDER BY timestamp DESC",
+                (cutoff, hours),
+            ).fetchall()
+        return [dict(r) for r in rows]
+
+    def get_recent_orders(self, hours: int = 24) -> list[dict]:
+        """Get orders from the past N hours."""
+        cutoff = datetime.now(timezone.utc).isoformat()
+        with self._conn() as conn:
+            rows = conn.execute(
+                "SELECT * FROM orders_log WHERE updated_at >= datetime(?, '-' || ? || ' hours') ORDER BY updated_at DESC",
+                (cutoff, hours),
+            ).fetchall()
+        return [dict(r) for r in rows]
+
+    def get_audit_log(self, hours: int = 24, action: Optional[str] = None) -> list[dict]:
+        """Get recent audit log entries."""
+        cutoff = datetime.now(timezone.utc).isoformat()
+        query = "SELECT * FROM audit_log WHERE timestamp >= datetime(?, '-' || ? || ' hours')"
+        params: list = [cutoff, hours]
+        if action:
+            query += " AND action = ?"
+            params.append(action)
+        query += " ORDER BY timestamp DESC"
+        with self._conn() as conn:
+            rows = conn.execute(query, params).fetchall()
+        return [dict(r) for r in rows]